@agilebot/eslint-plugin 0.8.1 → 0.8.2

package/dist/index.mjs

@@ -0,0 +1,2644 @@
+/**
+ * @license @agilebot/eslint-plugin v0.8.2
+ *
+ * Copyright (c) Agilebot, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import path__default from 'node:path';
+import { tsImport, isPascalCase, isCamelCase } from '@agilebot/eslint-utils';
+import * as Components from 'eslint-plugin-react/lib/util/Components.js';
+
+const docBaseUrl = 'https://github.com/sh-agilebot/frontend-toolkit/blob/master/packages/eslint-plugin/src/rules/';
+const hasDocs = typeof ["enforce-mui-icon-alias","intl-id-missing","intl-id-prefix","intl-no-default","react-better-exhaustive-deps"] !== 'undefined' ?
+["enforce-mui-icon-alias","intl-id-missing","intl-id-prefix","intl-no-default","react-better-exhaustive-deps"] : [];
+const createRule = ESLintUtils.RuleCreator(name => hasDocs.includes(name) ? "".concat(docBaseUrl).concat(name, ".md") : "".concat(docBaseUrl).concat(name, ".test.js"));
+
+const RULE_NAME$h = 'enforce-mui-icon-alias';
+var enforceMuiIconAlias = createRule({
+  name: RULE_NAME$h,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Enforce alias for @mui/icons-material imports',
+      recommended: 'recommended'
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      iconAlias: 'Import for {{ name }} should be aliased.'
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value !== '@mui/icons-material' && node.source.value !== 'mdi-material-ui') {
+          return;
+        }
+        for (const specifier of node.specifiers) {
+          if (specifier.type !== AST_NODE_TYPES.ImportSpecifier) {
+            return;
+          }
+          if (specifier.imported.name === specifier.local.name || !specifier.local.name.endsWith('Icon')) {
+            context.report({
+              node,
+              messageId: 'iconAlias',
+              data: {
+                name: node.source.value
+              },
+              fix: fixer => fixer.replaceText(specifier, "".concat(specifier.imported.name, " as ").concat(specifier.imported.name, "Icon"))
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+function getSetting(context, name) {
+  return context.settings["agilebot/".concat(name)];
+}
+
+const RULE_NAME$g = 'import-monorepo';
+var importMonorepo = createRule({
+  name: RULE_NAME$g,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Enforce import styles for monorepo',
+      recommended: 'recommended'
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      monorepoImport: 'Import for {{ module }} should not contains src folder.'
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        let prefix = getSetting(context, 'monorepo-scope');
+        if (!prefix) {
+          return;
+        }
+        prefix = "".concat(prefix, "/");
+        if (typeof node.source.value !== 'string') {
+          return;
+        }
+        if (!node.source.value.startsWith(prefix)) {
+          return;
+        }
+        const values = node.source.value.split('/');
+        if (values[2] === 'src') {
+          context.report({
+            node,
+            messageId: 'monorepoImport',
+            data: {
+              module: node.source.value
+            },
+            fix: fixer => {
+              const correctedPath = values.filter((_, index) => index !== 2).join('/');
+              return fixer.replaceText(node.source, "'".concat(correctedPath, "'"));
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+function findFormatMessageAttrNode(node, attrName) {
+  if (node.type === AST_NODE_TYPES.CallExpression && (node.callee.name === 'formatMessage' || node.callee.name === '$t') && node.arguments.length > 0 && node.arguments[0].properties) {
+    return node.arguments[0].properties.find(a => a.key && a.key.name === attrName);
+  }
+  if (node.type === AST_NODE_TYPES.CallExpression && node.callee.type === AST_NODE_TYPES.MemberExpression && (node.callee.object.name === 'intl' || node.callee.object.name && node.callee.object.name.endsWith('Intl')) && (node.callee.property.name === 'formatMessage' || node.callee.property.name === '$t')) {
+    return node.arguments[0].properties.find(a => a.key && a.key.name === attrName);
+  }
+}
+function findFormattedMessageAttrNode(node, attrName) {
+  if (node.type === AST_NODE_TYPES.JSXIdentifier && node.name === 'FormattedMessage' && node.parent && node.parent.type === AST_NODE_TYPES.JSXOpeningElement) {
+    return node.parent.attributes.find(a => a.name && a.name.name === attrName);
+  }
+}
+function findAttrNodeInDefineMessages(node, attrName) {
+  if (node.type === 'Property' && node.key.name === attrName && node.parent && node.parent.parent && node.parent.parent.parent && node.parent.parent.parent.parent && node.parent.parent.parent.parent.type === AST_NODE_TYPES.CallExpression && node.parent.parent.parent.parent.callee.name === 'defineMessages') {
+    return node;
+  }
+}
+function findAttrNodeInDefineMessage(node, attrName) {
+  if (node.type === 'Property' && node.key.name === attrName && node.parent && node.parent.parent && node.parent.parent.type === AST_NODE_TYPES.CallExpression && node.parent.parent.callee.name === 'defineMessage') {
+    return node;
+  }
+}
+function sortedTemplateElements(node) {
+  return [...node.quasis, ...node.expressions].sort((a, b) => a.range[0] - b.range[0]);
+}
+function templateLiteralDisplayStr(node) {
+  return sortedTemplateElements(node).map(e => !e.value ? '*' : e.value.raw).join('');
+}
+
+const localeFilesKeys = {};
+function getIntlIds(context) {
+  const projectRoot = getSetting(context, 'project-root');
+  const localeFiles = getSetting(context, 'locale-files');
+  if (!localeFiles) {
+    throw new Error('localeFiles not in settings');
+  }
+  const results = [];
+  localeFiles.forEach(f => {
+    const fullPath = projectRoot ? path.join(projectRoot, f) : f;
+    const mtime = fs.lstatSync(fullPath).mtime.getTime();
+    if (!localeFilesKeys[fullPath] || mtime !== localeFilesKeys[fullPath].mtime) {
+      let json;
+      if (fullPath.endsWith('.json')) {
+        json = JSON.parse(fs.readFileSync(fullPath, 'utf8'));
+      } else if (fullPath.endsWith('.ts')) {
+        json = tsImport(fullPath);
+        if (typeof json === 'object' && json["default"]) {
+          json = json["default"];
+        }
+      } else if (fullPath.endsWith('.js')) {
+        json = require(fullPath);
+        if (typeof json === 'object' && json["default"]) {
+          json = json["default"];
+        }
+      } else {
+        throw new Error('unsupported file extension');
+      }
+      localeFilesKeys[fullPath] = {
+        keys: Object.keys(json),
+        mtime: mtime
+      };
+    }
+    results.push(...localeFilesKeys[fullPath].keys);
+  });
+  return results;
+}
+
+const RULE_NAME$f = 'intl-id-missing';
+var intlIdMissing = createRule({
+  name: RULE_NAME$f,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Validates intl message ids are in locale file'
+    },
+    schema: [],
+    messages: {
+      missingId: 'Missing id: {{value}}',
+      missingIdPattern: 'Missing id pattern: {{value}}',
+      disallowInvoke: 'Do not invoke intl by {{value}}'
+    }
+  },
+  defaultOptions: [],
+  create: function (context) {
+    const translatedIds = getIntlIds(context);
+    const translatedIdSet = new Set(translatedIds);
+    function isLiteralTranslated(id) {
+      return translatedIdSet.has(id);
+    }
+    function isTemplateTranslated(re) {
+      return translatedIds.some(k => re.test(k));
+    }
+    function processLiteral(node) {
+      if (!isLiteralTranslated(node.value)) {
+        context.report({
+          node: node,
+          messageId: 'missingId',
+          data: {
+            value: node.value
+          }
+        });
+      }
+    }
+    function processTemplateLiteral(node) {
+      const exStr = sortedTemplateElements(node).map(e => !e.value ? '.*' : e.value.raw).join('');
+      const re = new RegExp(exStr);
+      if (!isTemplateTranslated(re)) {
+        context.report({
+          node: node,
+          messageId: 'missingIdPattern',
+          data: {
+            value: templateLiteralDisplayStr(node)
+          }
+        });
+      }
+    }
+    function processAttrNode(node) {
+      if (node.value.type === AST_NODE_TYPES.Literal) {
+        return processLiteral(node.value);
+      }
+      if (node.value.type === AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === AST_NODE_TYPES.TemplateLiteral) {
+        return processTemplateLiteral(node.value.expression);
+      }
+      if (node.value.type === AST_NODE_TYPES.TemplateLiteral) {
+        return processTemplateLiteral(node.value);
+      }
+      context.report({
+        node: node,
+        messageId: 'disallowInvoke',
+        data: {
+          value: node.value.type
+        }
+      });
+    }
+    return {
+      JSXIdentifier: function (node) {
+        const attrNode = findFormattedMessageAttrNode(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      CallExpression: function (node) {
+        const attrNode = findFormatMessageAttrNode(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      Property: function (node) {
+        const attrNode = findAttrNodeInDefineMessages(node, 'id') || findAttrNodeInDefineMessage(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      }
+    };
+  }
+});
+
+const RULE_NAME$e = 'intl-id-naming';
+var intlIdNaming = createRule({
+  name: RULE_NAME$e,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Validates intl message ids naming convention'
+    },
+    schema: [{
+      type: 'object',
+      properties: {
+        format: {
+          type: 'string',
+          "enum": ['camelCase', 'PascalCase']
+        }
+      }
+    }],
+    messages: {
+      invalidIdNaming: "Invalid id naming, expected {{format}}"
+    }
+  },
+  defaultOptions: [],
+  create: function (context) {
+    if (!context.options[0]) {
+      throw new Error('Missing options');
+    }
+    const format = context.options[0].format;
+    function report(node, value) {
+      const values = value.split('.');
+      let isPass;
+      for (const v of values) {
+        switch (format) {
+          case 'camelCase':
+            if (!isCamelCase(v)) {
+              isPass = false;
+            }
+            break;
+          case 'PascalCase':
+            if (!isPascalCase(v)) {
+              isPass = false;
+            }
+            break;
+        }
+      }
+      if (isPass === false) {
+        context.report({
+          node: node,
+          messageId: 'invalidIdNaming',
+          data: {
+            format
+          }
+        });
+      }
+    }
+    function processLiteral(node) {
+      report(node, node.value);
+    }
+    function processTemplateLiteral(node) {
+      const displayStr = templateLiteralDisplayStr(node);
+      report(node, displayStr);
+    }
+    function processAttrNode(node) {
+      if (node.value.type === AST_NODE_TYPES.Literal) {
+        return processLiteral(node.value);
+      }
+      if (node.value.type === AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === AST_NODE_TYPES.TemplateLiteral) {
+        return processTemplateLiteral(node.value.expression);
+      }
+      if (node.value.type === AST_NODE_TYPES.TemplateLiteral) {
+        return processTemplateLiteral(node.value);
+      }
+    }
+    return {
+      JSXIdentifier: function (node) {
+        const attrNode = findFormattedMessageAttrNode(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      CallExpression: function (node) {
+        const attrNode = findFormatMessageAttrNode(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      Property: function (node) {
+        const attrNode = findAttrNodeInDefineMessages(node, 'id') || findAttrNodeInDefineMessage(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      }
+    };
+  }
+});
+
+const RULE_NAME$d = 'intl-id-prefix';
+var intlIdPrefix = createRule({
+  name: RULE_NAME$d,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Validates intl message ids has correct prefixes'
+    },
+    schema: [{
+      type: 'array',
+      items: {
+        type: 'string'
+      }
+    }],
+    messages: {
+      invalidIdPrefix: 'Invalid id prefix: {{value}}'
+    }
+  },
+  defaultOptions: [],
+  create: function (context) {
+    if (context.options[0].length === 0) {
+      throw new Error('Prefixes are required in settings');
+    }
+    const hasPrefix = value => context.options[0].some(p => value.startsWith(p));
+    function report(node, value) {
+      if (!hasPrefix(value)) {
+        context.report({
+          node: node,
+          messageId: 'invalidIdPrefix',
+          data: {
+            value
+          }
+        });
+      }
+    }
+    function processLiteral(node) {
+      report(node, node.value);
+    }
+    function processTemplateLiteral(node) {
+      const displayStr = templateLiteralDisplayStr(node);
+      report(node, displayStr);
+    }
+    function processAttrNode(node) {
+      if (node.value.type === AST_NODE_TYPES.Literal) {
+        return processLiteral(node.value);
+      }
+      if (node.value.type === AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === AST_NODE_TYPES.TemplateLiteral) {
+        return processTemplateLiteral(node.value.expression);
+      }
+      if (node.value.type === AST_NODE_TYPES.TemplateLiteral) {
+        return processTemplateLiteral(node.value);
+      }
+    }
+    return {
+      JSXIdentifier: function (node) {
+        const attrNode = findFormattedMessageAttrNode(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      CallExpression: function (node) {
+        const attrNode = findFormatMessageAttrNode(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      Property: function (node) {
+        const attrNode = findAttrNodeInDefineMessages(node, 'id') || findAttrNodeInDefineMessage(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      }
+    };
+  }
+});
+
+const RULE_NAME$c = 'intl-id-unused';
+const usedIds = new Map();
+var intlIdUnused = createRule({
+  name: RULE_NAME$c,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Finds unused intl message ids in locale file'
+    },
+    schema: [],
+    messages: {}
+  },
+  defaultOptions: [],
+  create: function (context) {
+    const projectRoot = getSetting(context, 'project-root');
+    if (!projectRoot) {
+      throw new Error('projectRoot must be set in this rule');
+    }
+    if (!usedIds.has(projectRoot)) {
+      usedIds.set(projectRoot, new Set());
+    }
+    const usedIdSet = usedIds.get(projectRoot);
+    const translatedIds = getIntlIds(context);
+    const translatedIdSet = new Set(translatedIds);
+    function isLiteralTranslated(id) {
+      return translatedIdSet.has(id);
+    }
+    function isTemplateTranslated(re) {
+      return translatedIds.some(k => re.test(k));
+    }
+    function processLiteral(node) {
+      if (isLiteralTranslated(node.value)) {
+        usedIdSet.add(node.value);
+      }
+    }
+    function processTemplateLiteral(node) {
+      const exStr = sortedTemplateElements(node).map(e => !e.value ? '.*' : e.value.raw).join('');
+      const re = new RegExp(exStr);
+      if (isTemplateTranslated(re)) ;
+    }
+    function processAttrNode(node) {
+      if (node.value.type === AST_NODE_TYPES.Literal) {
+        return processLiteral(node.value);
+      }
+      if (node.value.type === AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === AST_NODE_TYPES.TemplateLiteral) {
+        return processTemplateLiteral(node.value.expression);
+      }
+      if (node.value.type === AST_NODE_TYPES.TemplateLiteral) {
+        return processTemplateLiteral(node.value);
+      }
+    }
+    return {
+      JSXIdentifier: function (node) {
+        const attrNode = findFormattedMessageAttrNode(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      CallExpression: function (node) {
+        const attrNode = findFormatMessageAttrNode(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      Property: function (node) {
+        const attrNode = findAttrNodeInDefineMessages(node, 'id') || findAttrNodeInDefineMessage(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      'Program:exit': function () {
+        const unusedIds = [...translatedIdSet].filter(id => !usedIdSet.has(id));
+        const jsonPath = path.join(projectRoot, 'intl-unused.json');
+        fs.writeFileSync(jsonPath, JSON.stringify(unusedIds, null, 2));
+      }
+    };
+  }
+});
+
+const RULE_NAME$b = 'intl-no-default';
+var intlNoDefault = createRule({
+  name: RULE_NAME$b,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Validates defaultMessage is not used with react-intl'
+    },
+    schema: [],
+    messages: {
+      noDefaultMessage: 'Do not use defaultMessage'
+    }
+  },
+  defaultOptions: [],
+  create: function (context) {
+    function processAttrNode(node) {
+      context.report({
+        node: node,
+        messageId: 'noDefaultMessage'
+      });
+    }
+    return {
+      JSXIdentifier: function (node) {
+        const attrNode = findFormattedMessageAttrNode(node, 'defaultMessage');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      CallExpression: function (node) {
+        const attrNode = findFormatMessageAttrNode(node, 'defaultMessage');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      Property: function (node) {
+        const attrNode = findAttrNodeInDefineMessages(node, 'defaultMessage') || findAttrNodeInDefineMessage(node, 'defaultMessage');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      }
+    };
+  }
+});
+
+const RULE_NAME$a = 'no-async-array-methods';
+var noAsyncArrayMethods = createRule({
+  name: RULE_NAME$a,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'No async callback for Array methods forEach, map, filter, reduce, some, every, etc.',
+      recommended: 'recommended'
+    },
+    schema: [],
+    messages: {
+      noAsyncArrayMethods: "No async function in method '{{ methodName }}'"
+    }
+  },
+  defaultOptions: [],
+  create: function (context) {
+    return {
+      ExpressionStatement: function (node) {
+        const notAllowedArrayMethods = ['forEach', 'filter', 'some', 'every', 'map', 'reduce', 'reduceRight', 'flatMap', 'find', 'findIndex', 'findLast', 'findLastIndex'];
+        const {
+          callee
+        } = node.expression;
+        if (!callee || !callee.property || !callee.property.name) {
+          return;
+        }
+        if (notAllowedArrayMethods.includes(callee.property.name)) {
+          const functionArguments = node.expression.arguments.find(n => {
+            return [AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression].includes(n.type);
+          });
+          if (functionArguments && functionArguments.async) {
+            context.report({
+              node,
+              messageId: 'noAsyncArrayMethods',
+              data: {
+                methodName: callee.property.name
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+const RULE_NAME$9 = 'no-extends-error';
+var noExtendsError = createRule({
+  name: RULE_NAME$9,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow extending the Error class',
+      recommended: 'recommended'
+    },
+    schema: [],
+    messages: {
+      noExtendsError: "Extending the 'Error' class is prohibited."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      ClassDeclaration(node) {
+        if (node.superClass && node.superClass.type === AST_NODE_TYPES.Identifier && node.superClass.name === 'Error') {
+          context.report({
+            node: node.superClass,
+            messageId: 'noExtendsError'
+          });
+        }
+      }
+    };
+  }
+});
+
+const RULE_NAME$8 = 'no-import-css';
+var noImportCss = createRule({
+  name: RULE_NAME$8,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Prevent importing CSS',
+      recommended: 'recommended'
+    },
+    schema: [],
+    messages: {
+      noImportCSS: 'Do not import CSS files. Use CSS-in-JS instead.'
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        const ext = path__default.extname(node.source.value);
+        if (ext.startsWith('.css') || ext.startsWith('.scss') || ext.startsWith('.sass') || ext.startsWith('.less') || ext.startsWith('.styl')) {
+          context.report({
+            node,
+            messageId: 'noImportCSS',
+            data: {
+              path: node.source.value
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+const RULE_NAME$7 = 'no-then-catch-finally';
+var noThenCatchFinally = createRule({
+  name: RULE_NAME$7,
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow the use of then()/catch()/finally() when invoking specific functions.'
+    },
+    schema: [{
+      type: 'object',
+      properties: {
+        restrictedFunctions: {
+          type: 'array',
+          uniqueItems: true,
+          items: {
+            type: 'string'
+          }
+        }
+      }
+    }],
+    messages: {
+      forbiddenThenCatchFinally: "then()/catch()/finally() is forbidden when invoke {{ name }}()."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const configuration = context.options[0] || {};
+    const restrictedFunctions = configuration.restrictedFunctions || [];
+    const getScope = typeof context.getScope === 'function' ? () => {
+      return context.getScope();
+    } : node => {
+      return context.sourceCode.getScope(node);
+    };
+    function isTopLevelScoped(node) {
+      return getScope(node).block.type === 'Program';
+    }
+    function isThenCatchFinally(node) {
+      return node.property && (node.property.name === 'then' || node.property.name === 'catch' || node.property.name === 'finally');
+    }
+    return {
+      ["".concat(AST_NODE_TYPES.CallExpression, " > ").concat(AST_NODE_TYPES.MemberExpression, ".callee")]: node => {
+        if (isTopLevelScoped(node)) {
+          return;
+        }
+        if (!isThenCatchFinally(node)) {
+          return;
+        }
+        const callExpression = node.object;
+        if (callExpression.type === AST_NODE_TYPES.CallExpression && callExpression.callee.type === AST_NODE_TYPES.Identifier && restrictedFunctions.includes(callExpression.callee.name)) {
+          context.report({
+            node: node.property,
+            messageId: 'forbiddenThenCatchFinally',
+            data: {
+              name: callExpression.callee.name
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+const RULE_NAME$6 = 'no-unnecessary-template-literals';
+var noUnnecessaryTemplateLiterals = createRule({
+  name: RULE_NAME$6,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Check if a template string contains only one ${}',
+      recommended: 'recommended'
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      unnecessaryTemplateString: 'Unnecessary template string with only one ${}.'
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      TemplateLiteral(node) {
+        const code = context.sourceCode.getText(node);
+        if (code.startsWith('`${') && code.endsWith('}`') && code.split('${').length === 2) {
+          context.report({
+            node,
+            messageId: 'unnecessaryTemplateString',
+            fix(fixer) {
+              return fixer.replaceText(node, code.substring(3, code.length - 2));
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+var reactBetterExhaustiveDeps = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'verifies the list of dependencies for Hooks like useEffect and similar',
+      url: 'https://github.com/facebook/react/issues/14920'
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    schema: [{
+      type: 'object',
+      additionalProperties: false,
+      enableDangerousAutofixThisMayCauseInfiniteLoops: false,
+      properties: {
+        additionalHooks: {
+          type: 'string'
+        },
+        enableDangerousAutofixThisMayCauseInfiniteLoops: {
+          type: 'boolean'
+        },
+        customHooks: {
+          type: 'object',
+          additionalProperties: {
+            callbackIndex: {
+              type: 'number'
+            }
+          }
+        },
+        staticHooks: {
+          type: 'object',
+          additionalProperties: {
+            oneOf: [{
+              type: 'boolean'
+            }, {
+              type: 'array',
+              items: {
+                type: 'boolean'
+              }
+            }, {
+              type: 'object',
+              additionalProperties: {
+                type: 'boolean'
+              }
+            }]
+          }
+        },
+        checkMemoizedVariableIsStatic: {
+          type: 'boolean'
+        }
+      }
+    }]
+  },
+  create(context) {
+    const additionalHooks = context.options && context.options[0] && context.options[0].additionalHooks ? new RegExp(context.options[0].additionalHooks) : undefined;
+    const enableDangerousAutofixThisMayCauseInfiniteLoops = context.options && context.options[0] && context.options[0].enableDangerousAutofixThisMayCauseInfiniteLoops || false;
+    const customHooks = context.options && context.options[0] && context.options[0].customHooks || {};
+    const staticHooks = context.options && context.options[0] && context.options[0].staticHooks || {};
+    const checkMemoizedVariableIsStatic = context.options && context.options[0] && context.options[0].checkMemoizedVariableIsStatic || false;
+    const options = {
+      additionalHooks,
+      customHooks,
+      staticHooks,
+      checkMemoizedVariableIsStatic
+    };
+    function reportProblem(problem) {
+      if (enableDangerousAutofixThisMayCauseInfiniteLoops &&
+      Array.isArray(problem.suggest) && problem.suggest.length > 0) {
+        problem.fix = problem.suggest[0].fix;
+      }
+      context.report(problem);
+    }
+    const getSource = typeof context.getSource === 'function' ? node => {
+      return context.getSource(node);
+    } : node => {
+      return context.sourceCode.getText(node);
+    };
+    const getScope = typeof context.getScope === 'function' ? () => {
+      return context.getScope();
+    } : node => {
+      return context.sourceCode.getScope(node);
+    };
+    const scopeManager = context.getSourceCode().scopeManager;
+    const setStateCallSites = new WeakMap();
+    const stateVariables = new WeakSet();
+    const stableKnownValueCache = new WeakMap();
+    const functionWithoutCapturedValueCache = new WeakMap();
+    const useEffectEventVariables = new WeakSet();
+    function memoizeWithWeakMap(fn, map) {
+      return function (arg) {
+        if (map.has(arg)) {
+          return map.get(arg);
+        }
+        const result = fn(arg);
+        map.set(arg, result);
+        return result;
+      };
+    }
+    function visitFunctionWithDependencies(node, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect) {
+      if (isEffect && node.async) {
+        let isCustomHook = false;
+        if (options.customHooks) {
+          Object.entries(options.customHooks).forEach(([key, customParts]) => {
+            if (typeof customParts === 'object' && new RegExp(key).test(reactiveHookName)) {
+              isCustomHook = true;
+            }
+          });
+        }
+        if (!isCustomHook) {
+          reportProblem({
+            node: node,
+            message: "Effect callbacks are synchronous to prevent race conditions. " + "Put the async function inside:\n\n" + 'useEffect(() => {\n' + '  async function fetchData() {\n' + '    // You can await here\n' + '    const response = await MyAPI.getData(someId);\n' + '    // ...\n' + '  }\n' + '  fetchData();\n' + "}, [someId]); // Or [] if effect doesn't need props or state\n\n" + 'Learn more about data fetching with Hooks: https://react.dev/link/hooks-data-fetching'
+          });
+        }
+      }
+      const scope = scopeManager.acquire(node);
+      const pureScopes = new Set();
+      let componentScope = null;
+      {
+        let currentScope = scope.upper;
+        while (currentScope) {
+          pureScopes.add(currentScope);
+          if (currentScope.type === 'function') {
+            break;
+          }
+          currentScope = currentScope.upper;
+        }
+        if (!currentScope) {
+          return;
+        }
+        componentScope = currentScope;
+      }
+      const isArray = Array.isArray;
+      const memoizedIsStableKnownHookValue = memoizeWithWeakMap(isStableKnownHookValue, stableKnownValueCache);
+      const memoizedIsFunctionWithoutCapturedValues = memoizeWithWeakMap(isFunctionWithoutCapturedValues, functionWithoutCapturedValueCache);
+      function isStableKnownHookValue(resolved) {
+        if (!isArray(resolved.defs)) {
+          return false;
+        }
+        const def = resolved.defs[0];
+        if (def == null) {
+          return false;
+        }
+        if (def.node.type !== 'VariableDeclarator') {
+          return false;
+        }
+        let init = def.node.init;
+        if (init == null) {
+          return false;
+        }
+        while (init.type === 'TSAsExpression' || init.type === 'AsExpression') {
+          init = init.expression;
+        }
+        let declaration = def.node.parent;
+        if (declaration == null) {
+          fastFindReferenceWithParent(componentScope.block, def.node.id);
+          declaration = def.node.parent;
+          if (declaration == null) {
+            return false;
+          }
+        }
+        if (declaration.kind === 'const' && init.type === 'Literal' && (typeof init.value === 'string' || typeof init.value === 'number' || init.value == null)) {
+          return true;
+        }
+        if (init.type !== 'CallExpression') {
+          return false;
+        }
+        let callee = init.callee;
+        if (callee.type === 'MemberExpression' && callee.object.name === 'React' && callee.property != null && !callee.computed) {
+          callee = callee.property;
+        }
+        if (callee.type !== 'Identifier') {
+          return false;
+        }
+        const id = def.node.id;
+        const {
+          name
+        } = callee;
+        if (name === 'useRef' && id.type === 'Identifier') {
+          return true;
+        } else if (isUseEffectEventIdentifier() && id.type === 'Identifier') {
+          for (const ref of resolved.references) {
+            if (ref !== id) {
+              useEffectEventVariables.add(ref.identifier);
+            }
+          }
+          return true;
+        } else if (name === 'useState' || name === 'useReducer' || name === 'useActionState') {
+          if (id.type === 'ArrayPattern' && id.elements.length === 2 && isArray(resolved.identifiers)) {
+            if (id.elements[1] === resolved.identifiers[0]) {
+              if (name === 'useState') {
+                const references = resolved.references;
+                let writeCount = 0;
+                for (const reference of references) {
+                  if (reference.isWrite()) {
+                    writeCount++;
+                  }
+                  if (writeCount > 1) {
+                    return false;
+                  }
+                  setStateCallSites.set(reference.identifier, id.elements[0]);
+                }
+              }
+              return true;
+            } else if (id.elements[0] === resolved.identifiers[0]) {
+              if (name === 'useState') {
+                const references = resolved.references;
+                for (const reference of references) {
+                  stateVariables.add(reference.identifier);
+                }
+              }
+              return false;
+            }
+          }
+        } else if (name === 'useTransition') {
+          if (id.type === 'ArrayPattern' && id.elements.length === 2 && Array.isArray(resolved.identifiers) &&
+          id.elements[1] === resolved.identifiers[0]) {
+            return true;
+          }
+        } else if (options.checkMemoizedVariableIsStatic && (name === 'useMemo' || name === 'useCallback')) {
+          const hookArgs = callee.parent.arguments;
+          if (hookArgs.length < 2) {
+            return false;
+          }
+          const dependencies = hookArgs[1].elements;
+          if (dependencies.length === 0) {
+            return true;
+          }
+          for (const dependencyNode of dependencies) {
+            const dependencyRefernece = resolved.scope.references.find(reference => reference.identifier === dependencyNode);
+            if (dependencyRefernece !== undefined && memoizedIsStableKnownHookValue(dependencyRefernece.resolved)) {
+              continue;
+            } else {
+              return false;
+            }
+          }
+          return true;
+        } else {
+          Object.entries(options.staticHooks).forEach(([key, staticParts]) => {
+            if (typeof staticParts === 'object' && staticParts.regexp && new RegExp(key).test(name)) {
+              options.staticHooks[name] = staticParts.value;
+            }
+          });
+          if (options.staticHooks[name]) {
+            const staticParts = options.staticHooks[name];
+            if (staticParts === true) {
+              return true;
+            } else if (Array.isArray(staticParts)) {
+              if (id.type === 'ArrayPattern' && id.elements.length <= staticParts.length && Array.isArray(resolved.identifiers)) {
+                const idx = id.elements.indexOf(resolved.identifiers[0]);
+                if (idx !== -1) {
+                  return staticParts[idx];
+                }
+              }
+            } else if (typeof staticParts === 'object' && id.type === 'ObjectPattern') {
+              const property = id.properties.find(p => p.key === resolved.identifiers[0]);
+              if (property) {
+                return staticParts[property.key.name];
+              }
+            }
+          }
+        }
+        return false;
+      }
+      function isFunctionWithoutCapturedValues(resolved) {
+        if (!isArray(resolved.defs)) {
+          return false;
+        }
+        const def = resolved.defs[0];
+        if (def == null) {
+          return false;
+        }
+        if (def.node == null || def.node.id == null) {
+          return false;
+        }
+        const fnNode = def.node;
+        const childScopes = componentScope.childScopes;
+        let fnScope = null;
+        let i;
+        for (i = 0; i < childScopes.length; i++) {
+          const childScope = childScopes[i];
+          const childScopeBlock = childScope.block;
+          if (
+          fnNode.type === 'FunctionDeclaration' && childScopeBlock === fnNode ||
+          fnNode.type === 'VariableDeclarator' && childScopeBlock.parent === fnNode) {
+            fnScope = childScope;
+            break;
+          }
+        }
+        if (fnScope == null) {
+          return false;
+        }
+        for (i = 0; i < fnScope.through.length; i++) {
+          const ref = fnScope.through[i];
+          if (ref.resolved == null) {
+            continue;
+          }
+          if (pureScopes.has(ref.resolved.scope) &&
+          !memoizedIsStableKnownHookValue(ref.resolved)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      const currentRefsInEffectCleanup = new Map();
+      function isInsideEffectCleanup(reference) {
+        let curScope = reference.from;
+        let isInReturnedFunction = false;
+        while (curScope.block !== node) {
+          if (curScope.type === 'function') {
+            isInReturnedFunction = curScope.block.parent != null && curScope.block.parent.type === 'ReturnStatement';
+          }
+          curScope = curScope.upper;
+        }
+        return isInReturnedFunction;
+      }
+      const dependencies = new Map();
+      const optionalChains = new Map();
+      gatherDependenciesRecursively(scope);
+      function gatherDependenciesRecursively(currentScope) {
+        for (const reference of currentScope.references) {
+          if (!reference.resolved) {
+            continue;
+          }
+          if (!pureScopes.has(reference.resolved.scope)) {
+            continue;
+          }
+          const referenceNode = fastFindReferenceWithParent(node, reference.identifier);
+          const dependencyNode = getDependency(referenceNode);
+          const dependency = analyzePropertyChain(dependencyNode, optionalChains);
+          if (
+          isEffect &&
+          dependencyNode.type === 'Identifier' && (dependencyNode.parent.type === 'MemberExpression' || dependencyNode.parent.type === 'OptionalMemberExpression') && !dependencyNode.parent.computed && dependencyNode.parent.property.type === 'Identifier' && dependencyNode.parent.property.name === 'current' &&
+          isInsideEffectCleanup(reference)) {
+            currentRefsInEffectCleanup.set(dependency, {
+              reference,
+              dependencyNode
+            });
+          }
+          if (dependencyNode.parent.type === 'TSTypeQuery' || dependencyNode.parent.type === 'TSTypeReference') {
+            continue;
+          }
+          const def = reference.resolved.defs[0];
+          if (def == null) {
+            continue;
+          }
+          if (def.node != null && def.node.init === node.parent) {
+            continue;
+          }
+          if (def.type === 'TypeParameter') {
+            continue;
+          }
+          if (!dependencies.has(dependency)) {
+            const resolved = reference.resolved;
+            const isStable = memoizedIsStableKnownHookValue(resolved) || memoizedIsFunctionWithoutCapturedValues(resolved);
+            dependencies.set(dependency, {
+              isStable,
+              references: [reference]
+            });
+          } else {
+            dependencies.get(dependency).references.push(reference);
+          }
+        }
+        for (const childScope of currentScope.childScopes) {
+          gatherDependenciesRecursively(childScope);
+        }
+      }
+      currentRefsInEffectCleanup.forEach(({
+        reference,
+        dependencyNode
+      }, dependency) => {
+        const references = reference.resolved.references;
+        let foundCurrentAssignment = false;
+        for (const {
+          identifier
+        } of references) {
+          const {
+            parent
+          } = identifier;
+          if (parent != null &&
+          parent.type === 'MemberExpression' && !parent.computed && parent.property.type === 'Identifier' && parent.property.name === 'current' &&
+          parent.parent.type === 'AssignmentExpression' && parent.parent.left === parent) {
+            foundCurrentAssignment = true;
+            break;
+          }
+        }
+        if (foundCurrentAssignment) {
+          return;
+        }
+        reportProblem({
+          node: dependencyNode.parent.property,
+          message: "The ref value '".concat(dependency, ".current' will likely have ") + "changed by the time this effect cleanup function runs. If " + "this ref points to a node rendered by React, copy " + "'".concat(dependency, ".current' to a variable inside the effect, and ") + "use that variable in the cleanup function."
+        });
+      });
+      const staleAssignments = new Set();
+      function reportStaleAssignment(writeExpr, key) {
+        if (staleAssignments.has(key)) {
+          return;
+        }
+        staleAssignments.add(key);
+        reportProblem({
+          node: writeExpr,
+          message: "Assignments to the '".concat(key, "' variable from inside React Hook ") + "".concat(getSource(reactiveHook), " will be lost after each ") + "render. To preserve the value over time, store it in a useRef " + "Hook and keep the mutable value in the '.current' property. " + "Otherwise, you can move this variable directly inside " + "".concat(getSource(reactiveHook), ".")
+        });
+      }
+      const stableDependencies = new Set();
+      dependencies.forEach(({
+        isStable,
+        references
+      }, key) => {
+        if (isStable) {
+          stableDependencies.add(key);
+        }
+        references.forEach(reference => {
+          if (reference.writeExpr) {
+            reportStaleAssignment(reference.writeExpr, key);
+          }
+        });
+      });
+      if (staleAssignments.size > 0) {
+        return;
+      }
+      if (!declaredDependenciesNode) {
+        let setStateInsideEffectWithoutDeps = null;
+        dependencies.forEach(({
+          references
+        }, key) => {
+          if (setStateInsideEffectWithoutDeps) {
+            return;
+          }
+          references.forEach(reference => {
+            if (setStateInsideEffectWithoutDeps) {
+              return;
+            }
+            const id = reference.identifier;
+            const isSetState = setStateCallSites.has(id);
+            if (!isSetState) {
+              return;
+            }
+            let fnScope = reference.from;
+            while (fnScope.type !== 'function') {
+              fnScope = fnScope.upper;
+            }
+            const isDirectlyInsideEffect = fnScope.block === node;
+            if (isDirectlyInsideEffect) {
+              setStateInsideEffectWithoutDeps = key;
+            }
+          });
+        });
+        if (setStateInsideEffectWithoutDeps) {
+          const {
+            suggestedDependencies
+          } = collectRecommendations({
+            dependencies,
+            declaredDependencies: [],
+            stableDependencies,
+            externalDependencies: new Set(),
+            isEffect: true
+          });
+          reportProblem({
+            node: reactiveHook,
+            message: "React Hook ".concat(reactiveHookName, " contains a call to '").concat(setStateInsideEffectWithoutDeps, "'. ") + "Without a list of dependencies, this can lead to an infinite chain of updates. " + "To fix this, pass [" + suggestedDependencies.join(', ') + "] as a second argument to the ".concat(reactiveHookName, " Hook."),
+            suggest: [{
+              desc: "Add dependencies array: [".concat(suggestedDependencies.join(', '), "]"),
+              fix(fixer) {
+                return fixer.insertTextAfter(node, ", [".concat(suggestedDependencies.join(', '), "]"));
+              }
+            }]
+          });
+        }
+        return;
+      }
+      const declaredDependencies = [];
+      const externalDependencies = new Set();
+      const isArrayExpression = declaredDependenciesNode.type === 'ArrayExpression';
+      const isTSAsArrayExpression = declaredDependenciesNode.type === 'TSAsExpression' && declaredDependenciesNode.expression.type === 'ArrayExpression';
+      if (!isArrayExpression && !isTSAsArrayExpression) {
+        reportProblem({
+          node: declaredDependenciesNode,
+          message: "React Hook ".concat(getSource(reactiveHook), " was passed a ") + 'dependency list that is not an array literal. This means we ' + "can't statically verify whether you've passed the correct " + 'dependencies.'
+        });
+      } else {
+        const arrayExpression = isTSAsArrayExpression ? declaredDependenciesNode.expression : declaredDependenciesNode;
+        arrayExpression.elements.forEach(declaredDependencyNode => {
+          if (declaredDependencyNode == null) {
+            return;
+          }
+          if (declaredDependencyNode.type === 'SpreadElement') {
+            reportProblem({
+              node: declaredDependencyNode,
+              message: "React Hook ".concat(getSource(reactiveHook), " has a spread ") + "element in its dependency array. This means we can't " + "statically verify whether you've passed the " + 'correct dependencies.'
+            });
+            return;
+          }
+          if (useEffectEventVariables.has(declaredDependencyNode)) {
+            reportProblem({
+              node: declaredDependencyNode,
+              message: 'Functions returned from `useEffectEvent` must not be included in the dependency array. ' + "Remove `".concat(getSource(declaredDependencyNode), "` from the list."),
+              suggest: [{
+                desc: "Remove the dependency `".concat(getSource(declaredDependencyNode), "`"),
+                fix(fixer) {
+                  return fixer.removeRange(declaredDependencyNode.range);
+                }
+              }]
+            });
+          }
+          let declaredDependency;
+          try {
+            declaredDependency = analyzePropertyChain(declaredDependencyNode, null);
+          } catch (err) {
+            if (/Unsupported node type/.test(err.message)) {
+              if (declaredDependencyNode.type === 'Literal') {
+                if (dependencies.has(declaredDependencyNode.value)) {
+                  reportProblem({
+                    node: declaredDependencyNode,
+                    message: "The ".concat(declaredDependencyNode.raw, " literal is not a valid dependency ") + "because it never changes. " + "Did you mean to include ".concat(declaredDependencyNode.value, " in the array instead?")
+                  });
+                } else {
+                  reportProblem({
+                    node: declaredDependencyNode,
+                    message: "The ".concat(declaredDependencyNode.raw, " literal is not a valid dependency ") + 'because it never changes. You can safely remove it.'
+                  });
+                }
+              } else {
+                reportProblem({
+                  node: declaredDependencyNode,
+                  message: "React Hook ".concat(getSource(reactiveHook), " has a ") + "complex expression in the dependency array. " + 'Extract it to a separate variable so it can be statically checked.'
+                });
+              }
+              return;
+            }
+            throw err;
+          }
+          let maybeID = declaredDependencyNode;
+          while (maybeID.type === 'MemberExpression' || maybeID.type === 'OptionalMemberExpression' || maybeID.type === 'ChainExpression') {
+            maybeID = maybeID.object || maybeID.expression.object;
+          }
+          const isDeclaredInComponent = !componentScope.through.some(ref => ref.identifier === maybeID);
+          declaredDependencies.push({
+            key: declaredDependency,
+            node: declaredDependencyNode
+          });
+          if (!isDeclaredInComponent) {
+            externalDependencies.add(declaredDependency);
+          }
+        });
+      }
+      const {
+        suggestedDependencies,
+        unnecessaryDependencies,
+        missingDependencies,
+        duplicateDependencies
+      } = collectRecommendations({
+        dependencies,
+        declaredDependencies,
+        stableDependencies,
+        externalDependencies,
+        isEffect
+      });
+      let suggestedDeps = suggestedDependencies;
+      const problemCount = duplicateDependencies.size + missingDependencies.size + unnecessaryDependencies.size;
+      if (problemCount === 0) {
+        const constructions = scanForConstructions({
+          declaredDependencies,
+          declaredDependenciesNode,
+          componentScope,
+          scope
+        });
+        constructions.forEach(({
+          construction,
+          isUsedOutsideOfHook,
+          depType
+        }) => {
+          const wrapperHook = depType === 'function' ? 'useCallback' : 'useMemo';
+          const constructionType = depType === 'function' ? 'definition' : 'initialization';
+          const defaultAdvice = "wrap the ".concat(constructionType, " of '").concat(construction.name.name, "' in its own ").concat(wrapperHook, "() Hook.");
+          const advice = isUsedOutsideOfHook ? "To fix this, ".concat(defaultAdvice) : "Move it inside the ".concat(reactiveHookName, " callback. Alternatively, ").concat(defaultAdvice);
+          const causation = depType === 'conditional' || depType === 'logical expression' ? 'could make' : 'makes';
+          const message = "The '".concat(construction.name.name, "' ").concat(depType, " ").concat(causation, " the dependencies of ") + "".concat(reactiveHookName, " Hook (at line ").concat(declaredDependenciesNode.loc.start.line, ") ") + "change on every render. ".concat(advice);
+          let suggest;
+          if (isUsedOutsideOfHook && construction.type === 'Variable' &&
+          depType === 'function') {
+            suggest = [{
+              desc: "Wrap the ".concat(constructionType, " of '").concat(construction.name.name, "' in its own ").concat(wrapperHook, "() Hook."),
+              fix(fixer) {
+                const [before, after] = wrapperHook === 'useMemo' ? ["useMemo(() => { return ", '; })'] : ['useCallback(', ')'];
+                return [
+                fixer.insertTextBefore(construction.node.init, before),
+                fixer.insertTextAfter(construction.node.init, after)];
+              }
+            }];
+          }
+          reportProblem({
+            node: construction.node,
+            message,
+            suggest
+          });
+        });
+        return;
+      }
+      if (!isEffect && missingDependencies.size > 0) {
+        suggestedDeps = collectRecommendations({
+          dependencies,
+          declaredDependencies: [],
+          stableDependencies,
+          externalDependencies,
+          isEffect
+        }).suggestedDependencies;
+      }
+      function areDeclaredDepsAlphabetized() {
+        if (declaredDependencies.length === 0) {
+          return true;
+        }
+        const declaredDepKeys = declaredDependencies.map(dep => dep.key);
+        const sortedDeclaredDepKeys = [...declaredDepKeys].sort();
+        return declaredDepKeys.join(',') === sortedDeclaredDepKeys.join(',');
+      }
+      if (areDeclaredDepsAlphabetized()) {
+        suggestedDeps.sort();
+      }
+      function formatDependency(path) {
+        const members = path.split('.');
+        let finalPath = '';
+        for (let i = 0; i < members.length; i++) {
+          if (i !== 0) {
+            const pathSoFar = members.slice(0, i + 1).join('.');
+            const isOptional = optionalChains.get(pathSoFar) === true;
+            finalPath += isOptional ? '?.' : '.';
+          }
+          finalPath += members[i];
+        }
+        return finalPath;
+      }
+      function getWarningMessage(deps, singlePrefix, label, fixVerb) {
+        if (deps.size === 0) {
+          return null;
+        }
+        return (deps.size > 1 ? '' : singlePrefix + ' ') + label + ' ' + (deps.size > 1 ? 'dependencies' : 'dependency') + ': ' + joinEnglish([...deps].sort().map(name => "'" + formatDependency(name) + "'")) + ". Either ".concat(fixVerb, " ").concat(deps.size > 1 ? 'them' : 'it', " or remove the dependency array.");
+      }
+      let extraWarning = '';
+      if (unnecessaryDependencies.size > 0) {
+        let badRef = null;
+        [...unnecessaryDependencies.keys()].forEach(key => {
+          if (badRef != null) {
+            return;
+          }
+          if (key.endsWith('.current')) {
+            badRef = key;
+          }
+        });
+        if (badRef != null) {
+          extraWarning = " Mutable values like '".concat(badRef, "' aren't valid dependencies ") + "because mutating them doesn't re-render the component.";
+        } else if (externalDependencies.size > 0) {
+          const dep = [...externalDependencies][0];
+          if (!scope.set.has(dep)) {
+            extraWarning = " Outer scope values like '".concat(dep, "' aren't valid dependencies ") + "because mutating them doesn't re-render the component.";
+          }
+        }
+      }
+      if (!extraWarning && missingDependencies.has('props')) {
+        const propDep = dependencies.get('props');
+        if (propDep == null) {
+          return;
+        }
+        const refs = propDep.references;
+        if (!Array.isArray(refs)) {
+          return;
+        }
+        let isPropsOnlyUsedInMembers = true;
+        for (const ref of refs) {
+          const id = fastFindReferenceWithParent(componentScope.block, ref.identifier);
+          if (!id) {
+            isPropsOnlyUsedInMembers = false;
+            break;
+          }
+          const parent = id.parent;
+          if (parent == null) {
+            isPropsOnlyUsedInMembers = false;
+            break;
+          }
+          if (parent.type !== 'MemberExpression' && parent.type !== 'OptionalMemberExpression') {
+            isPropsOnlyUsedInMembers = false;
+            break;
+          }
+        }
+        if (isPropsOnlyUsedInMembers) {
+          extraWarning = " However, 'props' will change when *any* prop changes, so the " + "preferred fix is to destructure the 'props' object outside of " + "the ".concat(reactiveHookName, " call and refer to those specific props ") + "inside ".concat(getSource(reactiveHook), ".");
+        }
+      }
+      if (!extraWarning && missingDependencies.size > 0) {
+        let missingCallbackDep = null;
+        missingDependencies.forEach(missingDep => {
+          if (missingCallbackDep) {
+            return;
+          }
+          const topScopeRef = componentScope.set.get(missingDep);
+          const usedDep = dependencies.get(missingDep);
+          if (usedDep.references[0].resolved !== topScopeRef) {
+            return;
+          }
+          const def = topScopeRef.defs[0];
+          if (def == null || def.name == null || def.type !== 'Parameter') {
+            return;
+          }
+          let isFunctionCall = false;
+          let id;
+          for (let i = 0; i < usedDep.references.length; i++) {
+            id = usedDep.references[i].identifier;
+            if (id != null && id.parent != null && (id.parent.type === 'CallExpression' || id.parent.type === 'OptionalCallExpression') && id.parent.callee === id) {
+              isFunctionCall = true;
+              break;
+            }
+          }
+          if (!isFunctionCall) {
+            return;
+          }
+          missingCallbackDep = missingDep;
+        });
+        if (missingCallbackDep != null) {
+          extraWarning = " If '".concat(missingCallbackDep, "' changes too often, ") + "find the parent component that defines it " + "and wrap that definition in useCallback.";
+        }
+      }
+      if (!extraWarning && missingDependencies.size > 0) {
+        let setStateRecommendation = null;
+        missingDependencies.forEach(missingDep => {
+          if (setStateRecommendation != null) {
+            return;
+          }
+          const usedDep = dependencies.get(missingDep);
+          const references = usedDep.references;
+          let id;
+          let maybeCall;
+          for (const reference of references) {
+            id = reference.identifier;
+            maybeCall = id.parent;
+            while (maybeCall != null && maybeCall !== componentScope.block) {
+              if (maybeCall.type === 'CallExpression') {
+                const correspondingStateVariable = setStateCallSites.get(maybeCall.callee);
+                if (correspondingStateVariable != null) {
+                  if (correspondingStateVariable.name === missingDep) {
+                    setStateRecommendation = {
+                      missingDep,
+                      setter: maybeCall.callee.name,
+                      form: 'updater'
+                    };
+                  } else if (stateVariables.has(id)) {
+                    setStateRecommendation = {
+                      missingDep,
+                      setter: maybeCall.callee.name,
+                      form: 'reducer'
+                    };
+                  } else {
+                    const resolved = reference.resolved;
+                    if (resolved != null) {
+                      const def = resolved.defs[0];
+                      if (def != null && def.type === 'Parameter') {
+                        setStateRecommendation = {
+                          missingDep,
+                          setter: maybeCall.callee.name,
+                          form: 'inlineReducer'
+                        };
+                      }
+                    }
+                  }
+                  break;
+                }
+              }
+              maybeCall = maybeCall.parent;
+            }
+            if (setStateRecommendation != null) {
+              break;
+            }
+          }
+        });
+        if (setStateRecommendation != null) {
+          switch (setStateRecommendation.form) {
+            case 'reducer':
+              extraWarning = " You can also replace multiple useState variables with useReducer " + "if '".concat(setStateRecommendation.setter, "' needs the ") + "current value of '".concat(setStateRecommendation.missingDep, "'.");
+              break;
+            case 'inlineReducer':
+              extraWarning = " If '".concat(setStateRecommendation.setter, "' needs the ") + "current value of '".concat(setStateRecommendation.missingDep, "', ") + "you can also switch to useReducer instead of useState and " + "read '".concat(setStateRecommendation.missingDep, "' in the reducer.");
+              break;
+            case 'updater':
+              extraWarning = " You can also do a functional update '".concat(setStateRecommendation.setter, "(").concat(setStateRecommendation.missingDep.slice(0, 1), " => ...)' if you only need '").concat(setStateRecommendation.missingDep
+              , "'") + " in the '".concat(setStateRecommendation.setter, "' call.");
+              break;
+            default:
+              throw new Error('Unknown case.');
+          }
+        }
+      }
+      reportProblem({
+        node: declaredDependenciesNode,
+        message: "React Hook ".concat(getSource(reactiveHook), " has ") + (
+        getWarningMessage(missingDependencies, 'a', 'missing', 'include') || getWarningMessage(unnecessaryDependencies, 'an', 'unnecessary', 'exclude') || getWarningMessage(duplicateDependencies, 'a', 'duplicate', 'omit')) + extraWarning,
+        suggest: [{
+          desc: "Update the dependencies array to be: [".concat(suggestedDeps.map(element => formatDependency(element)).join(', '), "]"),
+          fix(fixer) {
+            return fixer.replaceText(declaredDependenciesNode, "[".concat(suggestedDeps.map(element => formatDependency(element)).join(', '), "]"));
+          }
+        }]
+      });
+    }
+    function visitCallExpression(node) {
+      const callbackIndex = getReactiveHookCallbackIndex(node.callee, options);
+      if (callbackIndex === -1) {
+        return;
+      }
+      const callback = node.arguments[callbackIndex];
+      const reactiveHook = node.callee;
+      const reactiveHookName = getNodeWithoutReactNamespace(reactiveHook).name;
+      const maybeNode = node.arguments[callbackIndex + 1];
+      const declaredDependenciesNode = maybeNode && !(maybeNode.type === 'Identifier' && maybeNode.name === 'undefined') ? maybeNode : undefined;
+      const isEffect = /Effect($|[^a-z])/g.test(reactiveHookName);
+      if (!callback) {
+        reportProblem({
+          node: reactiveHook,
+          message: "React Hook ".concat(reactiveHookName, " requires an effect callback. ") + "Did you forget to pass a callback to the hook?"
+        });
+        return;
+      }
+      if (!declaredDependenciesNode && !isEffect) {
+        if (reactiveHookName === 'useMemo' || reactiveHookName === 'useCallback') {
+          reportProblem({
+            node: reactiveHook,
+            message: "React Hook ".concat(reactiveHookName, " does nothing when called with ") + "only one argument. Did you forget to pass an array of " + "dependencies?"
+          });
+        }
+        return;
+      }
+      switch (callback.type) {
+        case 'FunctionExpression':
+        case 'ArrowFunctionExpression':
+          visitFunctionWithDependencies(callback, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect);
+          return;
+        case 'TSAsExpression':
+          visitFunctionWithDependencies(callback.expression, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect);
+          return;
+        case 'Identifier':
+          if (!declaredDependenciesNode) {
+            return;
+          }
+          if (declaredDependenciesNode.elements && declaredDependenciesNode.elements.some(el => el && el.type === 'Identifier' && el.name === callback.name)) {
+            return;
+          }
+          const variable = getScope(callback).set.get(callback.name);
+          if (variable == null || variable.defs == null) {
+            return;
+          }
+          const def = variable.defs[0];
+          if (!def || !def.node) {
+            break;
+          }
+          if (def.type !== 'Variable' && def.type !== 'FunctionName') {
+            break;
+          }
+          switch (def.node.type) {
+            case 'FunctionDeclaration':
+              visitFunctionWithDependencies(def.node, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect);
+              return;
+            case 'VariableDeclarator':
+              const init = def.node.init;
+              if (!init) {
+                break;
+              }
+              switch (init.type) {
+                case 'ArrowFunctionExpression':
+                case 'FunctionExpression':
+                  visitFunctionWithDependencies(init, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect);
+                  return;
+              }
+              break;
+          }
+          break;
+        default:
+          reportProblem({
+            node: reactiveHook,
+            message: "React Hook ".concat(reactiveHookName, " received a function whose dependencies ") + "are unknown. Pass an inline function instead."
+          });
+          return;
+      }
+      reportProblem({
+        node: reactiveHook,
+        message: "React Hook ".concat(reactiveHookName, " has a missing dependency: '").concat(callback.name, "'. ") + "Either include it or remove the dependency array.",
+        suggest: [{
+          desc: "Update the dependencies array to be: [".concat(callback.name, "]"),
+          fix(fixer) {
+            return fixer.replaceText(declaredDependenciesNode, "[".concat(callback.name, "]"));
+          }
+        }]
+      });
+    }
+    return {
+      CallExpression: visitCallExpression
+    };
+  }
+};
+function collectRecommendations({
+  dependencies,
+  declaredDependencies,
+  stableDependencies,
+  externalDependencies,
+  isEffect
+}) {
+  const depTree = createDepTree();
+  function createDepTree() {
+    return {
+      isUsed: false,
+      isSatisfiedRecursively: false,
+      isSubtreeUsed: false,
+      children: new Map()
+    };
+  }
+  dependencies.forEach((_, key) => {
+    const node = getOrCreateNodeByPath(depTree, key);
+    node.isUsed = true;
+    markAllParentsByPath(depTree, key, parent => {
+      parent.isSubtreeUsed = true;
+    });
+  });
+  declaredDependencies.forEach(({
+    key
+  }) => {
+    const node = getOrCreateNodeByPath(depTree, key);
+    node.isSatisfiedRecursively = true;
+  });
+  stableDependencies.forEach(key => {
+    const node = getOrCreateNodeByPath(depTree, key);
+    node.isSatisfiedRecursively = true;
+  });
+  function getOrCreateNodeByPath(rootNode, path) {
+    const keys = path.split('.');
+    let node = rootNode;
+    for (const key of keys) {
+      let child = node.children.get(key);
+      if (!child) {
+        child = createDepTree();
+        node.children.set(key, child);
+      }
+      node = child;
+    }
+    return node;
+  }
+  function markAllParentsByPath(rootNode, path, fn) {
+    const keys = path.split('.');
+    let node = rootNode;
+    for (const key of keys) {
+      const child = node.children.get(key);
+      if (!child) {
+        return;
+      }
+      fn(child);
+      node = child;
+    }
+  }
+  const missingDependencies = new Set();
+  const satisfyingDependencies = new Set();
+  scanTreeRecursively(depTree, missingDependencies, satisfyingDependencies, key => key);
+  function scanTreeRecursively(node, missingPaths, satisfyingPaths, keyToPath) {
+    node.children.forEach((child, key) => {
+      const path = keyToPath(key);
+      if (child.isSatisfiedRecursively) {
+        if (child.isSubtreeUsed) {
+          satisfyingPaths.add(path);
+        }
+        return;
+      }
+      if (child.isUsed) {
+        missingPaths.add(path);
+        return;
+      }
+      scanTreeRecursively(child, missingPaths, satisfyingPaths, childKey => path + '.' + childKey);
+    });
+  }
+  const suggestedDependencies = [];
+  const unnecessaryDependencies = new Set();
+  const duplicateDependencies = new Set();
+  declaredDependencies.forEach(({
+    key
+  }) => {
+    if (satisfyingDependencies.has(key)) {
+      if (!suggestedDependencies.includes(key)) {
+        suggestedDependencies.push(key);
+      } else {
+        duplicateDependencies.add(key);
+      }
+    } else if (isEffect && !key.endsWith('.current') && !externalDependencies.has(key)) {
+      if (!suggestedDependencies.includes(key)) {
+        suggestedDependencies.push(key);
+      }
+    } else {
+      unnecessaryDependencies.add(key);
+    }
+  });
+  missingDependencies.forEach(key => {
+    suggestedDependencies.push(key);
+  });
+  return {
+    suggestedDependencies,
+    unnecessaryDependencies,
+    duplicateDependencies,
+    missingDependencies
+  };
+}
+function getConstructionExpressionType(node) {
+  switch (node.type) {
+    case 'ObjectExpression':
+      return 'object';
+    case 'ArrayExpression':
+      return 'array';
+    case 'ArrowFunctionExpression':
+    case 'FunctionExpression':
+      return 'function';
+    case 'ClassExpression':
+      return 'class';
+    case 'ConditionalExpression':
+      if (getConstructionExpressionType(node.consequent) != null || getConstructionExpressionType(node.alternate) != null) {
+        return 'conditional';
+      }
+      return null;
+    case 'LogicalExpression':
+      if (getConstructionExpressionType(node.left) != null || getConstructionExpressionType(node.right) != null) {
+        return 'logical expression';
+      }
+      return null;
+    case 'JSXFragment':
+      return 'JSX fragment';
+    case 'JSXElement':
+      return 'JSX element';
+    case 'AssignmentExpression':
+      if (getConstructionExpressionType(node.right) != null) {
+        return 'assignment expression';
+      }
+      return null;
+    case 'NewExpression':
+      return 'object construction';
+    case 'Literal':
+      if (node.value instanceof RegExp) {
+        return 'regular expression';
+      }
+      return null;
+    case 'TypeCastExpression':
+    case 'AsExpression':
+    case 'TSAsExpression':
+      return getConstructionExpressionType(node.expression);
+  }
+  return null;
+}
+function scanForConstructions({
+  declaredDependencies,
+  declaredDependenciesNode,
+  componentScope,
+  scope
+}) {
+  const constructions = declaredDependencies.map(({
+    key
+  }) => {
+    const ref = componentScope.variables.find(v => v.name === key);
+    if (ref == null) {
+      return null;
+    }
+    const node = ref.defs[0];
+    if (node == null) {
+      return null;
+    }
+    if (node.type === 'Variable' && node.node.type === 'VariableDeclarator' && node.node.id.type === 'Identifier' &&
+    node.node.init != null) {
+      const constantExpressionType = getConstructionExpressionType(node.node.init);
+      if (constantExpressionType != null) {
+        return [ref, constantExpressionType];
+      }
+    }
+    if (node.type === 'FunctionName' && node.node.type === 'FunctionDeclaration') {
+      return [ref, 'function'];
+    }
+    if (node.type === 'ClassName' && node.node.type === 'ClassDeclaration') {
+      return [ref, 'class'];
+    }
+    return null;
+  }).filter(Boolean);
+  function isUsedOutsideOfHook(ref) {
+    let foundWriteExpr = false;
+    for (let i = 0; i < ref.references.length; i++) {
+      const reference = ref.references[i];
+      if (reference.writeExpr) {
+        if (foundWriteExpr) {
+          return true;
+        }
+        foundWriteExpr = true;
+        continue;
+      }
+      let currentScope = reference.from;
+      while (currentScope !== scope && currentScope != null) {
+        currentScope = currentScope.upper;
+      }
+      if (currentScope !== scope &&
+      !isAncestorNodeOf(declaredDependenciesNode, reference.identifier)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  return constructions.map(([ref, depType]) => ({
+    construction: ref.defs[0],
+    depType,
+    isUsedOutsideOfHook: isUsedOutsideOfHook(ref)
+  }));
+}
+function getDependency(node) {
+  if ((node.parent.type === 'MemberExpression' || node.parent.type === 'OptionalMemberExpression') && node.parent.object === node && node.parent.property.name !== 'current' && !node.parent.computed && !(node.parent.parent != null && (node.parent.parent.type === 'CallExpression' || node.parent.parent.type === 'OptionalCallExpression') && node.parent.parent.callee === node.parent)) {
+    return getDependency(node.parent);
+  } else if (
+  node.type === 'MemberExpression' && node.parent && node.parent.type === 'AssignmentExpression' && node.parent.left === node) {
+    return node.object;
+  }
+  return node;
+}
+function markNode(node, optionalChains, result) {
+  if (optionalChains) {
+    if (node.optional) {
+      if (!optionalChains.has(result)) {
+        optionalChains.set(result, true);
+      }
+    } else {
+      optionalChains.set(result, false);
+    }
+  }
+}
+function analyzePropertyChain(node, optionalChains) {
+  if (node.type === 'Identifier' || node.type === 'JSXIdentifier') {
+    const result = node.name;
+    if (optionalChains) {
+      optionalChains.set(result, false);
+    }
+    return result;
+  } else if (node.type === 'MemberExpression' && !node.computed) {
+    const object = analyzePropertyChain(node.object, optionalChains);
+    const property = analyzePropertyChain(node.property, null);
+    const result = "".concat(object, ".").concat(property);
+    markNode(node, optionalChains, result);
+    return result;
+  } else if (node.type === 'OptionalMemberExpression' && !node.computed) {
+    const object = analyzePropertyChain(node.object, optionalChains);
+    const property = analyzePropertyChain(node.property, null);
+    const result = "".concat(object, ".").concat(property);
+    markNode(node, optionalChains, result);
+    return result;
+  } else if (node.type === 'ChainExpression' && !node.computed) {
+    const expression = node.expression;
+    if (expression.type === 'CallExpression') {
+      throw new Error("Unsupported node type: ".concat(expression.type));
+    }
+    const object = analyzePropertyChain(expression.object, optionalChains);
+    const property = analyzePropertyChain(expression.property, null);
+    const result = "".concat(object, ".").concat(property);
+    markNode(expression, optionalChains, result);
+    return result;
+  }
+  throw new Error("Unsupported node type: ".concat(node.type));
+}
+function getNodeWithoutReactNamespace(node) {
+  if (node.type === 'MemberExpression' && node.object.type === 'Identifier' && node.object.name === 'React' && node.property.type === 'Identifier' && !node.computed) {
+    return node.property;
+  }
+  return node;
+}
+function getReactiveHookCallbackIndex(calleeNode, options) {
+  const node = getNodeWithoutReactNamespace(calleeNode);
+  if (node.type !== 'Identifier') {
+    return -1;
+  }
+  switch (node.name) {
+    case 'useEffect':
+    case 'useLayoutEffect':
+    case 'useCallback':
+    case 'useMemo':
+      return 0;
+    case 'useImperativeHandle':
+      return 1;
+    default:
+      if (node === calleeNode && options && options.customHooks) {
+        let name;
+        try {
+          name = analyzePropertyChain(node, null);
+        } catch (err) {
+          if (/Unsupported node type/.test(err.message)) {
+            return 0;
+          }
+          throw err;
+        }
+        for (const [key, customParts] of Object.entries(options.customHooks)) {
+          if (typeof customParts === 'object' && typeof customParts.callbackIndex === 'number' && new RegExp(key).test(name)) {
+            return customParts.callbackIndex;
+          }
+        }
+      }
+      if (node === calleeNode && options && options.additionalHooks) {
+        let name;
+        try {
+          name = analyzePropertyChain(node, null);
+        } catch (err) {
+          if (/Unsupported node type/.test(err.message)) {
+            return 0;
+          }
+          throw err;
+        }
+        return options.additionalHooks.test(name) ? 0 : -1;
+      }
+      return -1;
+  }
+}
+function fastFindReferenceWithParent(start, target) {
+  const queue = [start];
+  let item = null;
+  while (queue.length > 0) {
+    item = queue.shift();
+    if (isSameIdentifier(item, target)) {
+      return item;
+    }
+    if (!isAncestorNodeOf(item, target)) {
+      continue;
+    }
+    for (const [key, value] of Object.entries(item)) {
+      if (key === 'parent') {
+        continue;
+      }
+      if (isNodeLike(value)) {
+        value.parent = item;
+        queue.push(value);
+      } else if (Array.isArray(value)) {
+        value.forEach(val => {
+          if (isNodeLike(val)) {
+            val.parent = item;
+            queue.push(val);
+          }
+        });
+      }
+    }
+  }
+  return null;
+}
+function joinEnglish(arr) {
+  let s = '';
+  for (let i = 0; i < arr.length; i++) {
+    s += arr[i];
+    if (i === 0 && arr.length === 2) {
+      s += ' and ';
+    } else if (i === arr.length - 2 && arr.length > 2) {
+      s += ', and ';
+    } else if (i < arr.length - 1) {
+      s += ', ';
+    }
+  }
+  return s;
+}
+function isNodeLike(val) {
+  return typeof val === 'object' && val != null && !Array.isArray(val) && typeof val.type === 'string';
+}
+function isSameIdentifier(a, b) {
+  return (a.type === 'Identifier' || a.type === 'JSXIdentifier') && a.type === b.type && a.name === b.name && a.range[0] === b.range[0] && a.range[1] === b.range[1];
+}
+function isAncestorNodeOf(a, b) {
+  return a.range[0] <= b.range[0] && a.range[1] >= b.range[1];
+}
+function isUseEffectEventIdentifier(node) {
+  return false;
+}
+
+const RULE_NAME$5 = 'react-hook-use-ref';
+var reactHookUseRef = createRule({
+  name: RULE_NAME$5,
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Ensure naming of useRef hook value.',
+      recommended: 'recommended'
+    },
+    schema: [],
+    hasSuggestions: true,
+    messages: {
+      useRefName: 'useRef call is not end with "Ref"'
+    }
+  },
+  defaultOptions: [],
+  create: Components["default"].detect((context, component, util) => ({
+    CallExpression(node) {
+      const isImmediateReturn = node.parent && node.parent.type === AST_NODE_TYPES.ReturnStatement;
+      if (isImmediateReturn || !util.isReactHookCall(node, ['useRef'])) {
+        return;
+      }
+      if (node.parent.id.type !== AST_NODE_TYPES.Identifier) {
+        return;
+      }
+      const variable = node.parent.id.name;
+      if (!variable.endsWith('Ref')) {
+        context.report({
+          node: node,
+          messageId: 'useRefName'
+        });
+      }
+    }
+  }))
+});
+
+const RULE_NAME$4 = 'react-prefer-sx-prop';
+var reactPreferSxProp = createRule({
+  name: RULE_NAME$4,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Prefer using sx prop instead of inline styles',
+      recommended: 'recommended'
+    },
+    messages: {
+      preferSxProp: 'Avoid using inline styles, use sx prop or tss-react or styled-component instead'
+    },
+    schema: [{
+      type: 'object',
+      properties: {
+        allowedFor: {
+          type: 'array',
+          uniqueItems: true,
+          items: {
+            type: 'string'
+          }
+        }
+      }
+    }]
+  },
+  defaultOptions: [],
+  create(context) {
+    const configuration = context.options[0] || {};
+    const allowedFor = configuration.allowedFor || [];
+    function checkComponent(node) {
+      const parentName = node.parent.name;
+      const tag = parentName.name || "".concat(parentName.object.name, ".").concat(parentName.property.name);
+      const componentName = parentName.name || parentName.property.name;
+      if (componentName && typeof componentName[0] === 'string' && componentName[0] !== componentName[0].toUpperCase()) {
+        return;
+      }
+      if (allowedFor.includes(tag)) {
+        return;
+      }
+      const prop = node.name.name;
+      if (prop === 'style') {
+        context.report({
+          node,
+          messageId: 'preferSxProp'
+        });
+      }
+    }
+    function checkDOMNodes(node) {
+      const tag = node.parent.name.name;
+      if (!(tag && typeof tag === 'string' && tag[0] !== tag[0].toUpperCase())) {
+        return;
+      }
+      if (allowedFor.includes(tag)) {
+        return;
+      }
+      const prop = node.name.name;
+      if (prop === 'style') {
+        context.report({
+          node,
+          messageId: 'preferSxProp'
+        });
+      }
+    }
+    return {
+      JSXAttribute(node) {
+        checkComponent(node);
+        checkDOMNodes(node);
+      }
+    };
+  }
+});
+
+function getBasicIdentifier(node) {
+  if (node.type === AST_NODE_TYPES.Identifier) {
+    return node.name;
+  }
+  if (node.type === AST_NODE_TYPES.Literal) {
+    return node.value;
+  }
+  if (node.type === AST_NODE_TYPES.TemplateLiteral) {
+    if (node.expressions.length > 0) {
+      return null;
+    }
+    return node.quasis[0].value.raw;
+  }
+  return null;
+}
+function getBaseIdentifier(node) {
+  switch (node.type) {
+    case AST_NODE_TYPES.Identifier:
+      {
+        return node;
+      }
+    case AST_NODE_TYPES.CallExpression:
+      {
+        return getBaseIdentifier(node.callee);
+      }
+    case AST_NODE_TYPES.MemberExpression:
+      {
+        return getBaseIdentifier(node.object);
+      }
+  }
+  return null;
+}
+function getStyesObj(node) {
+  const isMakeStyles = node.callee.name === 'makeStyles';
+  const isModernApi = node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.name === 'create' && getBaseIdentifier(node.callee.object) && getBaseIdentifier(node.callee.object).name === 'tss';
+  if (!isMakeStyles && !isModernApi) {
+    return;
+  }
+  const styles = (() => {
+    if (isMakeStyles) {
+      return node.parent.arguments[0];
+    }
+    if (isModernApi) {
+      return node.callee.parent.arguments[0];
+    }
+  })();
+  if (!styles) {
+    return;
+  }
+  switch (styles.type) {
+    case AST_NODE_TYPES.ObjectExpression:
+      return styles;
+    case AST_NODE_TYPES.ArrowFunctionExpression:
+      {
+        const {
+          body
+        } = styles;
+        switch (body.type) {
+          case AST_NODE_TYPES.ObjectExpression:
+            return body;
+          case AST_NODE_TYPES.BlockStatement:
+            {
+              let stylesObj;
+              body.body.forEach(bodyNode => {
+                if (bodyNode.type === AST_NODE_TYPES.ReturnStatement && bodyNode.argument.type === AST_NODE_TYPES.ObjectExpression) {
+                  stylesObj = bodyNode.argument;
+                }
+              });
+              return stylesObj;
+            }
+        }
+      }
+      break;
+  }
+}
+function loopStylesObj(node, callback) {
+  if (node && node.type === AST_NODE_TYPES.ObjectExpression) {
+    node.properties.forEach(property => {
+      if (property.type === AST_NODE_TYPES.Property && property.value) {
+        if (property.value.type === AST_NODE_TYPES.ObjectExpression) {
+          loopStylesObj(property.value, callback);
+        } else {
+          callback(property.value);
+        }
+      }
+    });
+  }
+}
+
+const RULE_NAME$3 = 'tss-class-naming';
+var tssClassNaming = createRule({
+  name: RULE_NAME$3,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Enforce camelCase class names in TSS',
+      recommended: 'recommended'
+    },
+    schema: [],
+    messages: {
+      camelCase: 'Class `{{ className }}` must be camelCase in TSS.'
+    }
+  },
+  defaultOptions: [],
+  create: function rule(context) {
+    return {
+      CallExpression(node) {
+        const stylesObj = getStyesObj(node);
+        if (stylesObj === undefined) {
+          return;
+        }
+        stylesObj.properties.forEach(property => {
+          if (property.computed) {
+            return;
+          }
+          if (property.type === 'ExperimentalSpreadProperty' || property.type === AST_NODE_TYPES.SpreadElement) {
+            return;
+          }
+          const className = property.key.value || property.key.name;
+          if (!isCamelCase(className)) {
+            context.report({
+              node: property,
+              messageId: 'camelCase',
+              data: {
+                className
+              }
+            });
+          }
+        });
+      }
+    };
+  }
+});
+
+var colors = {
+  aliceblue: [240, 248, 255],
+  antiquewhite: [250, 235, 215],
+  aqua: [0, 255, 255],
+  aquamarine: [127, 255, 212],
+  azure: [240, 255, 255],
+  beige: [245, 245, 220],
+  bisque: [255, 228, 196],
+  black: [0, 0, 0],
+  blanchedalmond: [255, 235, 205],
+  blue: [0, 0, 255],
+  blueviolet: [138, 43, 226],
+  brown: [165, 42, 42],
+  burlywood: [222, 184, 135],
+  cadetblue: [95, 158, 160],
+  chartreuse: [127, 255, 0],
+  chocolate: [210, 105, 30],
+  coral: [255, 127, 80],
+  cornflowerblue: [100, 149, 237],
+  cornsilk: [255, 248, 220],
+  crimson: [220, 20, 60],
+  cyan: [0, 255, 255],
+  darkblue: [0, 0, 139],
+  darkcyan: [0, 139, 139],
+  darkgoldenrod: [184, 134, 11],
+  darkgray: [169, 169, 169],
+  darkgreen: [0, 100, 0],
+  darkgrey: [169, 169, 169],
+  darkkhaki: [189, 183, 107],
+  darkmagenta: [139, 0, 139],
+  darkolivegreen: [85, 107, 47],
+  darkorange: [255, 140, 0],
+  darkorchid: [153, 50, 204],
+  darkred: [139, 0, 0],
+  darksalmon: [233, 150, 122],
+  darkseagreen: [143, 188, 143],
+  darkslateblue: [72, 61, 139],
+  darkslategray: [47, 79, 79],
+  darkslategrey: [47, 79, 79],
+  darkturquoise: [0, 206, 209],
+  darkviolet: [148, 0, 211],
+  deeppink: [255, 20, 147],
+  deepskyblue: [0, 191, 255],
+  dimgray: [105, 105, 105],
+  dimgrey: [105, 105, 105],
+  dodgerblue: [30, 144, 255],
+  firebrick: [178, 34, 34],
+  floralwhite: [255, 250, 240],
+  forestgreen: [34, 139, 34],
+  fuchsia: [255, 0, 255],
+  gainsboro: [220, 220, 220],
+  ghostwhite: [248, 248, 255],
+  gold: [255, 215, 0],
+  goldenrod: [218, 165, 32],
+  gray: [128, 128, 128],
+  green: [0, 128, 0],
+  greenyellow: [173, 255, 47],
+  grey: [128, 128, 128],
+  honeydew: [240, 255, 240],
+  hotpink: [255, 105, 180],
+  indianred: [205, 92, 92],
+  indigo: [75, 0, 130],
+  ivory: [255, 255, 240],
+  khaki: [240, 230, 140],
+  lavender: [230, 230, 250],
+  lavenderblush: [255, 240, 245],
+  lawngreen: [124, 252, 0],
+  lemonchiffon: [255, 250, 205],
+  lightblue: [173, 216, 230],
+  lightcoral: [240, 128, 128],
+  lightcyan: [224, 255, 255],
+  lightgoldenrodyellow: [250, 250, 210],
+  lightgray: [211, 211, 211],
+  lightgreen: [144, 238, 144],
+  lightgrey: [211, 211, 211],
+  lightpink: [255, 182, 193],
+  lightsalmon: [255, 160, 122],
+  lightseagreen: [32, 178, 170],
+  lightskyblue: [135, 206, 250],
+  lightslategray: [119, 136, 153],
+  lightslategrey: [119, 136, 153],
+  lightsteelblue: [176, 196, 222],
+  lightyellow: [255, 255, 224],
+  lime: [0, 255, 0],
+  limegreen: [50, 205, 50],
+  linen: [250, 240, 230],
+  magenta: [255, 0, 255],
+  maroon: [128, 0, 0],
+  mediumaquamarine: [102, 205, 170],
+  mediumblue: [0, 0, 205],
+  mediumorchid: [186, 85, 211],
+  mediumpurple: [147, 112, 219],
+  mediumseagreen: [60, 179, 113],
+  mediumslateblue: [123, 104, 238],
+  mediumspringgreen: [0, 250, 154],
+  mediumturquoise: [72, 209, 204],
+  mediumvioletred: [199, 21, 133],
+  midnightblue: [25, 25, 112],
+  mintcream: [245, 255, 250],
+  mistyrose: [255, 228, 225],
+  moccasin: [255, 228, 181],
+  navajowhite: [255, 222, 173],
+  navy: [0, 0, 128],
+  oldlace: [253, 245, 230],
+  olive: [128, 128, 0],
+  olivedrab: [107, 142, 35],
+  orange: [255, 165, 0],
+  orangered: [255, 69, 0],
+  orchid: [218, 112, 214],
+  palegoldenrod: [238, 232, 170],
+  palegreen: [152, 251, 152],
+  paleturquoise: [175, 238, 238],
+  palevioletred: [219, 112, 147],
+  papayawhip: [255, 239, 213],
+  peachpuff: [255, 218, 185],
+  peru: [205, 133, 63],
+  pink: [255, 192, 203],
+  plum: [221, 160, 221],
+  powderblue: [176, 224, 230],
+  purple: [128, 0, 128],
+  rebeccapurple: [102, 51, 153],
+  red: [255, 0, 0],
+  rosybrown: [188, 143, 143],
+  royalblue: [65, 105, 225],
+  saddlebrown: [139, 69, 19],
+  salmon: [250, 128, 114],
+  sandybrown: [244, 164, 96],
+  seagreen: [46, 139, 87],
+  seashell: [255, 245, 238],
+  sienna: [160, 82, 45],
+  silver: [192, 192, 192],
+  skyblue: [135, 206, 235],
+  slateblue: [106, 90, 205],
+  slategray: [112, 128, 144],
+  slategrey: [112, 128, 144],
+  snow: [255, 250, 250],
+  springgreen: [0, 255, 127],
+  steelblue: [70, 130, 180],
+  tan: [210, 180, 140],
+  teal: [0, 128, 128],
+  thistle: [216, 191, 216],
+  tomato: [255, 99, 71],
+  turquoise: [64, 224, 208],
+  violet: [238, 130, 238],
+  wheat: [245, 222, 179],
+  white: [255, 255, 255],
+  whitesmoke: [245, 245, 245],
+  yellow: [255, 255, 0],
+  yellowgreen: [154, 205, 50]
+};
+
+const RULE_NAME$2 = 'tss-no-color-name';
+var tssNoColorName = createRule({
+  name: RULE_NAME$2,
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce the use of color variables instead of color name within TSS',
+      recommended: 'recommended'
+    },
+    schema: [],
+    messages: {
+      disallowColorName: 'Disallowed color name. Use color from `@mui/material/colors` or `theme.palette`.'
+    }
+  },
+  defaultOptions: [],
+  create: function (context) {
+    return {
+      CallExpression(node) {
+        const stylesObj = getStyesObj(node);
+        if (!stylesObj) {
+          return;
+        }
+        function checkColorLiteral(value) {
+          if (value.type === AST_NODE_TYPES.Literal && typeof value.value === 'string' && Object.keys(colors).includes(value.value.toLowerCase())) {
+            context.report({
+              node: value,
+              messageId: 'disallowColorName'
+            });
+          }
+        }
+        loopStylesObj(stylesObj, checkColorLiteral);
+      }
+    };
+  }
+});
+
+const RULE_NAME$1 = 'tss-no-color-value';
+var tssNoColorValue = createRule({
+  name: RULE_NAME$1,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Enforce the use of color variables instead of color codes within TSS',
+      recommended: 'recommended'
+    },
+    schema: [],
+    messages: {
+      preferMuiColor: 'Prefer use color from `@mui/material/colors` or `theme.palette`.'
+    }
+  },
+  defaultOptions: [],
+  create: function (context) {
+    return {
+      CallExpression(node) {
+        const stylesObj = getStyesObj(node);
+        if (!stylesObj) {
+          return;
+        }
+        function checkColorLiteral(value) {
+          if (value.type === AST_NODE_TYPES.Literal && typeof value.value === 'string') {
+            const colorCodePattern = /#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})|rgb\?\(\s*(\d{1,3}\s*,\s*){2}\d{1,3}(?:\s*,\s*\d*(?:\.\d+)?)?\s*\)/g;
+            if (colorCodePattern.test(value.value)) {
+              context.report({
+                node: value,
+                messageId: 'preferMuiColor'
+              });
+            }
+          }
+        }
+        loopStylesObj(stylesObj, checkColorLiteral);
+      }
+    };
+  }
+});
+
+const RULE_NAME = 'tss-unused-classes';
+var tssUnusedClasses = createRule({
+  name: RULE_NAME,
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow unused classes in tss',
+      recommended: 'recommended'
+    },
+    schema: [],
+    messages: {
+      unusedClass: 'Class `{{ className }}` is unused in JSX'
+    }
+  },
+  defaultOptions: [],
+  create: function rule(context) {
+    const usedClasses = {};
+    const definedClasses = {};
+    return {
+      CallExpression(node) {
+        const stylesObj = getStyesObj(node);
+        if (stylesObj === undefined) {
+          return;
+        }
+        stylesObj.properties.forEach(property => {
+          if (property.computed) {
+            return;
+          }
+          if (property.type === 'ExperimentalSpreadProperty' || property.type === AST_NODE_TYPES.SpreadElement) {
+            return;
+          }
+          definedClasses[property.key.value || property.key.name] = property;
+        });
+      },
+      MemberExpression(node) {
+        if (node.object.type === AST_NODE_TYPES.Identifier && node.object.name === 'classes') {
+          const whichClass = getBasicIdentifier(node.property);
+          if (whichClass) {
+            usedClasses[whichClass] = true;
+          }
+          return;
+        }
+        const classIdentifier = getBasicIdentifier(node.property);
+        if (!classIdentifier) {
+          return;
+        }
+        if (classIdentifier !== 'classes') {
+          return;
+        }
+        const {
+          parent
+        } = node;
+        if (parent.type !== AST_NODE_TYPES.MemberExpression) {
+          return;
+        }
+        if (
+        node.object.object &&
+        node.object.object.type !== AST_NODE_TYPES.ThisExpression) {
+          return;
+        }
+        const propsIdentifier = getBasicIdentifier(parent.object);
+        if (propsIdentifier && propsIdentifier !== 'props') {
+          return;
+        }
+        if (!propsIdentifier && parent.object.type !== AST_NODE_TYPES.MemberExpression) {
+          return;
+        }
+        if (parent.parent.type === AST_NODE_TYPES.MemberExpression) {
+          return;
+        }
+        const parentClassIdentifier = getBasicIdentifier(parent.property);
+        if (parentClassIdentifier) {
+          usedClasses[parentClassIdentifier] = true;
+        }
+      },
+      'Program:exit': () => {
+        Object.keys(definedClasses).forEach(definedClassKey => {
+          if (!usedClasses[definedClassKey]) {
+            context.report({
+              node: definedClasses[definedClassKey],
+              messageId: 'unusedClass',
+              data: {
+                className: definedClassKey
+              }
+            });
+          }
+        });
+      }
+    };
+  }
+});
+
+var ruleFiles = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  rules_enforce_mui_icon_alias: enforceMuiIconAlias,
+  rules_import_monorepo: importMonorepo,
+  rules_intl_id_missing: intlIdMissing,
+  rules_intl_id_naming: intlIdNaming,
+  rules_intl_id_prefix: intlIdPrefix,
+  rules_intl_id_unused: intlIdUnused,
+  rules_intl_no_default: intlNoDefault,
+  rules_no_async_array_methods: noAsyncArrayMethods,
+  rules_no_extends_error: noExtendsError,
+  rules_no_import_css: noImportCss,
+  rules_no_then_catch_finally: noThenCatchFinally,
+  rules_no_unnecessary_template_literals: noUnnecessaryTemplateLiterals,
+  rules_react_better_exhaustive_deps: reactBetterExhaustiveDeps,
+  rules_react_hook_use_ref: reactHookUseRef,
+  rules_react_prefer_sx_prop: reactPreferSxProp,
+  rules_tss_class_naming: tssClassNaming,
+  rules_tss_no_color_name: tssNoColorName,
+  rules_tss_no_color_value: tssNoColorValue,
+  rules_tss_unused_classes: tssUnusedClasses
+});
+
+const plugin = {
+  rules: {},
+  configs: {
+    recommended: {
+      plugins: ['@agilebot'],
+      rules: {},
+      settings: {
+        react: {
+          version: '18.0.0'
+        }
+      }
+    }
+  }
+};
+Object.keys(ruleFiles).forEach(key => {
+  const ruleKey = key.replace(/^rules_/, '');
+  const finalKey = ruleKey.replace(/_/g, '-');
+  const rule = ruleFiles[key];
+  plugin.rules[finalKey] = rule;
+  if (rule.meta && rule.meta.docs && rule.meta.docs.recommended) {
+    plugin.configs.recommended.rules["@agilebot/".concat(finalKey)] = rule.meta.type === 'problem' ? 'error' : 'warn';
+  }
+});
+
+export { plugin as default };