@agilebot/eslint-plugin 0.8.10 → 0.9.0

package/dist/index.mjs

@@ -1,2763 +0,0 @@
-/**
- * @license @agilebot/eslint-plugin v0.8.10
- *
- * Copyright (c) Agilebot, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-import { createRequire } from "node:module";
-import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
-import * as fs$1 from "node:fs";
-import * as fs from "node:fs";
-import * as path$2 from "node:path";
-import * as path$1 from "node:path";
-import path from "node:path";
-import { isCamelCase, isPascalCase, tsImport } from "@agilebot/eslint-utils";
-import * as Components from "eslint-plugin-react/lib/util/Components.js";
-
-//#region rolldown:runtime
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-//#endregion
-//#region src/util/rule.js
-const docBaseUrl = "https://github.com/sh-agilebot/frontend-toolkit/blob/master/packages/eslint-plugin/src/rules/";
-const hasDocs = [
-	"enforce-mui-icon-alias",
-	"intl-id-missing",
-	"intl-id-prefix",
-	"intl-no-default",
-	"react-better-exhaustive-deps"
-];
-const createRule = ESLintUtils.RuleCreator((name) => hasDocs.includes(name) ? `${docBaseUrl}${name}.md` : `${docBaseUrl}${name}.test.js`);
-
-//#endregion
-//#region src/rules/enforce-mui-icon-alias.js
-const RULE_NAME$18 = "enforce-mui-icon-alias";
-var enforce_mui_icon_alias_default = createRule({
-	name: RULE_NAME$18,
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Enforce alias for @mui/icons-material imports",
-			recommended: "recommended"
-		},
-		fixable: "code",
-		schema: [],
-		messages: { iconAlias: "Import for {{ name }} should be aliased." }
-	},
-	defaultOptions: [],
-	create(context) {
-		return { ImportDeclaration(node) {
-			if (node.source.value !== "@mui/icons-material" && node.source.value !== "mdi-material-ui") return;
-			for (const specifier of node.specifiers) {
-				if (specifier.type !== AST_NODE_TYPES.ImportSpecifier) return;
-				if (specifier.imported.name === specifier.local.name || !specifier.local.name.endsWith("Icon")) context.report({
-					node,
-					messageId: "iconAlias",
-					data: { name: node.source.value },
-					fix: (fixer) => fixer.replaceText(specifier, `${specifier.imported.name} as ${specifier.imported.name}Icon`)
-				});
-			}
-		} };
-	}
-});
-
-//#endregion
-//#region src/util/context.js
-/**
-
-* Get a setting from eslint config
-
-* @param {import('eslint').Rule.RuleContext} context - Context
-
-* @param {string} name - Name
-
-* @returns {*} - result
-
-*/
-function getSetting(context, name) {
-	return context.settings[`agilebot/${name}`];
-}
-
-//#endregion
-//#region src/rules/import-monorepo.js
-const RULE_NAME$17 = "import-monorepo";
-var import_monorepo_default = createRule({
-	name: RULE_NAME$17,
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Enforce import styles for monorepo",
-			recommended: "recommended"
-		},
-		fixable: "code",
-		schema: [],
-		messages: { monorepoImport: "Import for {{ module }} should not contains src folder." }
-	},
-	defaultOptions: [],
-	create(context) {
-		return { ImportDeclaration(node) {
-			let prefix = getSetting(context, "monorepo-scope");
-			if (!prefix) return;
-			prefix = `${prefix}/`;
-			if (typeof node.source.value !== "string") return;
-			if (!node.source.value.startsWith(prefix)) return;
-			const values = node.source.value.split("/");
-			if (values[2] === "src") context.report({
-				node,
-				messageId: "monorepoImport",
-				data: { module: node.source.value },
-				fix: (fixer) => {
-					const correctedPath = values.filter((_, index) => index !== 2).join("/");
-					return fixer.replaceText(node.source, `'${correctedPath}'`);
-				}
-			});
-		} };
-	}
-});
-
-//#endregion
-//#region src/util/intl.js
-/**
-* Finds an attribute in formatMessage using attribute name.
-* @param {object} node - parent formatMessage node
-* @param {string} attrName - attribute name.
-* @returns {*} node - returns node if it finds the attribute.
-*/
-function findFormatMessageAttrNode(node, attrName) {
-	if (node.type === AST_NODE_TYPES.CallExpression && (node.callee.name === "formatMessage" || node.callee.name === "$t") && node.arguments.length > 0 && node.arguments[0].properties) return node.arguments[0].properties.find((a) => a.key && a.key.name === attrName);
-	if (node.type === AST_NODE_TYPES.CallExpression && node.callee.type === AST_NODE_TYPES.MemberExpression && (node.callee.object.name === "intl" || node.callee.object.name && node.callee.object.name.endsWith("Intl")) && (node.callee.property.name === "formatMessage" || node.callee.property.name === "$t")) return node.arguments[0].properties.find((a) => a.key && a.key.name === attrName);
-}
-/**
-* Finds an attribute in FormattedMessage using attribute name.
-* @param {object} node - parent FormattedMessage node
-* @param {string} attrName - attribute name.
-* @returns {*} node - returns node if it finds the attribute.
-*/
-function findFormattedMessageAttrNode(node, attrName) {
-	if (node.type === AST_NODE_TYPES.JSXIdentifier && node.name === "FormattedMessage" && node.parent && node.parent.type === AST_NODE_TYPES.JSXOpeningElement) return node.parent.attributes.find((a) => a.name && a.name.name === attrName);
-}
-/**
-* Finds an attribute in defineMessages using attribute name.
-* @param {object} node - parent defineMessages node
-* @param {string} attrName - attribute name.
-* @returns {*} node - returns node if it finds the attribute.
-*/
-function findAttrNodeInDefineMessages(node, attrName) {
-	if (node.type === "Property" && node.key.name === attrName && node.parent && node.parent.parent && node.parent.parent.parent && node.parent.parent.parent.parent && node.parent.parent.parent.parent.type === AST_NODE_TYPES.CallExpression && node.parent.parent.parent.parent.callee.name === "defineMessages") return node;
-}
-/**
-* Finds an attribute in defineMessages using attribute name.
-* @param {object} node - parent defineMessages node
-* @param {string} attrName - attribute name.
-* @returns {*} node - returns node if it finds the attribute.
-*/
-function findAttrNodeInDefineMessage(node, attrName) {
-	if (node.type === "Property" && node.key.name === attrName && node.parent && node.parent.parent && node.parent.parent.type === AST_NODE_TYPES.CallExpression && node.parent.parent.callee.name === "defineMessage") return node;
-}
-/**
-* Returns a sorted array of nodes, based on their starting posting in the locale id.
-* @param {object} node - parent node containing the locale id.
-* @returns {Array} child nodes - sorted list.
-*/
-function sortedTemplateElements(node) {
-	return [...node.quasis, ...node.expressions].sort((a, b) => a.range[0] - b.range[0]);
-}
-/**
-* Replaces place holders with asterisk and returns the resulting id.
-* @param {object} node - parent node containing the locale id.
-* @returns {string} id - fixed id.
-*/
-function templateLiteralDisplayStr(node) {
-	return sortedTemplateElements(node).map((e) => !e.value ? "*" : e.value.raw).join("");
-}
-
-//#endregion
-//#region src/util/translations.js
-/**
-
-* Map of locale file paths to keys and modified time
-
-* @type {Record<string, {keys: Array<string>, mtime: number}>}
-
-*/
-const localeFilesKeys = {};
-/**
-
-* Get a list of ids keys from reading locale files
-
-* Keeps track of modified times and reloads if changed,; useful for realtime eslint in-editor
-
-* @param {import('eslint').Rule.RuleContext} context - Context
-
-* @returns {string[]} results - Array of ids
-
-*/
-function getIntlIds(context) {
-	const projectRoot = getSetting(context, "project-root");
-	const localeFiles = getSetting(context, "locale-files");
-	if (!localeFiles) throw new Error("localeFiles not in settings");
-	const results = [];
-	localeFiles.forEach((f) => {
-		const fullPath = projectRoot ? path$2.join(projectRoot, f) : f;
-		const mtime = fs$1.lstatSync(fullPath).mtime.getTime();
-		if (!localeFilesKeys[fullPath] || mtime !== localeFilesKeys[fullPath].mtime) {
-			let json;
-			if (fullPath.endsWith(".json")) json = JSON.parse(fs$1.readFileSync(fullPath, "utf8"));
-			else if (fullPath.endsWith(".ts")) {
-				json = tsImport(fullPath);
-				if (typeof json === "object" && json.default) json = json.default;
-			} else if (fullPath.endsWith(".js")) {
-				json = __require(fullPath);
-				if (typeof json === "object" && json.default) json = json.default;
-			} else throw new Error("unsupported file extension");
-			localeFilesKeys[fullPath] = {
-				keys: Object.keys(json),
-				mtime
-			};
-		}
-		results.push(...localeFilesKeys[fullPath].keys);
-	});
-	return results;
-}
-
-//#endregion
-//#region src/rules/intl-id-missing.js
-const RULE_NAME$16 = "intl-id-missing";
-var intl_id_missing_default = createRule({
-	name: RULE_NAME$16,
-	meta: {
-		type: "problem",
-		docs: { description: "Validates intl message ids are in locale file" },
-		schema: [],
-		messages: {
-			missingId: "Missing id: {{value}}",
-			missingIdPattern: "Missing id pattern: {{value}}",
-			disallowInvoke: "Do not invoke intl by {{value}}"
-		}
-	},
-	defaultOptions: [],
-	create: function(context) {
-		const translatedIds = getIntlIds(context);
-		const translatedIdSet = new Set(translatedIds);
-		function isLiteralTranslated(id) {
-			return translatedIdSet.has(id);
-		}
-		function isTemplateTranslated(re) {
-			return translatedIds.some((k) => re.test(k));
-		}
-		function processLiteral(node) {
-			if (!isLiteralTranslated(node.value)) context.report({
-				node,
-				messageId: "missingId",
-				data: { value: node.value }
-			});
-		}
-		function processTemplateLiteral(node) {
-			const exStr = sortedTemplateElements(node).map((e) => !e.value ? ".*" : e.value.raw).join("");
-			const re = new RegExp(exStr);
-			if (!isTemplateTranslated(re)) context.report({
-				node,
-				messageId: "missingIdPattern",
-				data: { value: templateLiteralDisplayStr(node) }
-			});
-		}
-		function processAttrNode(node) {
-			if (node.value.type === AST_NODE_TYPES.Literal) return processLiteral(node.value);
-			if (node.value.type === AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === AST_NODE_TYPES.TemplateLiteral) return processTemplateLiteral(node.value.expression);
-			if (node.value.type === AST_NODE_TYPES.TemplateLiteral) return processTemplateLiteral(node.value);
-			context.report({
-				node,
-				messageId: "disallowInvoke",
-				data: { value: node.value.type }
-			});
-		}
-		return {
-			JSXIdentifier: function(node) {
-				const attrNode = findFormattedMessageAttrNode(node, "id");
-				if (attrNode) return processAttrNode(attrNode);
-			},
-			CallExpression: function(node) {
-				const attrNode = findFormatMessageAttrNode(node, "id");
-				if (attrNode) return processAttrNode(attrNode);
-			},
-			Property: function(node) {
-				const attrNode = findAttrNodeInDefineMessages(node, "id") || findAttrNodeInDefineMessage(node, "id");
-				if (attrNode) return processAttrNode(attrNode);
-			}
-		};
-	}
-});
-
-//#endregion
-//#region src/rules/intl-id-naming.js
-const RULE_NAME$15 = "intl-id-naming";
-var intl_id_naming_default = createRule({
-	name: RULE_NAME$15,
-	meta: {
-		type: "problem",
-		docs: { description: "Validates intl message ids naming convention" },
-		schema: [{
-			type: "object",
-			properties: { format: {
-				type: "string",
-				enum: ["camelCase", "PascalCase"]
-			} }
-		}],
-		messages: { invalidIdNaming: `Invalid id naming, expected {{format}}` }
-	},
-	defaultOptions: [],
-	create: function(context) {
-		if (!context.options[0]) throw new Error("Missing options");
-		const format = context.options[0].format;
-		function report(node, value) {
-			const values = value.split(".");
-			let isPass;
-			for (const v of values) switch (format) {
-				case "camelCase":
-					if (!isCamelCase(v)) isPass = false;
-					break;
-				case "PascalCase":
-					if (!isPascalCase(v)) isPass = false;
-					break;
-			}
-			if (isPass === false) context.report({
-				node,
-				messageId: "invalidIdNaming",
-				data: { format }
-			});
-		}
-		function processLiteral(node) {
-			report(node, node.value);
-		}
-		function processTemplateLiteral(node) {
-			const displayStr = templateLiteralDisplayStr(node);
-			report(node, displayStr);
-		}
-		function processAttrNode(node) {
-			if (node.value.type === AST_NODE_TYPES.Literal) return processLiteral(node.value);
-			if (node.value.type === AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === AST_NODE_TYPES.TemplateLiteral) return processTemplateLiteral(node.value.expression);
-			if (node.value.type === AST_NODE_TYPES.TemplateLiteral) return processTemplateLiteral(node.value);
-		}
-		return {
-			JSXIdentifier: function(node) {
-				const attrNode = findFormattedMessageAttrNode(node, "id");
-				if (attrNode) return processAttrNode(attrNode);
-			},
-			CallExpression: function(node) {
-				const attrNode = findFormatMessageAttrNode(node, "id");
-				if (attrNode) return processAttrNode(attrNode);
-			},
-			Property: function(node) {
-				const attrNode = findAttrNodeInDefineMessages(node, "id") || findAttrNodeInDefineMessage(node, "id");
-				if (attrNode) return processAttrNode(attrNode);
-			}
-		};
-	}
-});
-
-//#endregion
-//#region src/rules/intl-id-prefix.js
-const RULE_NAME$14 = "intl-id-prefix";
-var intl_id_prefix_default = createRule({
-	name: RULE_NAME$14,
-	meta: {
-		type: "problem",
-		docs: { description: "Validates intl message ids has correct prefixes" },
-		schema: [{
-			type: "array",
-			items: { type: "string" }
-		}],
-		messages: { invalidIdPrefix: "Invalid id prefix: {{value}}" }
-	},
-	defaultOptions: [],
-	create: function(context) {
-		if (context.options[0].length === 0) throw new Error("Prefixes are required in settings");
-		const hasPrefix = (value) => context.options[0].some((p) => value.startsWith(p));
-		function report(node, value) {
-			if (!hasPrefix(value)) context.report({
-				node,
-				messageId: "invalidIdPrefix",
-				data: { value }
-			});
-		}
-		function processLiteral(node) {
-			report(node, node.value);
-		}
-		function processTemplateLiteral(node) {
-			const displayStr = templateLiteralDisplayStr(node);
-			report(node, displayStr);
-		}
-		function processAttrNode(node) {
-			if (node.value.type === AST_NODE_TYPES.Literal) return processLiteral(node.value);
-			if (node.value.type === AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === AST_NODE_TYPES.TemplateLiteral) return processTemplateLiteral(node.value.expression);
-			if (node.value.type === AST_NODE_TYPES.TemplateLiteral) return processTemplateLiteral(node.value);
-		}
-		return {
-			JSXIdentifier: function(node) {
-				const attrNode = findFormattedMessageAttrNode(node, "id");
-				if (attrNode) return processAttrNode(attrNode);
-			},
-			CallExpression: function(node) {
-				const attrNode = findFormatMessageAttrNode(node, "id");
-				if (attrNode) return processAttrNode(attrNode);
-			},
-			Property: function(node) {
-				const attrNode = findAttrNodeInDefineMessages(node, "id") || findAttrNodeInDefineMessage(node, "id");
-				if (attrNode) return processAttrNode(attrNode);
-			}
-		};
-	}
-});
-
-//#endregion
-//#region src/rules/intl-id-unused.js
-const RULE_NAME$13 = "intl-id-unused";
-const usedIds = /* @__PURE__ */ new Map();
-var intl_id_unused_default = createRule({
-	name: RULE_NAME$13,
-	meta: {
-		type: "problem",
-		docs: { description: "Finds unused intl message ids in locale file" },
-		schema: [],
-		messages: {}
-	},
-	defaultOptions: [],
-	create: function(context) {
-		const projectRoot = getSetting(context, "project-root");
-		if (!projectRoot) throw new Error("projectRoot must be set in this rule");
-		if (!usedIds.has(projectRoot)) usedIds.set(projectRoot, /* @__PURE__ */ new Set());
-		const usedIdSet = usedIds.get(projectRoot);
-		const translatedIds = getIntlIds(context);
-		const translatedIdSet = new Set(translatedIds);
-		function isLiteralTranslated(id) {
-			return translatedIdSet.has(id);
-		}
-		function isTemplateTranslated(re) {
-			return translatedIds.some((k) => re.test(k));
-		}
-		function processLiteral(node) {
-			if (isLiteralTranslated(node.value)) usedIdSet.add(node.value);
-		}
-		function processTemplateLiteral(node) {
-			const exStr = sortedTemplateElements(node).map((e) => !e.value ? ".*" : e.value.raw).join("");
-			const re = new RegExp(exStr);
-			if (isTemplateTranslated(re)) {}
-		}
-		function processAttrNode(node) {
-			if (node.value.type === AST_NODE_TYPES.Literal) return processLiteral(node.value);
-			if (node.value.type === AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === AST_NODE_TYPES.TemplateLiteral) return processTemplateLiteral(node.value.expression);
-			if (node.value.type === AST_NODE_TYPES.TemplateLiteral) return processTemplateLiteral(node.value);
-		}
-		return {
-			JSXIdentifier: function(node) {
-				const attrNode = findFormattedMessageAttrNode(node, "id");
-				if (attrNode) return processAttrNode(attrNode);
-			},
-			CallExpression: function(node) {
-				const attrNode = findFormatMessageAttrNode(node, "id");
-				if (attrNode) return processAttrNode(attrNode);
-			},
-			Property: function(node) {
-				const attrNode = findAttrNodeInDefineMessages(node, "id") || findAttrNodeInDefineMessage(node, "id");
-				if (attrNode) return processAttrNode(attrNode);
-			},
-			"Program:exit": function() {
-				const unusedIds = [...translatedIdSet].filter((id) => !usedIdSet.has(id));
-				const jsonPath = path$1.join(projectRoot, "intl-unused.json");
-				fs.writeFileSync(jsonPath, JSON.stringify(unusedIds, null, 2));
-			}
-		};
-	}
-});
-
-//#endregion
-//#region src/rules/intl-no-default.js
-const RULE_NAME$12 = "intl-no-default";
-var intl_no_default_default = createRule({
-	name: RULE_NAME$12,
-	meta: {
-		type: "problem",
-		docs: { description: "Validates defaultMessage is not used with react-intl" },
-		schema: [],
-		messages: { noDefaultMessage: "Do not use defaultMessage" }
-	},
-	defaultOptions: [],
-	create: function(context) {
-		function processAttrNode(node) {
-			context.report({
-				node,
-				messageId: "noDefaultMessage"
-			});
-		}
-		return {
-			JSXIdentifier: function(node) {
-				const attrNode = findFormattedMessageAttrNode(node, "defaultMessage");
-				if (attrNode) return processAttrNode(attrNode);
-			},
-			CallExpression: function(node) {
-				const attrNode = findFormatMessageAttrNode(node, "defaultMessage");
-				if (attrNode) return processAttrNode(attrNode);
-			},
-			Property: function(node) {
-				const attrNode = findAttrNodeInDefineMessages(node, "defaultMessage") || findAttrNodeInDefineMessage(node, "defaultMessage");
-				if (attrNode) return processAttrNode(attrNode);
-			}
-		};
-	}
-});
-
-//#endregion
-//#region src/rules/no-async-array-methods.js
-const RULE_NAME$11 = "no-async-array-methods";
-var no_async_array_methods_default = createRule({
-	name: RULE_NAME$11,
-	meta: {
-		type: "problem",
-		docs: {
-			description: "No async callback for Array methods forEach, map, filter, reduce, some, every, etc.",
-			recommended: "recommended"
-		},
-		schema: [],
-		messages: { noAsyncArrayMethods: `No async function in method '{{ methodName }}'` }
-	},
-	defaultOptions: [],
-	create: function(context) {
-		return { ExpressionStatement: function(node) {
-			const notAllowedArrayMethods = [
-				"forEach",
-				"filter",
-				"some",
-				"every",
-				"map",
-				"reduce",
-				"reduceRight",
-				"flatMap",
-				"find",
-				"findIndex",
-				"findLast",
-				"findLastIndex"
-			];
-			const { callee } = node.expression;
-			if (!callee || !callee.property || !callee.property.name) return;
-			if (notAllowedArrayMethods.includes(callee.property.name)) {
-				const functionArguments = node.expression.arguments.find((n) => {
-					return [AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression].includes(n.type);
-				});
-				if (functionArguments && functionArguments.async) context.report({
-					node,
-					messageId: "noAsyncArrayMethods",
-					data: { methodName: callee.property.name }
-				});
-			}
-		} };
-	}
-});
-
-//#endregion
-//#region src/rules/no-extends-error.js
-const RULE_NAME$10 = "no-extends-error";
-var no_extends_error_default = createRule({
-	name: RULE_NAME$10,
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Disallow extending the Error class",
-			recommended: "recommended"
-		},
-		schema: [],
-		messages: { noExtendsError: "Extending the 'Error' class is prohibited." }
-	},
-	defaultOptions: [],
-	create(context) {
-		return { ClassDeclaration(node) {
-			if (node.superClass && node.superClass.type === AST_NODE_TYPES.Identifier && node.superClass.name === "Error") context.report({
-				node: node.superClass,
-				messageId: "noExtendsError"
-			});
-		} };
-	}
-});
-
-//#endregion
-//#region src/rules/no-import-css.js
-const RULE_NAME$9 = "no-import-css";
-var no_import_css_default = createRule({
-	name: RULE_NAME$9,
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Prevent importing CSS",
-			recommended: "recommended"
-		},
-		schema: [],
-		messages: { noImportCSS: "Do not import CSS files. Use CSS-in-JS instead." }
-	},
-	defaultOptions: [],
-	create(context) {
-		return { ImportDeclaration(node) {
-			const ext = path.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 }
-			});
-		} };
-	}
-});
-
-//#endregion
-//#region src/rules/no-then-catch-finally.js
-const RULE_NAME$8 = "no-then-catch-finally";
-var no_then_catch_finally_default = createRule({
-	name: RULE_NAME$8,
-	meta: {
-		type: "suggestion",
-		docs: { description: "Disallow the use of then()/catch()/finally() when invoking specific functions." },
-		schema: [{
-			type: "object",
-			properties: { restrictedFunctions: {
-				type: "array",
-				uniqueItems: true,
-				items: { type: "string" }
-			} }
-		}],
-		messages: { forbiddenThenCatchFinally: `then()/catch()/finally() is forbidden when invoke {{ name }}().` }
-	},
-	defaultOptions: [],
-	create(context) {
-		const configuration = context.options[0] || {};
-		const restrictedFunctions = configuration.restrictedFunctions || [];
-		const getScope = typeof context.getScope === "function" ? () => {
-			return context.getScope();
-		} : (node) => {
-			return context.sourceCode.getScope(node);
-		};
-		/**
-		* Returns true if node is created at the top-level scope.
-		* Await statements are not allowed at the top level,
-		* only within function declarations.
-		*/
-		function isTopLevelScoped(node) {
-			return getScope(node).block.type === "Program";
-		}
-		/**
-		* Returns true if node is a member expression that is a then/catch/finally
-		* @param {*} node - The node to check
-		*/
-		function isThenCatchFinally(node) {
-			return node.property && (node.property.name === "then" || node.property.name === "catch" || node.property.name === "finally");
-		}
-		return { [`${AST_NODE_TYPES.CallExpression} > ${AST_NODE_TYPES.MemberExpression}.callee`]: (node) => {
-			if (isTopLevelScoped(node)) return;
-			if (!isThenCatchFinally(node)) return;
-			const callExpression = node.object;
-			if (callExpression.type === AST_NODE_TYPES.CallExpression && callExpression.callee.type === AST_NODE_TYPES.Identifier && restrictedFunctions.includes(callExpression.callee.name)) context.report({
-				node: node.property,
-				messageId: "forbiddenThenCatchFinally",
-				data: { name: callExpression.callee.name }
-			});
-		} };
-	}
-});
-
-//#endregion
-//#region src/rules/no-unnecessary-template-literals.js
-const RULE_NAME$7 = "no-unnecessary-template-literals";
-var no_unnecessary_template_literals_default = createRule({
-	name: RULE_NAME$7,
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Check if a template string contains only one ${}",
-			recommended: "recommended"
-		},
-		fixable: "code",
-		schema: [],
-		messages: { unnecessaryTemplateString: "Unnecessary template string with only one ${}." }
-	},
-	defaultOptions: [],
-	create(context) {
-		return { TemplateLiteral(node) {
-			const code = context.sourceCode.getText(node);
-			if (code.startsWith("`${") && code.endsWith("}`") && code.split("${").length === 2) context.report({
-				node,
-				messageId: "unnecessaryTemplateString",
-				fix(fixer) {
-					return fixer.replaceText(node, code.substring(3, code.length - 2));
-				}
-			});
-		} };
-	}
-});
-
-//#endregion
-//#region src/rules/react-better-exhaustive-deps.js
-/**
-* Copyright (c) Meta Platforms, Inc. and affiliates.
-*
-* This source code is licensed under the MIT license found in the
-* LICENSE file in the root directory of this source tree.
-*/
-const RULE_NAME$6 = "react-better-exhaustive-deps";
-/** @type {import('eslint').Rule.RuleModule} */
-var react_better_exhaustive_deps_default = {
-	meta: {
-		type: "suggestion",
-		docs: {
-			description: "verifies the list of dependencies for Hooks like useEffect and similar",
-			url: "https://github.com/facebook/react/issues/14920"
-		},
-		fixable: "code",
-		hasSuggestions: true,
-		schema: [{
-			type: "object",
-			additionalProperties: false,
-			enableDangerousAutofixThisMayCauseInfiniteLoops: false,
-			properties: {
-				additionalHooks: { type: "string" },
-				enableDangerousAutofixThisMayCauseInfiniteLoops: { type: "boolean" },
-				customHooks: {
-					type: "object",
-					additionalProperties: { callbackIndex: { type: "number" } }
-				},
-				staticHooks: {
-					type: "object",
-					additionalProperties: { oneOf: [
-						{ type: "boolean" },
-						{
-							type: "array",
-							items: { type: "boolean" }
-						},
-						{
-							type: "object",
-							additionalProperties: { type: "boolean" }
-						}
-					] }
-				},
-				checkMemoizedVariableIsStatic: { type: "boolean" }
-			}
-		}]
-	},
-	create(context) {
-		const additionalHooks = context.options && context.options[0] && context.options[0].additionalHooks ? new RegExp(context.options[0].additionalHooks) : void 0;
-		const enableDangerousAutofixThisMayCauseInfiniteLoops = context.options && context.options[0] && context.options[0].enableDangerousAutofixThisMayCauseInfiniteLoops || false;
-		const customHooks = context.options && context.options[0] && context.options[0].customHooks || {};
-		const staticHooks = context.options && context.options[0] && context.options[0].staticHooks || {};
-		const checkMemoizedVariableIsStatic = context.options && context.options[0] && context.options[0].checkMemoizedVariableIsStatic || false;
-		const options = {
-			additionalHooks,
-			enableDangerousAutofixThisMayCauseInfiniteLoops,
-			customHooks,
-			staticHooks,
-			checkMemoizedVariableIsStatic
-		};
-		function reportProblem(problem) {
-			if (enableDangerousAutofixThisMayCauseInfiniteLoops && Array.isArray(problem.suggest) && problem.suggest.length > 0) problem.fix = problem.suggest[0].fix;
-			context.report(problem);
-		}
-		/**
-		* SourceCode#getText that also works down to ESLint 3.0.0
-		*/
-		const getSource = typeof context.getSource === "function" ? (node) => {
-			return context.getSource(node);
-		} : (node) => {
-			return context.sourceCode.getText(node);
-		};
-		/**
-		* SourceCode#getScope that also works down to ESLint 3.0.0
-		*/
-		const getScope = typeof context.getScope === "function" ? () => {
-			return context.getScope();
-		} : (node) => {
-			return context.sourceCode.getScope(node);
-		};
-		const scopeManager = context.getSourceCode().scopeManager;
-		const setStateCallSites = /* @__PURE__ */ new WeakMap();
-		const stateVariables = /* @__PURE__ */ new WeakSet();
-		const stableKnownValueCache = /* @__PURE__ */ new WeakMap();
-		const functionWithoutCapturedValueCache = /* @__PURE__ */ new WeakMap();
-		const useEffectEventVariables = /* @__PURE__ */ new WeakSet();
-		function memoizeWithWeakMap(fn, map) {
-			return function(arg) {
-				if (map.has(arg)) return map.get(arg);
-				const result = fn(arg);
-				map.set(arg, result);
-				return result;
-			};
-		}
-		function visitFunctionWithDependencies(node, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect) {
-			if (isEffect && node.async) {
-				let isCustomHook = false;
-				if (options.customHooks) Object.entries(options.customHooks).forEach(([key, customParts]) => {
-					if (typeof customParts === "object" && new RegExp(key).test(reactiveHookName)) isCustomHook = true;
-				});
-				if (!isCustomHook) reportProblem({
-					node,
-					message: "Effect callbacks are synchronous to prevent race conditions. Put the async function inside:\n\nuseEffect(() => {\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\nLearn more about data fetching with Hooks: https://react.dev/link/hooks-data-fetching"
-				});
-			}
-			const scope = scopeManager.acquire(node);
-			const pureScopes = /* @__PURE__ */ new Set();
-			let componentScope = null;
-			{
-				let currentScope = scope.upper;
-				while (currentScope) {
-					pureScopes.add(currentScope);
-					if (currentScope.type === "function") break;
-					currentScope = currentScope.upper;
-				}
-				if (!currentScope) return;
-				componentScope = currentScope;
-			}
-			const isArray = Array.isArray;
-			const memoizedIsStableKnownHookValue = memoizeWithWeakMap(isStableKnownHookValue, stableKnownValueCache);
-			const memoizedIsFunctionWithoutCapturedValues = memoizeWithWeakMap(isFunctionWithoutCapturedValues, functionWithoutCapturedValueCache);
-			function isStableKnownHookValue(resolved) {
-				if (!isArray(resolved.defs)) return false;
-				const def = resolved.defs[0];
-				if (def == null) return false;
-				if (def.node.type !== "VariableDeclarator") return false;
-				let init = def.node.init;
-				if (init == null) return false;
-				while (init.type === "TSAsExpression" || init.type === "AsExpression") init = init.expression;
-				let declaration = def.node.parent;
-				if (declaration == null) {
-					fastFindReferenceWithParent(componentScope.block, def.node.id);
-					declaration = def.node.parent;
-					if (declaration == null) return false;
-				}
-				if (declaration.kind === "const" && init.type === "Literal" && (typeof init.value === "string" || typeof init.value === "number" || init.value == null)) return true;
-				if (init.type !== "CallExpression") return false;
-				let callee = init.callee;
-				if (callee.type === "MemberExpression" && callee.object.name === "React" && callee.property != null && !callee.computed) callee = callee.property;
-				if (callee.type !== "Identifier") return false;
-				const id = def.node.id;
-				const { name } = callee;
-				if (name === "useRef" && id.type === "Identifier") return true;
-				else if (isUseEffectEventIdentifier(callee) && id.type === "Identifier") {
-					for (const ref of resolved.references) if (ref !== id) useEffectEventVariables.add(ref.identifier);
-					return true;
-				} else if (name === "useState" || name === "useReducer" || name === "useActionState") {
-					if (id.type === "ArrayPattern" && id.elements.length === 2 && isArray(resolved.identifiers)) {
-						if (id.elements[1] === resolved.identifiers[0]) {
-							if (name === "useState") {
-								const references = resolved.references;
-								let writeCount = 0;
-								for (const reference of references) {
-									if (reference.isWrite()) writeCount++;
-									if (writeCount > 1) return false;
-									setStateCallSites.set(reference.identifier, id.elements[0]);
-								}
-							}
-							return true;
-						} else if (id.elements[0] === resolved.identifiers[0]) {
-							if (name === "useState") {
-								const references = resolved.references;
-								for (const reference of references) stateVariables.add(reference.identifier);
-							}
-							return false;
-						}
-					}
-				} else if (name === "useTransition") {
-					if (id.type === "ArrayPattern" && id.elements.length === 2 && Array.isArray(resolved.identifiers) && id.elements[1] === resolved.identifiers[0]) return true;
-				} else if (options.checkMemoizedVariableIsStatic && (name === "useMemo" || name === "useCallback")) {
-					const hookArgs = callee.parent.arguments;
-					if (hookArgs.length < 2) return false;
-					const dependencies$1 = hookArgs[1].elements;
-					if (dependencies$1.length === 0) return true;
-					for (const dependencyNode of dependencies$1) {
-						const dependencyRefernece = resolved.scope.references.find((reference) => reference.identifier === dependencyNode);
-						if (dependencyRefernece !== void 0 && memoizedIsStableKnownHookValue(dependencyRefernece.resolved)) continue;
-						else return false;
-					}
-					return true;
-				} else {
-					Object.entries(options.staticHooks).forEach(([key, staticParts]) => {
-						if (typeof staticParts === "object" && staticParts.regexp && new RegExp(key).test(name)) options.staticHooks[name] = staticParts.value;
-					});
-					if (options.staticHooks[name]) {
-						const staticParts = options.staticHooks[name];
-						if (staticParts === true) return true;
-						else if (Array.isArray(staticParts)) {
-							if (id.type === "ArrayPattern" && id.elements.length <= staticParts.length && Array.isArray(resolved.identifiers)) {
-								const idx = id.elements.indexOf(resolved.identifiers[0]);
-								if (idx !== -1) return staticParts[idx];
-							}
-						} else if (typeof staticParts === "object" && id.type === "ObjectPattern") {
-							const property = id.properties.find((p) => p.key === resolved.identifiers[0]);
-							if (property) return staticParts[property.key.name];
-						}
-					}
-				}
-				return false;
-			}
-			function isFunctionWithoutCapturedValues(resolved) {
-				if (!isArray(resolved.defs)) return false;
-				const def = resolved.defs[0];
-				if (def == null) return false;
-				if (def.node == null || def.node.id == null) return false;
-				const fnNode = def.node;
-				const childScopes = componentScope.childScopes;
-				let fnScope = null;
-				let i;
-				for (i = 0; i < childScopes.length; i++) {
-					const childScope = childScopes[i];
-					const childScopeBlock = childScope.block;
-					if (fnNode.type === "FunctionDeclaration" && childScopeBlock === fnNode || fnNode.type === "VariableDeclarator" && childScopeBlock.parent === fnNode) {
-						fnScope = childScope;
-						break;
-					}
-				}
-				if (fnScope == null) return false;
-				for (i = 0; i < fnScope.through.length; i++) {
-					const ref = fnScope.through[i];
-					if (ref.resolved == null) continue;
-					if (pureScopes.has(ref.resolved.scope) && !memoizedIsStableKnownHookValue(ref.resolved)) return false;
-				}
-				return true;
-			}
-			const currentRefsInEffectCleanup = /* @__PURE__ */ new Map();
-			function isInsideEffectCleanup(reference) {
-				let curScope = reference.from;
-				let isInReturnedFunction = false;
-				while (curScope.block !== node) {
-					if (curScope.type === "function") isInReturnedFunction = curScope.block.parent != null && curScope.block.parent.type === "ReturnStatement";
-					curScope = curScope.upper;
-				}
-				return isInReturnedFunction;
-			}
-			const dependencies = /* @__PURE__ */ new Map();
-			const optionalChains = /* @__PURE__ */ new Map();
-			gatherDependenciesRecursively(scope);
-			function gatherDependenciesRecursively(currentScope) {
-				for (const reference of currentScope.references) {
-					if (!reference.resolved) continue;
-					if (!pureScopes.has(reference.resolved.scope)) continue;
-					const referenceNode = fastFindReferenceWithParent(node, reference.identifier);
-					const dependencyNode = getDependency(referenceNode);
-					const dependency = analyzePropertyChain(dependencyNode, optionalChains);
-					if (isEffect && dependencyNode.type === "Identifier" && (dependencyNode.parent.type === "MemberExpression" || dependencyNode.parent.type === "OptionalMemberExpression") && !dependencyNode.parent.computed && dependencyNode.parent.property.type === "Identifier" && dependencyNode.parent.property.name === "current" && isInsideEffectCleanup(reference)) currentRefsInEffectCleanup.set(dependency, {
-						reference,
-						dependencyNode
-					});
-					if (dependencyNode.parent.type === "TSTypeQuery" || dependencyNode.parent.type === "TSTypeReference") continue;
-					const def = reference.resolved.defs[0];
-					if (def == null) continue;
-					if (def.node != null && def.node.init === node.parent) continue;
-					if (def.type === "TypeParameter") continue;
-					if (!dependencies.has(dependency)) {
-						const resolved = reference.resolved;
-						const isStable = memoizedIsStableKnownHookValue(resolved) || memoizedIsFunctionWithoutCapturedValues(resolved);
-						dependencies.set(dependency, {
-							isStable,
-							references: [reference]
-						});
-					} else dependencies.get(dependency).references.push(reference);
-				}
-				for (const childScope of currentScope.childScopes) gatherDependenciesRecursively(childScope);
-			}
-			currentRefsInEffectCleanup.forEach(({ reference, dependencyNode }, dependency) => {
-				const references = reference.resolved.references;
-				let foundCurrentAssignment = false;
-				for (const { identifier } of references) {
-					const { parent } = identifier;
-					if (parent != null && parent.type === "MemberExpression" && !parent.computed && parent.property.type === "Identifier" && parent.property.name === "current" && parent.parent.type === "AssignmentExpression" && parent.parent.left === parent) {
-						foundCurrentAssignment = true;
-						break;
-					}
-				}
-				if (foundCurrentAssignment) return;
-				reportProblem({
-					node: dependencyNode.parent.property,
-					message: `The ref value '${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.`
-				});
-			});
-			const staleAssignments = /* @__PURE__ */ new Set();
-			function reportStaleAssignment(writeExpr, key) {
-				if (staleAssignments.has(key)) return;
-				staleAssignments.add(key);
-				reportProblem({
-					node: writeExpr,
-					message: `Assignments to the '${key}' variable from inside React Hook ${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 ${getSource(reactiveHook)}.`
-				});
-			}
-			const stableDependencies = /* @__PURE__ */ new Set();
-			dependencies.forEach(({ isStable, references }, key) => {
-				if (isStable) stableDependencies.add(key);
-				references.forEach((reference) => {
-					if (reference.writeExpr) reportStaleAssignment(reference.writeExpr, key);
-				});
-			});
-			if (staleAssignments.size > 0) return;
-			if (!declaredDependenciesNode) {
-				let setStateInsideEffectWithoutDeps = null;
-				dependencies.forEach(({ references }, key) => {
-					if (setStateInsideEffectWithoutDeps) return;
-					references.forEach((reference) => {
-						if (setStateInsideEffectWithoutDeps) return;
-						const id = reference.identifier;
-						const isSetState = setStateCallSites.has(id);
-						if (!isSetState) return;
-						let fnScope = reference.from;
-						while (fnScope.type !== "function") fnScope = fnScope.upper;
-						const isDirectlyInsideEffect = fnScope.block === node;
-						if (isDirectlyInsideEffect) setStateInsideEffectWithoutDeps = key;
-					});
-				});
-				if (setStateInsideEffectWithoutDeps) {
-					const { suggestedDependencies: suggestedDependencies$1 } = collectRecommendations({
-						dependencies,
-						declaredDependencies: [],
-						stableDependencies,
-						externalDependencies: /* @__PURE__ */ new Set(),
-						isEffect: true
-					});
-					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$1.join(", ") + `] as a second argument to the ${reactiveHookName} Hook.`,
-						suggest: [{
-							desc: `Add dependencies array: [${suggestedDependencies$1.join(", ")}]`,
-							fix(fixer) {
-								return fixer.insertTextAfter(node, `, [${suggestedDependencies$1.join(", ")}]`);
-							}
-						}]
-					});
-				}
-				return;
-			}
-			const declaredDependencies = [];
-			const externalDependencies = /* @__PURE__ */ new Set();
-			const isArrayExpression = declaredDependenciesNode.type === "ArrayExpression";
-			const isTSAsArrayExpression = declaredDependenciesNode.type === "TSAsExpression" && declaredDependenciesNode.expression.type === "ArrayExpression";
-			if (!isArrayExpression && !isTSAsArrayExpression) reportProblem({
-				node: declaredDependenciesNode,
-				message: `React Hook ${getSource(reactiveHook)} was passed a dependency list that is not an array literal. This means we can't statically verify whether you've passed the correct dependencies.`
-			});
-			else {
-				const arrayExpression = isTSAsArrayExpression ? declaredDependenciesNode.expression : declaredDependenciesNode;
-				arrayExpression.elements.forEach((declaredDependencyNode) => {
-					if (declaredDependencyNode == null) return;
-					if (declaredDependencyNode.type === "SpreadElement") {
-						reportProblem({
-							node: declaredDependencyNode,
-							message: `React Hook ${getSource(reactiveHook)} has a spread element in its dependency array. This means we can't statically verify whether you've passed the correct dependencies.`
-						});
-						return;
-					}
-					if (useEffectEventVariables.has(declaredDependencyNode)) reportProblem({
-						node: declaredDependencyNode,
-						message: `Functions returned from \`useEffectEvent\` must not be included in the dependency array. Remove \`${getSource(declaredDependencyNode)}\` from the list.`,
-						suggest: [{
-							desc: `Remove the dependency \`${getSource(declaredDependencyNode)}\``,
-							fix(fixer) {
-								return fixer.removeRange(declaredDependencyNode.range);
-							}
-						}]
-					});
-					let declaredDependency;
-					try {
-						declaredDependency = analyzePropertyChain(declaredDependencyNode, null);
-					} catch (err) {
-						if (/Unsupported node type/.test(err.message)) {
-							if (declaredDependencyNode.type === "Literal") if (dependencies.has(declaredDependencyNode.value)) reportProblem({
-								node: declaredDependencyNode,
-								message: `The ${declaredDependencyNode.raw} literal is not a valid dependency because it never changes. Did you mean to include ${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.`
-							});
-							else reportProblem({
-								node: declaredDependencyNode,
-								message: `React Hook ${getSource(reactiveHook)} has a complex expression in the dependency array. Extract it to a separate variable so it can be statically checked.`
-							});
-							return;
-						}
-						throw err;
-					}
-					let maybeID = declaredDependencyNode;
-					while (maybeID.type === "MemberExpression" || maybeID.type === "OptionalMemberExpression" || maybeID.type === "ChainExpression") maybeID = maybeID.object || maybeID.expression.object;
-					const isDeclaredInComponent = !componentScope.through.some((ref) => ref.identifier === maybeID);
-					declaredDependencies.push({
-						key: declaredDependency,
-						node: declaredDependencyNode
-					});
-					if (!isDeclaredInComponent) externalDependencies.add(declaredDependency);
-				});
-			}
-			const { suggestedDependencies, unnecessaryDependencies, missingDependencies, duplicateDependencies } = collectRecommendations({
-				dependencies,
-				declaredDependencies,
-				stableDependencies,
-				externalDependencies,
-				isEffect
-			});
-			let suggestedDeps = suggestedDependencies;
-			const problemCount = duplicateDependencies.size + missingDependencies.size + unnecessaryDependencies.size;
-			if (problemCount === 0) {
-				const constructions = scanForConstructions({
-					declaredDependencies,
-					declaredDependenciesNode,
-					componentScope,
-					scope
-				});
-				constructions.forEach(({ construction, isUsedOutsideOfHook, depType }) => {
-					const wrapperHook = depType === "function" ? "useCallback" : "useMemo";
-					const constructionType = depType === "function" ? "definition" : "initialization";
-					const defaultAdvice = `wrap the ${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
-					});
-				});
-				return;
-			}
-			if (!isEffect && missingDependencies.size > 0) suggestedDeps = collectRecommendations({
-				dependencies,
-				declaredDependencies: [],
-				stableDependencies,
-				externalDependencies,
-				isEffect
-			}).suggestedDependencies;
-			function areDeclaredDepsAlphabetized() {
-				if (declaredDependencies.length === 0) return true;
-				const declaredDepKeys = declaredDependencies.map((dep) => dep.key);
-				const sortedDeclaredDepKeys = [...declaredDepKeys].sort();
-				return declaredDepKeys.join(",") === sortedDeclaredDepKeys.join(",");
-			}
-			if (areDeclaredDepsAlphabetized()) suggestedDeps.sort();
-			function formatDependency(path$3) {
-				const members = path$3.split(".");
-				let finalPath = "";
-				for (let i = 0; i < members.length; i++) {
-					if (i !== 0) {
-						const pathSoFar = members.slice(0, i + 1).join(".");
-						const isOptional = optionalChains.get(pathSoFar) === true;
-						finalPath += isOptional ? "?." : ".";
-					}
-					finalPath += members[i];
-				}
-				return finalPath;
-			}
-			function getWarningMessage(deps, singlePrefix, label, fixVerb) {
-				if (deps.size === 0) return null;
-				return (deps.size > 1 ? "" : singlePrefix + " ") + label + " " + (deps.size > 1 ? "dependencies" : "dependency") + ": " + joinEnglish([...deps].sort().map((name) => "'" + formatDependency(name) + "'")) + `. Either ${fixVerb} ${deps.size > 1 ? "them" : "it"} or remove the dependency array.`;
-			}
-			let extraWarning = "";
-			if (unnecessaryDependencies.size > 0) {
-				let badRef = null;
-				[...unnecessaryDependencies.keys()].forEach((key) => {
-					if (badRef != null) return;
-					if (key.endsWith(".current")) badRef = key;
-				});
-				if (badRef != null) extraWarning = ` Mutable values like '${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.`;
-				}
-			}
-			if (!extraWarning && missingDependencies.has("props")) {
-				const propDep = dependencies.get("props");
-				if (propDep == null) return;
-				const refs = propDep.references;
-				if (!Array.isArray(refs)) return;
-				let isPropsOnlyUsedInMembers = true;
-				for (const ref of refs) {
-					const id = fastFindReferenceWithParent(componentScope.block, ref.identifier);
-					if (!id) {
-						isPropsOnlyUsedInMembers = false;
-						break;
-					}
-					const parent = id.parent;
-					if (parent == null) {
-						isPropsOnlyUsedInMembers = false;
-						break;
-					}
-					if (parent.type !== "MemberExpression" && parent.type !== "OptionalMemberExpression") {
-						isPropsOnlyUsedInMembers = false;
-						break;
-					}
-				}
-				if (isPropsOnlyUsedInMembers) extraWarning = ` However, 'props' will change when *any* prop changes, so the preferred fix is to destructure the 'props' object outside of the ${reactiveHookName} call and refer to those specific props inside ${getSource(reactiveHook)}.`;
-			}
-			if (!extraWarning && missingDependencies.size > 0) {
-				let missingCallbackDep = null;
-				missingDependencies.forEach((missingDep) => {
-					if (missingCallbackDep) return;
-					const topScopeRef = componentScope.set.get(missingDep);
-					const usedDep = dependencies.get(missingDep);
-					if (usedDep.references[0].resolved !== topScopeRef) return;
-					const def = topScopeRef.defs[0];
-					if (def == null || def.name == null || def.type !== "Parameter") return;
-					let isFunctionCall = false;
-					let id;
-					for (let i = 0; i < usedDep.references.length; i++) {
-						id = usedDep.references[i].identifier;
-						if (id != null && id.parent != null && (id.parent.type === "CallExpression" || id.parent.type === "OptionalCallExpression") && id.parent.callee === id) {
-							isFunctionCall = true;
-							break;
-						}
-					}
-					if (!isFunctionCall) return;
-					missingCallbackDep = missingDep;
-				});
-				if (missingCallbackDep != null) extraWarning = ` If '${missingCallbackDep}' changes too often, find the parent component that defines it and wrap that definition in useCallback.`;
-			}
-			if (!extraWarning && missingDependencies.size > 0) {
-				let setStateRecommendation = null;
-				missingDependencies.forEach((missingDep) => {
-					if (setStateRecommendation != null) return;
-					const usedDep = dependencies.get(missingDep);
-					const references = usedDep.references;
-					let id;
-					let maybeCall;
-					for (const reference of references) {
-						id = reference.identifier;
-						maybeCall = id.parent;
-						while (maybeCall != null && maybeCall !== componentScope.block) {
-							if (maybeCall.type === "CallExpression") {
-								const correspondingStateVariable = setStateCallSites.get(maybeCall.callee);
-								if (correspondingStateVariable != null) {
-									if (correspondingStateVariable.name === missingDep) setStateRecommendation = {
-										missingDep,
-										setter: maybeCall.callee.name,
-										form: "updater"
-									};
-									else if (stateVariables.has(id)) setStateRecommendation = {
-										missingDep,
-										setter: maybeCall.callee.name,
-										form: "reducer"
-									};
-									else {
-										const resolved = reference.resolved;
-										if (resolved != null) {
-											const def = resolved.defs[0];
-											if (def != null && def.type === "Parameter") setStateRecommendation = {
-												missingDep,
-												setter: maybeCall.callee.name,
-												form: "inlineReducer"
-											};
-										}
-									}
-									break;
-								}
-							}
-							maybeCall = maybeCall.parent;
-						}
-						if (setStateRecommendation != null) break;
-					}
-				});
-				if (setStateRecommendation != null) switch (setStateRecommendation.form) {
-					case "reducer":
-						extraWarning = ` You can also replace multiple useState variables with useReducer if '${setStateRecommendation.setter}' needs the current value of '${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.`;
-						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.`;
-						break;
-					default: throw new Error("Unknown case.");
-				}
-			}
-			reportProblem({
-				node: declaredDependenciesNode,
-				message: `React Hook ${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(", ")}]`);
-					}
-				}]
-			});
-		}
-		function visitCallExpression(node) {
-			const callbackIndex = getReactiveHookCallbackIndex(node.callee, options);
-			if (callbackIndex === -1) return;
-			const callback = node.arguments[callbackIndex];
-			const reactiveHook = node.callee;
-			const reactiveHookName = getNodeWithoutReactNamespace(reactiveHook).name;
-			const maybeNode = node.arguments[callbackIndex + 1];
-			const declaredDependenciesNode = maybeNode && !(maybeNode.type === "Identifier" && maybeNode.name === "undefined") ? maybeNode : void 0;
-			const isEffect = /Effect($|[^a-z])/g.test(reactiveHookName);
-			if (!callback) {
-				reportProblem({
-					node: reactiveHook,
-					message: `React Hook ${reactiveHookName} requires an effect callback. Did you forget to pass a callback to the hook?`
-				});
-				return;
-			}
-			if (!declaredDependenciesNode && !isEffect) {
-				if (reactiveHookName === "useMemo" || reactiveHookName === "useCallback") reportProblem({
-					node: reactiveHook,
-					message: `React Hook ${reactiveHookName} does nothing when called with only one argument. Did you forget to pass an array of dependencies?`
-				});
-				return;
-			}
-			switch (callback.type) {
-				case "FunctionExpression":
-				case "ArrowFunctionExpression":
-					visitFunctionWithDependencies(callback, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect);
-					return;
-				case "TSAsExpression":
-					visitFunctionWithDependencies(callback.expression, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect);
-					return;
-				case "Identifier":
-					if (!declaredDependenciesNode) return;
-					if (declaredDependenciesNode.elements && declaredDependenciesNode.elements.some((el) => el && el.type === "Identifier" && el.name === callback.name)) return;
-					const variable = getScope(callback).set.get(callback.name);
-					if (variable == null || variable.defs == null) return;
-					const def = variable.defs[0];
-					if (!def || !def.node) break;
-					if (def.type !== "Variable" && def.type !== "FunctionName") break;
-					switch (def.node.type) {
-						case "FunctionDeclaration":
-							visitFunctionWithDependencies(def.node, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect);
-							return;
-						case "VariableDeclarator":
-							const init = def.node.init;
-							if (!init) break;
-							switch (init.type) {
-								case "ArrowFunctionExpression":
-								case "FunctionExpression":
-									visitFunctionWithDependencies(init, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect);
-									return;
-							}
-							break;
-					}
-					break;
-				default:
-					reportProblem({
-						node: reactiveHook,
-						message: `React Hook ${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}]`);
-					}
-				}]
-			});
-		}
-		return { CallExpression: visitCallExpression };
-	}
-};
-function collectRecommendations({ dependencies, declaredDependencies, stableDependencies, externalDependencies, isEffect }) {
-	const depTree = createDepTree();
-	function createDepTree() {
-		return {
-			isUsed: false,
-			isSatisfiedRecursively: false,
-			isSubtreeUsed: false,
-			children: /* @__PURE__ */ new Map()
-		};
-	}
-	dependencies.forEach((_, key) => {
-		const node = getOrCreateNodeByPath(depTree, key);
-		node.isUsed = true;
-		markAllParentsByPath(depTree, key, (parent) => {
-			parent.isSubtreeUsed = true;
-		});
-	});
-	declaredDependencies.forEach(({ key }) => {
-		const node = getOrCreateNodeByPath(depTree, key);
-		node.isSatisfiedRecursively = true;
-	});
-	stableDependencies.forEach((key) => {
-		const node = getOrCreateNodeByPath(depTree, key);
-		node.isSatisfiedRecursively = true;
-	});
-	function getOrCreateNodeByPath(rootNode, path$3) {
-		const keys = path$3.split(".");
-		let node = rootNode;
-		for (const key of keys) {
-			let child = node.children.get(key);
-			if (!child) {
-				child = createDepTree();
-				node.children.set(key, child);
-			}
-			node = child;
-		}
-		return node;
-	}
-	function markAllParentsByPath(rootNode, path$3, fn) {
-		const keys = path$3.split(".");
-		let node = rootNode;
-		for (const key of keys) {
-			const child = node.children.get(key);
-			if (!child) return;
-			fn(child);
-			node = child;
-		}
-	}
-	const missingDependencies = /* @__PURE__ */ new Set();
-	const satisfyingDependencies = /* @__PURE__ */ new Set();
-	scanTreeRecursively(depTree, missingDependencies, satisfyingDependencies, (key) => key);
-	function scanTreeRecursively(node, missingPaths, satisfyingPaths, keyToPath) {
-		node.children.forEach((child, key) => {
-			const path$3 = keyToPath(key);
-			if (child.isSatisfiedRecursively) {
-				if (child.isSubtreeUsed) satisfyingPaths.add(path$3);
-				return;
-			}
-			if (child.isUsed) {
-				missingPaths.add(path$3);
-				return;
-			}
-			scanTreeRecursively(child, missingPaths, satisfyingPaths, (childKey) => path$3 + "." + childKey);
-		});
-	}
-	const suggestedDependencies = [];
-	const unnecessaryDependencies = /* @__PURE__ */ new Set();
-	const duplicateDependencies = /* @__PURE__ */ new Set();
-	declaredDependencies.forEach(({ key }) => {
-		if (satisfyingDependencies.has(key)) if (!suggestedDependencies.includes(key)) suggestedDependencies.push(key);
-		else duplicateDependencies.add(key);
-		else if (isEffect && !key.endsWith(".current") && !externalDependencies.has(key)) {
-			if (!suggestedDependencies.includes(key)) suggestedDependencies.push(key);
-		} else unnecessaryDependencies.add(key);
-	});
-	missingDependencies.forEach((key) => {
-		suggestedDependencies.push(key);
-	});
-	return {
-		suggestedDependencies,
-		unnecessaryDependencies,
-		duplicateDependencies,
-		missingDependencies
-	};
-}
-function getConstructionExpressionType(node) {
-	switch (node.type) {
-		case "ObjectExpression": return "object";
-		case "ArrayExpression": return "array";
-		case "ArrowFunctionExpression":
-		case "FunctionExpression": return "function";
-		case "ClassExpression": return "class";
-		case "ConditionalExpression":
-			if (getConstructionExpressionType(node.consequent) != null || getConstructionExpressionType(node.alternate) != null) return "conditional";
-			return null;
-		case "LogicalExpression":
-			if (getConstructionExpressionType(node.left) != null || getConstructionExpressionType(node.right) != null) return "logical expression";
-			return null;
-		case "JSXFragment": return "JSX fragment";
-		case "JSXElement": return "JSX element";
-		case "AssignmentExpression":
-			if (getConstructionExpressionType(node.right) != null) return "assignment expression";
-			return null;
-		case "NewExpression": return "object construction";
-		case "Literal":
-			if (node.value instanceof RegExp) return "regular expression";
-			return null;
-		case "TypeCastExpression":
-		case "AsExpression":
-		case "TSAsExpression": return getConstructionExpressionType(node.expression);
-	}
-	return null;
-}
-function scanForConstructions({ declaredDependencies, declaredDependenciesNode, componentScope, scope }) {
-	const constructions = declaredDependencies.map(({ key }) => {
-		const ref = componentScope.variables.find((v) => v.name === key);
-		if (ref == null) return null;
-		const node = ref.defs[0];
-		if (node == null) return null;
-		if (node.type === "Variable" && node.node.type === "VariableDeclarator" && node.node.id.type === "Identifier" && node.node.init != null) {
-			const constantExpressionType = getConstructionExpressionType(node.node.init);
-			if (constantExpressionType != null) return [ref, constantExpressionType];
-		}
-		if (node.type === "FunctionName" && node.node.type === "FunctionDeclaration") return [ref, "function"];
-		if (node.type === "ClassName" && node.node.type === "ClassDeclaration") return [ref, "class"];
-		return null;
-	}).filter(Boolean);
-	function isUsedOutsideOfHook(ref) {
-		let foundWriteExpr = false;
-		for (let i = 0; i < ref.references.length; i++) {
-			const reference = ref.references[i];
-			if (reference.writeExpr) {
-				if (foundWriteExpr) return true;
-				foundWriteExpr = true;
-				continue;
-			}
-			let currentScope = reference.from;
-			while (currentScope !== scope && currentScope != null) currentScope = currentScope.upper;
-			if (currentScope !== scope && !isAncestorNodeOf(declaredDependenciesNode, reference.identifier)) return true;
-		}
-		return false;
-	}
-	return constructions.map(([ref, depType]) => ({
-		construction: ref.defs[0],
-		depType,
-		isUsedOutsideOfHook: isUsedOutsideOfHook(ref)
-	}));
-}
-function getDependency(node) {
-	if ((node.parent.type === "MemberExpression" || node.parent.type === "OptionalMemberExpression") && node.parent.object === node && node.parent.property.name !== "current" && !node.parent.computed && !(node.parent.parent != null && (node.parent.parent.type === "CallExpression" || node.parent.parent.type === "OptionalCallExpression") && node.parent.parent.callee === node.parent)) return getDependency(node.parent);
-	else if (node.type === "MemberExpression" && node.parent && node.parent.type === "AssignmentExpression" && node.parent.left === node) return node.object;
-	return node;
-}
-/**
-* Mark a node as either optional or required.
-* Note: If the node argument is an OptionalMemberExpression, it doesn't necessarily mean it is optional.
-* It just means there is an optional member somewhere inside.
-* This particular node might still represent a required member, so check .optional field.
-* @param {*} node - Node
-* @param {*} optionalChains - Map of optional chains
-* @param {*} result - Resulting property chain
-*/
-function markNode(node, optionalChains, result) {
-	if (optionalChains) if (node.optional) {
-		if (!optionalChains.has(result)) optionalChains.set(result, true);
-	} else optionalChains.set(result, false);
-}
-/**
-* Assuming () means the passed node.
-* (foo) -> 'foo'
-* foo(.)bar -> 'foo.bar'
-* foo.bar(.)baz -> 'foo.bar.baz'
-* Otherwise throw.
-* @param {*} node - Node
-* @param {*} optionalChains - Map of optional chains
-*/
-function analyzePropertyChain(node, optionalChains) {
-	if (node.type === "Identifier" || node.type === "JSXIdentifier") {
-		const result = node.name;
-		if (optionalChains) optionalChains.set(result, false);
-		return result;
-	} else if (node.type === "MemberExpression" && !node.computed) {
-		const object = analyzePropertyChain(node.object, optionalChains);
-		const property = analyzePropertyChain(node.property, null);
-		const result = `${object}.${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}`;
-		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}`);
-		const object = analyzePropertyChain(expression.object, optionalChains);
-		const property = analyzePropertyChain(expression.property, null);
-		const result = `${object}.${property}`;
-		markNode(expression, optionalChains, result);
-		return result;
-	}
-	throw new Error(`Unsupported node type: ${node.type}`);
-}
-function getNodeWithoutReactNamespace(node) {
-	if (node.type === "MemberExpression" && node.object.type === "Identifier" && node.object.name === "React" && node.property.type === "Identifier" && !node.computed) return node.property;
-	return node;
-}
-function getReactiveHookCallbackIndex(calleeNode, options) {
-	const node = getNodeWithoutReactNamespace(calleeNode);
-	if (node.type !== "Identifier") return -1;
-	switch (node.name) {
-		case "useEffect":
-		case "useLayoutEffect":
-		case "useCallback":
-		case "useMemo": return 0;
-		case "useImperativeHandle": return 1;
-		default:
-			if (node === calleeNode && options && options.customHooks) {
-				let name;
-				try {
-					name = analyzePropertyChain(node, null);
-				} catch (err) {
-					if (/Unsupported node type/.test(err.message)) return 0;
-					throw err;
-				}
-				for (const [key, customParts] of Object.entries(options.customHooks)) if (typeof customParts === "object" && typeof customParts.callbackIndex === "number" && new RegExp(key).test(name)) return customParts.callbackIndex;
-			}
-			if (node === calleeNode && options && options.additionalHooks) {
-				let name;
-				try {
-					name = analyzePropertyChain(node, null);
-				} catch (err) {
-					if (/Unsupported node type/.test(err.message)) return 0;
-					throw err;
-				}
-				return options.additionalHooks.test(name) ? 0 : -1;
-			}
-			return -1;
-	}
-}
-/**
-* ESLint won't assign node.parent to references from context.getScope()
-*
-* So instead we search for the node from an ancestor assigning node.parent
-* as we go. This mutates the AST.
-*
-* This traversal is:
-* - optimized by only searching nodes with a range surrounding our target node
-* - agnostic to AST node types, it looks for `{ type: string, ... }`
-* @param {*} start - Start Node
-* @param {*} target - Target Node
-*/
-function fastFindReferenceWithParent(start, target) {
-	const queue = [start];
-	let item = null;
-	while (queue.length > 0) {
-		item = queue.shift();
-		if (isSameIdentifier(item, target)) return item;
-		if (!isAncestorNodeOf(item, target)) continue;
-		for (const [key, value] of Object.entries(item)) {
-			if (key === "parent") continue;
-			if (isNodeLike(value)) {
-				value.parent = item;
-				queue.push(value);
-			} else if (Array.isArray(value)) value.forEach((val) => {
-				if (isNodeLike(val)) {
-					val.parent = item;
-					queue.push(val);
-				}
-			});
-		}
-	}
-	return null;
-}
-function joinEnglish(arr) {
-	let s = "";
-	for (let i = 0; i < arr.length; i++) {
-		s += arr[i];
-		if (i === 0 && arr.length === 2) s += " and ";
-		else if (i === arr.length - 2 && arr.length > 2) s += ", and ";
-		else if (i < arr.length - 1) s += ", ";
-	}
-	return s;
-}
-function isNodeLike(val) {
-	return typeof val === "object" && val != null && !Array.isArray(val) && typeof val.type === "string";
-}
-function isSameIdentifier(a, b) {
-	return (a.type === "Identifier" || a.type === "JSXIdentifier") && a.type === b.type && a.name === b.name && a.range[0] === b.range[0] && a.range[1] === b.range[1];
-}
-function isAncestorNodeOf(a, b) {
-	return a.range[0] <= b.range[0] && a.range[1] >= b.range[1];
-}
-function isUseEffectEventIdentifier(node) {
-	return false;
-}
-
-//#endregion
-//#region src/rules/react-hook-use-ref.js
-const RULE_NAME$5 = "react-hook-use-ref";
-var react_hook_use_ref_default = createRule({
-	name: RULE_NAME$5,
-	meta: {
-		type: "suggestion",
-		docs: {
-			description: "Ensure naming of useRef hook value.",
-			recommended: "recommended"
-		},
-		schema: [],
-		hasSuggestions: true,
-		messages: { useRefName: "useRef call is not end with \"Ref\"" }
-	},
-	defaultOptions: [],
-	create: Components.default.detect((context, component, util) => ({ CallExpression(node) {
-		const isImmediateReturn = node.parent && node.parent.type === AST_NODE_TYPES.ReturnStatement;
-		if (isImmediateReturn || !util.isReactHookCall(node, ["useRef"])) return;
-		if (node.parent.id.type !== AST_NODE_TYPES.Identifier) return;
-		const variable = node.parent.id.name;
-		if (!variable.endsWith("Ref")) context.report({
-			node,
-			messageId: "useRefName"
-		});
-	} }))
-});
-
-//#endregion
-//#region src/rules/react-prefer-sx-prop.js
-const RULE_NAME$4 = "react-prefer-sx-prop";
-var react_prefer_sx_prop_default = createRule({
-	name: RULE_NAME$4,
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Prefer using sx prop instead of inline styles",
-			recommended: "recommended"
-		},
-		messages: { preferSxProp: "Avoid using inline styles, use sx prop or tss-react or styled-component instead" },
-		schema: [{
-			type: "object",
-			properties: { allowedFor: {
-				type: "array",
-				uniqueItems: true,
-				items: { type: "string" }
-			} }
-		}]
-	},
-	defaultOptions: [],
-	create(context) {
-		const configuration = context.options[0] || {};
-		const allowedFor = configuration.allowedFor || [];
-		function checkComponent(node) {
-			const parentName = node.parent.name;
-			const tag = parentName.name || `${parentName.object.name}.${parentName.property.name}`;
-			const componentName = parentName.name || parentName.property.name;
-			if (componentName && typeof componentName[0] === "string" && componentName[0] !== componentName[0].toUpperCase()) return;
-			if (allowedFor.includes(tag)) return;
-			const prop = node.name.name;
-			if (prop === "style") context.report({
-				node,
-				messageId: "preferSxProp"
-			});
-		}
-		function checkDOMNodes(node) {
-			const tag = node.parent.name.name;
-			if (!(tag && typeof tag === "string" && tag[0] !== tag[0].toUpperCase())) return;
-			if (allowedFor.includes(tag)) return;
-			const prop = node.name.name;
-			if (prop === "style") context.report({
-				node,
-				messageId: "preferSxProp"
-			});
-		}
-		return { JSXAttribute(node) {
-			checkComponent(node);
-			checkDOMNodes(node);
-		} };
-	}
-});
-
-//#endregion
-//#region src/util/tss.js
-/**
-* Helper function to get the basic identifier from various node types
-* @param {import('eslint').Rule.Node} node - The node to get the identifier from
-* @returns {string | null} The identifier name or null if it can't be determined
-*/
-function getBasicIdentifier(node) {
-	if (node.type === AST_NODE_TYPES.Identifier) return node.name;
-	if (node.type === AST_NODE_TYPES.Literal) return node.value;
-	if (node.type === AST_NODE_TYPES.TemplateLiteral) {
-		if (node.expressions.length > 0) return null;
-		return node.quasis[0].value.raw;
-	}
-	return null;
-}
-/**
-* Helper function to recursively get the base identifier from a MemberExpression node
-* @param {*} node - The node to get the identifier from
-* @returns {import('estree').Identifier | null} The identifier or null if it can't be determined
-*/
-function getBaseIdentifier(node) {
-	switch (node.type) {
-		case AST_NODE_TYPES.Identifier: return node;
-		case AST_NODE_TYPES.CallExpression: return getBaseIdentifier(node.callee);
-		case AST_NODE_TYPES.MemberExpression: return getBaseIdentifier(node.object);
-	}
-	return null;
-}
-/**
-* get the styles object from a makeStyles or tss.create call
-* @param {import('estree').CallExpression & import('eslint').Rule.NodeParentExtension} node - The node to get the styles object from
-* @returns - The styles object or null if it can't be determined
-*/
-function getStyesObj(node) {
-	const isMakeStyles = node.callee.name === "makeStyles";
-	const isModernApi = node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.name === "create" && getBaseIdentifier(node.callee.object) && getBaseIdentifier(node.callee.object).name === "tss";
-	if (!isMakeStyles && !isModernApi) return;
-	const styles = (() => {
-		if (isMakeStyles) return node.parent.arguments[0];
-		if (isModernApi) return node.callee.parent.arguments[0];
-	})();
-	if (!styles) return;
-	switch (styles.type) {
-		case AST_NODE_TYPES.ObjectExpression: return styles;
-		case AST_NODE_TYPES.ArrowFunctionExpression:
-			{
-				const { body } = styles;
-				switch (body.type) {
-					case AST_NODE_TYPES.ObjectExpression: return body;
-					case AST_NODE_TYPES.BlockStatement: {
-						let stylesObj;
-						body.body.forEach((bodyNode) => {
-							if (bodyNode.type === AST_NODE_TYPES.ReturnStatement && bodyNode.argument.type === AST_NODE_TYPES.ObjectExpression) stylesObj = bodyNode.argument;
-						});
-						return stylesObj;
-					}
-				}
-			}
-			break;
-	}
-}
-/**
-* Loop through the styles object and call the callback function for each property
-* @param {import('estree').CallExpression & import('eslint').Rule.NodeParentExtension} node - The node to get the styles object from
-* @param {Function} callback - The callback function to call for each property
-* @returns - The styles object or null if it can't be determined
-*/
-function loopStylesObj(node, callback) {
-	if (node && node.type === AST_NODE_TYPES.ObjectExpression) node.properties.forEach((property) => {
-		if (property.type === AST_NODE_TYPES.Property && property.value) if (property.value.type === AST_NODE_TYPES.ObjectExpression) loopStylesObj(property.value, callback);
-		else callback(property.value);
-	});
-}
-
-//#endregion
-//#region src/rules/tss-class-naming.js
-const RULE_NAME$3 = "tss-class-naming";
-var tss_class_naming_default = createRule({
-	name: RULE_NAME$3,
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Enforce camelCase class names in TSS",
-			recommended: "recommended"
-		},
-		schema: [],
-		messages: { camelCase: "Class `{{ className }}` must be camelCase in TSS." }
-	},
-	defaultOptions: [],
-	create: function rule(context) {
-		return { CallExpression(node) {
-			const stylesObj = getStyesObj(node);
-			if (stylesObj === void 0) return;
-			stylesObj.properties.forEach((property) => {
-				if (property.computed) return;
-				if (property.type === "ExperimentalSpreadProperty" || property.type === AST_NODE_TYPES.SpreadElement) return;
-				const className = property.key.value || property.key.name;
-				if (!isCamelCase(className)) context.report({
-					node: property,
-					messageId: "camelCase",
-					data: { className }
-				});
-			});
-		} };
-	}
-});
-
-//#endregion
-//#region ../../node_modules/.pnpm/color-name@2.0.0/node_modules/color-name/index.js
-var color_name_default = {
-	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
-	]
-};
-
-//#endregion
-//#region src/rules/tss-no-color-name.js
-const RULE_NAME$2 = "tss-no-color-name";
-var tss_no_color_name_default = createRule({
-	name: RULE_NAME$2,
-	meta: {
-		type: "suggestion",
-		docs: {
-			description: "Enforce the use of color variables instead of color name within TSS",
-			recommended: "recommended"
-		},
-		schema: [],
-		messages: { disallowColorName: "Disallowed color name. Use color from `@mui/material/colors` or `theme.palette`." }
-	},
-	defaultOptions: [],
-	create: function(context) {
-		return { CallExpression(node) {
-			const stylesObj = getStyesObj(node);
-			if (!stylesObj) return;
-			function checkColorLiteral(value) {
-				if (value.type === AST_NODE_TYPES.Literal && typeof value.value === "string" && Object.keys(color_name_default).includes(value.value.toLowerCase())) context.report({
-					node: value,
-					messageId: "disallowColorName"
-				});
-			}
-			loopStylesObj(stylesObj, checkColorLiteral);
-		} };
-	}
-});
-
-//#endregion
-//#region src/rules/tss-no-color-value.js
-const RULE_NAME$1 = "tss-no-color-value";
-var tss_no_color_value_default = createRule({
-	name: RULE_NAME$1,
-	meta: {
-		type: "problem",
-		docs: {
-			description: "Enforce the use of color variables instead of color codes within TSS",
-			recommended: "recommended"
-		},
-		schema: [],
-		messages: { preferMuiColor: "Prefer use color from `@mui/material/colors` or `theme.palette`." }
-	},
-	defaultOptions: [],
-	create: function(context) {
-		return { CallExpression(node) {
-			const stylesObj = getStyesObj(node);
-			if (!stylesObj) return;
-			function checkColorLiteral(value) {
-				if (value.type === AST_NODE_TYPES.Literal && typeof value.value === "string") {
-					const colorCodePattern = /#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})|rgb\?\(\s*(\d{1,3}\s*,\s*){2}\d{1,3}(?:\s*,\s*\d*(?:\.\d+)?)?\s*\)/g;
-					if (colorCodePattern.test(value.value)) context.report({
-						node: value,
-						messageId: "preferMuiColor"
-					});
-				}
-			}
-			loopStylesObj(stylesObj, checkColorLiteral);
-		} };
-	}
-});
-
-//#endregion
-//#region src/rules/tss-unused-classes.js
-const RULE_NAME = "tss-unused-classes";
-var tss_unused_classes_default = createRule({
-	name: RULE_NAME,
-	meta: {
-		type: "suggestion",
-		docs: {
-			description: "Disallow unused classes in tss",
-			recommended: "recommended"
-		},
-		schema: [],
-		messages: { unusedClass: "Class `{{ className }}` is unused in JSX" }
-	},
-	defaultOptions: [],
-	create: function rule(context) {
-		const usedClasses = {};
-		const definedClasses = {};
-		return {
-			CallExpression(node) {
-				const stylesObj = getStyesObj(node);
-				if (stylesObj === void 0) return;
-				stylesObj.properties.forEach((property) => {
-					if (property.computed) return;
-					if (property.type === "ExperimentalSpreadProperty" || property.type === AST_NODE_TYPES.SpreadElement) return;
-					definedClasses[property.key.value || property.key.name] = property;
-				});
-			},
-			MemberExpression(node) {
-				if (node.object.type === AST_NODE_TYPES.Identifier && node.object.name === "classes") {
-					const whichClass = getBasicIdentifier(node.property);
-					if (whichClass) usedClasses[whichClass] = true;
-					return;
-				}
-				const classIdentifier = getBasicIdentifier(node.property);
-				if (!classIdentifier) return;
-				if (classIdentifier !== "classes") return;
-				const { parent } = node;
-				if (parent.type !== AST_NODE_TYPES.MemberExpression) return;
-				if (node.object.object && node.object.object.type !== AST_NODE_TYPES.ThisExpression) return;
-				const propsIdentifier = getBasicIdentifier(parent.object);
-				if (propsIdentifier && propsIdentifier !== "props") return;
-				if (!propsIdentifier && parent.object.type !== AST_NODE_TYPES.MemberExpression) return;
-				if (parent.parent.type === AST_NODE_TYPES.MemberExpression) return;
-				const parentClassIdentifier = getBasicIdentifier(parent.property);
-				if (parentClassIdentifier) usedClasses[parentClassIdentifier] = true;
-			},
-			"Program:exit": () => {
-				Object.keys(definedClasses).forEach((definedClassKey) => {
-					if (!usedClasses[definedClassKey]) context.report({
-						node: definedClasses[definedClassKey],
-						messageId: "unusedClass",
-						data: { className: definedClassKey }
-					});
-				});
-			}
-		};
-	}
-});
-
-//#endregion
-//#region src/rules/index.js
-const rules = {
-	[RULE_NAME$18]: enforce_mui_icon_alias_default,
-	[RULE_NAME$17]: import_monorepo_default,
-	[RULE_NAME$16]: intl_id_missing_default,
-	[RULE_NAME$15]: intl_id_naming_default,
-	[RULE_NAME$14]: intl_id_prefix_default,
-	[RULE_NAME$13]: intl_id_unused_default,
-	[RULE_NAME$12]: intl_no_default_default,
-	[RULE_NAME$11]: no_async_array_methods_default,
-	[RULE_NAME$10]: no_extends_error_default,
-	[RULE_NAME$9]: no_import_css_default,
-	[RULE_NAME$8]: no_then_catch_finally_default,
-	[RULE_NAME$7]: no_unnecessary_template_literals_default,
-	[RULE_NAME$6]: react_better_exhaustive_deps_default,
-	[RULE_NAME$5]: react_hook_use_ref_default,
-	[RULE_NAME$4]: react_prefer_sx_prop_default,
-	[RULE_NAME$3]: tss_class_naming_default,
-	[RULE_NAME$2]: tss_no_color_name_default,
-	[RULE_NAME$1]: tss_no_color_value_default,
-	[RULE_NAME]: tss_unused_classes_default
-};
-
-//#endregion
-//#region src/index.js
-const plugin = {
-	rules: {},
-	configs: { recommended: {
-		plugins: ["@agilebot"],
-		rules: {},
-		settings: { react: { version: "18.0.0" } }
-	} }
-};
-Object.keys(rules).forEach((name) => {
-	const rule = rules[name];
-	plugin.rules[name] = rule;
-	if (rule.meta && rule.meta.docs && rule.meta.docs.recommended) plugin.configs.recommended.rules[`@agilebot/${name}`] = rule.meta.type === "problem" ? "error" : "warn";
-});
-var src_default = plugin;
-
-//#endregion
-export { src_default as default };