@pobammer-ts/eslint-cease-nonsense-rules 0.4.2 → 0.4.4

package/dist/stricty

@@ -0,0 +1,3303 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// node_modules/@typescript-eslint/types/dist/generated/ast-spec.js
+var require_ast_spec = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.AST_TOKEN_TYPES = exports.AST_NODE_TYPES = undefined;
+  var AST_NODE_TYPES;
+  (function(AST_NODE_TYPES2) {
+    AST_NODE_TYPES2["AccessorProperty"] = "AccessorProperty";
+    AST_NODE_TYPES2["ArrayExpression"] = "ArrayExpression";
+    AST_NODE_TYPES2["ArrayPattern"] = "ArrayPattern";
+    AST_NODE_TYPES2["ArrowFunctionExpression"] = "ArrowFunctionExpression";
+    AST_NODE_TYPES2["AssignmentExpression"] = "AssignmentExpression";
+    AST_NODE_TYPES2["AssignmentPattern"] = "AssignmentPattern";
+    AST_NODE_TYPES2["AwaitExpression"] = "AwaitExpression";
+    AST_NODE_TYPES2["BinaryExpression"] = "BinaryExpression";
+    AST_NODE_TYPES2["BlockStatement"] = "BlockStatement";
+    AST_NODE_TYPES2["BreakStatement"] = "BreakStatement";
+    AST_NODE_TYPES2["CallExpression"] = "CallExpression";
+    AST_NODE_TYPES2["CatchClause"] = "CatchClause";
+    AST_NODE_TYPES2["ChainExpression"] = "ChainExpression";
+    AST_NODE_TYPES2["ClassBody"] = "ClassBody";
+    AST_NODE_TYPES2["ClassDeclaration"] = "ClassDeclaration";
+    AST_NODE_TYPES2["ClassExpression"] = "ClassExpression";
+    AST_NODE_TYPES2["ConditionalExpression"] = "ConditionalExpression";
+    AST_NODE_TYPES2["ContinueStatement"] = "ContinueStatement";
+    AST_NODE_TYPES2["DebuggerStatement"] = "DebuggerStatement";
+    AST_NODE_TYPES2["Decorator"] = "Decorator";
+    AST_NODE_TYPES2["DoWhileStatement"] = "DoWhileStatement";
+    AST_NODE_TYPES2["EmptyStatement"] = "EmptyStatement";
+    AST_NODE_TYPES2["ExportAllDeclaration"] = "ExportAllDeclaration";
+    AST_NODE_TYPES2["ExportDefaultDeclaration"] = "ExportDefaultDeclaration";
+    AST_NODE_TYPES2["ExportNamedDeclaration"] = "ExportNamedDeclaration";
+    AST_NODE_TYPES2["ExportSpecifier"] = "ExportSpecifier";
+    AST_NODE_TYPES2["ExpressionStatement"] = "ExpressionStatement";
+    AST_NODE_TYPES2["ForInStatement"] = "ForInStatement";
+    AST_NODE_TYPES2["ForOfStatement"] = "ForOfStatement";
+    AST_NODE_TYPES2["ForStatement"] = "ForStatement";
+    AST_NODE_TYPES2["FunctionDeclaration"] = "FunctionDeclaration";
+    AST_NODE_TYPES2["FunctionExpression"] = "FunctionExpression";
+    AST_NODE_TYPES2["Identifier"] = "Identifier";
+    AST_NODE_TYPES2["IfStatement"] = "IfStatement";
+    AST_NODE_TYPES2["ImportAttribute"] = "ImportAttribute";
+    AST_NODE_TYPES2["ImportDeclaration"] = "ImportDeclaration";
+    AST_NODE_TYPES2["ImportDefaultSpecifier"] = "ImportDefaultSpecifier";
+    AST_NODE_TYPES2["ImportExpression"] = "ImportExpression";
+    AST_NODE_TYPES2["ImportNamespaceSpecifier"] = "ImportNamespaceSpecifier";
+    AST_NODE_TYPES2["ImportSpecifier"] = "ImportSpecifier";
+    AST_NODE_TYPES2["JSXAttribute"] = "JSXAttribute";
+    AST_NODE_TYPES2["JSXClosingElement"] = "JSXClosingElement";
+    AST_NODE_TYPES2["JSXClosingFragment"] = "JSXClosingFragment";
+    AST_NODE_TYPES2["JSXElement"] = "JSXElement";
+    AST_NODE_TYPES2["JSXEmptyExpression"] = "JSXEmptyExpression";
+    AST_NODE_TYPES2["JSXExpressionContainer"] = "JSXExpressionContainer";
+    AST_NODE_TYPES2["JSXFragment"] = "JSXFragment";
+    AST_NODE_TYPES2["JSXIdentifier"] = "JSXIdentifier";
+    AST_NODE_TYPES2["JSXMemberExpression"] = "JSXMemberExpression";
+    AST_NODE_TYPES2["JSXNamespacedName"] = "JSXNamespacedName";
+    AST_NODE_TYPES2["JSXOpeningElement"] = "JSXOpeningElement";
+    AST_NODE_TYPES2["JSXOpeningFragment"] = "JSXOpeningFragment";
+    AST_NODE_TYPES2["JSXSpreadAttribute"] = "JSXSpreadAttribute";
+    AST_NODE_TYPES2["JSXSpreadChild"] = "JSXSpreadChild";
+    AST_NODE_TYPES2["JSXText"] = "JSXText";
+    AST_NODE_TYPES2["LabeledStatement"] = "LabeledStatement";
+    AST_NODE_TYPES2["Literal"] = "Literal";
+    AST_NODE_TYPES2["LogicalExpression"] = "LogicalExpression";
+    AST_NODE_TYPES2["MemberExpression"] = "MemberExpression";
+    AST_NODE_TYPES2["MetaProperty"] = "MetaProperty";
+    AST_NODE_TYPES2["MethodDefinition"] = "MethodDefinition";
+    AST_NODE_TYPES2["NewExpression"] = "NewExpression";
+    AST_NODE_TYPES2["ObjectExpression"] = "ObjectExpression";
+    AST_NODE_TYPES2["ObjectPattern"] = "ObjectPattern";
+    AST_NODE_TYPES2["PrivateIdentifier"] = "PrivateIdentifier";
+    AST_NODE_TYPES2["Program"] = "Program";
+    AST_NODE_TYPES2["Property"] = "Property";
+    AST_NODE_TYPES2["PropertyDefinition"] = "PropertyDefinition";
+    AST_NODE_TYPES2["RestElement"] = "RestElement";
+    AST_NODE_TYPES2["ReturnStatement"] = "ReturnStatement";
+    AST_NODE_TYPES2["SequenceExpression"] = "SequenceExpression";
+    AST_NODE_TYPES2["SpreadElement"] = "SpreadElement";
+    AST_NODE_TYPES2["StaticBlock"] = "StaticBlock";
+    AST_NODE_TYPES2["Super"] = "Super";
+    AST_NODE_TYPES2["SwitchCase"] = "SwitchCase";
+    AST_NODE_TYPES2["SwitchStatement"] = "SwitchStatement";
+    AST_NODE_TYPES2["TaggedTemplateExpression"] = "TaggedTemplateExpression";
+    AST_NODE_TYPES2["TemplateElement"] = "TemplateElement";
+    AST_NODE_TYPES2["TemplateLiteral"] = "TemplateLiteral";
+    AST_NODE_TYPES2["ThisExpression"] = "ThisExpression";
+    AST_NODE_TYPES2["ThrowStatement"] = "ThrowStatement";
+    AST_NODE_TYPES2["TryStatement"] = "TryStatement";
+    AST_NODE_TYPES2["UnaryExpression"] = "UnaryExpression";
+    AST_NODE_TYPES2["UpdateExpression"] = "UpdateExpression";
+    AST_NODE_TYPES2["VariableDeclaration"] = "VariableDeclaration";
+    AST_NODE_TYPES2["VariableDeclarator"] = "VariableDeclarator";
+    AST_NODE_TYPES2["WhileStatement"] = "WhileStatement";
+    AST_NODE_TYPES2["WithStatement"] = "WithStatement";
+    AST_NODE_TYPES2["YieldExpression"] = "YieldExpression";
+    AST_NODE_TYPES2["TSAbstractAccessorProperty"] = "TSAbstractAccessorProperty";
+    AST_NODE_TYPES2["TSAbstractKeyword"] = "TSAbstractKeyword";
+    AST_NODE_TYPES2["TSAbstractMethodDefinition"] = "TSAbstractMethodDefinition";
+    AST_NODE_TYPES2["TSAbstractPropertyDefinition"] = "TSAbstractPropertyDefinition";
+    AST_NODE_TYPES2["TSAnyKeyword"] = "TSAnyKeyword";
+    AST_NODE_TYPES2["TSArrayType"] = "TSArrayType";
+    AST_NODE_TYPES2["TSAsExpression"] = "TSAsExpression";
+    AST_NODE_TYPES2["TSAsyncKeyword"] = "TSAsyncKeyword";
+    AST_NODE_TYPES2["TSBigIntKeyword"] = "TSBigIntKeyword";
+    AST_NODE_TYPES2["TSBooleanKeyword"] = "TSBooleanKeyword";
+    AST_NODE_TYPES2["TSCallSignatureDeclaration"] = "TSCallSignatureDeclaration";
+    AST_NODE_TYPES2["TSClassImplements"] = "TSClassImplements";
+    AST_NODE_TYPES2["TSConditionalType"] = "TSConditionalType";
+    AST_NODE_TYPES2["TSConstructorType"] = "TSConstructorType";
+    AST_NODE_TYPES2["TSConstructSignatureDeclaration"] = "TSConstructSignatureDeclaration";
+    AST_NODE_TYPES2["TSDeclareFunction"] = "TSDeclareFunction";
+    AST_NODE_TYPES2["TSDeclareKeyword"] = "TSDeclareKeyword";
+    AST_NODE_TYPES2["TSEmptyBodyFunctionExpression"] = "TSEmptyBodyFunctionExpression";
+    AST_NODE_TYPES2["TSEnumBody"] = "TSEnumBody";
+    AST_NODE_TYPES2["TSEnumDeclaration"] = "TSEnumDeclaration";
+    AST_NODE_TYPES2["TSEnumMember"] = "TSEnumMember";
+    AST_NODE_TYPES2["TSExportAssignment"] = "TSExportAssignment";
+    AST_NODE_TYPES2["TSExportKeyword"] = "TSExportKeyword";
+    AST_NODE_TYPES2["TSExternalModuleReference"] = "TSExternalModuleReference";
+    AST_NODE_TYPES2["TSFunctionType"] = "TSFunctionType";
+    AST_NODE_TYPES2["TSImportEqualsDeclaration"] = "TSImportEqualsDeclaration";
+    AST_NODE_TYPES2["TSImportType"] = "TSImportType";
+    AST_NODE_TYPES2["TSIndexedAccessType"] = "TSIndexedAccessType";
+    AST_NODE_TYPES2["TSIndexSignature"] = "TSIndexSignature";
+    AST_NODE_TYPES2["TSInferType"] = "TSInferType";
+    AST_NODE_TYPES2["TSInstantiationExpression"] = "TSInstantiationExpression";
+    AST_NODE_TYPES2["TSInterfaceBody"] = "TSInterfaceBody";
+    AST_NODE_TYPES2["TSInterfaceDeclaration"] = "TSInterfaceDeclaration";
+    AST_NODE_TYPES2["TSInterfaceHeritage"] = "TSInterfaceHeritage";
+    AST_NODE_TYPES2["TSIntersectionType"] = "TSIntersectionType";
+    AST_NODE_TYPES2["TSIntrinsicKeyword"] = "TSIntrinsicKeyword";
+    AST_NODE_TYPES2["TSLiteralType"] = "TSLiteralType";
+    AST_NODE_TYPES2["TSMappedType"] = "TSMappedType";
+    AST_NODE_TYPES2["TSMethodSignature"] = "TSMethodSignature";
+    AST_NODE_TYPES2["TSModuleBlock"] = "TSModuleBlock";
+    AST_NODE_TYPES2["TSModuleDeclaration"] = "TSModuleDeclaration";
+    AST_NODE_TYPES2["TSNamedTupleMember"] = "TSNamedTupleMember";
+    AST_NODE_TYPES2["TSNamespaceExportDeclaration"] = "TSNamespaceExportDeclaration";
+    AST_NODE_TYPES2["TSNeverKeyword"] = "TSNeverKeyword";
+    AST_NODE_TYPES2["TSNonNullExpression"] = "TSNonNullExpression";
+    AST_NODE_TYPES2["TSNullKeyword"] = "TSNullKeyword";
+    AST_NODE_TYPES2["TSNumberKeyword"] = "TSNumberKeyword";
+    AST_NODE_TYPES2["TSObjectKeyword"] = "TSObjectKeyword";
+    AST_NODE_TYPES2["TSOptionalType"] = "TSOptionalType";
+    AST_NODE_TYPES2["TSParameterProperty"] = "TSParameterProperty";
+    AST_NODE_TYPES2["TSPrivateKeyword"] = "TSPrivateKeyword";
+    AST_NODE_TYPES2["TSPropertySignature"] = "TSPropertySignature";
+    AST_NODE_TYPES2["TSProtectedKeyword"] = "TSProtectedKeyword";
+    AST_NODE_TYPES2["TSPublicKeyword"] = "TSPublicKeyword";
+    AST_NODE_TYPES2["TSQualifiedName"] = "TSQualifiedName";
+    AST_NODE_TYPES2["TSReadonlyKeyword"] = "TSReadonlyKeyword";
+    AST_NODE_TYPES2["TSRestType"] = "TSRestType";
+    AST_NODE_TYPES2["TSSatisfiesExpression"] = "TSSatisfiesExpression";
+    AST_NODE_TYPES2["TSStaticKeyword"] = "TSStaticKeyword";
+    AST_NODE_TYPES2["TSStringKeyword"] = "TSStringKeyword";
+    AST_NODE_TYPES2["TSSymbolKeyword"] = "TSSymbolKeyword";
+    AST_NODE_TYPES2["TSTemplateLiteralType"] = "TSTemplateLiteralType";
+    AST_NODE_TYPES2["TSThisType"] = "TSThisType";
+    AST_NODE_TYPES2["TSTupleType"] = "TSTupleType";
+    AST_NODE_TYPES2["TSTypeAliasDeclaration"] = "TSTypeAliasDeclaration";
+    AST_NODE_TYPES2["TSTypeAnnotation"] = "TSTypeAnnotation";
+    AST_NODE_TYPES2["TSTypeAssertion"] = "TSTypeAssertion";
+    AST_NODE_TYPES2["TSTypeLiteral"] = "TSTypeLiteral";
+    AST_NODE_TYPES2["TSTypeOperator"] = "TSTypeOperator";
+    AST_NODE_TYPES2["TSTypeParameter"] = "TSTypeParameter";
+    AST_NODE_TYPES2["TSTypeParameterDeclaration"] = "TSTypeParameterDeclaration";
+    AST_NODE_TYPES2["TSTypeParameterInstantiation"] = "TSTypeParameterInstantiation";
+    AST_NODE_TYPES2["TSTypePredicate"] = "TSTypePredicate";
+    AST_NODE_TYPES2["TSTypeQuery"] = "TSTypeQuery";
+    AST_NODE_TYPES2["TSTypeReference"] = "TSTypeReference";
+    AST_NODE_TYPES2["TSUndefinedKeyword"] = "TSUndefinedKeyword";
+    AST_NODE_TYPES2["TSUnionType"] = "TSUnionType";
+    AST_NODE_TYPES2["TSUnknownKeyword"] = "TSUnknownKeyword";
+    AST_NODE_TYPES2["TSVoidKeyword"] = "TSVoidKeyword";
+  })(AST_NODE_TYPES || (exports.AST_NODE_TYPES = AST_NODE_TYPES = {}));
+  var AST_TOKEN_TYPES;
+  (function(AST_TOKEN_TYPES2) {
+    AST_TOKEN_TYPES2["Boolean"] = "Boolean";
+    AST_TOKEN_TYPES2["Identifier"] = "Identifier";
+    AST_TOKEN_TYPES2["JSXIdentifier"] = "JSXIdentifier";
+    AST_TOKEN_TYPES2["PrivateIdentifier"] = "PrivateIdentifier";
+    AST_TOKEN_TYPES2["JSXText"] = "JSXText";
+    AST_TOKEN_TYPES2["Keyword"] = "Keyword";
+    AST_TOKEN_TYPES2["Null"] = "Null";
+    AST_TOKEN_TYPES2["Numeric"] = "Numeric";
+    AST_TOKEN_TYPES2["Punctuator"] = "Punctuator";
+    AST_TOKEN_TYPES2["RegularExpression"] = "RegularExpression";
+    AST_TOKEN_TYPES2["String"] = "String";
+    AST_TOKEN_TYPES2["Template"] = "Template";
+    AST_TOKEN_TYPES2["Block"] = "Block";
+    AST_TOKEN_TYPES2["Line"] = "Line";
+  })(AST_TOKEN_TYPES || (exports.AST_TOKEN_TYPES = AST_TOKEN_TYPES = {}));
+});
+
+// node_modules/@typescript-eslint/types/dist/lib.js
+var require_lib = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+});
+
+// node_modules/@typescript-eslint/types/dist/parser-options.js
+var require_parser_options = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+});
+
+// node_modules/@typescript-eslint/types/dist/ts-estree.js
+var require_ts_estree = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function() {
+    var ownKeys = function(o) {
+      ownKeys = Object.getOwnPropertyNames || function(o2) {
+        var ar = [];
+        for (var k in o2)
+          if (Object.prototype.hasOwnProperty.call(o2, k))
+            ar[ar.length] = k;
+        return ar;
+      };
+      return ownKeys(o);
+    };
+    return function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k = ownKeys(mod), i = 0;i < k.length; i++)
+          if (k[i] !== "default")
+            __createBinding(result, mod, k[i]);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+  }();
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.TSESTree = undefined;
+  exports.TSESTree = __importStar(require_ast_spec());
+});
+
+// node_modules/@typescript-eslint/types/dist/index.js
+var require_dist = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+        __createBinding(exports2, m, p);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.AST_TOKEN_TYPES = exports.AST_NODE_TYPES = undefined;
+  var ast_spec_1 = require_ast_spec();
+  Object.defineProperty(exports, "AST_NODE_TYPES", { enumerable: true, get: function() {
+    return ast_spec_1.AST_NODE_TYPES;
+  } });
+  Object.defineProperty(exports, "AST_TOKEN_TYPES", { enumerable: true, get: function() {
+    return ast_spec_1.AST_TOKEN_TYPES;
+  } });
+  __exportStar(require_lib(), exports);
+  __exportStar(require_parser_options(), exports);
+  __exportStar(require_ts_estree(), exports);
+});
+
+// src/rules/enforce-ianitor-check-type.ts
+var DEFAULT_CONFIG = {
+  baseThreshold: 10,
+  errorThreshold: 25,
+  interfacePenalty: 20,
+  performanceMode: true,
+  warnThreshold: 15
+};
+function hasTypeAnnotation(node) {
+  if (node.type === "VariableDeclarator" && node.id && typeof node.id === "object" && "typeAnnotation" in node.id)
+    return !!node.id.typeAnnotation;
+  if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression")
+    return !!node.returnType;
+  return false;
+}
+function getTypeName(node) {
+  return node.type === "TSInterfaceDeclaration" || node.type === "TSTypeAliasDeclaration" ? node.id.name : undefined;
+}
+function isIanitorValidator(node) {
+  return node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.object?.type === "Identifier" && node.callee.object.name === "Ianitor";
+}
+function hasIanitorStaticType(typeAnnotation) {
+  let currentType = typeAnnotation;
+  if (currentType.type === "TSTypeReference" && currentType.typeName.type === "Identifier" && currentType.typeName.name === "Readonly" && currentType.typeArguments?.params[0])
+    currentType = currentType.typeArguments.params[0];
+  if (currentType.type !== "TSTypeReference")
+    return false;
+  const { typeName, typeArguments } = currentType;
+  const firstParam = typeArguments?.params[0];
+  return typeName.type === "TSQualifiedName" && typeName.left.type === "Identifier" && typeName.left.name === "Ianitor" && typeName.right.type === "Identifier" && typeName.right.name === "Static" && firstParam?.type === "TSTypeQuery";
+}
+function calculateIanitorComplexity(node) {
+  const callee = node.callee;
+  if (callee?.type !== "MemberExpression" || callee.property?.type !== "Identifier")
+    return 0;
+  const method = callee.property.name;
+  switch (method) {
+    case "interface":
+    case "strictInterface": {
+      const properties = node.arguments?.[0];
+      return properties?.type === "ObjectExpression" ? 10 + (properties.properties?.length || 0) * 3 : 0;
+    }
+    case "optional":
+    case "array":
+    case "instanceIsA":
+    case "instanceOf":
+      return 2;
+    case "record":
+    case "map":
+      return 3;
+    case "union":
+    case "intersection":
+      return (node.arguments?.length || 0) * 2;
+    case "string":
+    case "number":
+    case "boolean":
+      return 1;
+    default:
+      return 1;
+  }
+}
+var enforceIanitorCheckType = {
+  create(context) {
+    const config = { ...DEFAULT_CONFIG, ...context.options[0] };
+    const cache = {
+      nodeCache: new WeakMap,
+      visitedNodes: new WeakSet
+    };
+    const ianitorStaticVariables = new Set;
+    const depthMultiplierCache = new Map;
+    const complexityCeiling = config.errorThreshold * 2;
+    function getDepthMultiplier(depth) {
+      const cached = depthMultiplierCache.get(depth);
+      if (cached !== undefined)
+        return cached;
+      const computed = Math.log2(depth + 1);
+      depthMultiplierCache.set(depth, computed);
+      return computed;
+    }
+    function addScore(current, addition) {
+      const nextScore = current + addition;
+      if (!config.performanceMode)
+        return nextScore;
+      return nextScore > complexityCeiling ? complexityCeiling : nextScore;
+    }
+    function extractIanitorStaticVariable(typeAnnotation) {
+      let currentType = typeAnnotation;
+      if (currentType.type === "TSTypeReference" && currentType.typeName.type === "Identifier" && currentType.typeName.name === "Readonly" && currentType.typeArguments?.params[0])
+        currentType = currentType.typeArguments.params[0];
+      if (currentType.type !== "TSTypeReference")
+        return null;
+      const { typeName, typeArguments } = currentType;
+      const firstParam = typeArguments?.params[0];
+      if (typeName.type === "TSQualifiedName" && typeName.left.type === "Identifier" && typeName.left.name === "Ianitor" && typeName.right.type === "Identifier" && typeName.right.name === "Static" && firstParam?.type === "TSTypeQuery" && firstParam.exprName.type === "Identifier")
+        return firstParam.exprName.name;
+      return null;
+    }
+    function calculateStructuralComplexity(node, depth = 0) {
+      const cached = cache.nodeCache.get(node);
+      if (cached !== undefined)
+        return cached;
+      if (cache.visitedNodes.has(node))
+        return 50;
+      cache.visitedNodes.add(node);
+      let score = 0;
+      const nextDepth = depth + 1;
+      switch (node.type) {
+        case "TSStringKeyword":
+        case "TSNumberKeyword":
+        case "TSBooleanKeyword":
+        case "TSNullKeyword":
+        case "TSUndefinedKeyword":
+        case "TSVoidKeyword":
+        case "TSSymbolKeyword":
+        case "TSBigIntKeyword":
+          score = 1;
+          break;
+        case "TSNeverKeyword":
+        case "TSUnknownKeyword":
+        case "TSAnyKeyword":
+          score = 0;
+          break;
+        case "TSInterfaceDeclaration": {
+          const iface = node;
+          score = config.interfacePenalty;
+          const extendsLength = iface.extends?.length;
+          if (extendsLength)
+            score = addScore(score, extendsLength * 5);
+          const { body } = iface.body;
+          score = addScore(score, body.length * 2);
+          for (const member of body) {
+            const typeAnnotation = "typeAnnotation" in member ? member.typeAnnotation : undefined;
+            if (typeAnnotation)
+              score = addScore(score, calculateStructuralComplexity(typeAnnotation.typeAnnotation, nextDepth));
+          }
+          break;
+        }
+        case "TSTypeLiteral": {
+          const { members } = node;
+          score = 2 + members.length * 0.5;
+          for (const member of members) {
+            const typeAnnotation = "typeAnnotation" in member ? member.typeAnnotation : undefined;
+            if (typeAnnotation)
+              score = addScore(score, calculateStructuralComplexity(typeAnnotation.typeAnnotation, nextDepth));
+          }
+          break;
+        }
+        case "TSUnionType": {
+          const { types } = node;
+          for (const type of types)
+            score = addScore(score, calculateStructuralComplexity(type, nextDepth));
+          score = addScore(score, 2 * (types.length - 1));
+          break;
+        }
+        case "TSIntersectionType": {
+          const { types } = node;
+          for (const type of types)
+            score = addScore(score, calculateStructuralComplexity(type, nextDepth));
+          score = addScore(score, 3 * types.length);
+          break;
+        }
+        case "TSArrayType":
+          score = addScore(calculateStructuralComplexity(node.elementType, nextDepth), 1);
+          break;
+        case "TSTupleType": {
+          const { elementTypes } = node;
+          score = 1;
+          for (const element of elementTypes) {
+            const elementType = element.type;
+            if (elementType !== "TSRestType" && elementType !== "TSOptionalType")
+              score = addScore(score, calculateStructuralComplexity(element, nextDepth));
+          }
+          score = addScore(score, 1.5 * elementTypes.length);
+          break;
+        }
+        case "TSTypeReference": {
+          score = 2;
+          const { typeArguments } = node;
+          if (typeArguments) {
+            for (const param of typeArguments.params)
+              score = addScore(score, calculateStructuralComplexity(param, nextDepth) + 2);
+          }
+          break;
+        }
+        case "TSConditionalType": {
+          score = 3;
+          score = addScore(score, calculateStructuralComplexity(node.checkType, nextDepth));
+          score = addScore(score, calculateStructuralComplexity(node.extendsType, nextDepth));
+          score = addScore(score, calculateStructuralComplexity(node.trueType, nextDepth));
+          score = addScore(score, calculateStructuralComplexity(node.falseType, nextDepth));
+          break;
+        }
+        case "TSMappedType": {
+          score = 5;
+          if (node.constraint)
+            score = addScore(score, calculateStructuralComplexity(node.constraint, nextDepth));
+          if (node.typeAnnotation)
+            score = addScore(score, calculateStructuralComplexity(node.typeAnnotation, nextDepth));
+          break;
+        }
+        case "TSFunctionType":
+        case "TSMethodSignature": {
+          const func = node;
+          score = 2;
+          for (const param of func.params) {
+            const typeAnnotation = "typeAnnotation" in param ? param.typeAnnotation : undefined;
+            if (typeAnnotation)
+              score = addScore(score, calculateStructuralComplexity(typeAnnotation.typeAnnotation, nextDepth));
+          }
+          if (func.returnType)
+            score = addScore(score, calculateStructuralComplexity(func.returnType.typeAnnotation, nextDepth));
+          break;
+        }
+        default:
+          score = 1;
+      }
+      score *= getDepthMultiplier(depth);
+      cache.nodeCache.set(node, score);
+      cache.visitedNodes.delete(node);
+      return score;
+    }
+    const variableDeclaratorsToCheck = new Map;
+    return {
+      "Program:exit"() {
+        for (const [nodeKey, data] of variableDeclaratorsToCheck.entries()) {
+          const node = nodeKey;
+          if (node.id.type === "Identifier" && ianitorStaticVariables.has(node.id.name))
+            continue;
+          context.report({
+            data: { score: data.complexity.toFixed(1) },
+            messageId: "missingIanitorCheckType",
+            node: node.id
+          });
+        }
+      },
+      TSInterfaceDeclaration(node) {
+        const complexity = calculateStructuralComplexity(node);
+        const name = getTypeName(node);
+        if (complexity >= config.interfacePenalty) {
+          context.report({
+            data: { name: name || "unknown" },
+            messageId: "complexInterfaceNeedsCheck",
+            node
+          });
+        }
+      },
+      TSTypeAliasDeclaration(node) {
+        const varName = extractIanitorStaticVariable(node.typeAnnotation);
+        if (varName)
+          ianitorStaticVariables.add(varName);
+        if (hasIanitorStaticType(node.typeAnnotation))
+          return;
+        const complexity = calculateStructuralComplexity(node.typeAnnotation);
+        if (complexity < config.baseThreshold)
+          return;
+        context.report({
+          data: { score: complexity.toFixed(1) },
+          messageId: "missingIanitorCheckType",
+          node
+        });
+      },
+      VariableDeclarator(node) {
+        if (!node.init || node.init.type !== "CallExpression")
+          return;
+        if (!isIanitorValidator(node.init))
+          return;
+        if (hasTypeAnnotation(node))
+          return;
+        const complexity = calculateIanitorComplexity(node.init);
+        if (complexity < config.baseThreshold)
+          return;
+        variableDeclaratorsToCheck.set(node, { complexity });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce Ianitor.Check<T> type annotations on complex TypeScript types",
+      recommended: false
+    },
+    fixable: undefined,
+    messages: {
+      complexInterfaceNeedsCheck: "Interface '{{name}}' requires Ianitor.Check<T> annotation (interfaces always need explicit checking)",
+      missingIanitorCheckType: "Complex type (score: {{score}}) requires Ianitor.Check<T> annotation for type safety"
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          baseThreshold: { minimum: 1, type: "number" },
+          errorThreshold: { minimum: 1, type: "number" },
+          interfacePenalty: { minimum: 1, type: "number" },
+          performanceMode: { type: "boolean" },
+          warnThreshold: { minimum: 1, type: "number" }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  }
+};
+var enforce_ianitor_check_type_default = enforceIanitorCheckType;
+
+// src/rules/no-color3-constructor.ts
+function isUnknownRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isNumericLiteralNode(value) {
+  return isUnknownRecord(value) && value.type === "Literal" && "value" in value && typeof value.value === "number";
+}
+function mapComponentToRgbRange(value) {
+  return Math.round(value > 1 ? value : value * 255);
+}
+function collectNumericComponents(parameters) {
+  const components = new Array;
+  let allZero = true;
+  for (const parameter of parameters) {
+    if (!isNumericLiteralNode(parameter))
+      return;
+    const mapped = mapComponentToRgbRange(parameter.value);
+    components.push(mapped);
+    if (mapped !== 0)
+      allZero = false;
+  }
+  return { allZero, components };
+}
+var noColor3Constructor = {
+  create(context) {
+    return {
+      NewExpression(node) {
+        if (node.callee.type !== "Identifier" || node.callee.name !== "Color3")
+          return;
+        const parameters = node.arguments;
+        if (parameters.length === 0)
+          return;
+        const collected = collectNumericComponents(parameters);
+        if (!collected) {
+          context.report({
+            messageId: parameters.length < 3 ? "useFromRGB" : "onlyZeroArgs",
+            node
+          });
+          return;
+        }
+        if (parameters.length < 3) {
+          const [red, green = 0] = collected.components;
+          context.report({
+            fix: (fixer) => fixer.replaceText(node, `Color3.fromRGB(${red}, ${green}, 0)`),
+            messageId: "useFromRGB",
+            node
+          });
+          return;
+        }
+        if (!collected.allZero) {
+          context.report({
+            fix: (fixer) => fixer.replaceText(node, `Color3.fromRGB(${collected.components.join(", ")})`),
+            messageId: "onlyZeroArgs",
+            node
+          });
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Ban new Color3(...) except new Color3() or new Color3(0, 0, 0). Use Color3.fromRGB() instead.",
+      recommended: true
+    },
+    fixable: "code",
+    messages: {
+      onlyZeroArgs: "Use Color3.fromRGB() instead of new Color3(). new Color3() uses floats [0-1] and performs worse than Color3.fromRGB() which uses [0-255]. Only 'new Color3()' or 'new Color3(0, 0, 0)' are allowed.",
+      useFromRGB: "Use Color3.fromRGB() instead of new Color3(). new Color3() uses floats [0-1] and performs worse than Color3.fromRGB() which uses [0-255]."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_color3_constructor_default = noColor3Constructor;
+
+// src/rules/no-print.ts
+var noPrint = {
+  create(context) {
+    return {
+      'CallExpression[callee.type="Identifier"][callee.name="print"]'(node) {
+        context.report({
+          messageId: "useLog",
+          node
+        });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Ban print() function calls. Use Log instead.",
+      recommended: false
+    },
+    messages: {
+      useLog: "Use Log instead of print()"
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_print_default = noPrint;
+
+// src/rules/no-shorthand-names.ts
+var DEFAULT_OPTIONS = {
+  allowPropertyAccess: ["char"],
+  shorthands: {
+    args: "parameters",
+    char: "character",
+    dt: "deltaTime",
+    plr: "player"
+  }
+};
+function isUnknownRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isStringRecord(value) {
+  return isUnknownRecord2(value) && Object.values(value).every((v) => typeof v === "string");
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function escapeRegex(str) {
+  return str.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isRuleOptions(value) {
+  if (!isUnknownRecord2(value))
+    return false;
+  return (!("shorthands" in value) || isStringRecord(value.shorthands)) && (!("allowPropertyAccess" in value) || isStringArray(value.allowPropertyAccess));
+}
+function normalizeOptions(rawOptions) {
+  const mergedShorthands = { ...DEFAULT_OPTIONS.shorthands };
+  if (rawOptions?.shorthands)
+    for (const [key, value] of Object.entries(rawOptions.shorthands))
+      mergedShorthands[key] = value;
+  const shorthandsMap = new Map(Object.entries(mergedShorthands));
+  const allowPropertyAccessSource = rawOptions?.allowPropertyAccess ?? DEFAULT_OPTIONS.allowPropertyAccess;
+  const escapedKeys = Array.from(shorthandsMap.keys()).map((key) => escapeRegex(key));
+  const selector = `Identifier[name=/^(${escapedKeys.join("|")})$/]`;
+  return {
+    allowPropertyAccess: new Set(allowPropertyAccessSource),
+    selector,
+    shorthands: shorthandsMap
+  };
+}
+var noShorthandNames = {
+  create(context) {
+    const validatedOptions = isRuleOptions(context.options[0]) ? context.options[0] : undefined;
+    const normalized = normalizeOptions(validatedOptions);
+    const { shorthands, allowPropertyAccess, selector } = normalized;
+    return {
+      [selector](node) {
+        const shorthandName = node.name;
+        const replacement = shorthands.get(shorthandName);
+        if (!replacement)
+          return;
+        const parent = node.parent;
+        if (allowPropertyAccess.has(shorthandName) && parent && isUnknownRecord2(parent) && parent.type === "MemberExpression" && parent.property === node)
+          return;
+        if (shorthandName === "plr" && parent?.type === "VariableDeclarator" && parent.id === node) {
+          const init = parent.init;
+          if (init && isUnknownRecord2(init) && init.type === "MemberExpression" && init.object && isUnknownRecord2(init.object) && init.object.type === "Identifier" && init.object.name === "Players" && init.property && isUnknownRecord2(init.property) && init.property.type === "Identifier" && init.property.name === "LocalPlayer") {
+            context.report({
+              data: { replacement: "localPlayer", shorthand: shorthandName },
+              messageId: "useReplacement",
+              node
+            });
+            return;
+          }
+        }
+        context.report({
+          data: { replacement, shorthand: shorthandName },
+          messageId: "useReplacement",
+          node
+        });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Ban shorthand variable names. Use descriptive full names instead.",
+      recommended: true
+    },
+    messages: {
+      useReplacement: "Use '{{replacement}}' instead of '{{shorthand}}' shorthand"
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowPropertyAccess: {
+            description: "Shorthand names that are allowed as property access",
+            items: { type: "string" },
+            type: "array"
+          },
+          shorthands: {
+            additionalProperties: { type: "string" },
+            description: "Map of shorthand names to their full replacements",
+            type: "object"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "suggestion"
+  }
+};
+var no_shorthand_names_default = noShorthandNames;
+
+// src/rules/no-warn.ts
+var noWarn = {
+  create(context) {
+    return {
+      'CallExpression[callee.type="Identifier"][callee.name="warn"]'(node) {
+        context.report({
+          messageId: "useLog",
+          node
+        });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Ban warn() function calls. Use Log instead.",
+      recommended: false
+    },
+    messages: {
+      useLog: "Use Log instead of warn()"
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_warn_default = noWarn;
+
+// src/rules/require-react-component-keys.ts
+var DEFAULT_OPTIONS2 = {
+  allowRootKeys: false,
+  ignoreCallExpressions: ["ReactTree.mount", "CreateReactStory"]
+};
+var WRAPPER_PARENT_TYPES = new Set([
+  "ParenthesizedExpression",
+  "TSAsExpression",
+  "TSSatisfiesExpression",
+  "TSTypeAssertion",
+  "TSNonNullExpression",
+  "TSInstantiationExpression",
+  "ChainExpression"
+]);
+var ARGUMENT_WRAPPER_TYPES = new Set([
+  ...WRAPPER_PARENT_TYPES,
+  "AwaitExpression",
+  "ConditionalExpression",
+  "LogicalExpression",
+  "SequenceExpression",
+  "SpreadElement"
+]);
+function ascendPastWrappers(node) {
+  let current = node;
+  while (current && WRAPPER_PARENT_TYPES.has(current.type))
+    current = current.parent;
+  return current;
+}
+function hasKeyAttribute(node) {
+  for (const attr of node.openingElement.attributes) {
+    if (attr.type === "JSXAttribute" && attr.name.name === "key")
+      return true;
+  }
+  return false;
+}
+function isReactComponentHOC(callExpr) {
+  const { callee } = callExpr;
+  if (callee.type === "Identifier") {
+    return callee.name === "forwardRef" || callee.name === "memo";
+  }
+  if (callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "React" && callee.property.type === "Identifier") {
+    return callee.property.name === "forwardRef" || callee.property.name === "memo";
+  }
+  return false;
+}
+function isInConditionalJSXChild(node) {
+  let parent = node.parent;
+  if (!parent)
+    return false;
+  const hasConditional = parent.type === "ConditionalExpression" || parent.type === "LogicalExpression";
+  if (!hasConditional)
+    return false;
+  while (parent && (parent.type === "ConditionalExpression" || parent.type === "LogicalExpression")) {
+    parent = parent.parent;
+  }
+  if (!parent)
+    return false;
+  if (parent.type === "JSXExpressionContainer") {
+    const jsxExprContainer = parent;
+    const containerParent = jsxExprContainer.parent;
+    if (!containerParent)
+      return false;
+    if (containerParent.type === "JSXElement" || containerParent.type === "JSXFragment") {
+      const children = containerParent.children;
+      const significantChildren = children.filter((child) => {
+        if (child.type === "JSXText") {
+          return child.value.trim().length > 0;
+        }
+        return true;
+      });
+      if (significantChildren.length > 1) {
+        return false;
+      }
+      return true;
+    }
+    return false;
+  }
+  return false;
+}
+function getEnclosingFunctionLike(node) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "ArrowFunctionExpression" || current.type === "FunctionExpression" || current.type === "FunctionDeclaration") {
+      return current;
+    }
+    current = current.parent;
+  }
+  return;
+}
+function findEnclosingCallExpression(node) {
+  let current = node;
+  let parent = node.parent;
+  while (parent) {
+    if (parent.type === "CallExpression") {
+      for (const argument of parent.arguments) {
+        if (argument === current)
+          return parent;
+        if (argument.type === "SpreadElement" && argument.argument === current)
+          return parent;
+      }
+      return;
+    }
+    if (ARGUMENT_WRAPPER_TYPES.has(parent.type)) {
+      current = parent;
+      parent = parent.parent;
+      continue;
+    }
+    break;
+  }
+  return;
+}
+function getVariableForFunction(context, fn) {
+  if (fn.type === "FunctionDeclaration") {
+    const declared = context.sourceCode.getDeclaredVariables(fn);
+    if (declared.length > 0)
+      return declared[0];
+    return;
+  }
+  const parent = fn.parent;
+  if (!parent)
+    return;
+  if (parent.type === "VariableDeclarator" || parent.type === "AssignmentExpression") {
+    const declared = context.sourceCode.getDeclaredVariables(parent);
+    if (declared.length > 0)
+      return declared[0];
+  }
+  return;
+}
+function referenceActsAsCallback(reference) {
+  if (!reference.isRead())
+    return false;
+  const callExpression = findEnclosingCallExpression(reference.identifier);
+  if (!callExpression)
+    return false;
+  return !isReactComponentHOC(callExpression);
+}
+function isFunctionUsedAsCallback(context, fn) {
+  const inlineCall = findEnclosingCallExpression(fn);
+  if (inlineCall && !isReactComponentHOC(inlineCall)) {
+    return true;
+  }
+  const variable = getVariableForFunction(context, fn);
+  if (!variable)
+    return false;
+  for (const reference of variable.references) {
+    if (referenceActsAsCallback(reference))
+      return true;
+  }
+  return false;
+}
+function isTopLevelReturn(node) {
+  let parent = ascendPastWrappers(node.parent);
+  if (!parent)
+    return false;
+  if (parent.type === "JSXExpressionContainer")
+    parent = ascendPastWrappers(parent.parent);
+  if (!parent)
+    return false;
+  while (parent && (parent.type === "ConditionalExpression" || parent.type === "LogicalExpression")) {
+    parent = ascendPastWrappers(parent.parent);
+  }
+  if (!parent)
+    return false;
+  if (parent.type === "ReturnStatement") {
+    let currentNode = ascendPastWrappers(parent.parent);
+    if (currentNode?.type === "BlockStatement") {
+      currentNode = ascendPastWrappers(currentNode.parent);
+    }
+    if (!currentNode)
+      return false;
+    if (currentNode.type === "ArrowFunctionExpression" || currentNode.type === "FunctionExpression") {
+      const functionParent = ascendPastWrappers(currentNode.parent);
+      if (functionParent?.type === "CallExpression") {
+        return isReactComponentHOC(functionParent);
+      }
+      return true;
+    }
+    return currentNode.type === "FunctionDeclaration";
+  }
+  if (parent.type === "ArrowFunctionExpression") {
+    const functionParent = ascendPastWrappers(parent.parent);
+    if (functionParent?.type === "CallExpression") {
+      return isReactComponentHOC(functionParent);
+    }
+    return true;
+  }
+  return false;
+}
+function isIgnoredCallExpression(node, ignoreList) {
+  let parent = node.parent;
+  if (!parent)
+    return false;
+  if (parent.type === "JSXExpressionContainer") {
+    parent = parent.parent;
+    if (!parent)
+      return false;
+  }
+  const maxDepth = 20;
+  for (let depth = 0;depth < maxDepth && parent; depth++) {
+    const { type } = parent;
+    if (type === "CallExpression") {
+      const { callee } = parent;
+      if (callee.type === "Identifier")
+        return ignoreList.includes(callee.name);
+      if (callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.property.type === "Identifier")
+        return ignoreList.includes(`${callee.object.name}.${callee.property.name}`);
+      return false;
+    }
+    parent = parent.parent;
+  }
+  return false;
+}
+function isJSXPropValue(node) {
+  let parent = node.parent;
+  if (!parent)
+    return false;
+  while (parent && (parent.type === "ConditionalExpression" || parent.type === "LogicalExpression"))
+    parent = parent.parent;
+  if (!parent)
+    return false;
+  if (parent.type === "JSXExpressionContainer") {
+    parent = parent.parent;
+    if (!parent)
+      return false;
+  }
+  return parent.type === "JSXAttribute";
+}
+var docs = {
+  description: "Enforce key props on all React elements except top-level returns",
+  recommended: true
+};
+var requireReactComponentKeys = {
+  create(context) {
+    const options = {
+      ...DEFAULT_OPTIONS2,
+      ...context.options[0]
+    };
+    function checkElement(node) {
+      const functionLike = getEnclosingFunctionLike(node);
+      const isCallback = functionLike ? isFunctionUsedAsCallback(context, functionLike) : false;
+      const isRoot = isTopLevelReturn(node);
+      if (isRoot && !isCallback) {
+        if (!options.allowRootKeys && node.type === "JSXElement" && hasKeyAttribute(node)) {
+          context.report({
+            messageId: "rootComponentWithKey",
+            node
+          });
+        }
+        return;
+      }
+      if (isIgnoredCallExpression(node, options.ignoreCallExpressions))
+        return;
+      if (isJSXPropValue(node))
+        return;
+      if (isInConditionalJSXChild(node))
+        return;
+      if (node.type === "JSXFragment") {
+        context.report({
+          messageId: "missingKey",
+          node
+        });
+        return;
+      }
+      if (!hasKeyAttribute(node)) {
+        context.report({
+          messageId: "missingKey",
+          node
+        });
+      }
+    }
+    return {
+      JSXElement(node) {
+        checkElement(node);
+      },
+      JSXFragment(node) {
+        checkElement(node);
+      }
+    };
+  },
+  defaultOptions: [DEFAULT_OPTIONS2],
+  meta: {
+    docs,
+    messages: {
+      missingKey: "All React elements except top-level returns require a key prop",
+      rootComponentWithKey: "Root component returns should not have key props"
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowRootKeys: {
+            default: false,
+            description: "Allow key props on root component returns",
+            type: "boolean"
+          },
+          ignoreCallExpressions: {
+            default: ["ReactTree.mount"],
+            description: "Function calls where JSX arguments don't need keys",
+            items: { type: "string" },
+            type: "array"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  }
+};
+var require_react_component_keys_default = requireReactComponentKeys;
+
+// src/rules/use-exhaustive-dependencies.ts
+var import_types = __toESM(require_dist(), 1);
+
+// node_modules/sury/src/Sury.res.mjs
+function valFromOption(x) {
+  if (x === null || x.BS_PRIVATE_NESTED_SOME_NONE === undefined) {
+    return x;
+  }
+  let depth = x.BS_PRIVATE_NESTED_SOME_NONE;
+  if (depth === 0) {
+    return;
+  } else {
+    return {
+      BS_PRIVATE_NESTED_SOME_NONE: depth - 1 | 0
+    };
+  }
+}
+var idMap = {};
+function create(str) {
+  let v = idMap[str];
+  if (v !== undefined) {
+    let id = v + 1 | 0;
+    idMap[str] = id;
+    return str + ("/" + id);
+  }
+  idMap[str] = 1;
+  return str;
+}
+var immutableEmpty$1 = [];
+function capitalize(string) {
+  return string.slice(0, 1).toUpperCase() + string.slice(1);
+}
+var copy = (d) => ({ ...d });
+function fromString(string) {
+  let _idx = 0;
+  while (true) {
+    let idx = _idx;
+    let match = string[idx];
+    if (match === undefined) {
+      return '"' + string + '"';
+    }
+    switch (match) {
+      case '"':
+      case `
+`:
+        return JSON.stringify(string);
+      default:
+        _idx = idx + 1 | 0;
+        continue;
+    }
+  }
+}
+function toArray(path) {
+  if (path === "") {
+    return [];
+  } else {
+    return JSON.parse(path.split('"]["').join('","'));
+  }
+}
+var vendor = "sury";
+var s = Symbol(vendor);
+var itemSymbol = Symbol(vendor + ":item");
+var $$Error = /* @__PURE__ */ create("Sury.Error");
+var constField = "const";
+function has(acc, flag) {
+  return (acc & flag) !== 0;
+}
+var flags = {
+  unknown: 1,
+  string: 2,
+  number: 4,
+  boolean: 8,
+  undefined: 16,
+  null: 32,
+  object: 64,
+  array: 128,
+  union: 256,
+  ref: 512,
+  bigint: 1024,
+  nan: 2048,
+  function: 4096,
+  instance: 8192,
+  never: 16384,
+  symbol: 32768
+};
+function stringify(unknown) {
+  let tagFlag = flags[typeof unknown];
+  if (tagFlag & 16) {
+    return "undefined";
+  }
+  if (!(tagFlag & 64)) {
+    if (tagFlag & 2) {
+      return '"' + unknown + '"';
+    } else if (tagFlag & 1024) {
+      return unknown + "n";
+    } else {
+      return unknown.toString();
+    }
+  }
+  if (unknown === null) {
+    return "null";
+  }
+  if (Array.isArray(unknown)) {
+    let string = "[";
+    for (let i = 0, i_finish = unknown.length;i < i_finish; ++i) {
+      if (i !== 0) {
+        string = string + ", ";
+      }
+      string = string + stringify(unknown[i]);
+    }
+    return string + "]";
+  }
+  if (unknown.constructor !== Object) {
+    return Object.prototype.toString.call(unknown);
+  }
+  let keys = Object.keys(unknown);
+  let string$1 = "{ ";
+  for (let i$1 = 0, i_finish$1 = keys.length;i$1 < i_finish$1; ++i$1) {
+    let key = keys[i$1];
+    let value = unknown[key];
+    string$1 = string$1 + key + ": " + stringify(value) + "; ";
+  }
+  return string$1 + "}";
+}
+function toExpression(schema) {
+  let tag = schema.type;
+  let $$const = schema.const;
+  let name = schema.name;
+  if (name !== undefined) {
+    return name;
+  }
+  if ($$const !== undefined) {
+    return stringify($$const);
+  }
+  let format = schema.format;
+  let anyOf = schema.anyOf;
+  if (anyOf !== undefined) {
+    return anyOf.map(toExpression).join(" | ");
+  }
+  if (format !== undefined) {
+    return format;
+  }
+  switch (tag) {
+    case "nan":
+      return "NaN";
+    case "object":
+      let additionalItems = schema.additionalItems;
+      let properties = schema.properties;
+      let locations = Object.keys(properties);
+      if (locations.length === 0) {
+        if (typeof additionalItems === "object") {
+          return "{ [key: string]: " + toExpression(additionalItems) + "; }";
+        } else {
+          return "{}";
+        }
+      } else {
+        return "{ " + locations.map((location) => location + ": " + toExpression(properties[location]) + ";").join(" ") + " }";
+      }
+    default:
+      if (schema.b) {
+        return tag;
+      }
+      switch (tag) {
+        case "instance":
+          return schema.class.name;
+        case "array":
+          let additionalItems$1 = schema.additionalItems;
+          let items = schema.items;
+          if (typeof additionalItems$1 !== "object") {
+            return "[" + items.map((item) => toExpression(item.schema)).join(", ") + "]";
+          }
+          let itemName = toExpression(additionalItems$1);
+          return (additionalItems$1.type === "union" ? "(" + itemName + ")" : itemName) + "[]";
+        default:
+          return tag;
+      }
+  }
+}
+
+class SuryError extends Error {
+  constructor(code, flag, path) {
+    super();
+    this.flag = flag;
+    this.code = code;
+    this.path = path;
+  }
+}
+var d = Object.defineProperty;
+var p = SuryError.prototype;
+d(p, "message", {
+  get() {
+    return message(this);
+  }
+});
+d(p, "reason", {
+  get() {
+    return reason(this);
+  }
+});
+d(p, "name", { value: "SuryError" });
+d(p, "s", { value: s });
+d(p, "_1", {
+  get() {
+    return this;
+  }
+});
+d(p, "RE_EXN_ID", {
+  value: $$Error
+});
+var Schema = function(type) {
+  this.type = type;
+};
+var sp = Object.create(null);
+d(sp, "with", {
+  get() {
+    return (fn, ...args) => fn(this, ...args);
+  }
+});
+Schema.prototype = sp;
+function getOrRethrow(exn) {
+  if (exn && exn.s === s) {
+    return exn;
+  }
+  throw exn;
+}
+function reason(error, nestedLevelOpt) {
+  let nestedLevel = nestedLevelOpt !== undefined ? nestedLevelOpt : 0;
+  let reason$1 = error.code;
+  if (typeof reason$1 !== "object") {
+    return "Encountered unexpected async transform or refine. Use parseAsyncOrThrow operation instead";
+  }
+  switch (reason$1.TAG) {
+    case "OperationFailed":
+      return reason$1._0;
+    case "InvalidOperation":
+      return reason$1.description;
+    case "InvalidType":
+      let unionErrors = reason$1.unionErrors;
+      let m = "Expected " + toExpression(reason$1.expected) + ", received " + stringify(reason$1.received);
+      if (unionErrors !== undefined) {
+        let lineBreak = `
+` + " ".repeat(nestedLevel << 1);
+        let reasonsDict = {};
+        for (let idx = 0, idx_finish = unionErrors.length;idx < idx_finish; ++idx) {
+          let error$1 = unionErrors[idx];
+          let reason$2 = reason(error$1, nestedLevel + 1);
+          let nonEmptyPath = error$1.path;
+          let location = nonEmptyPath === "" ? "" : "At " + nonEmptyPath + ": ";
+          let line = "- " + location + reason$2;
+          if (!reasonsDict[line]) {
+            reasonsDict[line] = 1;
+            m = m + lineBreak + line;
+          }
+        }
+      }
+      return m;
+    case "UnsupportedTransformation":
+      return "Unsupported transformation from " + toExpression(reason$1.from) + " to " + toExpression(reason$1.to);
+    case "ExcessField":
+      return 'Unrecognized key "' + reason$1._0 + '"';
+    case "InvalidJsonSchema":
+      return toExpression(reason$1._0) + " is not valid JSON";
+  }
+}
+function message(error) {
+  let op = error.flag;
+  let text = "Failed ";
+  if (op & 2) {
+    text = text + "async ";
+  }
+  text = text + (op & 1 ? op & 4 ? "asserting" : "parsing" : "converting");
+  if (op & 8) {
+    text = text + " to JSON" + (op & 16 ? " string" : "");
+  }
+  let nonEmptyPath = error.path;
+  let tmp = nonEmptyPath === "" ? "" : " at " + nonEmptyPath;
+  return text + tmp + ": " + reason(error, undefined);
+}
+var globalConfig = {
+  m: message,
+  d: undefined,
+  a: "strip",
+  n: false
+};
+var shakenRef = "as";
+var shakenTraps = {
+  get: (target, prop) => {
+    let l = target[shakenRef];
+    if (l === undefined) {
+      return target[prop];
+    }
+    if (prop === shakenRef) {
+      return target[prop];
+    }
+    let l$1 = valFromOption(l);
+    let message2 = "Schema S." + l$1 + " is not enabled. To start using it, add S.enable" + capitalize(l$1) + "() at the project root.";
+    throw new Error("[Sury] " + message2);
+  }
+};
+function shaken(apiName) {
+  let mut = new Schema("never");
+  mut[shakenRef] = apiName;
+  return new Proxy(mut, shakenTraps);
+}
+var unknown = new Schema("unknown");
+var bool = new Schema("boolean");
+var symbol = new Schema("symbol");
+var string = new Schema("string");
+var int = new Schema("number");
+int.format = "int32";
+var float = new Schema("number");
+var bigint = new Schema("bigint");
+var unit = new Schema("undefined");
+unit.const = undefined;
+var copyWithoutCache = (schema) => {
+  let c = new Schema(schema.type);
+  for (let k in schema) {
+    if (k > "a" || k === "$ref" || k === "$defs") {
+      c[k] = schema[k];
+    }
+  }
+  return c;
+};
+function updateOutput(schema, fn) {
+  let root = copyWithoutCache(schema);
+  let mut = root;
+  while (mut.to) {
+    let next = copyWithoutCache(mut.to);
+    mut.to = next;
+    mut = next;
+  }
+  fn(mut);
+  return root;
+}
+var value = SuryError;
+function constructor(prim0, prim1, prim2) {
+  return new SuryError(prim0, prim1, prim2);
+}
+var ErrorClass = {
+  value,
+  constructor
+};
+function embed(b, value2) {
+  let e = b.g.e;
+  let l = e.length;
+  e[l] = value2;
+  return "e[" + l + "]";
+}
+function inlineConst(b, schema) {
+  let tagFlag = flags[schema.type];
+  let $$const = schema.const;
+  if (tagFlag & 16) {
+    return "void 0";
+  } else if (tagFlag & 2) {
+    return fromString($$const);
+  } else if (tagFlag & 1024) {
+    return $$const + "n";
+  } else if (tagFlag & 45056) {
+    return embed(b, schema.const);
+  } else {
+    return $$const;
+  }
+}
+function inlineLocation(b, location) {
+  let key = '"' + location + '"';
+  let i = b.g[key];
+  if (i !== undefined) {
+    return i;
+  }
+  let inlinedLocation = fromString(location);
+  b.g[key] = inlinedLocation;
+  return inlinedLocation;
+}
+function secondAllocate(v) {
+  let b = this;
+  b.l = b.l + "," + v;
+}
+function initialAllocate(v) {
+  let b = this;
+  b.l = v;
+  b.a = secondAllocate;
+}
+function rootScope(flag, defs) {
+  let global = {
+    c: "",
+    l: "",
+    a: initialAllocate,
+    v: -1,
+    o: flag,
+    f: "",
+    e: [],
+    d: defs
+  };
+  global.g = global;
+  return global;
+}
+function allocateScope(b) {
+  delete b.a;
+  let varsAllocation = b.l;
+  if (varsAllocation === "") {
+    return b.f + b.c;
+  } else {
+    return b.f + "let " + varsAllocation + ";" + b.c;
+  }
+}
+function varWithoutAllocation(global) {
+  let newCounter = global.v + 1;
+  global.v = newCounter;
+  return "v" + newCounter;
+}
+function _var(_b) {
+  return this.i;
+}
+function _notVar(b) {
+  let val = this;
+  let v = varWithoutAllocation(b.g);
+  let i = val.i;
+  if (i === "") {
+    val.b.a(v);
+  } else if (b.a !== undefined) {
+    b.a(v + "=" + i);
+  } else {
+    b.c = b.c + (v + "=" + i + ";");
+    b.g.a(v);
+  }
+  val.v = _var;
+  val.i = v;
+  return v;
+}
+function allocateVal(b, schema) {
+  let v = varWithoutAllocation(b.g);
+  b.a(v);
+  return {
+    b,
+    v: _var,
+    i: v,
+    f: 0,
+    type: schema.type
+  };
+}
+function val(b, initial, schema) {
+  return {
+    b,
+    v: _notVar,
+    i: initial,
+    f: 0,
+    type: schema.type
+  };
+}
+function constVal(b, schema) {
+  return {
+    b,
+    v: _notVar,
+    i: inlineConst(b, schema),
+    f: 0,
+    type: schema.type,
+    const: schema.const
+  };
+}
+function asyncVal(b, initial) {
+  return {
+    b,
+    v: _notVar,
+    i: initial,
+    f: 2,
+    type: "unknown"
+  };
+}
+function addKey(b, input, key, val2) {
+  return input.v(b) + "[" + key + "]=" + val2.i;
+}
+function set(b, input, val2) {
+  if (input === val2) {
+    return "";
+  }
+  let inputVar = input.v(b);
+  let match = input.f & 2;
+  let match$1 = val2.f & 2;
+  if (match) {
+    if (!match$1) {
+      return inputVar + "=Promise.resolve(" + val2.i + ")";
+    }
+  } else if (match$1) {
+    input.f = input.f | 2;
+    return inputVar + "=" + val2.i;
+  }
+  return inputVar + "=" + val2.i;
+}
+function setInlined(b, input, inlined) {
+  return input.v(b) + "=" + inlined;
+}
+function map(inlinedFn, input) {
+  return {
+    b: input.b,
+    v: _notVar,
+    i: inlinedFn + "(" + input.i + ")",
+    f: 0,
+    type: "unknown"
+  };
+}
+function $$throw(b, code, path) {
+  throw new SuryError(code, b.g.o, path);
+}
+function failWithArg(b, path, fn, arg) {
+  return embed(b, (arg2) => $$throw(b, fn(arg2), path)) + "(" + arg + ")";
+}
+function withPathPrepend(b, input, path, maybeDynamicLocationVar, appendSafe, fn) {
+  if (path === "" && maybeDynamicLocationVar === undefined) {
+    return fn(b, input, path);
+  }
+  try {
+    let $$catch = (b2, errorVar2) => {
+      b2.c = errorVar2 + ".path=" + fromString(path) + "+" + (maybeDynamicLocationVar !== undefined ? `'["'+` + maybeDynamicLocationVar + `+'"]'+` : "") + errorVar2 + ".path";
+    };
+    let fn$1 = (b2) => fn(b2, input, "");
+    let prevCode = b.c;
+    b.c = "";
+    let errorVar = varWithoutAllocation(b.g);
+    let maybeResolveVal = $$catch(b, errorVar);
+    let catchCode = "if(" + (errorVar + "&&" + errorVar + ".s===s") + "){" + b.c;
+    b.c = "";
+    let bb = {
+      c: "",
+      l: "",
+      a: initialAllocate,
+      f: "",
+      g: b.g
+    };
+    let fnOutput = fn$1(bb);
+    b.c = b.c + allocateScope(bb);
+    let isNoop = fnOutput.i === input.i && b.c === "";
+    if (appendSafe !== undefined) {
+      appendSafe(b, fnOutput);
+    }
+    if (isNoop) {
+      return fnOutput;
+    }
+    let isAsync = fnOutput.f & 2;
+    let output = input === fnOutput ? input : appendSafe !== undefined ? fnOutput : {
+      b,
+      v: _notVar,
+      i: "",
+      f: isAsync ? 2 : 0,
+      type: "unknown"
+    };
+    let catchCode$1 = maybeResolveVal !== undefined ? (catchLocation) => catchCode + (catchLocation === 1 ? "return " + maybeResolveVal.i : set(b, output, maybeResolveVal)) + ("}else{throw " + errorVar + "}") : (param) => catchCode + "}throw " + errorVar;
+    b.c = prevCode + ("try{" + b.c + (isAsync ? setInlined(b, output, fnOutput.i + ".catch(" + errorVar + "=>{" + catchCode$1(1) + "})") : set(b, output, fnOutput)) + "}catch(" + errorVar + "){" + catchCode$1(0) + "}");
+    return output;
+  } catch (exn) {
+    let error = getOrRethrow(exn);
+    throw new SuryError(error.code, error.flag, path + "[]" + error.path);
+  }
+}
+function validation(b, inputVar, schema, negative) {
+  let eq = negative ? "!==" : "===";
+  let and_ = negative ? "||" : "&&";
+  let exp = negative ? "!" : "";
+  let tag = schema.type;
+  let tagFlag = flags[tag];
+  if (tagFlag & 2048) {
+    return exp + ("Number.isNaN(" + inputVar + ")");
+  }
+  if (constField in schema) {
+    return inputVar + eq + inlineConst(b, schema);
+  }
+  if (tagFlag & 4) {
+    return "typeof " + inputVar + eq + '"' + tag + '"';
+  }
+  if (tagFlag & 64) {
+    return "typeof " + inputVar + eq + '"' + tag + '"' + and_ + exp + inputVar;
+  }
+  if (tagFlag & 128) {
+    return exp + "Array.isArray(" + inputVar + ")";
+  }
+  if (!(tagFlag & 8192)) {
+    return "typeof " + inputVar + eq + '"' + tag + '"';
+  }
+  let c = inputVar + " instanceof " + embed(b, schema.class);
+  if (negative) {
+    return "!(" + c + ")";
+  } else {
+    return c;
+  }
+}
+function refinement(b, inputVar, schema, negative) {
+  let eq = negative ? "!==" : "===";
+  let and_ = negative ? "||" : "&&";
+  let not_ = negative ? "" : "!";
+  let lt = negative ? ">" : "<";
+  let gt = negative ? "<" : ">";
+  let match = schema.type;
+  let tag;
+  let exit = 0;
+  let match$1 = schema.const;
+  if (match$1 !== undefined) {
+    return "";
+  }
+  let match$2 = schema.format;
+  if (match$2 !== undefined) {
+    switch (match$2) {
+      case "int32":
+        return and_ + inputVar + lt + "2147483647" + and_ + inputVar + gt + "-2147483648" + and_ + inputVar + "%1" + eq + "0";
+      case "port":
+      case "json":
+        exit = 2;
+        break;
+    }
+  } else {
+    exit = 2;
+  }
+  if (exit === 2) {
+    switch (match) {
+      case "number":
+        if (globalConfig.n) {
+          return "";
+        } else {
+          return and_ + not_ + "Number.isNaN(" + inputVar + ")";
+        }
+      case "array":
+      case "object":
+        tag = match;
+        break;
+      default:
+        return "";
+    }
+  }
+  let additionalItems = schema.additionalItems;
+  let items = schema.items;
+  let length = items.length;
+  let code = tag === "array" ? additionalItems === "strip" || additionalItems === "strict" ? additionalItems === "strip" ? and_ + inputVar + ".length" + gt + length : and_ + inputVar + ".length" + eq + length : "" : additionalItems === "strip" ? "" : and_ + not_ + "Array.isArray(" + inputVar + ")";
+  for (let idx = 0, idx_finish = items.length;idx < idx_finish; ++idx) {
+    let match$3 = items[idx];
+    let location = match$3.location;
+    let item = match$3.schema;
+    let itemCode;
+    if (constField in item || schema.unnest) {
+      let inlinedLocation = inlineLocation(b, location);
+      itemCode = validation(b, inputVar + ("[" + inlinedLocation + "]"), item, negative);
+    } else if (item.items) {
+      let inlinedLocation$1 = inlineLocation(b, location);
+      let inputVar$1 = inputVar + ("[" + inlinedLocation$1 + "]");
+      itemCode = validation(b, inputVar$1, item, negative) + refinement(b, inputVar$1, item, negative);
+    } else {
+      itemCode = "";
+    }
+    if (itemCode !== "") {
+      code = code + and_ + itemCode;
+    }
+  }
+  return code;
+}
+function makeRefinedOf(b, input, schema) {
+  let mut = {
+    b,
+    v: input.v,
+    i: input.i,
+    f: input.f,
+    type: schema.type
+  };
+  let loop = (mut2, schema2) => {
+    if (constField in schema2) {
+      mut2.const = schema2.const;
+    }
+    let items = schema2.items;
+    if (items === undefined) {
+      return;
+    }
+    let properties = {};
+    items.forEach((item) => {
+      let schema3 = item.schema;
+      let isConst = constField in schema3;
+      if (!(isConst || schema3.items)) {
+        return;
+      }
+      let tmp;
+      if (isConst) {
+        tmp = inlineConst(b, schema3);
+      } else {
+        let inlinedLocation = inlineLocation(b, item.location);
+        tmp = mut2.v(b) + ("[" + inlinedLocation + "]");
+      }
+      let mut$1 = {
+        b: mut2.b,
+        v: _notVar,
+        i: tmp,
+        f: 0,
+        type: schema3.type
+      };
+      loop(mut$1, schema3);
+      properties[item.location] = mut$1;
+    });
+    mut2.properties = properties;
+    mut2.additionalItems = unknown;
+  };
+  loop(mut, schema);
+  return mut;
+}
+function typeFilterCode(b, schema, input, path) {
+  if (schema.noValidation || flags[schema.type] & 17153) {
+    return "";
+  }
+  let inputVar = input.v(b);
+  return "if(" + validation(b, inputVar, schema, true) + refinement(b, inputVar, schema, true) + "){" + failWithArg(b, path, (input2) => ({
+    TAG: "InvalidType",
+    expected: schema,
+    received: input2
+  }), inputVar) + "}";
+}
+function unsupportedTransform(b, from, target, path) {
+  return $$throw(b, {
+    TAG: "UnsupportedTransformation",
+    from,
+    to: target
+  }, path);
+}
+function noopOperation(i) {
+  return i;
+}
+function setHas(has2, tag) {
+  has2[tag === "union" || tag === "ref" ? "unknown" : tag] = true;
+}
+var jsonName = "JSON";
+var jsonString = shaken("jsonString");
+function inputToString(b, input) {
+  return val(b, '""+' + input.i, string);
+}
+function parse(prevB, schema, inputArg, path) {
+  let b = {
+    c: "",
+    l: "",
+    a: initialAllocate,
+    f: "",
+    g: prevB.g
+  };
+  if (schema.$defs) {
+    b.g.d = schema.$defs;
+  }
+  let input = inputArg;
+  let isFromLiteral = constField in input;
+  let isSchemaLiteral = constField in schema;
+  let isSameTag = input.type === schema.type;
+  let schemaTagFlag = flags[schema.type];
+  let inputTagFlag = flags[input.type];
+  let isUnsupported = false;
+  if (!(schemaTagFlag & 257 || schema.format === "json")) {
+    if (schema.name === jsonName && !(inputTagFlag & 1)) {
+      if (!(inputTagFlag & 14)) {
+        if (inputTagFlag & 1024) {
+          input = inputToString(b, input);
+        } else {
+          isUnsupported = true;
+        }
+      }
+    } else if (isSchemaLiteral) {
+      if (isFromLiteral) {
+        if (input.const !== schema.const) {
+          input = constVal(b, schema);
+        }
+      } else if (inputTagFlag & 2 && schemaTagFlag & 3132) {
+        let inputVar = input.v(b);
+        b.f = schema.noValidation ? "" : input.i + '==="' + schema.const + '"||' + failWithArg(b, path, (input2) => ({
+          TAG: "InvalidType",
+          expected: schema,
+          received: input2
+        }), inputVar) + ";";
+        input = constVal(b, schema);
+      } else if (schema.noValidation) {
+        input = constVal(b, schema);
+      } else {
+        b.f = typeFilterCode(prevB, schema, input, path);
+        input.type = schema.type;
+        input.const = schema.const;
+      }
+    } else if (isFromLiteral && !isSchemaLiteral) {
+      if (!isSameTag) {
+        if (schemaTagFlag & 2 && inputTagFlag & 3132) {
+          let $$const = "" + input.const;
+          input = {
+            b,
+            v: _notVar,
+            i: '"' + $$const + '"',
+            f: 0,
+            type: "string",
+            const: $$const
+          };
+        } else {
+          isUnsupported = true;
+        }
+      }
+    } else if (inputTagFlag & 1) {
+      let ref = schema.$ref;
+      if (ref !== undefined) {
+        let defs = b.g.d;
+        let identifier = ref.slice(8);
+        let def = defs[identifier];
+        let flag = schema.noValidation ? (b.g.o | 1) ^ 1 : b.g.o;
+        let fn = def[flag];
+        let recOperation;
+        if (fn !== undefined) {
+          let fn$1 = valFromOption(fn);
+          recOperation = fn$1 === 0 ? embed(b, def) + ("[" + flag + "]") : embed(b, fn$1);
+        } else {
+          def[flag] = 0;
+          let fn$2 = internalCompile(def, flag, b.g.d);
+          def[flag] = fn$2;
+          recOperation = embed(b, fn$2);
+        }
+        input = withPathPrepend(b, input, path, undefined, undefined, (param, input2, param$1) => {
+          let output = map(recOperation, input2);
+          if (def.isAsync === undefined) {
+            let defsMut = copy(defs);
+            defsMut[identifier] = unknown;
+            isAsyncInternal(def, defsMut);
+          }
+          if (def.isAsync) {
+            output.f = output.f | 2;
+          }
+          return output;
+        });
+        input.v(b);
+      } else {
+        if (b.g.o & 1) {
+          b.f = typeFilterCode(prevB, schema, input, path);
+        }
+        let refined = makeRefinedOf(b, input, schema);
+        input.type = refined.type;
+        input.i = refined.i;
+        input.v = refined.v;
+        input.additionalItems = refined.additionalItems;
+        input.properties = refined.properties;
+        if (constField in refined) {
+          input.const = refined.const;
+        }
+      }
+    } else if (schemaTagFlag & 2 && inputTagFlag & 1036) {
+      input = inputToString(b, input);
+    } else if (!isSameTag) {
+      if (inputTagFlag & 2) {
+        let inputVar$1 = input.v(b);
+        if (schemaTagFlag & 8) {
+          let output = allocateVal(b, schema);
+          b.c = b.c + ("(" + output.i + "=" + inputVar$1 + '==="true")||' + inputVar$1 + '==="false"||' + failWithArg(b, path, (input2) => ({
+            TAG: "InvalidType",
+            expected: schema,
+            received: input2
+          }), inputVar$1) + ";");
+          input = output;
+        } else if (schemaTagFlag & 4) {
+          let output$1 = val(b, "+" + inputVar$1, schema);
+          let outputVar = output$1.v(b);
+          let match = schema.format;
+          b.c = b.c + (match !== undefined ? "(" + refinement(b, outputVar, schema, true).slice(2) + ")" : "Number.isNaN(" + outputVar + ")") + ("&&" + failWithArg(b, path, (input2) => ({
+            TAG: "InvalidType",
+            expected: schema,
+            received: input2
+          }), inputVar$1) + ";");
+          input = output$1;
+        } else if (schemaTagFlag & 1024) {
+          let output$2 = allocateVal(b, schema);
+          b.c = b.c + ("try{" + output$2.i + "=BigInt(" + inputVar$1 + ")}catch(_){" + failWithArg(b, path, (input2) => ({
+            TAG: "InvalidType",
+            expected: schema,
+            received: input2
+          }), inputVar$1) + "}");
+          input = output$2;
+        } else {
+          isUnsupported = true;
+        }
+      } else if (inputTagFlag & 4 && schemaTagFlag & 1024) {
+        input = val(b, "BigInt(" + input.i + ")", schema);
+      } else {
+        isUnsupported = true;
+      }
+    }
+  }
+  if (isUnsupported) {
+    unsupportedTransform(b, input, schema, path);
+  }
+  let compiler = schema.compiler;
+  if (compiler !== undefined) {
+    input = compiler(b, input, schema, path);
+  }
+  if (input.t !== true) {
+    let refiner = schema.refiner;
+    if (refiner !== undefined) {
+      b.c = b.c + refiner(b, input.v(b), schema, path);
+    }
+  }
+  let to = schema.to;
+  if (to !== undefined) {
+    let parser = schema.parser;
+    if (parser !== undefined) {
+      input = parser(b, input, schema, path);
+    }
+    if (input.t !== true) {
+      input = parse(b, to, input, path);
+    }
+  }
+  prevB.c = prevB.c + allocateScope(b);
+  return input;
+}
+function jsonableValidation(output, parent, path, flag) {
+  let tagFlag = flags[output.type];
+  if (tagFlag & 48129 || tagFlag & 16 && parent.type !== "object") {
+    throw new SuryError({
+      TAG: "InvalidJsonSchema",
+      _0: parent
+    }, flag, path);
+  }
+  if (tagFlag & 256) {
+    output.anyOf.forEach((s2) => jsonableValidation(s2, parent, path, flag));
+    return;
+  }
+  if (!(tagFlag & 192)) {
+    return;
+  }
+  let additionalItems = output.additionalItems;
+  if (additionalItems === "strip" || additionalItems === "strict")
+    ;
+  else {
+    jsonableValidation(additionalItems, parent, path, flag);
+  }
+  let p2 = output.properties;
+  if (p2 !== undefined) {
+    let keys = Object.keys(p2);
+    for (let idx = 0, idx_finish = keys.length;idx < idx_finish; ++idx) {
+      let key = keys[idx];
+      jsonableValidation(p2[key], parent, path, flag);
+    }
+    return;
+  }
+  output.items.forEach((item) => jsonableValidation(item.schema, output, path + ("[" + fromString(item.location) + "]"), flag));
+}
+function reverse(schema) {
+  let reversedHead;
+  let current = schema;
+  while (current) {
+    let mut = copyWithoutCache(current);
+    let next = mut.to;
+    let to = reversedHead;
+    if (to !== undefined) {
+      mut.to = to;
+    } else {
+      delete mut.to;
+    }
+    let parser = mut.parser;
+    let serializer = mut.serializer;
+    if (serializer !== undefined) {
+      mut.parser = serializer;
+    } else {
+      delete mut.parser;
+    }
+    if (parser !== undefined) {
+      mut.serializer = parser;
+    } else {
+      delete mut.serializer;
+    }
+    let fromDefault = mut.fromDefault;
+    let $$default = mut.default;
+    if ($$default !== undefined) {
+      mut.fromDefault = $$default;
+    } else {
+      delete mut.fromDefault;
+    }
+    if (fromDefault !== undefined) {
+      mut.default = fromDefault;
+    } else {
+      delete mut.default;
+    }
+    let items = mut.items;
+    if (items !== undefined) {
+      let properties = {};
+      let newItems = new Array(items.length);
+      for (let idx = 0, idx_finish = items.length;idx < idx_finish; ++idx) {
+        let item = items[idx];
+        let reversed_schema = reverse(item.schema);
+        let reversed_location = item.location;
+        let reversed = {
+          schema: reversed_schema,
+          location: reversed_location
+        };
+        if (item.r) {
+          reversed.r = item.r;
+        }
+        properties[item.location] = reversed_schema;
+        newItems[idx] = reversed;
+      }
+      mut.items = newItems;
+      let match = mut.properties;
+      if (match !== undefined) {
+        mut.properties = properties;
+      }
+    }
+    if (typeof mut.additionalItems === "object") {
+      mut.additionalItems = reverse(mut.additionalItems);
+    }
+    let anyOf = mut.anyOf;
+    if (anyOf !== undefined) {
+      let has2 = {};
+      let newAnyOf = [];
+      for (let idx$1 = 0, idx_finish$1 = anyOf.length;idx$1 < idx_finish$1; ++idx$1) {
+        let s2 = anyOf[idx$1];
+        let reversed$1 = reverse(s2);
+        newAnyOf.push(reversed$1);
+        setHas(has2, reversed$1.type);
+      }
+      mut.has = has2;
+      mut.anyOf = newAnyOf;
+    }
+    let defs = mut.$defs;
+    if (defs !== undefined) {
+      let reversedDefs = {};
+      for (let idx$2 = 0, idx_finish$2 = Object.keys(defs).length;idx$2 < idx_finish$2; ++idx$2) {
+        let key = Object.keys(defs)[idx$2];
+        reversedDefs[key] = reverse(defs[key]);
+      }
+      mut.$defs = reversedDefs;
+    }
+    reversedHead = mut;
+    current = next;
+  }
+  return reversedHead;
+}
+function internalCompile(schema, flag, defs) {
+  let b = rootScope(flag, defs);
+  if (flag & 8) {
+    let output = reverse(schema);
+    jsonableValidation(output, output, "", flag);
+  }
+  let input = {
+    b,
+    v: _var,
+    i: "i",
+    f: 0,
+    type: "unknown"
+  };
+  let schema$1 = flag & 4 ? updateOutput(schema, (mut) => {
+    let t = new Schema(unit.type);
+    t.const = unit.const;
+    t.noValidation = true;
+    mut.to = t;
+  }) : flag & 16 ? updateOutput(schema, (mut) => {
+    mut.to = jsonString;
+  }) : schema;
+  let output$1 = parse(b, schema$1, input, "");
+  let code = allocateScope(b);
+  let isAsync = has(output$1.f, 2);
+  schema$1.isAsync = isAsync;
+  if (code === "" && output$1 === input && !(flag & 2)) {
+    return noopOperation;
+  }
+  let inlinedOutput = output$1.i;
+  if (flag & 2 && !isAsync && !defs) {
+    inlinedOutput = "Promise.resolve(" + inlinedOutput + ")";
+  }
+  let inlinedFunction = "i=>{" + code + "return " + inlinedOutput + "}";
+  let ctxVarValue1 = b.g.e;
+  return new Function("e", "s", "return " + inlinedFunction)(ctxVarValue1, s);
+}
+function isAsyncInternal(schema, defs) {
+  try {
+    let b = rootScope(2, defs);
+    let input = {
+      b,
+      v: _var,
+      i: "i",
+      f: 0,
+      type: "unknown"
+    };
+    let output = parse(b, schema, input, "");
+    let isAsync = has(output.f, 2);
+    schema.isAsync = isAsync;
+    return isAsync;
+  } catch (exn) {
+    getOrRethrow(exn);
+    return false;
+  }
+}
+function operationFn(s2, o) {
+  if (o in s2) {
+    return s2[o];
+  }
+  let f = internalCompile(o & 32 ? reverse(s2) : s2, o, 0);
+  s2[o] = f;
+  return f;
+}
+d(sp, "~standard", {
+  get: function() {
+    let schema = this;
+    return {
+      version: 1,
+      vendor,
+      validate: (input) => {
+        try {
+          return {
+            value: operationFn(schema, 1)(input)
+          };
+        } catch (exn) {
+          let error = getOrRethrow(exn);
+          return {
+            issues: [{
+              message: reason(error, undefined),
+              path: error.path === "" ? undefined : toArray(error.path)
+            }]
+          };
+        }
+      }
+    };
+  }
+});
+function parseOrThrow(any, schema) {
+  return operationFn(schema, 1)(any);
+}
+var $$null = new Schema("null");
+$$null.const = null;
+function wrapExnToFailure(exn) {
+  if (exn && exn.s === s) {
+    return {
+      success: false,
+      error: exn
+    };
+  }
+  throw exn;
+}
+function js_safe(fn) {
+  try {
+    return {
+      success: true,
+      value: fn()
+    };
+  } catch (exn) {
+    return wrapExnToFailure(exn);
+  }
+}
+var nullAsUnit = new Schema("null");
+nullAsUnit.const = null;
+nullAsUnit.to = unit;
+function neverBuilder(b, input, selfSchema, path) {
+  b.c = b.c + failWithArg(b, path, (input2) => ({
+    TAG: "InvalidType",
+    expected: selfSchema,
+    received: input2
+  }), input.i) + ";";
+  return input;
+}
+var never = new Schema("never");
+never.compiler = neverBuilder;
+function arrayCompiler(b, input, selfSchema, path) {
+  let item = selfSchema.additionalItems;
+  let inputVar = input.v(b);
+  let iteratorVar = varWithoutAllocation(b.g);
+  let bb = {
+    c: "",
+    l: "",
+    a: initialAllocate,
+    f: "",
+    g: b.g
+  };
+  let itemInput = val(bb, inputVar + "[" + iteratorVar + "]", unknown);
+  let itemOutput = withPathPrepend(bb, itemInput, path, iteratorVar, undefined, (b2, input2, path2) => parse(b2, item, input2, path2));
+  let itemCode = allocateScope(bb);
+  let isTransformed = itemInput !== itemOutput;
+  let output = isTransformed ? val(b, "new Array(" + inputVar + ".length)", selfSchema) : input;
+  output.type = selfSchema.type;
+  output.additionalItems = selfSchema.additionalItems;
+  if (isTransformed || itemCode !== "") {
+    b.c = b.c + ("for(let " + iteratorVar + "=0;" + iteratorVar + "<" + inputVar + ".length;++" + iteratorVar + "){" + itemCode + (isTransformed ? addKey(b, output, iteratorVar, itemOutput) : "") + "}");
+  }
+  if (itemOutput.f & 2) {
+    return asyncVal(output.b, "Promise.all(" + output.i + ")");
+  } else {
+    return output;
+  }
+}
+function factory$2(item) {
+  let mut = new Schema("array");
+  mut.additionalItems = item;
+  mut.items = immutableEmpty$1;
+  mut.compiler = arrayCompiler;
+  return mut;
+}
+var json = shaken("json");
+var array = factory$2;
+
+// node_modules/sury/src/S.mjs
+var Error2 = ErrorClass.value;
+var string2 = string;
+var number = float;
+var array2 = array;
+var safe = js_safe;
+var parseOrThrow2 = parseOrThrow;
+
+// src/rules/use-exhaustive-dependencies.ts
+var FUNCTION_DECLARATIONS = new Set([
+  import_types.TSESTree.AST_NODE_TYPES.FunctionExpression,
+  import_types.TSESTree.AST_NODE_TYPES.ArrowFunctionExpression,
+  import_types.TSESTree.AST_NODE_TYPES.FunctionDeclaration
+]);
+var UNSTABLE_VALUES = new Set([
+  ...FUNCTION_DECLARATIONS,
+  import_types.TSESTree.AST_NODE_TYPES.ObjectExpression,
+  import_types.TSESTree.AST_NODE_TYPES.ArrayExpression
+]);
+var testingMetrics = {
+  moduleLevelStableConst: 0,
+  outerScopeSkip: 0
+};
+var DEFAULT_HOOKS = new Map([
+  ["useEffect", { closureIndex: 0, dependenciesIndex: 1 }],
+  ["useLayoutEffect", { closureIndex: 0, dependenciesIndex: 1 }],
+  ["useInsertionEffect", { closureIndex: 0, dependenciesIndex: 1 }],
+  ["useCallback", { closureIndex: 0, dependenciesIndex: 1 }],
+  ["useMemo", { closureIndex: 0, dependenciesIndex: 1 }],
+  ["useImperativeHandle", { closureIndex: 1, dependenciesIndex: 2 }],
+  ["useSpring", { closureIndex: 0, dependenciesIndex: 1 }],
+  ["useSprings", { closureIndex: 1, dependenciesIndex: 2 }],
+  ["useTrail", { closureIndex: 1, dependenciesIndex: 2 }]
+]);
+var STABLE_HOOKS = new Map([
+  ["useState", new Set([1])],
+  ["useReducer", new Set([1])],
+  ["useTransition", new Set([1])],
+  ["useRef", true],
+  ["useBinding", true]
+]);
+var STABLE_VALUE_TYPES = new Set(["ImportBinding", "FunctionDeclaration", "ClassDeclaration", "FunctionName"]);
+var GLOBAL_BUILTINS = new Set([
+  "undefined",
+  "null",
+  "Infinity",
+  "NaN",
+  "Array",
+  "Object",
+  "String",
+  "Number",
+  "Boolean",
+  "Symbol",
+  "BigInt",
+  "Function",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Promise",
+  "Date",
+  "RegExp",
+  "Error",
+  "Math",
+  "JSON",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "encodeURI",
+  "encodeURIComponent",
+  "decodeURI",
+  "decodeURIComponent",
+  "ReadonlyArray",
+  "ReadonlyMap",
+  "ReadonlySet",
+  "Partial",
+  "Required",
+  "Readonly",
+  "Pick",
+  "Omit",
+  "Exclude",
+  "Extract",
+  "Record",
+  "NonNullable",
+  "ReturnType",
+  "InstanceType",
+  "Parameters",
+  "console",
+  "setTimeout",
+  "setInterval",
+  "clearTimeout",
+  "clearInterval",
+  "Element",
+  "Node",
+  "Document",
+  "Window",
+  "Event"
+]);
+function getHookName(node) {
+  const { callee } = node;
+  if (callee.type === "Identifier") {
+    return callee.name;
+  }
+  if (callee.type === "MemberExpression" && callee.property.type === "Identifier") {
+    return callee.property.name;
+  }
+  return;
+}
+function getMemberExpressionDepth(node) {
+  let depth = 0;
+  let current = node;
+  while (current.type === "MemberExpression") {
+    depth += 1;
+    current = current.object;
+  }
+  return depth;
+}
+function getRootIdentifier(node) {
+  let current = node;
+  while (current.type === "MemberExpression")
+    current = current.object;
+  return current.type === "Identifier" ? current : undefined;
+}
+function nodeToDependencyString(node, sourceCode) {
+  return sourceCode.getText(node);
+}
+function isStableArrayIndex(stableResult, node, identifierName) {
+  if (!stableResult)
+    return false;
+  if (!(stableResult instanceof Set) || node.type !== "VariableDeclarator" || node.id.type !== "ArrayPattern")
+    return false;
+  const elements = node.id.elements;
+  for (let index = 0;index < elements.length; index += 1) {
+    const element = elements[index];
+    if (element?.type === "Identifier" && element.name === identifierName)
+      return stableResult.has(index);
+  }
+  return false;
+}
+function isStableHookValue(init, node, identifierName, stableHooks) {
+  const initNode = init;
+  if (initNode.type !== "CallExpression")
+    return false;
+  const hookName = getHookName(initNode);
+  if (!hookName)
+    return false;
+  const stableResult = stableHooks.get(hookName);
+  if (stableResult === true)
+    return true;
+  return isStableArrayIndex(stableResult, node, identifierName);
+}
+function isStableValue(variable, identifierName, stableHooks) {
+  if (!variable)
+    return false;
+  const { defs } = variable;
+  if (defs.length === 0)
+    return false;
+  for (const def of defs) {
+    const { node, type } = def;
+    if (STABLE_VALUE_TYPES.has(type))
+      return true;
+    if (type === "Variable" && node.type === "VariableDeclarator") {
+      const parent = node.parent;
+      if (!parent || parent.type !== "VariableDeclaration" || parent.kind !== "const")
+        continue;
+      const { init } = node;
+      if (init && isStableHookValue(init, node, identifierName, stableHooks))
+        return true;
+      if (init?.type === "CallExpression") {
+        const { callee } = init;
+        if (callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "React" && callee.property.type === "Identifier" && callee.property.name === "joinBindings")
+          return true;
+        if (callee.type === "MemberExpression" && callee.property.type === "Identifier" && callee.property.name === "map")
+          return true;
+      }
+      if (init) {
+        if (init.type === "Literal" || init.type === "TemplateLiteral")
+          return true;
+        if (init.type === "UnaryExpression" && init.argument.type === "Literal")
+          return true;
+      }
+      const varDef = variable.defs.find((d2) => d2.node === node);
+      if (varDef && varDef.node.type === "VariableDeclarator") {
+        const declParent = varDef.node.parent?.parent;
+        if (declParent && (declParent.type === "Program" || declParent.type === "ExportNamedDeclaration")) {
+          testingMetrics.moduleLevelStableConst += 1;
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function findTopmostMemberExpression(node) {
+  let current = node;
+  let parent = node.parent;
+  while (parent?.type === "MemberExpression" && parent.object === current) {
+    current = parent;
+    parent = parent.parent;
+  }
+  return current;
+}
+var IS_CEASE_BOUNDARY = new Set([
+  import_types.TSESTree.AST_NODE_TYPES.FunctionDeclaration,
+  import_types.TSESTree.AST_NODE_TYPES.FunctionExpression,
+  import_types.TSESTree.AST_NODE_TYPES.ArrowFunctionExpression,
+  import_types.TSESTree.AST_NODE_TYPES.VariableDeclarator
+]);
+function isInTypePosition(identifier) {
+  let parent = identifier.parent;
+  while (parent) {
+    if (parent.type.startsWith("TS"))
+      return true;
+    if (IS_CEASE_BOUNDARY.has(parent.type))
+      return false;
+    parent = parent.parent;
+  }
+  return false;
+}
+function isDeclaredInComponentBody(variable, closureNode) {
+  let parent = closureNode.parent;
+  while (parent) {
+    const isFunction = FUNCTION_DECLARATIONS.has(parent.type);
+    if (isFunction) {
+      const functionParent = parent;
+      const isParameter = variable.defs.some((def) => {
+        if (def.type !== "Parameter")
+          return false;
+        return def.node === functionParent;
+      });
+      if (isParameter)
+        return true;
+      return variable.defs.some((def) => {
+        let node = def.node.parent;
+        while (node && node !== functionParent)
+          node = node.parent;
+        return node === functionParent;
+      });
+    }
+    parent = parent.parent;
+  }
+  return false;
+}
+function resolveFunctionReference(identifier, scope) {
+  let variable;
+  let currentScope = scope;
+  while (currentScope) {
+    variable = currentScope.set.get(identifier.name);
+    if (variable)
+      break;
+    currentScope = currentScope.upper;
+  }
+  if (!variable || variable.defs.length === 0)
+    return;
+  for (const def of variable.defs) {
+    const { node } = def;
+    if (node.type === "FunctionDeclaration")
+      return node;
+    if (node.type === "VariableDeclarator" && node.init && (node.init.type === "ArrowFunctionExpression" || node.init.type === "FunctionExpression"))
+      return node.init;
+  }
+  return;
+}
+function collectCaptures(node, scope, sourceCode) {
+  const captures = new Array;
+  const captureSet = new Set;
+  function visit(current) {
+    if (current.type === "Identifier") {
+      const { name } = current;
+      if (captureSet.has(name))
+        return;
+      if (GLOBAL_BUILTINS.has(name))
+        return;
+      if (isInTypePosition(current))
+        return;
+      let variable;
+      let currentScope = scope;
+      while (currentScope) {
+        variable = currentScope.set.get(name);
+        if (variable)
+          break;
+        currentScope = currentScope.upper;
+      }
+      if (variable) {
+        const isDefinedInClosure = variable.defs.some((def) => {
+          let defNode = def.node;
+          while (defNode) {
+            if (defNode === node)
+              return true;
+            defNode = defNode.parent;
+          }
+          return false;
+        });
+        if (!isDefinedInClosure) {
+          if (!isDeclaredInComponentBody(variable, node)) {
+            testingMetrics.outerScopeSkip += 1;
+            return;
+          }
+          captureSet.add(name);
+          const depthNode = findTopmostMemberExpression(current);
+          const usagePath = sourceCode.getText(depthNode);
+          captures.push({
+            depth: getMemberExpressionDepth(depthNode),
+            name,
+            node: depthNode,
+            usagePath,
+            variable
+          });
+        }
+      }
+    }
+    if (current.type === "TSSatisfiesExpression" || current.type === "TSAsExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression") {
+      visit(current.expression);
+      return;
+    }
+    if (current.type === "MemberExpression") {
+      visit(current.object);
+      if (current.computed)
+        visit(current.property);
+      return;
+    }
+    const keys = sourceCode.visitorKeys?.[current.type] || [];
+    for (const key of keys) {
+      const value2 = current[key];
+      if (Array.isArray(value2)) {
+        for (const item of value2)
+          if (item && typeof item === "object" && "type" in item)
+            visit(item);
+      } else if (value2 && typeof value2 === "object" && "type" in value2)
+        visit(value2);
+    }
+  }
+  visit(node);
+  return captures;
+}
+function parseDependencies(node, sourceCode) {
+  const dependencies = new Array;
+  for (const element of node.elements) {
+    if (!element || element.type === "SpreadElement")
+      continue;
+    const name = nodeToDependencyString(element, sourceCode);
+    const depth = getMemberExpressionDepth(element);
+    dependencies.push({
+      depth,
+      name,
+      node: element
+    });
+  }
+  return dependencies;
+}
+function isUnstableValue(node) {
+  return node ? UNSTABLE_VALUES.has(node.type) : false;
+}
+var isNumberArray = array2(number);
+var isStringArray2 = array2(string2);
+function validate(validator, value2) {
+  return safe(() => parseOrThrow2(value2, validator)).success;
+}
+function convertStableResult(stableResult) {
+  if (typeof stableResult === "boolean")
+    return stableResult;
+  if (typeof stableResult === "number")
+    return new Set([stableResult]);
+  if (validate(isNumberArray, stableResult) && stableResult.length > 0)
+    return new Set(stableResult);
+  if (validate(isStringArray2, stableResult) && stableResult.length > 0)
+    return new Set(stableResult);
+  return false;
+}
+var useExhaustiveDependencies = {
+  create(context) {
+    const options = {
+      hooks: [],
+      reportMissingDependenciesArray: true,
+      reportUnnecessaryDependencies: true,
+      ...context.options[0]
+    };
+    const hookConfigs = new Map(DEFAULT_HOOKS);
+    for (const customHook of options.hooks) {
+      if (customHook.closureIndex !== undefined && customHook.dependenciesIndex !== undefined) {
+        hookConfigs.set(customHook.name, {
+          closureIndex: customHook.closureIndex,
+          dependenciesIndex: customHook.dependenciesIndex
+        });
+      }
+    }
+    const stableHooks = new Map(STABLE_HOOKS);
+    for (const customHook of options.hooks) {
+      if (customHook.stableResult !== undefined) {
+        stableHooks.set(customHook.name, convertStableResult(customHook.stableResult));
+      }
+    }
+    const scopeCache = new WeakMap;
+    function getScope(node) {
+      const cached = scopeCache.get(node);
+      if (cached)
+        return cached;
+      const scope = context.sourceCode.getScope(node);
+      scopeCache.set(node, scope);
+      return scope;
+    }
+    return {
+      CallExpression(node) {
+        const callNode = node;
+        const hookName = getHookName(callNode);
+        if (!hookName)
+          return;
+        const hookConfig = hookConfigs.get(hookName);
+        if (!hookConfig)
+          return;
+        const { closureIndex, dependenciesIndex } = hookConfig;
+        const { arguments: args } = callNode;
+        const closureArg = args[closureIndex];
+        if (!closureArg)
+          return;
+        let closureFunction;
+        if (closureArg.type === "ArrowFunctionExpression" || closureArg.type === "FunctionExpression") {
+          closureFunction = closureArg;
+        } else if (closureArg.type === "Identifier") {
+          const scope2 = getScope(callNode);
+          closureFunction = resolveFunctionReference(closureArg, scope2);
+        }
+        if (!closureFunction)
+          return;
+        const dependenciesArgument = args[dependenciesIndex];
+        if (!dependenciesArgument && options.reportMissingDependenciesArray) {
+          const scope2 = getScope(closureFunction);
+          const captures2 = collectCaptures(closureFunction, scope2, context.sourceCode);
+          const requiredCaptures = captures2.filter((capture) => !isStableValue(capture.variable, capture.name, stableHooks));
+          if (requiredCaptures.length > 0) {
+            const missingNames = Array.from(new Set(requiredCaptures.map(({ name }) => name))).join(", ");
+            const usagePaths = requiredCaptures.map(({ usagePath }) => usagePath);
+            const uniqueDeps = Array.from(new Set(usagePaths)).toSorted();
+            const depsArrayString = `[${uniqueDeps.join(", ")}]`;
+            context.report({
+              data: { deps: missingNames },
+              messageId: "missingDependenciesArray",
+              node: callNode,
+              suggest: [
+                {
+                  desc: `Add dependencies array: ${depsArrayString}`,
+                  fix(fixer) {
+                    const closureArgNode = args[closureIndex];
+                    return fixer.insertTextAfter(closureArgNode, `, ${depsArrayString}`);
+                  }
+                }
+              ]
+            });
+          }
+          return;
+        }
+        if (!dependenciesArgument)
+          return;
+        if (dependenciesArgument.type !== "ArrayExpression")
+          return;
+        const depsArray = dependenciesArgument;
+        const scope = getScope(closureFunction);
+        const captures = collectCaptures(closureFunction, scope, context.sourceCode);
+        const dependencies = parseDependencies(depsArray, context.sourceCode);
+        for (const dependency of dependencies) {
+          const dependencyRootIdentifier = getRootIdentifier(dependency.node);
+          if (!dependencyRootIdentifier)
+            continue;
+          const dependencyName = dependencyRootIdentifier.name;
+          const matchingCaptures = captures.filter(({ node: node2 }) => getRootIdentifier(node2)?.name === dependencyName);
+          if (matchingCaptures.length === 0) {
+            if (options.reportUnnecessaryDependencies) {
+              const newDeps = dependencies.filter((d2) => d2.name !== dependency.name).map((d2) => d2.name);
+              const newDepsString = `[${newDeps.join(", ")}]`;
+              context.report({
+                data: { name: dependency.name },
+                messageId: "unnecessaryDependency",
+                node: dependency.node,
+                suggest: [
+                  {
+                    desc: `Remove '${dependency.name}' from dependencies array`,
+                    fix(fixer) {
+                      return fixer.replaceText(depsArray, newDepsString);
+                    }
+                  }
+                ]
+              });
+            }
+            continue;
+          }
+          const maxCaptureDepth = Math.max(...matchingCaptures.map((c) => c.depth));
+          if (dependency.depth > maxCaptureDepth && options.reportUnnecessaryDependencies) {
+            const newDeps = dependencies.filter((d2) => d2.name !== dependency.name).map((d2) => d2.name);
+            const newDepsString = `[${newDeps.join(", ")}]`;
+            context.report({
+              data: { name: dependency.name },
+              messageId: "unnecessaryDependency",
+              node: dependency.node,
+              suggest: [
+                {
+                  desc: `Remove '${dependency.name}' from dependencies array`,
+                  fix(fixer) {
+                    return fixer.replaceText(depsArray, newDepsString);
+                  }
+                }
+              ]
+            });
+          }
+        }
+        for (const capture of captures) {
+          if (isStableValue(capture.variable, capture.name, stableHooks))
+            continue;
+          const rootIdentifier = getRootIdentifier(capture.node);
+          if (!rootIdentifier)
+            continue;
+          const captureName = rootIdentifier.name;
+          let isInDependencies = false;
+          for (const dependency of dependencies) {
+            const dependencyRootIdentifier = getRootIdentifier(dependency.node);
+            if (dependencyRootIdentifier?.name === captureName && dependency.depth <= capture.depth) {
+              isInDependencies = true;
+              break;
+            }
+          }
+          if (!isInDependencies) {
+            const lastDependency = dependencies.at(-1);
+            const dependencyNames = dependencies.map(({ name }) => name);
+            const newDependencies = [...dependencyNames, capture.usagePath].toSorted();
+            const newDependenciesString = `[${newDependencies.join(", ")}]`;
+            context.report({
+              data: { name: capture.usagePath },
+              messageId: "missingDependency",
+              node: lastDependency?.node || depsArray,
+              suggest: [
+                {
+                  desc: `Add '${capture.usagePath}' to dependencies array`,
+                  fix(fixer) {
+                    return fixer.replaceText(depsArray, newDependenciesString);
+                  }
+                }
+              ]
+            });
+          }
+        }
+        for (const capture of captures) {
+          if (isStableValue(capture.variable, capture.name, stableHooks))
+            continue;
+          const rootIdentifier = getRootIdentifier(capture.node);
+          if (!rootIdentifier)
+            continue;
+          const captureName = rootIdentifier.name;
+          for (const dependency of dependencies) {
+            const dependencyRootIdentifier = getRootIdentifier(dependency.node);
+            const isMatch = dependencyRootIdentifier?.name === captureName && dependency.depth === capture.depth;
+            const isDirectIdentifier = dependency.depth === 0;
+            if (isMatch && isDirectIdentifier) {
+              const variableDefinition = capture.variable?.defs[0];
+              const initialNode = variableDefinition?.node.type === "VariableDeclarator" ? variableDefinition.node.init ?? undefined : undefined;
+              if (isUnstableValue(initialNode)) {
+                context.report({
+                  data: { name: capture.usagePath },
+                  messageId: "unstableDependency",
+                  node: dependency.node
+                });
+              }
+              break;
+            }
+            if (isMatch)
+              break;
+          }
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce exhaustive and correct dependency specification in React hooks to prevent stale closures and unnecessary re-renders",
+      recommended: true,
+      url: "https://biomejs.dev/linter/rules/use-exhaustive-dependencies/"
+    },
+    fixable: "code",
+    hasSuggestions: true,
+    messages: {
+      missingDependenciesArray: "This hook does not specify its dependencies array. Missing: {{deps}}",
+      missingDependency: "This hook does not specify its dependency on {{name}}.",
+      unnecessaryDependency: "This dependency {{name}} can be removed from the list.",
+      unstableDependency: "{{name}} changes on every re-render. Wrap the definition in useCallback() or useMemo() to stabilize it."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          hooks: {
+            description: "Array of custom hook entries to check for exhaustive dependencies",
+            items: {
+              additionalProperties: false,
+              properties: {
+                closureIndex: {
+                  description: "Index of the closure argument for dependency validation",
+                  type: "number"
+                },
+                dependenciesIndex: {
+                  description: "Index of the dependencies array for validation",
+                  type: "number"
+                },
+                name: {
+                  description: "The name of the hook",
+                  type: "string"
+                },
+                stableResult: {
+                  description: "Specify stable results: true (whole result), number (array index), number[] (multiple indices), or string[] (object properties)",
+                  oneOf: [
+                    { type: "boolean" },
+                    { type: "number" },
+                    { items: { type: "number" }, type: "array" },
+                    { items: { type: "string" }, type: "array" }
+                  ]
+                }
+              },
+              required: ["name"],
+              type: "object"
+            },
+            type: "array"
+          },
+          reportMissingDependenciesArray: {
+            default: true,
+            description: "Report when the dependencies array is completely missing",
+            type: "boolean"
+          },
+          reportUnnecessaryDependencies: {
+            default: true,
+            description: "Report when unnecessary dependencies are specified",
+            type: "boolean"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  }
+};
+var use_exhaustive_dependencies_default = useExhaustiveDependencies;
+
+// src/rules/use-hook-at-top-level.ts
+var import_types2 = __toESM(require_dist(), 1);
+var HOOK_NAME_PATTERN = /^use[A-Z]/;
+var COMPONENT_NAME_PATTERN = /^[A-Z]/;
+function isReactHook(name) {
+  return HOOK_NAME_PATTERN.test(name);
+}
+function isComponent(name) {
+  return COMPONENT_NAME_PATTERN.test(name);
+}
+function isComponentOrHook(node) {
+  if (node.type === "FunctionDeclaration" && node.id) {
+    const { name } = node.id;
+    return isComponent(name) || isReactHook(name);
+  }
+  if (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+    const { parent } = node;
+    if (!parent)
+      return false;
+    if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier") {
+      const { name } = parent.id;
+      return isComponent(name) || isReactHook(name);
+    }
+    if (parent.type === "Property" && parent.key.type === "Identifier") {
+      const { name } = parent.key;
+      return isComponent(name) || isReactHook(name);
+    }
+    if (parent.type === "MethodDefinition" && parent.key.type === "Identifier") {
+      const { name } = parent.key;
+      return isComponent(name) || isReactHook(name);
+    }
+  }
+  return false;
+}
+function isHookCall(node) {
+  const { callee } = node;
+  if (callee.type === "Identifier")
+    return isReactHook(callee.name);
+  if (callee.type === "MemberExpression" && callee.property.type === "Identifier")
+    return isReactHook(callee.property.name);
+  return false;
+}
+var FUNCTION_BOUNDARIES = new Set([
+  import_types2.TSESTree.AST_NODE_TYPES.FunctionDeclaration,
+  import_types2.TSESTree.AST_NODE_TYPES.FunctionExpression,
+  import_types2.TSESTree.AST_NODE_TYPES.ArrowFunctionExpression
+]);
+function isInFinallyBlock(node) {
+  let current = node.parent;
+  const maxDepth = 20;
+  for (let depth = 0;depth < maxDepth && current; depth++) {
+    if (FUNCTION_BOUNDARIES.has(current.type))
+      return false;
+    if (current.type === "TryStatement") {
+      let checkNode = node;
+      while (checkNode && checkNode !== current) {
+        if (checkNode === current.finalizer)
+          return true;
+        checkNode = checkNode.parent;
+      }
+      return false;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function isRecursiveCall(node, functionName) {
+  if (!functionName)
+    return false;
+  const { callee } = node;
+  if (callee.type === "Identifier")
+    return callee.name === functionName;
+  return false;
+}
+var useHookAtTopLevel = {
+  create(context) {
+    const contextStack = new Array;
+    let currentFunctionName;
+    function getCurrentContext() {
+      return contextStack.length > 0 ? contextStack.at(-1) : undefined;
+    }
+    function pushContext(newContext) {
+      contextStack.push(newContext);
+    }
+    function popContext() {
+      contextStack.pop();
+    }
+    function updateContext(updates) {
+      const current = getCurrentContext();
+      if (!current)
+        return;
+      contextStack[contextStack.length - 1] = {
+        ...current,
+        ...updates
+      };
+    }
+    function handleFunctionEnter(node) {
+      const funcNode = node;
+      const current = getCurrentContext();
+      const depth = current ? current.functionDepth + 1 : 0;
+      const isComp = isComponentOrHook(funcNode);
+      if (funcNode.type === "FunctionDeclaration" && funcNode.id)
+        currentFunctionName = funcNode.id.name;
+      if (current?.isComponentOrHook) {
+        pushContext({
+          afterEarlyReturn: false,
+          functionDepth: depth,
+          inConditional: false,
+          inLoop: false,
+          inNestedFunction: true,
+          inTryBlock: false,
+          isComponentOrHook: false
+        });
+      } else if (isComp) {
+        pushContext({
+          afterEarlyReturn: false,
+          functionDepth: depth,
+          inConditional: false,
+          inLoop: false,
+          inNestedFunction: false,
+          inTryBlock: false,
+          isComponentOrHook: true
+        });
+      }
+    }
+    function handleFunctionExit() {
+      const current = getCurrentContext();
+      if (current)
+        popContext();
+      currentFunctionName = undefined;
+    }
+    return {
+      ArrowFunctionExpression: handleFunctionEnter,
+      "ArrowFunctionExpression:exit": handleFunctionExit,
+      CallExpression(node) {
+        const callNode = node;
+        if (!isHookCall(callNode))
+          return;
+        const current = getCurrentContext();
+        if (!current)
+          return;
+        if (!current.isComponentOrHook && !current.inNestedFunction)
+          return;
+        if (isInFinallyBlock(callNode))
+          return;
+        if (isRecursiveCall(callNode, currentFunctionName)) {
+          context.report({
+            messageId: "recursiveHookCall",
+            node: callNode
+          });
+          return;
+        }
+        if (current.inNestedFunction) {
+          context.report({
+            messageId: "nestedFunction",
+            node: callNode
+          });
+          return;
+        }
+        if (current.inConditional) {
+          context.report({
+            messageId: "conditionalHook",
+            node: callNode
+          });
+          return;
+        }
+        if (current.inLoop) {
+          context.report({
+            messageId: "loopHook",
+            node: callNode
+          });
+          return;
+        }
+        if (current.inTryBlock) {
+          context.report({
+            messageId: "tryBlockHook",
+            node: callNode
+          });
+          return;
+        }
+        if (current.afterEarlyReturn) {
+          context.report({
+            messageId: "afterEarlyReturn",
+            node: callNode
+          });
+        }
+      },
+      ConditionalExpression() {
+        updateContext({ inConditional: true });
+      },
+      "ConditionalExpression:exit"() {
+        updateContext({ inConditional: false });
+      },
+      DoWhileStatement() {
+        updateContext({ inLoop: true });
+      },
+      "DoWhileStatement:exit"() {
+        updateContext({ inLoop: false });
+      },
+      ForInStatement() {
+        updateContext({ inLoop: true });
+      },
+      "ForInStatement:exit"() {
+        updateContext({ inLoop: false });
+      },
+      ForOfStatement() {
+        updateContext({ inLoop: true });
+      },
+      "ForOfStatement:exit"() {
+        updateContext({ inLoop: false });
+      },
+      ForStatement() {
+        updateContext({ inLoop: true });
+      },
+      "ForStatement:exit"() {
+        updateContext({ inLoop: false });
+      },
+      FunctionDeclaration: handleFunctionEnter,
+      "FunctionDeclaration:exit": handleFunctionExit,
+      FunctionExpression: handleFunctionEnter,
+      "FunctionExpression:exit": handleFunctionExit,
+      IfStatement() {
+        updateContext({ inConditional: true });
+      },
+      "IfStatement:exit"() {
+        updateContext({ inConditional: false });
+      },
+      LogicalExpression() {
+        updateContext({ inConditional: true });
+      },
+      "LogicalExpression:exit"() {
+        updateContext({ inConditional: false });
+      },
+      "ReturnStatement:exit"() {
+        updateContext({ afterEarlyReturn: true });
+      },
+      SwitchStatement() {
+        updateContext({ inConditional: true });
+      },
+      "SwitchStatement:exit"() {
+        updateContext({ inConditional: false });
+      },
+      TryStatement() {
+        updateContext({ inTryBlock: true });
+      },
+      "TryStatement:exit"() {
+        updateContext({ inTryBlock: false });
+      },
+      WhileStatement() {
+        updateContext({ inLoop: true });
+      },
+      "WhileStatement:exit"() {
+        updateContext({ inLoop: false });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce that React hooks are only called at the top level of components or custom hooks, never conditionally or in nested functions",
+      recommended: true,
+      url: "https://react.dev/reference/rules/rules-of-hooks"
+    },
+    messages: {
+      afterEarlyReturn: "This hook is being called after an early return. Hooks must be called unconditionally and in the same order every render.",
+      conditionalHook: "This hook is being called conditionally. All hooks must be called in the exact same order in every component render.",
+      loopHook: "This hook is being called inside a loop. All hooks must be called in the exact same order in every component render.",
+      nestedFunction: "This hook is being called from a nested function. All hooks must be called unconditionally from the top-level component.",
+      recursiveHookCall: "This hook is being called recursively. Recursive calls require a condition to terminate, which violates hook rules.",
+      tryBlockHook: "This hook is being called inside a try block. Hooks must be called unconditionally at the top level."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          hooks: {
+            description: "Additional custom hook names to check",
+            items: { type: "string" },
+            type: "array"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  }
+};
+var use_hook_at_top_level_default = useHookAtTopLevel;
+
+// src/index.ts
+var rules = {
+  "enforce-ianitor-check-type": enforce_ianitor_check_type_default,
+  "no-color3-constructor": no_color3_constructor_default,
+  "no-print": no_print_default,
+  "no-shorthand-names": no_shorthand_names_default,
+  "no-warn": no_warn_default,
+  "require-react-component-keys": require_react_component_keys_default,
+  "use-exhaustive-dependencies": use_exhaustive_dependencies_default,
+  "use-hook-at-top-level": use_hook_at_top_level_default
+};
+var recommended = {
+  plugins: {
+    "cease-nonsense": {
+      rules
+    }
+  },
+  rules: {
+    "cease-nonsense/enforce-ianitor-check-type": "error",
+    "cease-nonsense/no-color3-constructor": "error",
+    "cease-nonsense/no-print": "error",
+    "cease-nonsense/no-shorthand-names": "error",
+    "cease-nonsense/no-warn": "error",
+    "cease-nonsense/require-react-component-keys": "error",
+    "cease-nonsense/use-exhaustive-dependencies": "error",
+    "cease-nonsense/use-hook-at-top-level": "error"
+  }
+};
+var plugin = {
+  configs: { recommended },
+  rules
+};
+var src_default = plugin;
+export {
+  src_default as default
+};