@agilebot/eslint-plugin 0.3.5 → 0.3.7

package/dist/index.js

@@ -1,5 +1,5 @@
 /**
- * @license @agilebot/eslint-plugin v0.3.5
+ * @license @agilebot/eslint-plugin v0.3.7
  *
  * Copyright (c) Agilebot, Inc. and its affiliates.
  *
@@ -33,7 +33,7 @@ function _interopNamespaceDefault(e) {
 var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 
-var enforceIconAlias = {
+var enforceMuiIconAlias = {
   meta: {
     type: 'problem',
     docs: {
@@ -49,10 +49,7 @@ var enforceIconAlias = {
   create(context) {
     return {
       ImportDeclaration(node) {
-        if (
-          node.source.value !== '@mui/icons-material' &&
-          node.source.value !== 'mdi-material-ui'
-        ) {
+        if (node.source.value !== '@mui/icons-material' && node.source.value !== 'mdi-material-ui') {
           return;
         }
         for (const specifier of node.specifiers) {
@@ -66,11 +63,7 @@ var enforceIconAlias = {
               data: {
                 name: node.source.value
               },
-              fix: fixer =>
-                fixer.replaceText(
-                  specifier,
-                  `${specifier.imported.name} as ${specifier.imported.name}Icon`
-                )
+              fix: fixer => fixer.replaceText(specifier, "".concat(specifier.imported.name, " as ").concat(specifier.imported.name, "Icon"))
             });
           }
         }
@@ -80,11 +73,19 @@ var enforceIconAlias = {
 };
 
 function getSetting(context, name) {
-  return context.settings[`agilebot/${name}`];
+  return context.settings["agilebot/".concat(name)];
 }
 
-let warnedForMissingPrefix = false;
-var monorepo = {
+const warned = new Set();
+function warnOnce(message) {
+  if (warned.has(message)) {
+    return;
+  }
+  warned.add(message);
+  console.warn("Warning: ".concat(message));
+}
+
+var importMonorepo = {
   meta: {
     type: 'problem',
     docs: {
@@ -102,13 +103,10 @@ var monorepo = {
       ImportDeclaration(node) {
         let prefix = getSetting(context, 'monorepo-scope');
         if (!prefix) {
-          if (!warnedForMissingPrefix) {
-            console.error('Warning: agilebot/monorepo-scope is not set.');
-            warnedForMissingPrefix = true;
-          }
+          warnOnce('agilebot/monorepo-scope is not set.');
           return;
         }
-        prefix = `${prefix}/`;
+        prefix = "".concat(prefix, "/");
         if (typeof node.source.value !== 'string') {
           return;
         }
@@ -124,10 +122,8 @@ var monorepo = {
               module: node.source.value
             },
             fix: fixer => {
-              const correctedPath = values
-                .filter((_, index) => index !== 2)
-                .join('/');
-              return fixer.replaceText(node.source, `'${correctedPath}'`);
+              const correctedPath = values.filter((_, index) => index !== 2).join('/');
+              return fixer.replaceText(node.source, "'".concat(correctedPath, "'"));
             }
           });
         }
@@ -137,74 +133,33 @@ var monorepo = {
 };
 
 function findFormatMessageAttrNode(node, attrName) {
-  if (
-    node.type === '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 === '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 === 'CallExpression' &&
-    node.callee.type === '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
-    );
+  if (node.type === 'CallExpression' && node.callee.type === '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 === 'JSXIdentifier' &&
-    node.name === 'FormattedMessage' &&
-    node.parent &&
-    node.parent.type === 'JSXOpeningElement'
-  ) {
+  if (node.type === 'JSXIdentifier' && node.name === 'FormattedMessage' && node.parent && node.parent.type === '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 === 'CallExpression' &&
-    node.parent.parent.parent.parent.callee.name === 'defineMessages'
-  ) {
+  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 === '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 === 'CallExpression' &&
-    node.parent.parent.callee.name === 'defineMessage'
-  ) {
+  if (node.type === 'Property' && node.key.name === attrName && node.parent && node.parent.parent && node.parent.parent.type === '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]
-  );
+  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('');
+  return sortedTemplateElements(node).map(e => !e.value ? '*' : e.value.raw).join('');
 }
 
 const localeFilesKeys = {};
@@ -218,22 +173,19 @@ function getIntlIds(context) {
   localeFiles.forEach(f => {
     const fullPath = projectRoot ? path__namespace.join(projectRoot, f) : f;
     const mtime = fs__namespace.lstatSync(fullPath).mtime.getTime();
-    if (
-      !localeFilesKeys[fullPath] ||
-      mtime !== localeFilesKeys[fullPath].mtime
-    ) {
+    if (!localeFilesKeys[fullPath] || mtime !== localeFilesKeys[fullPath].mtime) {
       let json;
       if (fullPath.endsWith('.json')) {
         json = JSON.parse(fs__namespace.readFileSync(fullPath, 'utf8'));
       } else if (fullPath.endsWith('.ts')) {
         json = eslintUtils.tsImport(fullPath);
-        if (typeof json === 'object' && json.default) {
-          json = json.default;
+        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;
+        if (typeof json === 'object' && json["default"]) {
+          json = json["default"];
         }
       } else {
         throw new Error('unsupported file extension');
@@ -248,7 +200,7 @@ function getIntlIds(context) {
   return results;
 }
 
-var idMissing = {
+var intlIdMissing = {
   meta: {
     docs: {
       description: 'Validates intl message ids are in locale file',
@@ -275,9 +227,7 @@ var idMissing = {
       }
     }
     function processTemplateLiteral(node) {
-      const exStr = sortedTemplateElements(node)
-        .map(e => (!e.value ? '.*' : e.value.raw))
-        .join('');
+      const exStr = sortedTemplateElements(node).map(e => !e.value ? '.*' : e.value.raw).join('');
       const re = new RegExp(exStr);
       if (!isTemplateTranslated(re)) {
         context.report({
@@ -290,10 +240,7 @@ var idMissing = {
       if (node.value.type === 'Literal') {
         return processLiteral(node.value);
       }
-      if (
-        node.value.type === 'JSXExpressionContainer' &&
-        node.value.expression.type === 'TemplateLiteral'
-      ) {
+      if (node.value.type === 'JSXExpressionContainer' && node.value.expression.type === 'TemplateLiteral') {
         return processTemplateLiteral(node.value.expression);
       }
       if (node.value.type === 'TemplateLiteral') {
@@ -318,9 +265,7 @@ var idMissing = {
         }
       },
       Property: function (node) {
-        const attrNode =
-          findAttrNodeInDefineMessages(node, 'id') ||
-          findAttrNodeInDefineMessage(node, 'id');
+        const attrNode = findAttrNodeInDefineMessages(node, 'id') || findAttrNodeInDefineMessage(node, 'id');
         if (attrNode) {
           return processAttrNode(attrNode);
         }
@@ -329,33 +274,122 @@ var idMissing = {
   }
 };
 
-var idPrefix = {
+var intlIdNaming = {
   meta: {
     docs: {
-      description: 'Validates intl message ids has correct prefixes',
+      description: 'Validates intl message ids naming convention',
       category: 'Intl'
     },
     fixable: undefined,
-    schema: [
-      {
-        type: 'array',
-        items: {
-          type: 'string'
+    schema: [{
+      type: 'object',
+      properties: {
+        format: {
+          "enum": ['camelCase', 'PascalCase']
         }
       }
-    ]
+    }],
+    messages: {
+      invalidIdNaming: "Invalid id naming, expected {{format}}"
+    }
+  },
+  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 (!eslintUtils.isCamelCase(v)) {
+              isPass = false;
+            }
+            break;
+          case 'PascalCase':
+            if (!eslintUtils.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 === 'Literal') {
+        return processLiteral(node.value);
+      }
+      if (node.value.type === 'JSXExpressionContainer' && node.value.expression.type === 'TemplateLiteral') {
+        return processTemplateLiteral(node.value.expression);
+      }
+      if (node.value.type === '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);
+        }
+      }
+    };
+  }
+};
+
+var intlIdPrefix = {
+  meta: {
+    docs: {
+      description: 'Validates intl message ids has correct prefixes',
+      category: 'Intl'
+    },
+    fixable: undefined,
+    schema: [{
+      type: 'array',
+      items: {
+        type: 'string'
+      }
+    }]
   },
   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));
+    const hasPrefix = value => context.options[0].some(p => value.startsWith(p));
     function report(node, value) {
       if (!hasPrefix(value)) {
         context.report({
           node: node,
-          message: `Invalid id prefix: ${value}`
+          message: "Invalid id prefix: ".concat(value)
         });
       }
     }
@@ -370,10 +404,7 @@ var idPrefix = {
       if (node.value.type === 'Literal') {
         return processLiteral(node.value);
       }
-      if (
-        node.value.type === 'JSXExpressionContainer' &&
-        node.value.expression.type === 'TemplateLiteral'
-      ) {
+      if (node.value.type === 'JSXExpressionContainer' && node.value.expression.type === 'TemplateLiteral') {
         return processTemplateLiteral(node.value.expression);
       }
       if (node.value.type === 'TemplateLiteral') {
@@ -394,9 +425,7 @@ var idPrefix = {
         }
       },
       Property: function (node) {
-        const attrNode =
-          findAttrNodeInDefineMessages(node, 'id') ||
-          findAttrNodeInDefineMessage(node, 'id');
+        const attrNode = findAttrNodeInDefineMessages(node, 'id') || findAttrNodeInDefineMessage(node, 'id');
         if (attrNode) {
           return processAttrNode(attrNode);
         }
@@ -406,7 +435,7 @@ var idPrefix = {
 };
 
 const usedIds = new Map();
-var idUnused = {
+var intlIdUnused = {
   meta: {
     docs: {
       description: 'Finds unused intl message ids in locale file',
@@ -438,9 +467,7 @@ var idUnused = {
       }
     }
     function processTemplateLiteral(node) {
-      const exStr = sortedTemplateElements(node)
-        .map(e => (!e.value ? '.*' : e.value.raw))
-        .join('');
+      const exStr = sortedTemplateElements(node).map(e => !e.value ? '.*' : e.value.raw).join('');
       const re = new RegExp(exStr);
       if (isTemplateTranslated(re)) ;
     }
@@ -448,10 +475,7 @@ var idUnused = {
       if (node.value.type === 'Literal') {
         return processLiteral(node.value);
       }
-      if (
-        node.value.type === 'JSXExpressionContainer' &&
-        node.value.expression.type === 'TemplateLiteral'
-      ) {
+      if (node.value.type === 'JSXExpressionContainer' && node.value.expression.type === 'TemplateLiteral') {
         return processTemplateLiteral(node.value.expression);
       }
       if (node.value.type === 'TemplateLiteral') {
@@ -472,9 +496,7 @@ var idUnused = {
         }
       },
       Property: function (node) {
-        const attrNode =
-          findAttrNodeInDefineMessages(node, 'id') ||
-          findAttrNodeInDefineMessage(node, 'id');
+        const attrNode = findAttrNodeInDefineMessages(node, 'id') || findAttrNodeInDefineMessage(node, 'id');
         if (attrNode) {
           return processAttrNode(attrNode);
         }
@@ -488,7 +510,7 @@ var idUnused = {
   }
 };
 
-var noDefault = {
+var intlNoDefault = {
   meta: {
     docs: {
       description: 'Validates defaultMessage is not used with react-intl',
@@ -518,9 +540,7 @@ var noDefault = {
         }
       },
       Property: function (node) {
-        const attrNode =
-          findAttrNodeInDefineMessages(node, 'defaultMessage') ||
-          findAttrNodeInDefineMessage(node, 'defaultMessage');
+        const attrNode = findAttrNodeInDefineMessages(node, 'defaultMessage') || findAttrNodeInDefineMessage(node, 'defaultMessage');
         if (attrNode) {
           return processAttrNode(attrNode);
         }
@@ -529,79 +549,213 @@ var noDefault = {
   }
 };
 
-var betterExhaustiveDeps = {
+var noAsyncArrayMethods = {
+  meta: {
+    docs: {
+      description: 'No async callback for Array methods forEach, map, filter, reduce, some, every, etc.',
+      category: 'Array',
+      recommended: true
+    },
+    fixable: undefined,
+    schema: [],
+    messages: {
+      noAsyncArrayMethods: "No async function in method '{{ methodName }}'"
+    }
+  },
+  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 ['ArrowFunctionExpression', 'FunctionExpression'].includes(n.type);
+          });
+          if (functionArguments && functionArguments.async) {
+            context.report({
+              node,
+              messageId: 'noAsyncArrayMethods',
+              data: {
+                methodName: callee.property.name
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+var noImportCss = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Prevent importing CSS',
+      recommended: true
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      noImportCSS: 'Do not import CSS files. Use CSS-in-JS instead.'
+    }
+  },
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        const ext = path.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
+            }
+          });
+        }
+      }
+    };
+  }
+};
+
+var noThenCatchFinally = {
+  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 }}()."
+    }
+  },
+  create(context) {
+    const configuration = context.options[0] || {};
+    const restrictedFunctions = configuration.restrictedFunctions || [];
+    function isTopLevelScoped() {
+      return context.getScope().block.type === 'Program';
+    }
+    function isThenCatchFinally(node) {
+      return node.property && (node.property.name === 'then' || node.property.name === 'catch' || node.property.name === 'finally');
+    }
+    return {
+      'CallExpression > MemberExpression.callee'(node) {
+        if (isTopLevelScoped()) {
+          return;
+        }
+        if (!isThenCatchFinally(node)) {
+          return;
+        }
+        const callExpression = node.object;
+        if (callExpression.type === 'CallExpression' && callExpression.callee.type === 'Identifier' && restrictedFunctions.includes(callExpression.callee.name)) {
+          context.report({
+            node: node.property,
+            messageId: 'forbiddenThenCatchFinally',
+            data: {
+              name: callExpression.callee.name
+            }
+          });
+        }
+      }
+    };
+  }
+};
+
+var noUnnecessaryTemplateLiterals = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Check if a template string contains only one ${}',
+      recommended: true
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      unnecessaryTemplateString: 'Unnecessary template string with only one ${}.'
+    }
+  },
+  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',
+      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'
-          },
-          staticHooks: {
-            type: 'object',
-            additionalProperties: {
-              oneOf: [
-                {
-                  type: 'boolean'
-                },
-                {
-                  type: 'array',
-                  items: {
-                    type: 'boolean'
-                  }
-                },
-                {
-                  type: 'object',
-                  additionalProperties: {
-                    type: 'boolean'
-                  }
-                }
-              ]
-            }
-          },
-          checkMemoizedVariableIsStatic: {
-            type: 'boolean'
+    schema: [{
+      type: 'object',
+      additionalProperties: false,
+      enableDangerousAutofixThisMayCauseInfiniteLoops: false,
+      properties: {
+        additionalHooks: {
+          type: 'string'
+        },
+        enableDangerousAutofixThisMayCauseInfiniteLoops: {
+          type: 'boolean'
+        },
+        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 staticHooks =
-      (context.options &&
-        context.options[0] &&
-        context.options[0].staticHooks) ||
-      {};
-    const checkMemoizedVariableIsStatic =
-      (context.options &&
-        context.options[0] &&
-        context.options[0].checkMemoizedVariableIsStatic) ||
-      false;
+    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 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,
       enableDangerousAutofixThisMayCauseInfiniteLoops,
@@ -609,11 +763,8 @@ var betterExhaustiveDeps = {
       checkMemoizedVariableIsStatic
     };
     function reportProblem(problem) {
-      if (
-        enableDangerousAutofixThisMayCauseInfiniteLoops &&
-        Array.isArray(problem.suggest) &&
-        problem.suggest.length > 0
-      ) {
+      if (enableDangerousAutofixThisMayCauseInfiniteLoops &&
+      Array.isArray(problem.suggest) && problem.suggest.length > 0) {
         problem.fix = problem.suggest[0].fix;
       }
       context.report(problem);
@@ -633,28 +784,11 @@ var betterExhaustiveDeps = {
         return result;
       };
     }
-    function visitFunctionWithDependencies(
-      node,
-      declaredDependenciesNode,
-      reactiveHook,
-      reactiveHookName,
-      isEffect
-    ) {
+    function visitFunctionWithDependencies(node, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect) {
       if (isEffect && node.async) {
         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://reactjs.org/link/hooks-data-fetching'
+          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://reactjs.org/link/hooks-data-fetching'
         });
       }
       const scope = scopeManager.acquire(node);
@@ -675,14 +809,8 @@ var betterExhaustiveDeps = {
         componentScope = currentScope;
       }
       const isArray = Array.isArray;
-      const memoizedIsStableKnownHookValue = memoizeWithWeakMap(
-        isStableKnownHookValue,
-        stableKnownValueCache
-      );
-      const memoizedIsFunctionWithoutCapturedValues = memoizeWithWeakMap(
-        isFunctionWithoutCapturedValues,
-        functionWithoutCapturedValueCache
-      );
+      const memoizedIsStableKnownHookValue = memoizeWithWeakMap(isStableKnownHookValue, stableKnownValueCache);
+      const memoizedIsFunctionWithoutCapturedValues = memoizeWithWeakMap(isFunctionWithoutCapturedValues, functionWithoutCapturedValueCache);
       function isStableKnownHookValue(resolved) {
         if (!isArray(resolved.defs)) {
           return false;
@@ -709,40 +837,27 @@ var betterExhaustiveDeps = {
             return false;
           }
         }
-        if (
-          declaration.kind === 'const' &&
-          init.type === 'Literal' &&
-          (typeof init.value === 'string' ||
-            typeof init.value === 'number' ||
-            init.value == null)
-        ) {
+        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
-        ) {
+        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;
+        const {
+          name
+        } = callee;
         if (name === 'useRef' && id.type === 'Identifier') {
           return true;
         } else if (name === 'useState' || name === 'useReducer') {
-          if (
-            id.type === 'ArrayPattern' &&
-            id.elements.length === 2 &&
-            isArray(resolved.identifiers)
-          ) {
+          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;
@@ -769,18 +884,11 @@ var betterExhaustiveDeps = {
             }
           }
         } else if (name === 'useTransition') {
-          if (
-            id.type === 'ArrayPattern' &&
-            id.elements.length === 2 &&
-            Array.isArray(resolved.identifiers) &&
-            id.elements[1] === resolved.identifiers[0]
-          ) {
+          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')
-        ) {
+        } else if (options.checkMemoizedVariableIsStatic && (name === 'useMemo' || name === 'useCallback')) {
           const hookArgs = callee.parent.arguments;
           if (hookArgs.length < 2) {
             return false;
@@ -790,13 +898,8 @@ var betterExhaustiveDeps = {
             return true;
           }
           for (const dependencyNode of dependencies) {
-            const dependencyRefernece = resolved.scope.references.find(
-              reference => reference.identifier === dependencyNode
-            );
-            if (
-              dependencyRefernece !== undefined &&
-              memoizedIsStableKnownHookValue(dependencyRefernece.resolved)
-            ) {
+            const dependencyRefernece = resolved.scope.references.find(reference => reference.identifier === dependencyNode);
+            if (dependencyRefernece !== undefined && memoizedIsStableKnownHookValue(dependencyRefernece.resolved)) {
               continue;
             } else {
               return false;
@@ -805,11 +908,7 @@ var betterExhaustiveDeps = {
           return true;
         } else {
           Object.entries(options.staticHooks).forEach(([key, staticParts]) => {
-            if (
-              typeof staticParts === 'object' &&
-              staticParts.regexp &&
-              new RegExp(key).test(name)
-            ) {
+            if (typeof staticParts === 'object' && staticParts.regexp && new RegExp(key).test(name)) {
               options.staticHooks[name] = staticParts.value;
             }
           });
@@ -818,23 +917,14 @@ var betterExhaustiveDeps = {
             if (staticParts === true) {
               return true;
             } else if (Array.isArray(staticParts)) {
-              if (
-                id.type === 'ArrayPattern' &&
-                id.elements.length <= staticParts.length &&
-                Array.isArray(resolved.identifiers)
-              ) {
+              if (id.type === 'ArrayPattern' && id.elements.length <= staticParts.length && Array.isArray(resolved.identifiers)) {
                 const idx = id.elements.indexOf(resolved.identifiers[0]);
                 if (idx >= 0) {
                   return staticParts[idx];
                 }
               }
-            } else if (
-              typeof staticParts === 'object' &&
-              id.type === 'ObjectPattern'
-            ) {
-              const property = id.properties.find(
-                p => p.key === resolved.identifiers[0]
-              );
+            } 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];
               }
@@ -862,11 +952,8 @@ var betterExhaustiveDeps = {
           const childScope = childScopes[i];
           const childScopeBlock = childScope.block;
           if (
-            (fnNode.type === 'FunctionDeclaration' &&
-              childScopeBlock === fnNode) ||
-            (fnNode.type === 'VariableDeclarator' &&
-              childScopeBlock.parent === fnNode)
-          ) {
+          fnNode.type === 'FunctionDeclaration' && childScopeBlock === fnNode ||
+          fnNode.type === 'VariableDeclarator' && childScopeBlock.parent === fnNode) {
             fnScope = childScope;
             break;
           }
@@ -879,10 +966,8 @@ var betterExhaustiveDeps = {
           if (ref.resolved == null) {
             continue;
           }
-          if (
-            pureScopes.has(ref.resolved.scope) &&
-            !memoizedIsStableKnownHookValue(ref.resolved)
-          ) {
+          if (pureScopes.has(ref.resolved.scope) &&
+          !memoizedIsStableKnownHookValue(ref.resolved)) {
             return false;
           }
         }
@@ -894,9 +979,7 @@ var betterExhaustiveDeps = {
         let isInReturnedFunction = false;
         while (curScope.block !== node) {
           if (curScope.type === 'function') {
-            isInReturnedFunction =
-              curScope.block.parent != null &&
-              curScope.block.parent.type === 'ReturnStatement';
+            isInReturnedFunction = curScope.block.parent != null && curScope.block.parent.type === 'ReturnStatement';
           }
           curScope = curScope.upper;
         }
@@ -913,34 +996,19 @@ var betterExhaustiveDeps = {
           if (!pureScopes.has(reference.resolved.scope)) {
             continue;
           }
-          const referenceNode = fastFindReferenceWithParent(
-            node,
-            reference.identifier
-          );
+          const referenceNode = fastFindReferenceWithParent(node, reference.identifier);
           const dependencyNode = getDependency(referenceNode);
-          const dependency = analyzePropertyChain(
-            dependencyNode,
-            optionalChains
-          );
+          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)
-          ) {
+          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'
-          ) {
+          if (dependencyNode.parent.type === 'TSTypeQuery' || dependencyNode.parent.type === 'TSTypeReference') {
             continue;
           }
           const def = reference.resolved.defs[0];
@@ -955,9 +1023,7 @@ var betterExhaustiveDeps = {
           }
           if (!dependencies.has(dependency)) {
             const resolved = reference.resolved;
-            const isStable =
-              memoizedIsStableKnownHookValue(resolved) ||
-              memoizedIsFunctionWithoutCapturedValues(resolved);
+            const isStable = memoizedIsStableKnownHookValue(resolved) || memoizedIsFunctionWithoutCapturedValues(resolved);
             dependencies.set(dependency, {
               isStable,
               references: [reference]
@@ -970,39 +1036,33 @@ var betterExhaustiveDeps = {
           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;
+      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;
           }
-          reportProblem({
-            node: dependencyNode.parent.property,
-            message:
-              `The ref value '${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 ` +
-              `'${dependency}.current' to a variable inside the effect, and ` +
-              `use that variable in the cleanup function.`
-          });
         }
-      );
+        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)) {
@@ -1011,17 +1071,14 @@ var betterExhaustiveDeps = {
         staleAssignments.add(key);
         reportProblem({
           node: writeExpr,
-          message:
-            `Assignments to the '${key}' variable from inside React Hook ` +
-            `${context.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 ` +
-            `${context.getSource(reactiveHook)}.`
+          message: "Assignments to the '".concat(key, "' variable from inside React Hook ") + "".concat(context.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(context.getSource(reactiveHook), ".")
         });
       }
       const stableDependencies = new Set();
-      dependencies.forEach(({ isStable, references }, key) => {
+      dependencies.forEach(({
+        isStable,
+        references
+      }, key) => {
         if (isStable) {
           stableDependencies.add(key);
         }
@@ -1036,7 +1093,9 @@ var betterExhaustiveDeps = {
       }
       if (!declaredDependenciesNode) {
         let setStateInsideEffectWithoutDeps = null;
-        dependencies.forEach(({ references }, key) => {
+        dependencies.forEach(({
+          references
+        }, key) => {
           if (setStateInsideEffectWithoutDeps) {
             return;
           }
@@ -1060,7 +1119,9 @@ var betterExhaustiveDeps = {
           });
         });
         if (setStateInsideEffectWithoutDeps) {
-          const { suggestedDependencies } = collectRecommendations({
+          const {
+            suggestedDependencies
+          } = collectRecommendations({
             dependencies,
             declaredDependencies: [],
             stableDependencies,
@@ -1069,25 +1130,13 @@ var betterExhaustiveDeps = {
           });
           reportProblem({
             node: reactiveHook,
-            message:
-              `React Hook ${reactiveHookName} contains a call to '${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 ${reactiveHookName} Hook.`,
-            suggest: [
-              {
-                desc: `Add dependencies array: [${suggestedDependencies.join(
-                  ', '
-                )}]`,
-                fix(fixer) {
-                  return fixer.insertTextAfter(
-                    node,
-                    `, [${suggestedDependencies.join(', ')}]`
-                  );
-                }
+            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;
@@ -1097,11 +1146,7 @@ var betterExhaustiveDeps = {
       if (declaredDependenciesNode.type !== 'ArrayExpression') {
         reportProblem({
           node: declaredDependenciesNode,
-          message:
-            `React Hook ${context.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.'
+          message: "React Hook ".concat(context.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 {
         declaredDependenciesNode.elements.forEach(declaredDependencyNode => {
@@ -1111,46 +1156,31 @@ var betterExhaustiveDeps = {
           if (declaredDependencyNode.type === 'SpreadElement') {
             reportProblem({
               node: declaredDependencyNode,
-              message:
-                `React Hook ${context.getSource(reactiveHook)} has a spread ` +
-                "element in its dependency array. This means we can't " +
-                "statically verify whether you've passed the " +
-                'correct dependencies.'
+              message: "React Hook ".concat(context.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;
           }
           let declaredDependency;
           try {
-            declaredDependency = analyzePropertyChain(
-              declaredDependencyNode,
-              null
-            );
+            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 ${declaredDependencyNode.raw} literal is not a valid dependency ` +
-                      `because it never changes. ` +
-                      `Did you mean to include ${declaredDependencyNode.value} in the array instead?`
+                    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 ${declaredDependencyNode.raw} literal is not a valid dependency ` +
-                      'because it never changes. You can safely remove it.'
+                    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 ${context.getSource(reactiveHook)} has a ` +
-                    `complex expression in the dependency array. ` +
-                    'Extract it to a separate variable so it can be statically checked.'
+                  message: "React Hook ".concat(context.getSource(reactiveHook), " has a ") + "complex expression in the dependency array. " + 'Extract it to a separate variable so it can be statically checked.'
                 });
               }
               return;
@@ -1158,16 +1188,10 @@ var betterExhaustiveDeps = {
             throw err;
           }
           let maybeID = declaredDependencyNode;
-          while (
-            maybeID.type === 'MemberExpression' ||
-            maybeID.type === 'OptionalMemberExpression' ||
-            maybeID.type === 'ChainExpression'
-          ) {
+          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
-          );
+          const isDeclaredInComponent = !componentScope.through.some(ref => ref.identifier === maybeID);
           declaredDependencies.push({
             key: declaredDependency,
             node: declaredDependencyNode
@@ -1190,10 +1214,7 @@ var betterExhaustiveDeps = {
         isEffect
       });
       let suggestedDeps = suggestedDependencies;
-      const problemCount =
-        duplicateDependencies.size +
-        missingDependencies.size +
-        unnecessaryDependencies.size;
+      const problemCount = duplicateDependencies.size + missingDependencies.size + unnecessaryDependencies.size;
       if (problemCount === 0) {
         const constructions = scanForConstructions({
           declaredDependencies,
@@ -1201,53 +1222,36 @@ var betterExhaustiveDeps = {
           componentScope,
           scope
         });
-        constructions.forEach(
-          ({ construction, isUsedOutsideOfHook, depType }) => {
-            const wrapperHook =
-              depType === 'function' ? 'useCallback' : 'useMemo';
-            const constructionType =
-              depType === 'function' ? 'definition' : 'initialization';
-            const defaultAdvice = `wrap the ${constructionType} of '${construction.name.name}' in its own ${wrapperHook}() Hook.`;
-            const advice = isUsedOutsideOfHook
-              ? `To fix this, ${defaultAdvice}`
-              : `Move it inside the ${reactiveHookName} callback. Alternatively, ${defaultAdvice}`;
-            const causation =
-              depType === 'conditional' || depType === 'logical expression'
-                ? 'could make'
-                : 'makes';
-            const message =
-              `The '${construction.name.name}' ${depType} ${causation} the dependencies of ` +
-              `${reactiveHookName} Hook (at line ${declaredDependenciesNode.loc.start.line}) ` +
-              `change on every render. ${advice}`;
-            let suggest;
-            if (
-              isUsedOutsideOfHook &&
-              construction.type === 'Variable' &&
-              depType === 'function'
-            ) {
-              suggest = [
-                {
-                  desc: `Wrap the ${constructionType} of '${construction.name.name}' in its own ${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
-            });
+        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) {
@@ -1287,19 +1291,7 @@ var betterExhaustiveDeps = {
         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 ${fixVerb} ${
-            deps.size > 1 ? 'them' : 'it'
-          } or remove the dependency array.`
-        );
+        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) {
@@ -1313,15 +1305,11 @@ var betterExhaustiveDeps = {
           }
         });
         if (badRef != null) {
-          extraWarning =
-            ` Mutable values like '${badRef}' aren't valid dependencies ` +
-            "because mutating them doesn't re-render the component.";
+          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 '${dep}' aren't valid dependencies ` +
-              `because mutating them doesn't re-render the component.`;
+            extraWarning = " Outer scope values like '".concat(dep, "' aren't valid dependencies ") + "because mutating them doesn't re-render the component.";
           }
         }
       }
@@ -1336,10 +1324,7 @@ var betterExhaustiveDeps = {
         }
         let isPropsOnlyUsedInMembers = true;
         for (const ref of refs) {
-          const id = fastFindReferenceWithParent(
-            componentScope.block,
-            ref.identifier
-          );
+          const id = fastFindReferenceWithParent(componentScope.block, ref.identifier);
           if (!id) {
             isPropsOnlyUsedInMembers = false;
             break;
@@ -1349,20 +1334,13 @@ var betterExhaustiveDeps = {
             isPropsOnlyUsedInMembers = false;
             break;
           }
-          if (
-            parent.type !== 'MemberExpression' &&
-            parent.type !== 'OptionalMemberExpression'
-          ) {
+          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 ${reactiveHookName} call and refer to those specific props ` +
-            `inside ${context.getSource(reactiveHook)}.`;
+          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(context.getSource(reactiveHook), ".");
         }
       }
       if (!extraWarning && missingDependencies.size > 0) {
@@ -1384,13 +1362,7 @@ var betterExhaustiveDeps = {
           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
-            ) {
+            if (id != null && id.parent != null && (id.parent.type === 'CallExpression' || id.parent.type === 'OptionalCallExpression') && id.parent.callee === id) {
               isFunctionCall = true;
               break;
             }
@@ -1401,10 +1373,7 @@ var betterExhaustiveDeps = {
           missingCallbackDep = missingDep;
         });
         if (missingCallbackDep != null) {
-          extraWarning =
-            ` If '${missingCallbackDep}' changes too often, ` +
-            `find the parent component that defines it ` +
-            `and wrap that definition in useCallback.`;
+          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) {
@@ -1422,9 +1391,7 @@ var betterExhaustiveDeps = {
             maybeCall = id.parent;
             while (maybeCall != null && maybeCall !== componentScope.block) {
               if (maybeCall.type === 'CallExpression') {
-                const correspondingStateVariable = setStateCallSites.get(
-                  maybeCall.callee
-                );
+                const correspondingStateVariable = setStateCallSites.get(maybeCall.callee);
                 if (correspondingStateVariable != null) {
                   if (correspondingStateVariable.name === missingDep) {
                     setStateRecommendation = {
@@ -1464,27 +1431,13 @@ var betterExhaustiveDeps = {
         if (setStateRecommendation != null) {
           switch (setStateRecommendation.form) {
             case 'reducer':
-              extraWarning =
-                ` You can also replace multiple useState variables with useReducer ` +
-                `if '${setStateRecommendation.setter}' needs the ` +
-                `current value of '${setStateRecommendation.missingDep}'.`;
+              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 '${setStateRecommendation.setter}' needs the ` +
-                `current value of '${setStateRecommendation.missingDep}', ` +
-                `you can also switch to useReducer instead of useState and ` +
-                `read '${setStateRecommendation.missingDep}' in the reducer.`;
+              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 '${
-                setStateRecommendation.setter
-              }(${setStateRecommendation.missingDep.slice(
-                0,
-                1
-              )} => ...)' if you only need '${
-                setStateRecommendation.missingDep
-              }' in the '${setStateRecommendation.setter}' call.`;
+              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.');
@@ -1493,35 +1446,14 @@ var betterExhaustiveDeps = {
       }
       reportProblem({
         node: declaredDependenciesNode,
-        message:
-          `React Hook ${context.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: [${suggestedDeps
-              .map(element => formatDependency(element))
-              .join(', ')}]`,
-            fix(fixer) {
-              return fixer.replaceText(
-                declaredDependenciesNode,
-                `[${suggestedDeps.map(element => formatDependency(element)).join(', ')}]`
-              );
-            }
-          }
-        ]
+        message: "React Hook ".concat(context.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) {
@@ -1537,23 +1469,15 @@ var betterExhaustiveDeps = {
       if (!callback) {
         reportProblem({
           node: reactiveHook,
-          message:
-            `React Hook ${reactiveHookName} requires an effect callback. ` +
-            `Did you forget to pass a callback to the hook?`
+          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'
-        ) {
+        if (reactiveHookName === 'useMemo' || reactiveHookName === 'useCallback') {
           reportProblem({
             node: reactiveHook,
-            message:
-              `React Hook ${reactiveHookName} does nothing when called with ` +
-              `only one argument. Did you forget to pass an array of ` +
-              `dependencies?`
+            message: "React Hook ".concat(reactiveHookName, " does nothing when called with ") + "only one argument. Did you forget to pass an array of " + "dependencies?"
           });
         }
         return;
@@ -1561,24 +1485,13 @@ var betterExhaustiveDeps = {
       switch (callback.type) {
         case 'FunctionExpression':
         case 'ArrowFunctionExpression':
-          visitFunctionWithDependencies(
-            callback,
-            declaredDependenciesNode,
-            reactiveHook,
-            reactiveHookName,
-            isEffect
-          );
+          visitFunctionWithDependencies(callback, 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
-            )
-          ) {
+          if (declaredDependenciesNode.elements && declaredDependenciesNode.elements.some(el => el && el.type === 'Identifier' && el.name === callback.name)) {
             return;
           }
           const variable = context.getScope().set.get(callback.name);
@@ -1594,13 +1507,7 @@ var betterExhaustiveDeps = {
           }
           switch (def.node.type) {
             case 'FunctionDeclaration':
-              visitFunctionWithDependencies(
-                def.node,
-                declaredDependenciesNode,
-                reactiveHook,
-                reactiveHookName,
-                isEffect
-              );
+              visitFunctionWithDependencies(def.node, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect);
               return;
             case 'VariableDeclarator':
               const init = def.node.init;
@@ -1610,13 +1517,7 @@ var betterExhaustiveDeps = {
               switch (init.type) {
                 case 'ArrowFunctionExpression':
                 case 'FunctionExpression':
-                  visitFunctionWithDependencies(
-                    init,
-                    declaredDependenciesNode,
-                    reactiveHook,
-                    reactiveHookName,
-                    isEffect
-                  );
+                  visitFunctionWithDependencies(init, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect);
                   return;
               }
               break;
@@ -1625,28 +1526,19 @@ var betterExhaustiveDeps = {
         default:
           reportProblem({
             node: reactiveHook,
-            message:
-              `React Hook ${reactiveHookName} received a function whose dependencies ` +
-              `are unknown. Pass an inline function instead.`
+            message: "React Hook ".concat(reactiveHookName, " received a function whose dependencies ") + "are unknown. Pass an inline function instead."
           });
           return;
       }
       reportProblem({
         node: reactiveHook,
-        message:
-          `React Hook ${reactiveHookName} has a missing dependency: '${callback.name}'. ` +
-          `Either include it or remove the dependency array.`,
-        suggest: [
-          {
-            desc: `Update the dependencies array to be: [${callback.name}]`,
-            fix(fixer) {
-              return fixer.replaceText(
-                declaredDependenciesNode,
-                `[${callback.name}]`
-              );
-            }
+        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 {
@@ -1677,7 +1569,9 @@ function collectRecommendations({
       parent.isSubtreeUsed = true;
     });
   });
-  declaredDependencies.forEach(({ key }) => {
+  declaredDependencies.forEach(({
+    key
+  }) => {
     const node = getOrCreateNodeByPath(depTree, key);
     node.isSatisfiedRecursively = true;
   });
@@ -1712,12 +1606,7 @@ function collectRecommendations({
   }
   const missingDependencies = new Set();
   const satisfyingDependencies = new Set();
-  scanTreeRecursively(
-    depTree,
-    missingDependencies,
-    satisfyingDependencies,
-    key => key
-  );
+  scanTreeRecursively(depTree, missingDependencies, satisfyingDependencies, key => key);
   function scanTreeRecursively(node, missingPaths, satisfyingPaths, keyToPath) {
     node.children.forEach((child, key) => {
       const path = keyToPath(key);
@@ -1731,29 +1620,22 @@ function collectRecommendations({
         missingPaths.add(path);
         return;
       }
-      scanTreeRecursively(
-        child,
-        missingPaths,
-        satisfyingPaths,
-        childKey => path + '.' + childKey
-      );
+      scanTreeRecursively(child, missingPaths, satisfyingPaths, childKey => path + '.' + childKey);
     });
   }
   const suggestedDependencies = [];
   const unnecessaryDependencies = new Set();
   const duplicateDependencies = new Set();
-  declaredDependencies.forEach(({ key }) => {
+  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)
-    ) {
+    } else if (isEffect && !key.endsWith('.current') && !externalDependencies.has(key)) {
       if (!suggestedDependencies.includes(key)) {
         suggestedDependencies.push(key);
       }
@@ -1783,18 +1665,12 @@ function getConstructionExpressionType(node) {
     case 'ClassExpression':
       return 'class';
     case 'ConditionalExpression':
-      if (
-        getConstructionExpressionType(node.consequent) != null ||
-        getConstructionExpressionType(node.alternate) != null
-      ) {
+      if (getConstructionExpressionType(node.consequent) != null || getConstructionExpressionType(node.alternate) != null) {
         return 'conditional';
       }
       return null;
     case 'LogicalExpression':
-      if (
-        getConstructionExpressionType(node.left) != null ||
-        getConstructionExpressionType(node.right) != null
-      ) {
+      if (getConstructionExpressionType(node.left) != null || getConstructionExpressionType(node.right) != null) {
         return 'logical expression';
       }
       return null;
@@ -1827,41 +1703,32 @@ function scanForConstructions({
   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'];
-      }
+  const constructions = declaredDependencies.map(({
+    key
+  }) => {
+    const ref = componentScope.variables.find(v => v.name === key);
+    if (ref == null) {
       return null;
-    })
-    .filter(Boolean);
+    }
+    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++) {
@@ -1877,10 +1744,8 @@ function scanForConstructions({
       while (currentScope !== scope && currentScope != null) {
         currentScope = currentScope.upper;
       }
-      if (
-        currentScope !== scope &&
-        !isAncestorNodeOf(declaredDependenciesNode, reference.identifier)
-      ) {
+      if (currentScope !== scope &&
+      !isAncestorNodeOf(declaredDependenciesNode, reference.identifier)) {
         return true;
       }
     }
@@ -1893,26 +1758,10 @@ function scanForConstructions({
   }));
 }
 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
-    )
-  ) {
+  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
-  ) {
+  node.type === 'MemberExpression' && node.parent && node.parent.type === 'AssignmentExpression' && node.parent.left === node) {
     return node.object;
   }
   return node;
@@ -1938,36 +1787,30 @@ function analyzePropertyChain(node, optionalChains) {
   } else if (node.type === 'MemberExpression' && !node.computed) {
     const object = analyzePropertyChain(node.object, optionalChains);
     const property = analyzePropertyChain(node.property, null);
-    const result = `${object}.${property}`;
+    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 = `${object}.${property}`;
+    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: ${expression.type}`);
+      throw new Error("Unsupported node type: ".concat(expression.type));
     }
     const object = analyzePropertyChain(expression.object, optionalChains);
     const property = analyzePropertyChain(expression.property, null);
-    const result = `${object}.${property}`;
+    const result = "".concat(object, ".").concat(property);
     markNode(expression, optionalChains, result);
     return result;
   }
-  throw new Error(`Unsupported node type: ${node.type}`);
+  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
-  ) {
+  if (node.type === 'MemberExpression' && node.object.type === 'Identifier' && node.object.name === 'React' && node.property.type === 'Identifier' && !node.computed) {
     return node.property;
   }
   return node;
@@ -2046,28 +1889,17 @@ function joinEnglish(arr) {
   return s;
 }
 function isNodeLike(val) {
-  return (
-    typeof val === 'object' &&
-    val != null &&
-    !Array.isArray(val) &&
-    typeof val.type === 'string'
-  );
+  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]
-  );
+  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];
 }
 
 const Components = require('eslint-plugin-react/lib/util/Components');
-var hookUseRef = {
+var reactHookUseRef = {
   meta: {
     docs: {
       description: 'Ensure naming of useRef hook value.',
@@ -2075,12 +1907,14 @@ var hookUseRef = {
     },
     schema: [],
     type: 'suggestion',
-    hasSuggestions: true
+    hasSuggestions: true,
+    messages: {
+      useRefName: 'useRef call is not end with "Ref"'
+    }
   },
   create: Components.detect((context, component, util) => ({
     CallExpression(node) {
-      const isImmediateReturn =
-        node.parent && node.parent.type === 'ReturnStatement';
+      const isImmediateReturn = node.parent && node.parent.type === 'ReturnStatement';
       if (isImmediateReturn || !util.isReactHookCall(node, ['useRef'])) {
         return;
       }
@@ -2091,7 +1925,7 @@ var hookUseRef = {
       if (!variable.endsWith('Ref')) {
         context.report({
           node: node,
-          message: 'useRef call is not end with "Ref"'
+          messageId: 'useRefName'
         });
       }
     }
@@ -2100,54 +1934,39 @@ var hookUseRef = {
 
 function* updateImportStatement(context, fixer, key) {
   const sourceCode = context.sourceCode;
-  const importNode = sourceCode.ast.body.find(
-    node => node.type === 'ImportDeclaration' && node.source.value === 'react'
-  );
+  const importNode = sourceCode.ast.body.find(node => node.type === 'ImportDeclaration' && node.source.value === 'react');
   if (!importNode) {
-    yield fixer.insertTextBefore(
-      sourceCode.ast.body[0],
-      `import { ${key} } from 'react';\n`
-    );
+    yield fixer.insertTextBefore(sourceCode.ast.body[0], "import { ".concat(key, " } from 'react';\n"));
     return;
   }
-  if (
-    importNode.specifiers.length === 1 &&
-    importNode.specifiers[0].type === 'ImportDefaultSpecifier'
-  ) {
-    yield fixer.insertTextAfter(importNode.specifiers[0], `, { ${key} }`);
+  if (importNode.specifiers.length === 1 && importNode.specifiers[0].type === 'ImportDefaultSpecifier') {
+    yield fixer.insertTextAfter(importNode.specifiers[0], ", { ".concat(key, " }"));
     return;
   }
-  const alreadyImportedKeys = importNode.specifiers
-    .filter(specifier => specifier.type === 'ImportSpecifier')
-    .map(specifier => specifier.imported.name);
+  const alreadyImportedKeys = importNode.specifiers.filter(specifier => specifier.type === 'ImportSpecifier').map(specifier => specifier.imported.name);
   if (alreadyImportedKeys.includes(key)) {
     return;
   }
-  yield fixer.insertTextAfter([...importNode.specifiers].pop(), `, ${key}`);
+  yield fixer.insertTextAfter([...importNode.specifiers].pop(), ", ".concat(key));
 }
-var preferNamedPropertyAccess = utils.ESLintUtils.RuleCreator.withoutDocs({
+var reactPreferNamedPropertyAccess = utils.ESLintUtils.RuleCreator.withoutDocs({
   defaultOptions: [],
   meta: {
     type: 'layout',
     fixable: 'code',
     docs: {
-      description:
-        'Enforce importing each member of React namespace separately instead of accessing them through React namespace',
+      description: 'Enforce importing each member of React namespace separately instead of accessing them through React namespace',
       recommended: 'recommended'
     },
     messages: {
-      illegalReactPropertyAccess:
-        'Illegal React property access: {{name}}. Use named import instead.'
+      illegalReactPropertyAccess: 'Illegal React property access: {{name}}. Use named import instead.'
     },
     schema: []
   },
   create(context) {
     return {
       TSQualifiedName(node) {
-        if (
-          ('name' in node.left && node.left.name !== 'React') ||
-          ('name' in node.right && node.right.name.endsWith('Event'))
-        ) {
+        if ('name' in node.left && node.left.name !== 'React' || 'name' in node.right && node.right.name.endsWith('Event')) {
           return;
         }
         context.report({
@@ -2182,7 +2001,7 @@ var preferNamedPropertyAccess = utils.ESLintUtils.RuleCreator.withoutDocs({
   }
 });
 
-var preferSxProp = {
+var reactPreferSxProp = {
   meta: {
     docs: {
       description: 'Prefer using sx prop instead of inline styles',
@@ -2190,36 +2009,29 @@ var preferSxProp = {
       recommended: true
     },
     messages: {
-      preferSxProp:
-        'Avoid using inline styles, use sx prop or tss-react or styled-component instead'
+      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' }
+    schema: [{
+      type: 'object',
+      properties: {
+        allowedFor: {
+          type: 'array',
+          uniqueItems: true,
+          items: {
+            type: 'string'
           }
         }
       }
-    ]
+    }]
   },
   create(context) {
     const configuration = context.options[0] || {};
     const allowedFor = configuration.allowedFor || [];
     function checkComponent(node) {
       const parentName = node.parent.name;
-      const tag =
-        parentName.name ||
-        `${parentName.object.name}.${parentName.property.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()
-      ) {
+      if (componentName && typeof componentName[0] === 'string' && componentName[0] !== componentName[0].toUpperCase()) {
         return;
       }
       if (allowedFor.includes(tag)) {
@@ -2235,9 +2047,7 @@ var preferSxProp = {
     }
     function checkDOMNodes(node) {
       const tag = node.parent.name.name;
-      if (
-        !(tag && typeof tag === 'string' && tag[0] !== tag[0].toUpperCase())
-      ) {
+      if (!(tag && typeof tag === 'string' && tag[0] !== tag[0].toUpperCase())) {
         return;
       }
       if (allowedFor.includes(tag)) {
@@ -2277,25 +2087,24 @@ function getBasicIdentifier(node) {
 }
 function getBaseIdentifier(node) {
   switch (node.type) {
-    case 'Identifier': {
-      return node;
-    }
-    case 'CallExpression': {
-      return getBaseIdentifier(node.callee);
-    }
-    case 'MemberExpression': {
-      return getBaseIdentifier(node.object);
-    }
+    case 'Identifier':
+      {
+        return node;
+      }
+    case 'CallExpression':
+      {
+        return getBaseIdentifier(node.callee);
+      }
+    case 'MemberExpression':
+      {
+        return getBaseIdentifier(node.object);
+      }
   }
   return null;
 }
 function getStyesObj(node) {
   const isMakeStyles = node.callee.name === 'makeStyles';
-  const isModernApi =
-    node.callee.type === 'MemberExpression' &&
-    node.callee.property.name === 'create' &&
-    getBaseIdentifier(node.callee.object) &&
-    getBaseIdentifier(node.callee.object).name === 'tss';
+  const isModernApi = node.callee.type === 'MemberExpression' && node.callee.property.name === 'create' && getBaseIdentifier(node.callee.object) && getBaseIdentifier(node.callee.object).name === 'tss';
   if (!isMakeStyles && !isModernApi) {
     return;
   }
@@ -2315,35 +2124,51 @@ function getStyesObj(node) {
       return styles;
     case 'ArrowFunctionExpression':
       {
-        const { body } = styles;
+        const {
+          body
+        } = styles;
         switch (body.type) {
           case 'ObjectExpression':
             return body;
-          case 'BlockStatement': {
-            let stylesObj;
-            body.body.forEach(bodyNode => {
-              if (
-                bodyNode.type === 'ReturnStatement' &&
-                bodyNode.argument.type === 'ObjectExpression'
-              ) {
-                stylesObj = bodyNode.argument;
-              }
-            });
-            return stylesObj;
-          }
+          case 'BlockStatement':
+            {
+              let stylesObj;
+              body.body.forEach(bodyNode => {
+                if (bodyNode.type === 'ReturnStatement' && bodyNode.argument.type === 'ObjectExpression') {
+                  stylesObj = bodyNode.argument;
+                }
+              });
+              return stylesObj;
+            }
         }
       }
       break;
   }
 }
+function loopStylesObj(node, callback) {
+  if (node && node.type === 'ObjectExpression') {
+    node.properties.forEach(property => {
+      if (property.type === 'Property' && property.value) {
+        if (property.value.type === 'ObjectExpression') {
+          loopStylesObj(property.value, callback);
+        } else {
+          callback(property.value);
+        }
+      }
+    });
+  }
+}
 
-var classNaming = {
+var tssClassNaming = {
   meta: {
     type: 'problem',
     docs: {
       description: 'Enforce camelCase class names in TSS',
       category: 'Best Practices',
       recommended: true
+    },
+    messages: {
+      camelCase: 'Class `{{ className }}` must be camelCase in TSS.'
     }
   },
   create: function rule(context) {
@@ -2357,17 +2182,17 @@ var classNaming = {
           if (property.computed) {
             return;
           }
-          if (
-            property.type === 'ExperimentalSpreadProperty' ||
-            property.type === 'SpreadElement'
-          ) {
+          if (property.type === 'ExperimentalSpreadProperty' || property.type === 'SpreadElement') {
             return;
           }
           const className = property.key.value || property.key.name;
           if (!eslintUtils.isCamelCase(className)) {
             context.report({
               node: property,
-              message: `Class \`${className}\` must be camelCase in TSS.`
+              messageId: 'camelCase',
+              data: {
+                className
+              }
             });
           }
         });
@@ -2376,20 +2201,201 @@ var classNaming = {
   }
 };
 
-var noColorValue = {
+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]
+};
+
+var tssNoColorName = {
   meta: {
-    type: 'problem',
+    type: 'suggestion',
     docs: {
-      description:
-        'Enforce the use of color variables instead of color codes within TSS',
+      description: 'Enforce the use of color variables instead of color name within TSS',
       recommended: true
+    },
+    messages: {
+      disallowColorName: 'Disallowed color name. Use color from `@mui/material/colors` or `theme.palette`.'
     }
   },
   create: function (context) {
-    const parserOptions = context.parserOptions;
-    if (!parserOptions || !parserOptions.project) {
-      return {};
+    return {
+      CallExpression(node) {
+        const stylesObj = getStyesObj(node);
+        if (!stylesObj) {
+          return;
+        }
+        function checkColorLiteral(value) {
+          if (value.type === 'Literal' && typeof value.value === 'string' && Object.keys(colors).includes(value.value.toLowerCase())) {
+            context.report({
+              node: value,
+              messageId: 'disallowColorName'
+            });
+          }
+        }
+        loopStylesObj(stylesObj, checkColorLiteral);
+      }
+    };
+  }
+};
+
+var tssNoColorValue = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Enforce the use of color variables instead of color codes within TSS',
+      recommended: true
+    },
+    messages: {
+      preferMuiColor: 'Prefer use color from `@mui/material/colors` or `theme.palette`.'
     }
+  },
+  create: function (context) {
     return {
       CallExpression(node) {
         const stylesObj = getStyesObj(node);
@@ -2398,43 +2404,31 @@ var noColorValue = {
         }
         function checkColorLiteral(value) {
           if (value.type === '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;
-            const isColorCode = colorCodePattern.test(value.value);
-            if (isColorCode) {
+            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,
-                message: 'Use color variables instead of color codes in TSS.'
+                messageId: 'preferMuiColor'
               });
             }
           }
         }
-        function loopStylesObj(obj) {
-          if (obj && obj.type === 'ObjectExpression') {
-            obj.properties.forEach(property => {
-              if (property.type === 'Property' && property.value) {
-                if (property.value.type === 'ObjectExpression') {
-                  loopStylesObj(property.value);
-                } else {
-                  checkColorLiteral(property.value);
-                }
-              }
-            });
-          }
-        }
-        loopStylesObj(stylesObj);
+        loopStylesObj(stylesObj, checkColorLiteral);
       }
     };
   }
 };
 
-var unusedClasses = {
+var tssUnusedClasses = {
   meta: {
     type: 'suggestion',
     docs: {
       description: 'Disallow unused classes in tss',
       category: 'Best Practices',
       recommended: true
+    },
+    messages: {
+      unusedClass: 'Class `{{ className }}` is unused in JSX'
     }
   },
   create: function rule(context) {
@@ -2450,20 +2444,14 @@ var unusedClasses = {
           if (property.computed) {
             return;
           }
-          if (
-            property.type === 'ExperimentalSpreadProperty' ||
-            property.type === 'SpreadElement'
-          ) {
+          if (property.type === 'ExperimentalSpreadProperty' || property.type === 'SpreadElement') {
             return;
           }
           definedClasses[property.key.value || property.key.name] = property;
         });
       },
       MemberExpression(node) {
-        if (
-          node.object.type === 'Identifier' &&
-          node.object.name === 'classes'
-        ) {
+        if (node.object.type === 'Identifier' && node.object.name === 'classes') {
           const whichClass = getBasicIdentifier(node.property);
           if (whichClass) {
             usedClasses[whichClass] = true;
@@ -2477,14 +2465,15 @@ var unusedClasses = {
         if (classIdentifier !== 'classes') {
           return;
         }
-        const { parent } = node;
+        const {
+          parent
+        } = node;
         if (parent.type !== 'MemberExpression') {
           return;
         }
         if (
-          node.object.object &&
-          node.object.object.type !== 'ThisExpression'
-        ) {
+        node.object.object &&
+        node.object.object.type !== 'ThisExpression') {
           return;
         }
         const propsIdentifier = getBasicIdentifier(parent.object);
@@ -2507,7 +2496,10 @@ var unusedClasses = {
           if (!usedClasses[definedClassKey]) {
             context.report({
               node: definedClasses[definedClassKey],
-              message: `Class \`${definedClassKey}\` is unused`
+              messageId: 'unusedClass',
+              data: {
+                className: definedClassKey
+              }
             });
           }
         });
@@ -2516,177 +2508,27 @@ var unusedClasses = {
   }
 };
 
-var noAsyncArrayMethods = {
-  meta: {
-    docs: {
-      description:
-        'No async callback for Array methods forEach, map, filter, reduce, some, every, etc.',
-      category: 'Array',
-      recommended: true
-    },
-    fixable: undefined,
-    schema: []
-  },
-  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 ['ArrowFunctionExpression', 'FunctionExpression'].includes(
-              n.type
-            );
-          });
-          if (functionArguments && functionArguments.async) {
-            context.report({
-              node,
-              message: `No async function in method '${callee.property.name}'`
-            });
-          }
-        }
-      }
-    };
-  }
-};
-
-var noThenCatchFinally = {
-  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 }}().`
-    }
-  },
-  create(context) {
-    const configuration = context.options[0] || {};
-    const restrictedFunctions = configuration.restrictedFunctions || [];
-    function isTopLevelScoped() {
-      return context.getScope().block.type === 'Program';
-    }
-    function isThenCatchFinally(node) {
-      return (
-        node.property &&
-        (node.property.name === 'then' ||
-          node.property.name === 'catch' ||
-          node.property.name === 'finally')
-      );
-    }
-    return {
-      'CallExpression > MemberExpression.callee'(node) {
-        if (isTopLevelScoped()) {
-          return;
-        }
-        if (!isThenCatchFinally(node)) {
-          return;
-        }
-        const callExpression = node.object;
-        if (
-          callExpression.type === 'CallExpression' &&
-          callExpression.callee.type === 'Identifier' &&
-          restrictedFunctions.includes(callExpression.callee.name)
-        ) {
-          context.report({
-            node: node.property,
-            messageId: 'forbiddenThenCatchFinally',
-            data: {
-              name: callExpression.callee.name
-            }
-          });
-        }
-      }
-    };
-  }
-};
-
-var noUnnecessaryTemplateLiterals = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Check if a template string contains only one ${}',
-      recommended: true
-    },
-    fixable: 'code',
-    schema: [],
-    messages: {
-      unnecessaryTemplateString:
-        'Unnecessary template string with only one ${}.'
-    }
-  },
-  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 ruleFiles = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  rules_import_enforce_icon_alias: enforceIconAlias,
-  rules_import_monorepo: monorepo,
-  rules_intl_id_missing: idMissing,
-  rules_intl_id_prefix: idPrefix,
-  rules_intl_id_unused: idUnused,
-  rules_intl_no_default: noDefault,
-  rules_react_better_exhaustive_deps: betterExhaustiveDeps,
-  rules_react_hook_use_ref: hookUseRef,
-  rules_react_prefer_named_property_access: preferNamedPropertyAccess,
-  rules_react_prefer_sx_prop: preferSxProp,
-  rules_tss_class_naming: classNaming,
-  rules_tss_no_color_value: noColorValue,
-  rules_tss_unused_classes: unusedClasses,
-  rules_unprefixed_no_async_array_methods: noAsyncArrayMethods,
-  rules_unprefixed_no_then_catch_finally: noThenCatchFinally,
-  rules_unprefixed_no_unnecessary_template_literals: noUnnecessaryTemplateLiterals
+  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_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_named_property_access: reactPreferNamedPropertyAccess,
+  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 = {
@@ -2704,13 +2546,12 @@ const plugin = {
   }
 };
 Object.keys(ruleFiles).forEach(key => {
-  const ruleKey = key.replace(/^rules_/, '').replace(/^unprefixed_/, '');
+  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/${finalKey}`] =
-      rule.meta.type === 'suggestion' ? 'warn' : 'error';
+    plugin.configs.recommended.rules["@agilebot/".concat(finalKey)] = rule.meta.type === 'suggestion' ? 'warn' : 'error';
   }
 });