eslint-plugin-flawless 0.1.10 → 0.1.12

package/dist/plugin-DYVtpuio.mjs

@@ -0,0 +1,4226 @@
+import { ASTUtils, AST_NODE_TYPES, ESLintUtils, TSESLint } from "@typescript-eslint/utils";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createSyncFn } from "synckit";
+import { RuleCreator, getParserServices } from "@typescript-eslint/utils/eslint-utils";
+import { DefinitionType, ImplicitLibVariable, PatternVisitor, ScopeType, Visitor } from "@typescript-eslint/scope-manager";
+import { requiresQuoting } from "@typescript-eslint/type-utils";
+import assert from "node:assert";
+import * as core from "@eslint-react/core";
+import { findVariable } from "@typescript-eslint/utils/ast-utils";
+import ts9 from "typescript";
+import { getStaticTOMLValue } from "toml-eslint-parser";
+//#region package.json
+var name = "eslint-plugin-flawless";
+var version = "0.1.12";
+var repository = {
+	"url": "git+https://github.com/christopher-buss/eslint-plugin-flawless.git",
+	"type": "git"
+};
+//#endregion
+//#region src/util.ts
+const createRule = RuleCreator((name) => {
+	return `${repository.url.replace(/^git\+/, "").replace(/\.git$/, "")}/blob/v${version}/src/rules/${name}/documentation.md`;
+});
+/**
+* Creates a rule with a docs URL, allowing a rule's `create` to receive a
+* context with a custom `sourceCode` type (such as a YAML source code). The
+* `SourceCode` type parameter defaults to ESLint's `SourceCode`, so standard
+* rules are unaffected.
+*
+* @template Options - The rule's options tuple.
+* @template MessageIds - The rule's message identifiers.
+* @template SourceCode - The source code type exposed on `context.sourceCode`.
+* @param rule - The rule definition (meta, name, defaultOptions, create).
+* @returns The created rule module.
+*/
+function createEslintRule(rule) {
+	return createRule(rule);
+}
+/**
+* Creates a dual-runtime rule from oxlint's `createOnce` alternative API.
+*
+* The rule is authored once against `createOnce` (oxlint's per-run entry point,
+* where per-file state is created in a `before` hook). The returned module
+* also exposes an ESLint-compatible `create` that delegates to `createOnce` on
+* each file, so the same object works with ESLint's `RuleTester` and the oxlint
+* `jsPlugins` loader alike. Oxlint ignores `create` when `createOnce` is
+* present; ESLint ignores `createOnce`.
+*
+* Rule bodies keep `@typescript-eslint` node/context types at the boundary
+* (oxlint's AST is structurally ESTree at runtime); `@eslint-react/core` helpers
+* are typed against those contexts, so a full switch to oxlint's `ESTree` types
+* is intentionally avoided.
+*
+* IMPORTANT: `context.sourceCode`, `context.options`, and `context.report` must
+* not be read in the `createOnce` body — only inside `before` or a visitor. In
+* oxlint's runtime they throw at setup time.
+*
+* @template Options - The rule's options tuple.
+* @template MessageIds - The rule's message identifiers.
+* @template SourceCode - The source code type exposed on `context.sourceCode`.
+* @param rule - The rule definition (meta, name, defaultOptions, createOnce).
+* @returns A rule module usable by both ESLint and oxlint.
+*/
+function createFlawlessRule({ createOnce, ...meta }) {
+	function create(context) {
+		const { after, before, ...visitors } = createOnce(context);
+		if (before !== void 0 && before() === false) return {};
+		if (after === void 0) return visitors;
+		const existing = visitors["Program:exit"];
+		visitors["Program:exit"] = (node) => {
+			existing?.(node);
+			after();
+		};
+		return visitors;
+	}
+	const module = createRule({
+		...meta,
+		create
+	});
+	return Object.assign(module, { createOnce });
+}
+//#endregion
+//#region src/rules/arrow-return-style/rule.ts
+const RULE_NAME$12 = "arrow-return-style";
+const IMPLICIT = "useImplicitReturn";
+const EXPLICIT = "useExplicitReturn";
+const COMPLEX_EXPLICIT = "useExplicitReturnComplex";
+const DEFAULTS = {
+	jsxAlwaysUseExplicitReturn: false,
+	maxLen: 80,
+	maxObjectProperties: 4,
+	namedExportsAlwaysUseExplicitReturn: true,
+	objectReturnStyle: "complex-explicit",
+	tabWidth: 4,
+	useOxfmt: true
+};
+/** `undefined` = not initialized yet; `null` = initialization failed. */
+let formatSync;
+function getFormatSync() {
+	if (formatSync !== void 0) return formatSync;
+	try {
+		const directory = path.dirname(fileURLToPath(import.meta.url));
+		const workerPath = [
+			path.join(directory, "worker.mjs"),
+			path.join(directory, "rules", "arrow-return-style", "worker.mjs"),
+			path.join(directory, "worker.ts")
+		].find((candidate) => existsSync(candidate));
+		if (workerPath === void 0) formatSync = null;
+		else formatSync = createSyncFn(workerPath, {
+			timeout: 15e3,
+			...workerPath.endsWith(".ts") ? { tsRunner: "tsx" } : {}
+		});
+	} catch {
+		formatSync = null;
+	}
+	return formatSync;
+}
+/**
+* Worker verdicts cached across files and fix passes: a snippet formats the
+* same way regardless of which file (or autofix iteration) asked. Bounded LRU
+* so long sessions (editors, watch mode) cannot grow it without limit.
+*/
+const formatCache = /* @__PURE__ */ new Map();
+const FORMAT_CACHE_MAX_ENTRIES = 1024;
+function formatCacheGet(key) {
+	const value = formatCache.get(key);
+	if (value !== void 0) {
+		formatCache.delete(key);
+		formatCache.set(key, value);
+	}
+	return value;
+}
+function formatCacheSet(key, value) {
+	formatCache.delete(key);
+	formatCache.set(key, value);
+	if (formatCache.size > FORMAT_CACHE_MAX_ENTRIES) {
+		const oldest = formatCache.keys().next().value;
+		if (oldest !== void 0) formatCache.delete(oldest);
+	}
+}
+/**
+* Visual width of `text` with tabs expanded to `tabWidth`-column tab stops.
+*
+* @param text - The text to measure.
+* @param tabWidth - Columns a tab occupies.
+* @returns The tab-expanded width in columns.
+*/
+function expandedWidth(text, tabWidth) {
+	let width = 0;
+	for (const character of text) width += character === "	" ? tabWidth - width % tabWidth : 1;
+	return width;
+}
+function leadingWhitespace(line) {
+	return /^[\t ]*/.exec(line)?.[0] ?? "";
+}
+function isJsx(node) {
+	return node.type === AST_NODE_TYPES.JSXElement || node.type === AST_NODE_TYPES.JSXFragment;
+}
+function isNamedExportArrow(node) {
+	if (node.parent.type !== AST_NODE_TYPES.VariableDeclarator) return false;
+	return node.parent.parent.parent.type === AST_NODE_TYPES.ExportNamedDeclaration;
+}
+/**
+* Does the collapsed body need wrapping parens to stay an expression body?
+*
+* @param node - The would-be implicit body expression.
+* @returns Whether the fixer must wrap the body in parentheses.
+*/
+function needsParens(node) {
+	return node.type === AST_NODE_TYPES.ObjectExpression || node.type === AST_NODE_TYPES.SequenceExpression;
+}
+function countObjectComplexity(node) {
+	let features = 0;
+	for (const property of node.properties) {
+		if (property.type === AST_NODE_TYPES.SpreadElement) {
+			features += 1;
+			continue;
+		}
+		if (property.computed) features += 1;
+		if (property.value.type === AST_NODE_TYPES.CallExpression) features += 1;
+	}
+	return features;
+}
+function isComplexLiteral(node, maxObjectProperties) {
+	if (node.type === AST_NODE_TYPES.ObjectExpression) {
+		if (node.properties.length > maxObjectProperties) return true;
+		return countObjectComplexity(node) >= 2;
+	}
+	if (node.type === AST_NODE_TYPES.ArrayExpression) {
+		const spreads = node.elements.filter((element) => element?.type === AST_NODE_TYPES.SpreadElement).length;
+		const calls = node.elements.filter((element) => element?.type === AST_NODE_TYPES.CallExpression).length;
+		return spreads >= 1 && node.elements.length > 1 || calls >= 2 || spreads + calls >= 2;
+	}
+	return false;
+}
+function isLiteralBody(node) {
+	return node.type === AST_NODE_TYPES.ObjectExpression || node.type === AST_NODE_TYPES.ArrayExpression;
+}
+/**
+* Walks up to the outermost node whose parent is the Program.
+*
+* @param node - The node to walk up from.
+* @returns The top-level statement containing `node`.
+*/
+function statementOf(node) {
+	let current = node;
+	while (current.parent !== void 0 && current.parent.type !== AST_NODE_TYPES.Program) current = current.parent;
+	return current;
+}
+function pushChildNodes$1(stack, value) {
+	const candidates = Array.isArray(value) ? value : [value];
+	for (const item of candidates) if (typeof item === "object" && item !== null && "type" in item) stack.push(item);
+}
+/**
+* Collects arrow functions in `root`'s subtree, ordered by source position.
+*
+* @param root - The subtree to search.
+* @returns All arrow function nodes, sorted by range start.
+*/
+function collectArrows(root) {
+	const arrows = [];
+	const stack = [root];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (current === void 0) continue;
+		if (current.type === AST_NODE_TYPES.ArrowFunctionExpression) arrows.push(current);
+		for (const [key, value] of Object.entries(current)) if (key !== "parent" && key !== "loc" && key !== "range") pushChildNodes$1(stack, value);
+	}
+	return arrows.sort((a, b) => a.range[0] - b.range[0]);
+}
+const arrowReturnStyle = createFlawlessRule({
+	name: RULE_NAME$12,
+	createOnce(context) {
+		let config = DEFAULTS;
+		let sourceCode;
+		let lines;
+		let pendingConsults;
+		/**
+		* Effective line-length limit for emitted lines: the fixer must never
+		* produce a line the formatter would immediately rewrap.
+		*
+		* @returns The maximum permitted tab-expanded line width.
+		*/
+		function limit() {
+			const { maxLen, useOxfmt } = config;
+			return useOxfmt === false ? maxLen : Math.min(maxLen, printWidth());
+		}
+		function printWidth() {
+			const { maxLen, useOxfmt } = config;
+			if (typeof useOxfmt === "object" && typeof useOxfmt.printWidth === "number") return useOxfmt.printWidth;
+			return maxLen;
+		}
+		function width(text) {
+			return expandedWidth(text, config.tabWidth);
+		}
+		function lineOf(lineNumber) {
+			return lines[lineNumber - 1] ?? "";
+		}
+		function objectStyleWantsExplicit(body) {
+			if (!isLiteralBody(body) || config.objectReturnStyle === "off") return false;
+			if (config.objectReturnStyle === "always-explicit") return true;
+			return isComplexLiteral(body, config.maxObjectProperties);
+		}
+		function arrowTokenOf(node) {
+			let token = sourceCode.getTokenBefore(node.body);
+			while (token !== null && token.value === "(") token = sourceCode.getTokenBefore(token);
+			if (token?.value !== "=>") throw new Error("arrow-return-style: could not locate the => token");
+			return token;
+		}
+		/**
+		* The `(`/`)` pair directly wrapping the body, if any.
+		*
+		* @param node - Function whose body may be parenthesized.
+		* @param arrowToken - Token of the `=>` operator, used to distinguish
+		*   body parens from parameter-list parens.
+		* @returns The wrapping paren tokens, or `null` when not parenthesized.
+		*/
+		function bodyParens(node, arrowToken) {
+			const before = sourceCode.getTokenBefore(node.body);
+			if (before?.value !== "(" || before.range[0] < arrowToken.range[1]) return null;
+			const after = sourceCode.getTokenAfter(node.body);
+			if (after?.value !== ")") return null;
+			return {
+				close: after,
+				open: before
+			};
+		}
+		/**
+		* Resolves every deferred oxfmt consult with a single worker round-trip:
+		* would the formatter render each arrow (params through body) on a single
+		* line that fits `maxLen`? Arrows the formatter cannot keep on one fitting
+		* line are reported. Fails open (no report) when the worker or oxfmt is
+		* unavailable so that an unavailable formatter can never introduce reports
+		* it would have to fight over.
+		*/
+		function resolvePendingConsults() {
+			if (pendingConsults.length === 0) return;
+			const nodes = pendingConsults;
+			pendingConsults = [];
+			const worker = getFormatSync();
+			if (worker === null) return;
+			const consults = nodes.flatMap((node) => {
+				const statement = statementOf(node);
+				const snippet = sourceCode.getText(statement);
+				const baseIndent = leadingWhitespace(lineOf(statement.loc.start.line));
+				const arrowIndex = collectArrows(statement).findIndex((arrow) => arrow.range[0] === node.range[0]);
+				if (arrowIndex === -1) return [];
+				const request = {
+					arrowIndex,
+					code: `${snippet}\n`,
+					printWidth: printWidth(),
+					tabWidth: config.tabWidth
+				};
+				return [{
+					baseIndent,
+					cacheKey: `${arrowIndex}${request.printWidth}${request.tabWidth}${snippet}`,
+					node,
+					request
+				}];
+			});
+			const misses = /* @__PURE__ */ new Map();
+			for (const consult of consults) if (formatCacheGet(consult.cacheKey) === void 0) misses.set(consult.cacheKey, consult.request);
+			if (misses.size > 0) {
+				let responses = [];
+				try {
+					responses = worker([...misses.values()]);
+				} catch {
+					responses = [];
+				}
+				for (const [index, cacheKey] of [...misses.keys()].entries()) {
+					const response = responses[index];
+					if (response !== void 0) formatCacheSet(cacheKey, response);
+				}
+			}
+			for (const consult of consults) {
+				const response = formatCacheGet(consult.cacheKey);
+				if (response === void 0) continue;
+				if (response.lineText === null) continue;
+				if (!(response.singleLine && width(consult.baseIndent) + width(response.lineText) <= config.maxLen)) reportExplicit(consult.node, EXPLICIT);
+			}
+		}
+		/**
+		* Derives the one-level indent unit for an inserted block: prefer the
+		* offset between the arrow's line and the body's (or its continuation's)
+		* deeper indentation; otherwise infer from the indent character in use.
+		*
+		* @param arrowIndent - Leading whitespace of the arrow's line.
+		* @param node - The arrow function being fixed.
+		* @param bodyStart - The body's first token or node (including parens).
+		* @param bodyEnd - The body's last token or node (including parens).
+		* @returns The whitespace string for one indentation level.
+		*/
+		function indentUnit(arrowIndent, node, bodyStart, bodyEnd) {
+			const referenceLines = [];
+			const arrowLine = bodyStart.loc.start.line;
+			if (bodyStart.loc.start.line !== node.loc.start.line) referenceLines.push(bodyStart.loc.start.line);
+			else if (bodyEnd.loc.end.line > arrowLine) referenceLines.push(arrowLine + 1);
+			for (const lineNumber of referenceLines) {
+				const reference = leadingWhitespace(lineOf(lineNumber));
+				if (reference.length > arrowIndent.length && reference.startsWith(arrowIndent)) return reference.slice(arrowIndent.length);
+			}
+			if (arrowIndent.includes("	")) return "	";
+			return arrowIndent.length > 0 ? "  " : "	";
+		}
+		/**
+		* Reports and fixes an implicit arrow into an explicit block body.
+		*
+		* @param node - The arrow function to convert.
+		* @param messageId - The violation to report.
+		*/
+		function reportExplicit(node, messageId) {
+			const arrowToken = arrowTokenOf(node);
+			const parens = bodyParens(node, arrowToken);
+			const bodyStart = parens?.open ?? node.body;
+			const bodyEnd = parens?.close ?? node.body;
+			const comments = sourceCode.getCommentsBefore(bodyStart);
+			const arrowIndent = leadingWhitespace(lineOf(node.loc.start.line));
+			const targetIndent = arrowIndent + indentUnit(arrowIndent, node, bodyStart, bodyEnd);
+			const bodyLines = sourceCode.getText(node.body).split("\n");
+			const [firstLine, ...restLines] = bodyLines;
+			const lastLineIndent = leadingWhitespace(bodyLines.at(-1) ?? "");
+			let shifted = restLines;
+			if (restLines.length > 0) {
+				if (targetIndent.startsWith(lastLineIndent)) {
+					const prefix = targetIndent.slice(lastLineIndent.length);
+					shifted = restLines.map((line) => prefix + line);
+				} else if (lastLineIndent.startsWith(targetIndent)) {
+					const strip = lastLineIndent.length - targetIndent.length;
+					shifted = restLines.map((line) => {
+						return leadingWhitespace(line).length >= strip ? line.slice(strip) : line;
+					});
+				}
+			}
+			const commentLines = comments.map((comment) => targetIndent + sourceCode.getText(comment));
+			const returnLine = `${targetIndent}return ${[firstLine, ...shifted].join("\n")};`;
+			const replacement = ` {\n${[...commentLines, returnLine].join("\n")}\n${arrowIndent}}`;
+			context.report({
+				fix: (fixer) => fixer.replaceTextRange([arrowToken.range[1], bodyEnd.range[1]], replacement),
+				messageId,
+				node
+			});
+		}
+		/**
+		* Reports and fixes a single-`return` block into an implicit body.
+		*
+		* @param node - The arrow function to convert.
+		* @param block - The block body being replaced.
+		* @param replacement - The implicit body text.
+		*/
+		function reportImplicit(node, block, replacement) {
+			context.report({
+				fix: (fixer) => fixer.replaceTextRange(block.range, replacement),
+				messageId: IMPLICIT,
+				node
+			});
+		}
+		function checkBlockBody(node) {
+			const block = node.body;
+			if (block.body.length !== 1) return;
+			const [statement] = block.body;
+			if (statement?.type !== AST_NODE_TYPES.ReturnStatement || statement.argument === null) return;
+			if (sourceCode.getCommentsInside(block).length > 0) return;
+			const { argument } = statement;
+			if (isJsx(argument) && config.jsxAlwaysUseExplicitReturn) return;
+			if (isNamedExportArrow(node) && config.namedExportsAlwaysUseExplicitReturn) return;
+			if (objectStyleWantsExplicit(argument)) return;
+			if (argument.loc.start.line !== argument.loc.end.line) return;
+			const argumentText = sourceCode.getText(argument);
+			const collapsed = needsParens(argument) ? `(${argumentText})` : argumentText;
+			const prefix = lineOf(block.loc.start.line).slice(0, block.loc.start.column);
+			const suffix = lineOf(block.loc.end.line).slice(block.loc.end.column);
+			if (width(prefix + collapsed + suffix) > limit()) return;
+			reportImplicit(node, block, collapsed);
+		}
+		function checkExpressionBody(node) {
+			const body = node.body;
+			const arrowToken = arrowTokenOf(node);
+			const parens = bodyParens(node, arrowToken);
+			const bodyStart = parens?.open ?? body;
+			const bodyEnd = parens?.close ?? body;
+			if (sourceCode.getCommentsBefore(bodyStart).length > 0) {
+				reportExplicit(node, EXPLICIT);
+				return;
+			}
+			if (isJsx(body) && config.jsxAlwaysUseExplicitReturn) {
+				reportExplicit(node, EXPLICIT);
+				return;
+			}
+			if (isNamedExportArrow(node) && config.namedExportsAlwaysUseExplicitReturn) {
+				reportExplicit(node, EXPLICIT);
+				return;
+			}
+			if (bodyStart.loc.start.line !== arrowToken.loc.end.line) {
+				reportExplicit(node, EXPLICIT);
+				return;
+			}
+			if (bodyEnd.loc.end.line !== bodyStart.loc.start.line) {
+				if (body.type === AST_NODE_TYPES.ObjectExpression) reportExplicit(node, EXPLICIT);
+				return;
+			}
+			if (width(lineOf(bodyStart.loc.start.line)) > limit()) {
+				if (config.useOxfmt !== false) pendingConsults.push(node);
+				else reportExplicit(node, EXPLICIT);
+				return;
+			}
+			if (objectStyleWantsExplicit(body)) reportExplicit(node, COMPLEX_EXPLICIT);
+		}
+		return {
+			"ArrowFunctionExpression": function(node) {
+				if (node.body.type === AST_NODE_TYPES.BlockStatement) checkBlockBody(node);
+				else checkExpressionBody(node);
+			},
+			"before": function() {
+				config = {
+					...DEFAULTS,
+					...context.options[0]
+				};
+				({sourceCode} = context);
+				lines = [...sourceCode.lines];
+				pendingConsults = [];
+			},
+			"Program:exit": function() {
+				resolvePendingConsults();
+			}
+		};
+	},
+	defaultOptions: [DEFAULTS],
+	meta: {
+		docs: {
+			description: "Enforce arrow function return style based on line length",
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		messages: {
+			[COMPLEX_EXPLICIT]: "Use an explicit return block for complex object or array bodies.",
+			[EXPLICIT]: "Use an explicit return block for this arrow function body.",
+			[IMPLICIT]: "Use an implicit return for this arrow function body."
+		},
+		schema: [{
+			additionalProperties: false,
+			properties: {
+				jsxAlwaysUseExplicitReturn: { type: "boolean" },
+				maxLen: {
+					minimum: 0,
+					type: "integer"
+				},
+				maxObjectProperties: {
+					minimum: 0,
+					type: "integer"
+				},
+				namedExportsAlwaysUseExplicitReturn: { type: "boolean" },
+				objectReturnStyle: {
+					enum: [
+						"always-explicit",
+						"complex-explicit",
+						"off"
+					],
+					type: "string"
+				},
+				tabWidth: {
+					minimum: 1,
+					type: "integer"
+				},
+				useOxfmt: { oneOf: [{ type: "boolean" }, {
+					additionalProperties: false,
+					properties: { printWidth: {
+						minimum: 0,
+						type: "integer"
+					} },
+					type: "object"
+				}] }
+			},
+			type: "object"
+		}],
+		type: "suggestion"
+	}
+});
+//#endregion
+//#region src/rules/jsx-shorthand-boolean/rule.ts
+const RULE_NAME$11 = "jsx-shorthand-boolean";
+const MESSAGE_ID$5 = "setAttributeValue";
+const messages$11 = { [MESSAGE_ID$5]: "Set an explicit value for boolean attribute '{{name}}'." };
+function createOnce$7(context) {
+	return { JSXAttribute(node) {
+		if (node.value !== null) return;
+		context.report({
+			data: { name: context.sourceCode.getText(node.name) },
+			fix: (fixer) => fixer.insertTextAfter(node.name, "={true}"),
+			messageId: MESSAGE_ID$5,
+			node
+		});
+	} };
+}
+const jsxShorthandBoolean = createFlawlessRule({
+	name: RULE_NAME$11,
+	createOnce: createOnce$7,
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Disallow shorthand boolean JSX attributes",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$11,
+		schema: [],
+		type: "suggestion"
+	}
+});
+//#endregion
+//#region src/rules/jsx-shorthand-fragment/rule.ts
+const RULE_NAME$10 = "jsx-shorthand-fragment";
+const MESSAGE_ID_NAMED = "useNamedFragment";
+const MESSAGE_ID_SHORTHAND = "useShorthandFragment";
+const DEFAULT_MODE = "syntax";
+const DEFAULT_FRAGMENT_NAME = "Fragment";
+const messages$10 = {
+	[MESSAGE_ID_NAMED]: "Use the '{{name}}' component instead of fragment shorthand syntax.",
+	[MESSAGE_ID_SHORTHAND]: "Use the fragment shorthand syntax '<>...</>' instead of the '{{name}}' component."
+};
+const schema$2 = [{
+	additionalProperties: false,
+	properties: {
+		fragmentName: {
+			description: "The identifier to use for the named fragment element in \"element\" mode.",
+			type: "string"
+		},
+		mode: {
+			description: "Which form to enforce: \"syntax\" (shorthand `<>...</>`, default) or \"element\" (a named fragment).",
+			enum: ["element", "syntax"],
+			type: "string"
+		}
+	},
+	type: "object"
+}];
+/**
+* Flattens a JSX element name into a dotted string, e.g. `Fragment` or
+* `React.Fragment`. Returns `null` for namespaced names (`<a:b>`) which cannot
+* be a fragment.
+*
+* @param node - The JSX element name node.
+* @returns The dotted name, or `null` when it is not a plain identifier chain.
+*/
+function jsxNameToString(node) {
+	if (node.type === AST_NODE_TYPES.JSXIdentifier) return node.name;
+	if (node.type === AST_NODE_TYPES.JSXMemberExpression) {
+		const object = jsxNameToString(node.object);
+		if (object === null) return null;
+		return `${object}.${node.property.name}`;
+	}
+	return null;
+}
+function createOnce$6(context) {
+	let mode;
+	let fragmentName;
+	let namedFragments;
+	return {
+		before() {
+			const options = context.options[0] ?? {};
+			mode = options.mode ?? DEFAULT_MODE;
+			fragmentName = options.fragmentName ?? DEFAULT_FRAGMENT_NAME;
+			namedFragments = /* @__PURE__ */ new Set([
+				"Fragment",
+				fragmentName,
+				"React.Fragment"
+			]);
+		},
+		JSXElement(node) {
+			if (mode !== "syntax") return;
+			const { openingElement } = node;
+			const name = jsxNameToString(openingElement.name);
+			if (name === null || !namedFragments.has(name)) return;
+			if (openingElement.attributes.length > 0) return;
+			context.report({
+				data: { name },
+				fix: (fixer) => {
+					const { closingElement } = node;
+					if (closingElement === null) return fixer.replaceText(node, "<></>");
+					return [fixer.replaceText(openingElement, "<>"), fixer.replaceText(closingElement, "</>")];
+				},
+				messageId: MESSAGE_ID_SHORTHAND,
+				node
+			});
+		},
+		JSXFragment(node) {
+			if (mode !== "element") return;
+			const { closingFragment, openingFragment } = node;
+			context.report({
+				data: { name: fragmentName },
+				fix: (fixer) => {
+					return [fixer.replaceText(openingFragment, `<${fragmentName}>`), fixer.replaceText(closingFragment, `</${fragmentName}>`)];
+				},
+				messageId: MESSAGE_ID_NAMED,
+				node
+			});
+		}
+	};
+}
+const jsxShorthandFragment = createFlawlessRule({
+	name: RULE_NAME$10,
+	createOnce: createOnce$6,
+	defaultOptions: [{
+		fragmentName: DEFAULT_FRAGMENT_NAME,
+		mode: DEFAULT_MODE
+	}],
+	meta: {
+		defaultOptions: [{
+			fragmentName: DEFAULT_FRAGMENT_NAME,
+			mode: DEFAULT_MODE
+		}],
+		docs: {
+			description: "Enforce a consistent fragment form: the shorthand `<>...</>` or a named fragment",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$10,
+		schema: schema$2,
+		type: "suggestion"
+	}
+});
+//#endregion
+//#region src/utils/is-type-import.ts
+/**
+* Determine whether a variable definition is a type import. E.g.:.
+*
+* ```ts
+* import type { Foo } from 'foo';
+* import { type Bar } from 'bar';
+* ```
+*
+* @param definition - The variable definition to check.
+* @returns True if the definition is a type import, false otherwise.
+*/
+function isTypeImport(definition) {
+	return definition?.type === DefinitionType.ImportBinding && (definition.parent.importKind === "type" || definition.node.type === AST_NODE_TYPES.ImportSpecifier && definition.node.importKind === "type");
+}
+//#endregion
+//#region src/utils/reference-contains-type-query.ts
+/**
+* Recursively checks whether a given reference has a type query declaration among its parents.
+* @param node - The AST node to check.
+* @returns True if a TSTypeQuery is found in the parent chain, false otherwise.
+*/
+function referenceContainsTypeQuery(node) {
+	switch (node.type) {
+		case AST_NODE_TYPES.Identifier:
+		case AST_NODE_TYPES.TSQualifiedName: return referenceContainsTypeQuery(node.parent);
+		case AST_NODE_TYPES.TSTypeQuery: return true;
+		default: return false;
+	}
+}
+//#endregion
+//#region src/utils/collect-variables.ts
+/**
+* This class leverages an AST visitor to mark variables as used via the
+* `eslintUsed` property.
+*/
+var UnusedVariablesVisitor = class extends Visitor {
+	/**
+	* We keep a weak cache so that multiple rules can share the calculation.
+	*/
+	static RESULTS_CACHE = /* @__PURE__ */ new WeakMap();
+	#scopeManager;
+	ClassDeclaration = this.visitClass;
+	ClassExpression = this.visitClass;
+	ForInStatement = this.visitForInForOf;
+	/**
+	* #region HELPERS
+	*/
+	ForOfStatement = this.visitForInForOf;
+	FunctionDeclaration = this.visitFunction;
+	FunctionExpression = this.visitFunction;
+	MethodDefinition = this.visitSetter;
+	Property = this.visitSetter;
+	TSCallSignatureDeclaration = this.visitFunctionTypeSignature;
+	TSConstructorType = this.visitFunctionTypeSignature;
+	TSConstructSignatureDeclaration = this.visitFunctionTypeSignature;
+	TSDeclareFunction = this.visitFunctionTypeSignature;
+	/**
+	* NOTE - This is a simple visitor - meaning it does not support selectors.
+	*/
+	TSEmptyBodyFunctionExpression = this.visitFunctionTypeSignature;
+	TSFunctionType = this.visitFunctionTypeSignature;
+	TSMethodSignature = this.visitFunctionTypeSignature;
+	constructor(scopeManager) {
+		super({ visitChildrenEvenIfSelectorExists: true });
+		this.#scopeManager = scopeManager;
+	}
+	static collectUnusedVariables(program, scopeManager) {
+		const cached = this.RESULTS_CACHE.get(program);
+		if (cached) return cached;
+		const visitor = new this(scopeManager);
+		visitor.visit(program);
+		const unusedVariables = visitor.collectUnusedVariables({ scope: visitor.getScope(program) });
+		this.RESULTS_CACHE.set(program, unusedVariables);
+		return unusedVariables;
+	}
+	Identifier(node) {
+		const scope = this.getScope(node);
+		if (scope.type === TSESLint.Scope.ScopeType.function && node.name === "this" && "params" in scope.block && scope.block.params.includes(node)) this.markVariableAsUsed(node);
+	}
+	TSEnumDeclaration(node) {
+		const scope = this.getScope(node);
+		for (const variable of scope.variables) this.markVariableAsUsed(variable);
+	}
+	TSMappedType(node) {
+		this.markVariableAsUsed(node.key);
+	}
+	TSModuleDeclaration(node) {
+		if (node.kind === "global") this.markVariableAsUsed("global", node.parent);
+	}
+	TSParameterProperty(node) {
+		let identifier;
+		switch (node.parameter.type) {
+			case AST_NODE_TYPES.AssignmentPattern:
+				identifier = node.parameter.left;
+				break;
+			case AST_NODE_TYPES.Identifier:
+				identifier = node.parameter;
+				break;
+		}
+		this.markVariableAsUsed(identifier);
+	}
+	collectUnusedVariables({ scope, variables = {
+		unusedVariables: /* @__PURE__ */ new Set(),
+		usedVariables: /* @__PURE__ */ new Set()
+	} }) {
+		if (!scope.functionExpressionScope) for (const variable of scope.variables) {
+			if (variable instanceof ImplicitLibVariable) continue;
+			if (variable.eslintUsed || isExported$1(variable) || isMergeableExported(variable) || isUsedVariable(variable)) variables.usedVariables.add(variable);
+			else variables.unusedVariables.add(variable);
+		}
+		for (const childScope of scope.childScopes) this.collectUnusedVariables({
+			scope: childScope,
+			variables
+		});
+		return variables;
+	}
+	getScope(currentNode) {
+		const inner = currentNode.type !== AST_NODE_TYPES.Program;
+		let node = currentNode;
+		while (node) {
+			const scope = this.#scopeManager.acquire(node, inner);
+			if (scope) {
+				if (scope.type === ScopeType.functionExpressionName) {
+					const returnValue = scope.childScopes[0];
+					assert(returnValue, "Function expression name scope should have a child scope");
+					return returnValue;
+				}
+				return scope;
+			}
+			node = node.parent;
+		}
+		const returnValue = this.#scopeManager.scopes[0];
+		assert(returnValue, "There should be at least one scope");
+		return returnValue;
+	}
+	markVariableAsUsed(variableOrIdentifierOrName, parent) {
+		if (typeof variableOrIdentifierOrName !== "string" && !("type" in variableOrIdentifierOrName)) {
+			variableOrIdentifierOrName.eslintUsed = true;
+			return;
+		}
+		let name;
+		let node;
+		if (typeof variableOrIdentifierOrName === "string") {
+			name = variableOrIdentifierOrName;
+			assert(parent, "Parent node is required when marking by name");
+			node = parent;
+		} else {
+			({name} = variableOrIdentifierOrName);
+			node = variableOrIdentifierOrName;
+		}
+		let currentScope = this.getScope(node);
+		while (currentScope) {
+			const variable = currentScope.variables.find((scopeVariable) => scopeVariable.name === name);
+			if (variable) {
+				variable.eslintUsed = true;
+				return;
+			}
+			currentScope = currentScope.upper ?? void 0;
+		}
+	}
+	visitClass(node) {
+		const scope = this.getScope(node);
+		for (const variable of scope.variables) if (variable.identifiers[0] === scope.block.id) {
+			this.markVariableAsUsed(variable);
+			return;
+		}
+	}
+	visitForInForOf(node) {
+		/**
+		* // cspell:ignore Zacher
+		* (Brad Zacher): I hate that this has to exist.
+		* But it is required for compat with the base ESLint rule.
+		*
+		* In 2015, ESLint decided to add an exception for these two specific cases.
+		* ```
+		* for (var key in object) return;
+		*
+		* var key;
+		* for (key in object) return;
+		* ```
+		*
+		* I disagree with it, but what are you going to do...
+		*
+		* Https://github.com/eslint/eslint/issues/2342.
+		*/
+		let idOrVariable;
+		if (node.left.type === AST_NODE_TYPES.VariableDeclaration) {
+			const variable = this.#scopeManager.getDeclaredVariables(node.left).at(0);
+			if (!variable) return;
+			idOrVariable = variable;
+		}
+		if (node.left.type === AST_NODE_TYPES.Identifier) idOrVariable = node.left;
+		if (idOrVariable === void 0) return;
+		let { body } = node;
+		if (body.type === AST_NODE_TYPES.BlockStatement) {
+			if (body.body.length !== 1) return;
+			body = body.body[0];
+		}
+		if (body.type !== AST_NODE_TYPES.ReturnStatement) return;
+		this.markVariableAsUsed(idOrVariable);
+	}
+	visitFunction(node) {
+		const variable = this.getScope(node).set.get("arguments");
+		if (variable?.defs.length === 0) this.markVariableAsUsed(variable);
+	}
+	visitFunctionTypeSignature(node) {
+		for (const parameter of node.params) this.visitPattern(parameter, (name) => {
+			this.markVariableAsUsed(name);
+		});
+	}
+	visitSetter(node) {
+		if (node.kind === "set") for (const parameter of node.value.params) this.visitPattern(parameter, (id) => {
+			this.markVariableAsUsed(id);
+		});
+	}
+};
+/**
+* Checks the position of given nodes.
+* @param inner - A node which is expected as inside.
+* @param outer - A node which is expected as outside.
+* @returns `true` if the `inner` node exists in the `outer` node.
+*/
+function isInside(inner, outer) {
+	return inner.range[0] >= outer.range[0] && inner.range[1] <= outer.range[1];
+}
+/**
+* Determine if an identifier is referencing an enclosing name.
+* This only applies to declarations that create their own scope (modules, functions, classes).
+* @param ref - The reference to check.
+* @param nodes - The candidate function nodes.
+* @returns True if it's a self-reference, false if not.
+*/
+function isSelfReference(ref, nodes) {
+	let scope = ref.from;
+	while (scope) {
+		if (nodes.has(scope.block)) return true;
+		scope = scope.upper ?? void 0;
+	}
+	return false;
+}
+const MERGEABLE_TYPES = /* @__PURE__ */ new Set([
+	AST_NODE_TYPES.ClassDeclaration,
+	AST_NODE_TYPES.FunctionDeclaration,
+	AST_NODE_TYPES.TSInterfaceDeclaration,
+	AST_NODE_TYPES.TSModuleDeclaration,
+	AST_NODE_TYPES.TSTypeAliasDeclaration
+]);
+/**
+* Determines if a given variable is being exported from a module.
+* @param variable - Eslint-scope variable object.
+* @returns True if the variable is exported, false if not.
+*/
+function isExported$1(variable) {
+	return variable.defs.some((definition) => {
+		let { node } = definition;
+		if (node.type === AST_NODE_TYPES.VariableDeclarator) node = node.parent;
+		else if (definition.type === TSESLint.Scope.DefinitionType.Parameter) return false;
+		return node.parent.type.startsWith("Export");
+	});
+}
+/**
+* Determine if the variable is directly exported.
+* @param variable - The variable to check.
+* @returns True if the variable is exported via a merged declaration.
+*/
+function isMergeableExported(variable) {
+	for (const definition of variable.defs) {
+		if (definition.type === TSESLint.Scope.DefinitionType.Parameter) continue;
+		if (MERGEABLE_TYPES.has(definition.node.type) && definition.node.parent.type === AST_NODE_TYPES.ExportNamedDeclaration || definition.node.parent.type === AST_NODE_TYPES.ExportDefaultDeclaration) return true;
+	}
+	return false;
+}
+const LOGICAL_ASSIGNMENT_OPERATORS = /* @__PURE__ */ new Set([
+	"&&=",
+	"??=",
+	"||="
+]);
+/**
+* Collects the set of unused variables for a given context.
+*
+* Due to complexity, this does not take into consideration:
+* - variables within declaration files
+* - variables within ambient module declarations.
+* @param context - The rule context.
+* @returns The collected variables.
+* @template MessageIds
+* @template Options
+*/
+function collectVariables(context) {
+	return UnusedVariablesVisitor.collectUnusedVariables(context.sourceCode.ast, ESLintUtils.nullThrows(context.sourceCode.scopeManager, "Missing required scope manager"));
+}
+/**
+* Determines if the variable is used.
+* @param variable - The variable to check.
+* @returns True if the variable is used.
+*/
+function isUsedVariable(variable) {
+	/**
+	* Gets a list of function definitions for a specified variable.
+	* @param scopeVariable - Eslint-scope variable object.
+	* @returns Function nodes.
+	*/
+	function getFunctionDefinitions(scopeVariable) {
+		const functionDefinitions = /* @__PURE__ */ new Set();
+		for (const definition of scopeVariable.defs) {
+			if (definition.type === TSESLint.Scope.DefinitionType.FunctionName) functionDefinitions.add(definition.node);
+			if (definition.type === TSESLint.Scope.DefinitionType.Variable && (definition.node.init?.type === AST_NODE_TYPES.FunctionExpression || definition.node.init?.type === AST_NODE_TYPES.ArrowFunctionExpression)) functionDefinitions.add(definition.node.init);
+		}
+		return functionDefinitions;
+	}
+	function getTypeDeclarations(scopeVariable) {
+		const nodes = /* @__PURE__ */ new Set();
+		for (const definition of scopeVariable.defs) if (definition.node.type === AST_NODE_TYPES.TSInterfaceDeclaration || definition.node.type === AST_NODE_TYPES.TSTypeAliasDeclaration) nodes.add(definition.node);
+		return nodes;
+	}
+	function getModuleDeclarations(scopeVariable) {
+		const nodes = /* @__PURE__ */ new Set();
+		for (const definition of scopeVariable.defs) if (definition.node.type === AST_NODE_TYPES.TSModuleDeclaration) nodes.add(definition.node);
+		return nodes;
+	}
+	function getEnumDeclarations(scopeVariable) {
+		const nodes = /* @__PURE__ */ new Set();
+		for (const definition of scopeVariable.defs) if (definition.node.type === AST_NODE_TYPES.TSEnumDeclaration) nodes.add(definition.node);
+		return nodes;
+	}
+	/**
+	* Checks if the ref is contained within one of the given nodes.
+	* @param ref - A reference to check.
+	* @param nodes - A set of nodes.
+	* @returns `true` if the ref is inside one of the nodes.
+	*/
+	function isInsideOneOf(ref, nodes) {
+		for (const node of nodes) if (isInside(ref.identifier, node)) return true;
+		return false;
+	}
+	/**
+	* Checks whether a given node is unused expression or not.
+	* @param node - The node itself.
+	* @returns The node is an unused expression.
+	*/
+	function isUnusedExpression(node) {
+		const { parent } = node;
+		if (parent.type === AST_NODE_TYPES.ExpressionStatement) return true;
+		if (parent.type === AST_NODE_TYPES.SequenceExpression) {
+			if (!(parent.expressions[parent.expressions.length - 1] === node)) return true;
+			return isUnusedExpression(parent);
+		}
+		return false;
+	}
+	/**
+	* If a given reference is left-hand side of an assignment, this gets
+	* the right-hand side node of the assignment.
+	*
+	* In the following cases, this returns undefined.
+	*
+	* - The reference is not the LHS of an assignment expression.
+	* - The reference is inside of a loop.
+	* - The reference is inside of a function scope which is different from
+	*   the declaration.
+	* @param ref - A reference to check.
+	* @param previousRhsNode - The previous RHS node. This is for `a = a + a`-like code.
+	* @returns The RHS node or undefined.
+	*/
+	function getRhsNode(ref, previousRhsNode) {
+		/**
+		* Checks whether the given node is in a loop or not.
+		* @param node - The node to check.
+		* @returns `true` if the node is in a loop.
+		*/
+		function isInLoop(node) {
+			let currentNode = node;
+			while (currentNode) {
+				if (ASTUtils.isFunction(currentNode)) break;
+				if (ASTUtils.isLoop(currentNode)) return true;
+				currentNode = currentNode.parent;
+			}
+			return false;
+		}
+		const id = ref.identifier;
+		const { parent } = id;
+		const refScope = ref.from.variableScope;
+		const { variableScope } = ref.resolved.scope;
+		const canBeUsedLater = refScope !== variableScope || isInLoop(id);
+		if (previousRhsNode && isInside(id, previousRhsNode)) return previousRhsNode;
+		if (parent.type === AST_NODE_TYPES.AssignmentExpression && isUnusedExpression(parent) && id === parent.left && !canBeUsedLater) return parent.right;
+	}
+	/**
+	* Checks whether a given reference is a read to update itself or not.
+	* @param ref - A reference to check.
+	* @param rhsNode - The RHS node of the previous assignment.
+	* @returns The reference is a read to update itself.
+	*/
+	function isReadForItself(ref, rhsNode) {
+		/**
+		* Checks whether a given Identifier node exists inside of a function node which can be used later.
+		*
+		* "can be used later" means:
+		* - the function is assigned to a variable.
+		* - the function is bound to a property and the object can be used later.
+		* - the function is bound as an argument of a function call.
+		*
+		* If a reference exists in a function which can be used later, the reference is read when the function is called.
+		* @param id - An Identifier node to check.
+		* @param rightHandSideNode - The RHS node of the previous assignment.
+		* @returns `true` if the `id` node exists inside of a function node which can be used later.
+		*/
+		function isInsideOfStorableFunction(id, rightHandSideNode) {
+			/**
+			* Finds a function node from ancestors of a node.
+			* @param node - A start node to find.
+			* @returns A found function node.
+			*/
+			function getUpperFunction(node) {
+				let currentNode = node;
+				while (currentNode) {
+					if (ASTUtils.isFunction(currentNode)) return currentNode;
+					currentNode = currentNode.parent;
+				}
+			}
+			/**
+			* Checks whether a given function node is stored to somewhere or not.
+			* If the function node is stored, the function can be used later.
+			* @param funcNode - A function node to check.
+			* @param storableRhsNode - The RHS node of the previous assignment.
+			* @returns `true` if under the following conditions:
+			*      - the funcNode is assigned to a variable.
+			*      - the funcNode is bound as an argument of a function call.
+			*      - the function is bound to a property and the object satisfies above conditions.
+			*/
+			function isStorableFunction(funcNode, storableRhsNode) {
+				let node = funcNode;
+				let { parent } = funcNode;
+				while (parent && isInside(parent, storableRhsNode)) {
+					switch (parent.type) {
+						case AST_NODE_TYPES.AssignmentExpression:
+						case AST_NODE_TYPES.TaggedTemplateExpression:
+						case AST_NODE_TYPES.YieldExpression: return true;
+						case AST_NODE_TYPES.CallExpression:
+						case AST_NODE_TYPES.NewExpression: return parent.callee !== node;
+						case AST_NODE_TYPES.SequenceExpression:
+							if (parent.expressions[parent.expressions.length - 1] !== node) return false;
+							break;
+						default: if (parent.type.endsWith("Statement") || parent.type.endsWith("Declaration")) return true;
+					}
+					node = parent;
+					({parent} = parent);
+				}
+				return false;
+			}
+			const funcNode = getUpperFunction(id);
+			return !!funcNode && isInside(funcNode, rightHandSideNode) && isStorableFunction(funcNode, rightHandSideNode);
+		}
+		const id = ref.identifier;
+		const { parent } = id;
+		return ref.isRead() && (parent.type === AST_NODE_TYPES.AssignmentExpression && !LOGICAL_ASSIGNMENT_OPERATORS.has(parent.operator) && isUnusedExpression(parent) && parent.left === id || parent.type === AST_NODE_TYPES.UpdateExpression && isUnusedExpression(parent) || !!rhsNode && isInside(id, rhsNode) && !isInsideOfStorableFunction(id, rhsNode));
+	}
+	const functionNodes = getFunctionDefinitions(variable);
+	const isFunctionDefinition = functionNodes.size > 0;
+	const typeDeclNodes = getTypeDeclarations(variable);
+	const isTypeDecl = typeDeclNodes.size > 0;
+	const moduleDeclNodes = getModuleDeclarations(variable);
+	const isModuleDecl = moduleDeclNodes.size > 0;
+	const enumDeclNodes = getEnumDeclarations(variable);
+	const isEnumDecl = enumDeclNodes.size > 0;
+	const isImportedAsType = variable.defs.every(isTypeImport);
+	let rhsNode;
+	return variable.references.some((ref) => {
+		const forItself = isReadForItself(ref, rhsNode);
+		rhsNode = getRhsNode(ref, rhsNode);
+		return ref.isRead() && !forItself && (isImportedAsType || !referenceContainsTypeQuery(ref.identifier)) && (!isFunctionDefinition || !isSelfReference(ref, functionNodes)) && (!isTypeDecl || !isInsideOneOf(ref, typeDeclNodes)) && (!isModuleDecl || !isSelfReference(ref, moduleDeclNodes)) && (!isEnumDecl || !isSelfReference(ref, enumDeclNodes));
+	});
+}
+//#endregion
+//#region src/rules/naming-convention/utils/enums.ts
+const Selector = {
+	variable: 1,
+	function: 2,
+	parameter: 4,
+	objectStyleEnum: 8,
+	parameterProperty: 16,
+	classicAccessor: 32,
+	enumMember: 64,
+	classMethod: 128,
+	objectLiteralMethod: 256,
+	typeMethod: 512,
+	classProperty: 1024,
+	objectLiteralProperty: 2048,
+	typeProperty: 4096,
+	autoAccessor: 8192,
+	class: 16384,
+	interface: 32768,
+	typeAlias: 65536,
+	enum: 131072,
+	typeParameter: 262144,
+	import: 524288
+};
+const MetaSelector = {
+	default: -1,
+	variableLike: 15,
+	memberLike: 16368,
+	typeLike: 507904,
+	method: 896,
+	property: 7168,
+	accessor: 8224
+};
+const Modifier = {
+	"const": 1,
+	"readonly": 2,
+	"static": 4,
+	"public": 8,
+	"protected": 16,
+	"private": 32,
+	"#private": 64,
+	"abstract": 128,
+	"destructured": 256,
+	"global": 512,
+	"exported": 1024,
+	"unused": 2048,
+	"requiresQuotes": 4096,
+	"override": 8192,
+	"async": 16384,
+	"default": 32768,
+	"namespace": 65536
+};
+const PredefinedFormat = {
+	camelCase: 1,
+	strictCamelCase: 2,
+	PascalCase: 3,
+	StrictPascalCase: 4,
+	snake_case: 5,
+	UPPER_CASE: 6
+};
+const PredefinedFormatValueToKey = Object.fromEntries(Object.entries(PredefinedFormat).map(([key, value]) => [value, key]));
+const TypeModifier = {
+	boolean: 131072,
+	string: 262144,
+	number: 524288,
+	function: 1048576,
+	array: 2097152
+};
+const TypeModifierValueToKey = Object.fromEntries(Object.entries(TypeModifier).map(([key, value]) => [value, key]));
+const UnderscoreOption = {
+	forbid: 1,
+	allow: 2,
+	require: 3,
+	requireDouble: 4,
+	allowDouble: 5,
+	allowSingleOrDouble: 6
+};
+//#endregion
+//#region src/rules/naming-convention/utils/shared.ts
+function isMetaSelector(selector) {
+	return selector in MetaSelector;
+}
+function isMethodOrPropertySelector(selector) {
+	return selector === MetaSelector.method || selector === MetaSelector.property;
+}
+function selectorTypeToMessageString(selectorType) {
+	const notCamelCase = selectorType.replaceAll(/([A-Z])/g, " $1");
+	return notCamelCase.charAt(0).toUpperCase() + notCamelCase.slice(1);
+}
+//#endregion
+//#region src/rules/naming-convention/utils/format.ts
+function isUppercaseChar(char) {
+	return char === char.toUpperCase() && char !== char.toLowerCase();
+}
+function hasStrictCamelHumps(name, isUpper) {
+	if (name.startsWith("_")) return false;
+	for (let index = 1; index < name.length; ++index) {
+		const char = name[index];
+		if (char === "_") return false;
+		if (isUpper === isUppercaseChar(char)) {
+			if (isUpper) return false;
+		} else isUpper = !isUpper;
+	}
+	return true;
+}
+function isCamelCase(name) {
+	return name.length === 0 || name[0] === name[0]?.toLowerCase() && !name.includes("_");
+}
+function isPascalCase(name) {
+	return name.length === 0 || name[0] === name[0]?.toUpperCase() && !name.includes("_");
+}
+/**
+* Check for leading trailing and adjacent underscores.
+* @param name - The name to check.
+* @returns True if the underscores are valid.
+*/
+function validateUnderscores(name) {
+	if (name.startsWith("_")) return false;
+	let wasUnderscore = false;
+	for (let index = 1; index < name.length; ++index) if (name[index] === "_") {
+		if (wasUnderscore) return false;
+		wasUnderscore = true;
+	} else wasUnderscore = false;
+	return !wasUnderscore;
+}
+function isSnakeCase(name) {
+	return name.length === 0 || name === name.toLowerCase() && validateUnderscores(name);
+}
+function isStrictCamelCase(name) {
+	return name.length === 0 || name[0] === name[0]?.toLowerCase() && hasStrictCamelHumps(name, false);
+}
+function isStrictPascalCase(name) {
+	return name.length === 0 || name[0] === name[0]?.toUpperCase() && hasStrictCamelHumps(name, true);
+}
+function isUpperCase(name) {
+	return name.length === 0 || name === name.toUpperCase() && validateUnderscores(name);
+}
+const FormatCheckersMap = {
+	[PredefinedFormat.camelCase]: isCamelCase,
+	[PredefinedFormat.PascalCase]: isPascalCase,
+	[PredefinedFormat.snake_case]: isSnakeCase,
+	[PredefinedFormat.strictCamelCase]: isStrictCamelCase,
+	[PredefinedFormat.StrictPascalCase]: isStrictPascalCase,
+	[PredefinedFormat.UPPER_CASE]: isUpperCase
+};
+//#endregion
+//#region src/rules/naming-convention/utils/validator.ts
+function createValidator(type, context, allConfigs) {
+	const selectorType = Selector[type];
+	const configs = allConfigs.filter((configItem) => {
+		return (configItem.selector & selectorType) !== 0 || configItem.selector === MetaSelector.default;
+	}).sort((a, b) => {
+		if (a.selector === b.selector) return b.modifierWeight - a.modifierWeight;
+		const aIsMeta = isMetaSelector(a.selector);
+		const bIsMeta = isMetaSelector(b.selector);
+		if (aIsMeta && !bIsMeta) return 1;
+		if (!aIsMeta && bIsMeta) return -1;
+		const aIsMethodOrProperty = isMethodOrPropertySelector(a.selector);
+		const bIsMethodOrProperty = isMethodOrPropertySelector(b.selector);
+		if (aIsMethodOrProperty && !bIsMethodOrProperty) return -1;
+		if (!aIsMethodOrProperty && bIsMethodOrProperty) return 1;
+		return b.selector - a.selector;
+	});
+	return (node, modifiers = /* @__PURE__ */ new Set()) => {
+		const originalName = node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier ? node.name : `${node.value}`;
+		for (const config of configs) {
+			if (config.filter?.regex.test(originalName) !== config.filter?.match) continue;
+			if (config.modifiers?.some((modifier) => !modifiers.has(modifier)) === true) continue;
+			if (!isCorrectType(node, config, context, selectorType)) continue;
+			let name = originalName;
+			name = validateUnderscore({
+				name,
+				config,
+				node,
+				originalName,
+				position: "leading"
+			});
+			if (name === void 0) return;
+			name = validateUnderscore({
+				name,
+				config,
+				node,
+				originalName,
+				position: "trailing"
+			});
+			if (name === void 0) return;
+			name = validateAffix({
+				name,
+				config,
+				node,
+				originalName,
+				position: "prefix"
+			});
+			if (name === void 0) return;
+			name = validateAffix({
+				name,
+				config,
+				node,
+				originalName,
+				position: "suffix"
+			});
+			if (name === void 0) return;
+			if (!validateCustom({
+				name,
+				config,
+				node,
+				originalName
+			})) return;
+			if (!validatePredefinedFormat({
+				name,
+				config,
+				modifiers,
+				node,
+				originalName
+			})) return;
+			return;
+		}
+	};
+	function formatReportData({ affixes, count, custom, formats, originalName, position, processedName }) {
+		let regexMatch = null;
+		if (custom?.match === true) regexMatch = "match";
+		else if (custom?.match === false) regexMatch = "not match";
+		return {
+			name: originalName,
+			affixes: affixes?.join(", "),
+			count,
+			formats: formats?.map((formatItem) => PredefinedFormatValueToKey[formatItem]).join(", "),
+			position,
+			processedName,
+			regex: custom?.regex.toString(),
+			regexMatch,
+			type: selectorTypeToMessageString(type)
+		};
+	}
+	function validateUnderscore({ name, config, node, originalName, position }) {
+		const option = position === "leading" ? config.leadingUnderscore : config.trailingUnderscore;
+		if (!option) return name;
+		const hasSingleUnderscore = position === "leading" ? () => name.startsWith("_") : () => name.endsWith("_");
+		const trimSingleUnderscore = position === "leading" ? () => name.slice(1) : () => name.slice(0, -1);
+		const hasDoubleUnderscore = position === "leading" ? () => name.startsWith("__") : () => name.endsWith("__");
+		const trimDoubleUnderscore = position === "leading" ? () => name.slice(2) : () => name.slice(0, -2);
+		switch (option) {
+			case UnderscoreOption.allow:
+				if (hasSingleUnderscore()) return trimSingleUnderscore();
+				return name;
+			case UnderscoreOption.allowDouble:
+				if (hasDoubleUnderscore()) return trimDoubleUnderscore();
+				return name;
+			case UnderscoreOption.allowSingleOrDouble:
+				if (hasDoubleUnderscore()) return trimDoubleUnderscore();
+				if (hasSingleUnderscore()) return trimSingleUnderscore();
+				return name;
+			case UnderscoreOption.forbid:
+				if (hasSingleUnderscore()) {
+					context.report({
+						data: formatReportData({
+							count: "one",
+							originalName,
+							position
+						}),
+						messageId: "unexpectedUnderscore",
+						node
+					});
+					return;
+				}
+				return name;
+			case UnderscoreOption.require:
+				if (!hasSingleUnderscore()) {
+					context.report({
+						data: formatReportData({
+							count: "one",
+							originalName,
+							position
+						}),
+						messageId: "missingUnderscore",
+						node
+					});
+					return;
+				}
+				return trimSingleUnderscore();
+			case UnderscoreOption.requireDouble:
+				if (!hasDoubleUnderscore()) {
+					context.report({
+						data: formatReportData({
+							count: "two",
+							originalName,
+							position
+						}),
+						messageId: "missingUnderscore",
+						node
+					});
+					return;
+				}
+				return trimDoubleUnderscore();
+		}
+	}
+	function validateAffix({ name, config, node, originalName, position }) {
+		const affixes = config[position];
+		if (!affixes || affixes.length === 0) return name;
+		for (const affix of affixes) {
+			const hasAffix = position === "prefix" ? name.startsWith(affix) : name.endsWith(affix);
+			const trimAffix = position === "prefix" ? () => name.slice(affix.length) : () => name.slice(0, -affix.length);
+			if (hasAffix) return trimAffix();
+		}
+		context.report({
+			data: formatReportData({
+				affixes,
+				originalName,
+				position
+			}),
+			messageId: "missingAffix",
+			node
+		});
+	}
+	function validateCustom({ name, config, node, originalName }) {
+		const { custom } = config;
+		if (!custom) return true;
+		const result = custom.regex.test(name);
+		if (custom.match && result) return true;
+		if (!custom.match && !result) return true;
+		context.report({
+			data: formatReportData({
+				custom,
+				originalName
+			}),
+			messageId: "satisfyCustom",
+			node
+		});
+		return false;
+	}
+	function validatePredefinedFormat({ name, config, modifiers, node, originalName }) {
+		const formats = config.format;
+		if (!formats || formats.length === 0) return true;
+		if (!modifiers.has(Modifier.requiresQuotes)) for (const format of formats) {
+			const checker = FormatCheckersMap[format];
+			if (checker(name)) return true;
+		}
+		context.report({
+			data: formatReportData({
+				formats,
+				originalName,
+				processedName: name
+			}),
+			messageId: originalName === name ? "doesNotMatchFormat" : "doesNotMatchFormatTrimmed",
+			node
+		});
+		return false;
+	}
+}
+const SelectorsAllowedToHaveTypes = Selector.variable | Selector.parameter | Selector.classProperty | Selector.objectLiteralProperty | Selector.typeProperty | Selector.parameterProperty | Selector.classicAccessor;
+function isAllTypesMatch(type, callback) {
+	if (type.isUnion()) return type.types.every((inner) => callback(inner));
+	return callback(type);
+}
+function isCorrectType(node, config, context, selector) {
+	if (config.types === void 0) return true;
+	if ((SelectorsAllowedToHaveTypes & selector) === 0) return true;
+	const services = getParserServices(context);
+	const checker = services.program.getTypeChecker();
+	const type = services.getTypeAtLocation(node).getNonNullableType();
+	for (const allowedType of config.types) switch (allowedType) {
+		case TypeModifier.array:
+			if (isAllTypesMatch(type, (inner) => checker.isArrayType(inner) || checker.isTupleType(inner))) return true;
+			break;
+		case TypeModifier.boolean:
+		case TypeModifier.number:
+		case TypeModifier.string:
+			if (checker.typeToString(checker.getWidenedType(checker.getBaseTypeOfLiteralType(type))) === TypeModifierValueToKey[allowedType]) return true;
+			break;
+		case TypeModifier.function:
+			if (isAllTypesMatch(type, (inner) => inner.getCallSignatures().length > 0)) return true;
+			break;
+	}
+	return false;
+}
+//#endregion
+//#region src/rules/naming-convention/utils/parse-options.ts
+function parseOptions(context) {
+	const normalizedOptions = context.options.flatMap(normalizeOption);
+	return Object.fromEntries(Object.keys(Selector).map((key) => [key, createValidator(key, context, normalizedOptions)]));
+}
+function normalizeOption(option) {
+	let weight = 0;
+	if (option.modifiers) for (const modifier of option.modifiers) weight |= Modifier[modifier];
+	if (option.types) for (const type of option.types) weight |= TypeModifier[type];
+	if (option.filter !== void 0) weight |= 1 << 30;
+	const normalizedOption = {
+		custom: option.custom ? {
+			match: option.custom.match,
+			regex: new RegExp(option.custom.regex, "u")
+		} : void 0,
+		filter: option.filter !== void 0 ? typeof option.filter === "string" ? {
+			match: true,
+			regex: new RegExp(option.filter, "u")
+		} : {
+			match: option.filter.match,
+			regex: new RegExp(option.filter.regex, "u")
+		} : void 0,
+		format: option.format ? option.format.map((format) => PredefinedFormat[format]) : void 0,
+		leadingUnderscore: option.leadingUnderscore !== void 0 ? UnderscoreOption[option.leadingUnderscore] : void 0,
+		modifiers: option.modifiers?.map((modifier) => Modifier[modifier]) ?? void 0,
+		modifierWeight: weight,
+		prefix: option.prefix && option.prefix.length > 0 ? option.prefix : void 0,
+		suffix: option.suffix && option.suffix.length > 0 ? option.suffix : void 0,
+		trailingUnderscore: option.trailingUnderscore !== void 0 ? UnderscoreOption[option.trailingUnderscore] : void 0,
+		types: option.types?.map((type) => TypeModifier[type]) ?? void 0
+	};
+	return (Array.isArray(option.selector) ? option.selector : [option.selector]).map((selector) => {
+		return {
+			selector: isMetaSelector(selector) ? MetaSelector[selector] : Selector[selector],
+			...normalizedOption
+		};
+	});
+}
+//#endregion
+//#region src/rules/naming-convention/utils/schema.ts
+const $DEFS = {
+	formatOptionsConfig: { oneOf: [{
+		additionalItems: false,
+		items: { $ref: "#/$defs/predefinedFormats" },
+		type: "array"
+	}, { type: "null" }] },
+	matchRegexConfig: {
+		additionalProperties: false,
+		properties: {
+			match: { type: "boolean" },
+			regex: { type: "string" }
+		},
+		required: ["match", "regex"],
+		type: "object"
+	},
+	predefinedFormats: {
+		enum: Object.keys(PredefinedFormat),
+		type: "string"
+	},
+	prefixSuffixConfig: {
+		additionalItems: false,
+		items: {
+			minLength: 1,
+			type: "string"
+		},
+		type: "array"
+	},
+	typeModifiers: {
+		enum: Object.keys(TypeModifier),
+		type: "string"
+	},
+	underscoreOptions: {
+		enum: Object.keys(UnderscoreOption),
+		type: "string"
+	}
+};
+const UNDERSCORE_SCHEMA = { $ref: "#/$defs/underscoreOptions" };
+const PREFIX_SUFFIX_SCHEMA = { $ref: "#/$defs/prefixSuffixConfig" };
+const MATCH_REGEX_SCHEMA = { $ref: "#/$defs/matchRegexConfig" };
+const FORMAT_OPTIONS_PROPERTIES = {
+	custom: MATCH_REGEX_SCHEMA,
+	failureMessage: { type: "string" },
+	format: { $ref: "#/$defs/formatOptionsConfig" },
+	leadingUnderscore: UNDERSCORE_SCHEMA,
+	prefix: PREFIX_SUFFIX_SCHEMA,
+	suffix: PREFIX_SUFFIX_SCHEMA,
+	trailingUnderscore: UNDERSCORE_SCHEMA
+};
+function selectorSchema(selectorString, allowType, modifiers) {
+	const selector = {
+		filter: { oneOf: [{
+			minLength: 1,
+			type: "string"
+		}, MATCH_REGEX_SCHEMA] },
+		selector: {
+			enum: [selectorString],
+			type: "string"
+		}
+	};
+	if (modifiers && modifiers.length > 0) selector["modifiers"] = {
+		additionalItems: false,
+		items: {
+			enum: modifiers,
+			type: "string"
+		},
+		type: "array"
+	};
+	if (allowType) selector["types"] = {
+		additionalItems: false,
+		items: { $ref: "#/$defs/typeModifiers" },
+		type: "array"
+	};
+	return [{
+		additionalProperties: false,
+		description: `Selector '${selectorString}'`,
+		properties: {
+			...FORMAT_OPTIONS_PROPERTIES,
+			...selector
+		},
+		required: ["selector", "format"],
+		type: "object"
+	}];
+}
+function selectorsSchema() {
+	return {
+		additionalProperties: false,
+		description: "Multiple selectors in one config",
+		properties: {
+			...FORMAT_OPTIONS_PROPERTIES,
+			filter: { oneOf: [{
+				minLength: 1,
+				type: "string"
+			}, MATCH_REGEX_SCHEMA] },
+			modifiers: {
+				additionalItems: false,
+				items: {
+					enum: Object.keys(Modifier),
+					type: "string"
+				},
+				type: "array"
+			},
+			selector: {
+				additionalItems: false,
+				items: {
+					enum: [...Object.keys(MetaSelector), ...Object.keys(Selector)],
+					type: "string"
+				},
+				type: "array"
+			},
+			types: {
+				additionalItems: false,
+				items: { $ref: "#/$defs/typeModifiers" },
+				type: "array"
+			}
+		},
+		required: ["selector", "format"],
+		type: "object"
+	};
+}
+const SCHEMA = {
+	$defs: $DEFS,
+	additionalItems: false,
+	items: { oneOf: [
+		selectorsSchema(),
+		...selectorSchema("default", false, Object.keys(Modifier)),
+		...selectorSchema("variableLike", false, ["unused", "async"]),
+		...selectorSchema("variable", true, [
+			"const",
+			"destructured",
+			"exported",
+			"global",
+			"unused",
+			"async"
+		]),
+		...selectorSchema("function", false, [
+			"exported",
+			"global",
+			"unused",
+			"async"
+		]),
+		...selectorSchema("parameter", true, ["destructured", "unused"]),
+		...selectorSchema("objectStyleEnum", false, [
+			"const",
+			"exported",
+			"global",
+			"unused"
+		]),
+		...selectorSchema("memberLike", false, [
+			"abstract",
+			"private",
+			"#private",
+			"protected",
+			"public",
+			"readonly",
+			"requiresQuotes",
+			"static",
+			"override",
+			"async"
+		]),
+		...selectorSchema("classProperty", true, [
+			"abstract",
+			"private",
+			"#private",
+			"protected",
+			"public",
+			"readonly",
+			"requiresQuotes",
+			"static",
+			"override"
+		]),
+		...selectorSchema("objectLiteralProperty", true, ["public", "requiresQuotes"]),
+		...selectorSchema("typeProperty", true, [
+			"public",
+			"readonly",
+			"requiresQuotes"
+		]),
+		...selectorSchema("parameterProperty", true, [
+			"private",
+			"protected",
+			"public",
+			"readonly"
+		]),
+		...selectorSchema("property", true, [
+			"abstract",
+			"private",
+			"#private",
+			"protected",
+			"public",
+			"readonly",
+			"requiresQuotes",
+			"static",
+			"override",
+			"async"
+		]),
+		...selectorSchema("classMethod", false, [
+			"abstract",
+			"private",
+			"#private",
+			"protected",
+			"public",
+			"requiresQuotes",
+			"static",
+			"override",
+			"async"
+		]),
+		...selectorSchema("objectLiteralMethod", false, [
+			"public",
+			"requiresQuotes",
+			"async"
+		]),
+		...selectorSchema("typeMethod", false, ["public", "requiresQuotes"]),
+		...selectorSchema("method", false, [
+			"abstract",
+			"private",
+			"#private",
+			"protected",
+			"public",
+			"requiresQuotes",
+			"static",
+			"override",
+			"async"
+		]),
+		...selectorSchema("classicAccessor", true, [
+			"abstract",
+			"private",
+			"protected",
+			"public",
+			"requiresQuotes",
+			"static",
+			"override"
+		]),
+		...selectorSchema("autoAccessor", true, [
+			"abstract",
+			"private",
+			"protected",
+			"public",
+			"requiresQuotes",
+			"static",
+			"override"
+		]),
+		...selectorSchema("accessor", true, [
+			"abstract",
+			"private",
+			"protected",
+			"public",
+			"requiresQuotes",
+			"static",
+			"override"
+		]),
+		...selectorSchema("enumMember", false, ["requiresQuotes"]),
+		...selectorSchema("typeLike", false, [
+			"abstract",
+			"exported",
+			"unused"
+		]),
+		...selectorSchema("class", false, [
+			"abstract",
+			"exported",
+			"unused"
+		]),
+		...selectorSchema("interface", false, ["exported", "unused"]),
+		...selectorSchema("typeAlias", false, ["exported", "unused"]),
+		...selectorSchema("enum", false, ["exported", "unused"]),
+		...selectorSchema("typeParameter", false, ["unused"]),
+		...selectorSchema("import", false, ["default", "namespace"])
+	] },
+	type: "array"
+};
+//#endregion
+//#region src/rules/naming-convention/rule.ts
+const RULE_NAME$9 = "naming-convention";
+const messages$9 = {
+	doesNotMatchFormat: "{{type}} name `{{name}}` must match one of the following formats: {{formats}}",
+	doesNotMatchFormatTrimmed: "{{type}} name `{{name}}` trimmed as `{{processedName}}` must match one of the following formats: {{formats}}",
+	missingAffix: "{{type}} name `{{name}}` must have one of the following {{position}}es: {{affixes}}",
+	missingUnderscore: "{{type}} name `{{name}}` must have {{count}} {{position}} underscore(s).",
+	satisfyCustom: "{{type}} name `{{name}}` must {{regexMatch}} the RegExp: {{regex}}",
+	unexpectedUnderscore: "{{type}} name `{{name}}` must not have a {{position}} underscore."
+};
+const camelCaseNamingConfig = [
+	{
+		format: ["camelCase"],
+		leadingUnderscore: "allow",
+		selector: "default",
+		trailingUnderscore: "allow"
+	},
+	{
+		format: ["camelCase", "PascalCase"],
+		selector: "import"
+	},
+	{
+		format: ["camelCase", "UPPER_CASE"],
+		leadingUnderscore: "allow",
+		selector: "variable",
+		trailingUnderscore: "allow"
+	},
+	{
+		format: ["PascalCase"],
+		selector: "typeLike"
+	}
+];
+function create$3(contextWithoutDefaults) {
+	const context = contextWithoutDefaults.options.length > 0 ? contextWithoutDefaults : Object.setPrototypeOf({ options: camelCaseNamingConfig }, contextWithoutDefaults);
+	const validators = parseOptions(context);
+	const compilerOptions = getParserServices(context, true).program?.getCompilerOptions() ?? {};
+	function handleMember(validator, { key }, modifiers) {
+		if (requiresQuoting$1(key, compilerOptions.target)) modifiers.add(Modifier.requiresQuotes);
+		validator(key, modifiers);
+	}
+	function getMemberModifiers(node) {
+		const modifiers = /* @__PURE__ */ new Set();
+		if ("key" in node && node.key.type === AST_NODE_TYPES.PrivateIdentifier) modifiers.add(Modifier["#private"]);
+		else if (node.accessibility) modifiers.add(Modifier[node.accessibility]);
+		else modifiers.add(Modifier.public);
+		if (node.static) modifiers.add(Modifier.static);
+		if ("readonly" in node && node.readonly) modifiers.add(Modifier.readonly);
+		if ("override" in node && node.override) modifiers.add(Modifier.override);
+		if (node.type === AST_NODE_TYPES.TSAbstractPropertyDefinition || node.type === AST_NODE_TYPES.TSAbstractMethodDefinition || node.type === AST_NODE_TYPES.TSAbstractAccessorProperty) modifiers.add(Modifier.abstract);
+		return modifiers;
+	}
+	const { unusedVariables } = collectVariables(context);
+	function isUnused(name, initialScope) {
+		let variable = null;
+		let scope = initialScope;
+		while (scope) {
+			variable = scope.set.get(name) ?? null;
+			if (variable) break;
+			scope = scope.upper;
+		}
+		if (!variable) return false;
+		return unusedVariables.has(variable);
+	}
+	function isDestructured(id) {
+		return id.parent.type === AST_NODE_TYPES.Property && id.parent.shorthand || id.parent.type === AST_NODE_TYPES.AssignmentPattern && id.parent.parent.type === AST_NODE_TYPES.Property && id.parent.parent.shorthand;
+	}
+	function isAsyncMemberOrProperty(propertyOrMemberNode) {
+		return Boolean("value" in propertyOrMemberNode && propertyOrMemberNode.value && "async" in propertyOrMemberNode.value && propertyOrMemberNode.value.async);
+	}
+	function isAsyncVariableIdentifier(id) {
+		return Boolean("async" in id.parent && id.parent.async || "init" in id.parent && id.parent.init && "async" in id.parent.init && id.parent.init.async);
+	}
+	/**
+	* Determines if a VariableDeclarator represents an object-style enum declaration.
+	*
+	* Object-style enums are const assertions applied to object expressions, commonly
+	* used as an alternative to TypeScript enums. Examples:
+	* - `const Colors = { RED: 'red', BLUE: 'blue' } as const`
+	* - `const Status = <const>{ OK: 200, ERROR: 500 }`.
+	*
+	* @param node - The VariableDeclarator AST node to check.
+	* @param parent - The parent VariableDeclaration node.
+	* @returns True if this represents an object-style enum declaration.
+	*/
+	function isObjectStyleEnumDeclaration(node, parent) {
+		if (parent.kind !== "const") return false;
+		if (!node.init) return false;
+		if (node.init.type === AST_NODE_TYPES.TSAsExpression && node.init.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference && node.init.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier && node.init.typeAnnotation.typeName.name === "const" && node.init.expression.type === AST_NODE_TYPES.ObjectExpression) return true;
+		if (node.init.type === AST_NODE_TYPES.TSTypeAssertion && node.init.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference && node.init.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier && node.init.typeAnnotation.typeName.name === "const" && node.init.expression.type === AST_NODE_TYPES.ObjectExpression) return true;
+		return false;
+	}
+	/**
+	* Checks if a method name exists in any of the implemented interfaces.
+	*
+	* @param implementsList - List of implemented interfaces.
+	* @param methodName - Name of the method to check.
+	* @param checker - TypeScript type checker.
+	* @param services - Parser services.
+	* @returns True if the method name is found in any interface.
+	*/
+	function checkInterfacesForMethod(implementsList, methodName, checker, services) {
+		for (const implementsClause of implementsList) {
+			const interfaceType = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(implementsClause));
+			if (!interfaceType.getSymbol()) continue;
+			const interfaceMembers = checker.getPropertiesOfType(interfaceType);
+			for (const member of interfaceMembers) if (member.name === methodName) return true;
+		}
+		return false;
+	}
+	/**
+	* Determines if a class method is implementing an interface method.
+	*
+	* @param node - The class method node to check.
+	* @returns True if the method is implementing an interface method.
+	*/
+	function isImplementingInterfaceMethod(node) {
+		const services = getParserServices(context, true);
+		if (!services.program) return false;
+		const checker = services.program.getTypeChecker();
+		let parentClass = null;
+		let current = node.parent;
+		while (current) {
+			if (current.type === AST_NODE_TYPES.ClassDeclaration || current.type === AST_NODE_TYPES.ClassExpression) {
+				parentClass = current;
+				break;
+			}
+			current = current.parent;
+		}
+		if (!parentClass?.implements || parentClass.implements.length === 0) return false;
+		let methodName = null;
+		if (node.key.type === AST_NODE_TYPES.Identifier) methodName = node.key.name;
+		else if (node.key.type === AST_NODE_TYPES.Literal) methodName = String(node.key.value);
+		if (methodName === null) return false;
+		return checkInterfacesForMethod(parentClass.implements, methodName, checker, services);
+	}
+	const selectors = {
+		":matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type != \"ArrowFunctionExpression\"][value.type != \"FunctionExpression\"][value.type != \"TSEmptyBodyFunctionExpression\"]": {
+			handler: (node, validator) => {
+				handleMember(validator, node, getMemberModifiers(node));
+			},
+			validator: validators.classProperty
+		},
+		":not(ObjectPattern) > Property[computed = false][kind = \"init\"][value.type != \"ArrowFunctionExpression\"][value.type != \"FunctionExpression\"][value.type != \"TSEmptyBodyFunctionExpression\"]": {
+			handler: (node, validator) => {
+				handleMember(validator, node, /* @__PURE__ */ new Set([Modifier.public]));
+			},
+			validator: validators.objectLiteralProperty
+		},
+		[["TSMethodSignature[computed = false]", "TSPropertySignature[computed = false][typeAnnotation.typeAnnotation.type = \"TSFunctionType\"]"].join(", ")]: {
+			handler: (node, validator) => {
+				handleMember(validator, node, /* @__PURE__ */ new Set([Modifier.public]));
+			},
+			validator: validators.typeMethod
+		},
+		[[
+			":matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type = \"ArrowFunctionExpression\"]",
+			":matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type = \"FunctionExpression\"]",
+			":matches(PropertyDefinition, TSAbstractPropertyDefinition)[computed = false][value.type = \"TSEmptyBodyFunctionExpression\"]",
+			":matches(MethodDefinition, TSAbstractMethodDefinition)[computed = false][kind = \"method\"]"
+		].join(", ")]: {
+			handler: (node, validator) => {
+				if (isImplementingInterfaceMethod(node)) return;
+				const modifiers = getMemberModifiers(node);
+				if (isAsyncMemberOrProperty(node)) modifiers.add(Modifier.async);
+				handleMember(validator, node, modifiers);
+			},
+			validator: validators.classMethod
+		},
+		[["MethodDefinition[computed = false]:matches([kind = \"get\"], [kind = \"set\"])", "TSAbstractMethodDefinition[computed = false]:matches([kind=\"get\"], [kind=\"set\"])"].join(", ")]: {
+			handler: (node, validator) => {
+				handleMember(validator, node, getMemberModifiers(node));
+			},
+			validator: validators.classicAccessor
+		},
+		[[
+			"Property[computed = false][kind = \"init\"][value.type = \"ArrowFunctionExpression\"]",
+			"Property[computed = false][kind = \"init\"][value.type = \"FunctionExpression\"]",
+			"Property[computed = false][kind = \"init\"][value.type = \"TSEmptyBodyFunctionExpression\"]"
+		].join(", ")]: {
+			handler: (node, validator) => {
+				const modifiers = /* @__PURE__ */ new Set([Modifier.public]);
+				if (isAsyncMemberOrProperty(node)) modifiers.add(Modifier.async);
+				handleMember(validator, node, modifiers);
+			},
+			validator: validators.objectLiteralMethod
+		},
+		[[AST_NODE_TYPES.AccessorProperty, AST_NODE_TYPES.TSAbstractAccessorProperty].join(", ")]: {
+			handler: (node, validator) => {
+				handleMember(validator, node, getMemberModifiers(node));
+			},
+			validator: validators.autoAccessor
+		},
+		"ClassDeclaration, ClassExpression": {
+			handler: (node, validator) => {
+				const { id, abstract } = node;
+				if (id === null) return;
+				const modifiers = /* @__PURE__ */ new Set();
+				const scope = context.sourceCode.getScope(node).upper;
+				if (abstract) modifiers.add(Modifier.abstract);
+				if (isExported(node, id.name, scope)) modifiers.add(Modifier.exported);
+				if (isUnused(id.name, scope)) modifiers.add(Modifier.unused);
+				validator(id, modifiers);
+			},
+			validator: validators.class
+		},
+		"FunctionDeclaration, TSDeclareFunction, FunctionExpression": {
+			handler: (node, validator) => {
+				if (node.id === null) return;
+				const modifiers = /* @__PURE__ */ new Set();
+				const scope = context.sourceCode.getScope(node).upper;
+				if (isGlobal(scope)) modifiers.add(Modifier.global);
+				if (isExported(node, node.id.name, scope)) modifiers.add(Modifier.exported);
+				if (isUnused(node.id.name, scope)) modifiers.add(Modifier.unused);
+				if (node.async) modifiers.add(Modifier.async);
+				validator(node.id, modifiers);
+			},
+			validator: validators.function
+		},
+		"FunctionDeclaration, TSDeclareFunction, TSEmptyBodyFunctionExpression, FunctionExpression, ArrowFunctionExpression": {
+			handler: (node, validator) => {
+				for (const parameter of node.params) {
+					if (parameter.type === AST_NODE_TYPES.TSParameterProperty) continue;
+					const identifiers = getIdentifiersFromPattern(parameter);
+					for (const index of identifiers) {
+						const modifiers = /* @__PURE__ */ new Set();
+						if (isDestructured(index)) modifiers.add(Modifier.destructured);
+						if (isUnused(index.name, context.sourceCode.getScope(index))) modifiers.add(Modifier.unused);
+						validator(index, modifiers);
+					}
+				}
+			},
+			validator: validators.parameter
+		},
+		"ImportDefaultSpecifier, ImportNamespaceSpecifier, ImportSpecifier": {
+			handler: (node, validator) => {
+				const modifiers = /* @__PURE__ */ new Set();
+				switch (node.type) {
+					case AST_NODE_TYPES.ImportDefaultSpecifier:
+						modifiers.add(Modifier.default);
+						break;
+					case AST_NODE_TYPES.ImportNamespaceSpecifier:
+						modifiers.add(Modifier.namespace);
+						break;
+					case AST_NODE_TYPES.ImportSpecifier:
+						if (node.imported.type === AST_NODE_TYPES.Identifier && node.imported.name !== "default") return;
+						modifiers.add(Modifier.default);
+						break;
+				}
+				validator(node.local, modifiers);
+			},
+			validator: validators.import
+		},
+		"Property[computed = false]:matches([kind = \"get\"], [kind = \"set\"])": {
+			handler: (node, validator) => {
+				handleMember(validator, node, /* @__PURE__ */ new Set([Modifier.public]));
+			},
+			validator: validators.classicAccessor
+		},
+		"TSEnumDeclaration": {
+			handler: (node, validator) => {
+				const modifiers = /* @__PURE__ */ new Set();
+				const scope = context.sourceCode.getScope(node).upper;
+				if (isExported(node, node.id.name, scope)) modifiers.add(Modifier.exported);
+				if (isUnused(node.id.name, scope)) modifiers.add(Modifier.unused);
+				validator(node.id, modifiers);
+			},
+			validator: validators.enum
+		},
+		"TSEnumMember": {
+			handler: ({ id }, validator) => {
+				const modifiers = /* @__PURE__ */ new Set();
+				if (requiresQuoting$1(id, compilerOptions.target)) modifiers.add(Modifier.requiresQuotes);
+				validator(id, modifiers);
+			},
+			validator: validators.enumMember
+		},
+		"TSInterfaceDeclaration": {
+			handler: (node, validator) => {
+				const modifiers = /* @__PURE__ */ new Set();
+				const scope = context.sourceCode.getScope(node);
+				if (isExported(node, node.id.name, scope)) modifiers.add(Modifier.exported);
+				if (isUnused(node.id.name, scope)) modifiers.add(Modifier.unused);
+				validator(node.id, modifiers);
+			},
+			validator: validators.interface
+		},
+		"TSParameterProperty": {
+			handler: (node, validator) => {
+				const modifiers = getMemberModifiers(node);
+				const identifiers = getIdentifiersFromPattern(node.parameter);
+				for (const index of identifiers) validator(index, modifiers);
+			},
+			validator: validators.parameterProperty
+		},
+		"TSPropertySignature[computed = false][typeAnnotation.typeAnnotation.type != \"TSFunctionType\"]": {
+			handler: (node, validator) => {
+				const modifiers = /* @__PURE__ */ new Set([Modifier.public]);
+				if (node.readonly) modifiers.add(Modifier.readonly);
+				handleMember(validator, node, modifiers);
+			},
+			validator: validators.typeProperty
+		},
+		"TSTypeAliasDeclaration": {
+			handler: (node, validator) => {
+				const modifiers = /* @__PURE__ */ new Set();
+				const scope = context.sourceCode.getScope(node);
+				if (isExported(node, node.id.name, scope)) modifiers.add(Modifier.exported);
+				if (isUnused(node.id.name, scope)) modifiers.add(Modifier.unused);
+				validator(node.id, modifiers);
+			},
+			validator: validators.typeAlias
+		},
+		"TSTypeParameterDeclaration > TSTypeParameter": {
+			handler: (node, validator) => {
+				const modifiers = /* @__PURE__ */ new Set();
+				const scope = context.sourceCode.getScope(node);
+				if (isUnused(node.name.name, scope)) modifiers.add(Modifier.unused);
+				validator(node.name, modifiers);
+			},
+			validator: validators.typeParameter
+		},
+		"VariableDeclarator": {
+			handler: (node, validator) => {
+				const identifiers = getIdentifiersFromPattern(node.id);
+				const baseModifiers = /* @__PURE__ */ new Set();
+				const { parent } = node;
+				if (parent.kind === "const") baseModifiers.add(Modifier.const);
+				if (isGlobal(context.sourceCode.getScope(node))) baseModifiers.add(Modifier.global);
+				const isObjectStyleEnum = isObjectStyleEnumDeclaration(node, parent);
+				for (const id of identifiers) {
+					const modifiers = new Set(baseModifiers);
+					if (isDestructured(id)) modifiers.add(Modifier.destructured);
+					const scope = context.sourceCode.getScope(id);
+					if (isExported(parent, id.name, scope)) modifiers.add(Modifier.exported);
+					if (isUnused(id.name, scope)) modifiers.add(Modifier.unused);
+					if (isAsyncVariableIdentifier(id)) modifiers.add(Modifier.async);
+					if (isObjectStyleEnum) validators.objectStyleEnum(id, modifiers);
+					else validator(id, modifiers);
+				}
+			},
+			validator: validators.variable
+		}
+	};
+	return Object.fromEntries(Object.entries(selectors).map(([selector, { handler, validator }]) => {
+		return [selector, (node) => {
+			handler(node, validator);
+		}];
+	}));
+}
+const namingConvention = createEslintRule({
+	name: RULE_NAME$9,
+	create: create$3,
+	defaultOptions: camelCaseNamingConfig,
+	meta: {
+		docs: {
+			description: "Enforce naming conventions for everything across a codebase",
+			recommended: true,
+			requiresTypeChecking: true
+		},
+		fixable: void 0,
+		hasSuggestions: false,
+		messages: messages$9,
+		schema: SCHEMA,
+		type: "suggestion"
+	}
+});
+function getIdentifiersFromPattern(pattern) {
+	const identifiers = [];
+	new PatternVisitor({}, pattern, (id) => {
+		identifiers.push(id);
+	}).visit(pattern);
+	return identifiers;
+}
+function isExported(node, name, scope) {
+	if (node?.parent?.type === AST_NODE_TYPES.ExportDefaultDeclaration || node?.parent?.type === AST_NODE_TYPES.ExportNamedDeclaration) return true;
+	if (scope === null) return false;
+	const variable = scope.set.get(name);
+	if (variable) for (const ref of variable.references) {
+		const refParent = ref.identifier.parent;
+		if (refParent.type === AST_NODE_TYPES.ExportDefaultDeclaration || refParent.type === AST_NODE_TYPES.ExportSpecifier) return true;
+	}
+	return false;
+}
+function isGlobal(scope) {
+	if (scope === null) return false;
+	return scope.type === TSESLint.Scope.ScopeType.global || scope.type === TSESLint.Scope.ScopeType.module;
+}
+function requiresQuoting$1(node, target) {
+	return requiresQuoting(node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier ? node.name : `${node.value}`, target);
+}
+//#endregion
+//#region src/rules/no-export-default-arrow/rule.ts
+const RULE_NAME$8 = "no-export-default-arrow";
+const MESSAGE_ID$4 = "disallowExportDefaultArrow";
+const messages$8 = { [MESSAGE_ID$4]: "Assign the arrow function to a named constant instead of exporting it anonymously." };
+/**
+* Converts a filename stem to camelCase, treating `-`, `_`, and whitespace as
+* word separators (`use-mouse` -> `useMouse`).
+*
+* @param value - The filename stem.
+* @returns The camelCase name.
+*/
+function toCamelCase(value) {
+	return value.replace(/[-_\s]+(.)?/g, (_, char) => char?.toUpperCase() ?? "").replace(/^[A-Z]/, (char) => char.toLowerCase());
+}
+/**
+* Converts a filename stem to PascalCase, treating `-`, `_`, and whitespace as
+* word separators (`use-mouse` -> `UseMouse`).
+*
+* @param value - The filename stem.
+* @returns The PascalCase name.
+*/
+function toPascalCase(value) {
+	return value.replace(/[-_\s]+(.)?/g, (_, char) => char?.toUpperCase() ?? "").replace(/^[a-z]/, (char) => char.toUpperCase());
+}
+/**
+* Checks whether a node is a JSX element or fragment.
+*
+* @param node - The expression to test.
+* @returns `true` when the node renders JSX.
+*/
+function isJsxElement(node) {
+	return node.type === AST_NODE_TYPES.JSXElement || node.type === AST_NODE_TYPES.JSXFragment;
+}
+/**
+* Collects the expressions an arrow function can return: the body itself for a
+* concise arrow, or every `return` argument for a block body.
+*
+* @param body - The arrow function's body.
+* @returns The returned expressions, in source order.
+*/
+function getArrowReturnValues(body) {
+	if (body.type !== AST_NODE_TYPES.BlockStatement) return [body];
+	return body.body.filter((node) => node.type === AST_NODE_TYPES.ReturnStatement).map((node) => node.argument).filter((argument) => argument !== null);
+}
+/**
+* Determines whether an arrow function is a component — that is, whether any of
+* its return values is JSX — which selects PascalCase for the generated name.
+*
+* @param body - The arrow function's body.
+* @returns `true` when the arrow can return JSX.
+*/
+function arrowReturnIsJsxElement(body) {
+	return getArrowReturnValues(body).some((node) => isJsxElement(node));
+}
+/**
+* Builds the autofix: replaces the `export default` declaration with a named
+* `const` derived from the filename, and appends `export default <name>` after
+* the file's last token (comments included, so a trailing comment keeps its
+* position).
+*
+* @param options - The reported arrow, its export declaration, and the context
+*   and source code needed to derive the name and locate the file's end.
+* @returns A fixer callback producing both edits.
+*/
+function createFixFunction({ arrowFunction, context, exportDeclaration, sourceCode }) {
+	return (fixer) => {
+		const program = sourceCode.ast;
+		const lastToken = sourceCode.getLastToken(program, { includeComments: true });
+		const fileName = context.physicalFilename || context.filename || "namedFunction";
+		const { name: stem } = path.parse(fileName);
+		const functionName = arrowReturnIsJsxElement(arrowFunction.body) ? toPascalCase(stem) : toCamelCase(stem);
+		return [fixer.replaceText(exportDeclaration, `const ${functionName} = ${sourceCode.getText(arrowFunction)}`), fixer.insertTextAfter(lastToken ?? exportDeclaration, `\n\nexport default ${functionName}`)];
+	};
+}
+/**
+* Reports anonymous arrow functions used as `export default`, which surface as
+* unnamed functions in stack traces and devtools.
+*
+* @param context - The rule context.
+* @returns The rule listener.
+*/
+function createOnce$5(context) {
+	return { ArrowFunctionExpression(node) {
+		const { parent } = node;
+		if (parent.type !== AST_NODE_TYPES.ExportDefaultDeclaration) return;
+		context.report({
+			fix: createFixFunction({
+				arrowFunction: node,
+				context,
+				exportDeclaration: parent,
+				sourceCode: context.sourceCode
+			}),
+			messageId: MESSAGE_ID$4,
+			node
+		});
+	} };
+}
+const noExportDefaultArrow = createFlawlessRule({
+	name: RULE_NAME$8,
+	createOnce: createOnce$5,
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Disallow anonymous arrow functions as export default declarations",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$8,
+		schema: [],
+		type: "suggestion"
+	}
+});
+//#endregion
+//#region src/utils/nested-expressions.ts
+/**
+* Determines whether the given AST subtree contains a call or `new`
+* expression.
+*
+* Replaces `@eslint-react/ast`'s `getNestedCallExpressions` /
+* `getNestedNewExpressions` (not exposed by `@eslint-react/kit`). The `useMemo`
+* rule uses this to avoid flagging a factory that performs real computation.
+* The walk descends into every child node (skipping the `parent` back-link to
+* avoid cycles), so calls nested in awaits, tagged templates, computed member
+* expressions, call targets and the like are all detected.
+*
+* @param root - The subtree root to inspect (typically a function body).
+* @returns `true` if a `CallExpression` or `NewExpression` is present.
+*/
+function hasNestedCallOrNew(root) {
+	const stack = [root];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (current === void 0) break;
+		if (current.type === AST_NODE_TYPES.CallExpression || current.type === AST_NODE_TYPES.NewExpression) return true;
+		pushChildNodes(current, stack);
+	}
+	return false;
+}
+/**
+* Type guard for an AST node value encountered while walking arbitrary
+* properties of a parent node.
+*
+* @param value - The candidate value.
+* @returns `true` if the value looks like a `TSESTree.Node`.
+*/
+function isNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+/**
+* Pushes every child node of `node` onto the traversal stack, skipping the
+* `parent` back-link.
+*
+* @param node - The node whose children to enqueue.
+* @param stack - The traversal stack to push onto.
+*/
+function pushChildNodes(node, stack) {
+	for (const key of Object.keys(node)) {
+		if (key === "parent") continue;
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const item of value) if (isNode(item)) stack.push(item);
+		} else if (isNode(value)) stack.push(value);
+	}
+}
+//#endregion
+//#region src/utils/resolve.ts
+/**
+* Resolves an identifier to the AST node that represents its value.
+*
+* This is a focused re-implementation of `@eslint-react/var`'s `resolve`
+* covering only the cases the unnecessary-hook rules need: variable
+* initializers and function/class declarations. Every other definition kind
+* (imports, parameters, catch bindings, ...) resolves to `null`.
+*
+* @param sourceCode - Provides the scope used to look up the binding.
+* @param node - The identifier to resolve.
+* @returns The resolved value node, or `null` when it cannot be determined.
+*/
+function resolve(sourceCode, node) {
+	const variable = findVariable(sourceCode.getScope(node), node);
+	if (variable === null) return null;
+	const definition = variable.defs.at(0);
+	if (definition === void 0) return null;
+	if (definition.type === DefinitionType.ClassName || definition.type === DefinitionType.FunctionName) return definition.node;
+	if (definition.type === DefinitionType.Variable) return definition.node.init;
+	return null;
+}
+//#endregion
+//#region src/utils/unnecessary-hook.ts
+/**
+* Builds the `create` for the `no-unnecessary-use-memo` /
+* `no-unnecessary-use-callback` rules.
+*
+* Faithfully ports the rules removed from `eslint-plugin-react-x` (they were
+* dropped because the React Compiler makes them redundant; the Roblox /
+* `@rbxts/react` ecosystem has no Compiler). Hook detection is delegated to
+* `@eslint-react/core` so it matches the upstream semantics (fully-qualified
+* name resolution across imports, namespaces and `require`).
+*
+* @param config - The hook-specific configuration.
+* @returns A rule `createOnce` function.
+* @template MessageIds - The rule's message identifiers.
+*/
+function createUnnecessaryHookRule({ hook, messageIds }) {
+	const skipComputation = hook === "useMemo";
+	return (context) => {
+		const reactContext = context;
+		const detectHookCall = hook === "useMemo" ? core.isUseMemoCall : core.isUseCallbackCall;
+		return { VariableDeclarator(node) {
+			const { sourceCode } = context;
+			const { id, init } = node;
+			if (id.type !== AST_NODE_TYPES.Identifier || init?.type !== AST_NODE_TYPES.CallExpression || !detectHookCall(reactContext, init)) return;
+			const [variable, ...rest] = sourceCode.getDeclaredVariables(node);
+			if (variable === void 0 || rest.length > 0) return;
+			const insideEffectReport = checkForUsageInsideUseEffect(sourceCode, init, messageIds.insideUseEffect);
+			const component = sourceCode.getScope(init).block;
+			if (!ASTUtils.isFunction(component)) return;
+			const [argument0, argument1] = init.arguments;
+			if (argument0 === void 0 || argument1 === void 0) return;
+			if (skipComputation && ASTUtils.isFunction(argument0) && hasNestedCallOrNew(argument0.body)) {
+				reportIf(context, insideEffectReport);
+				return;
+			}
+			if (!hasEmptyDeps(sourceCode, argument1)) {
+				reportIf(context, insideEffectReport);
+				return;
+			}
+			const factory = resolveFactory(sourceCode, argument0);
+			if (factory === null) return;
+			if (!referencesComponentScope(sourceCode, factory, component)) {
+				context.report({
+					messageId: messageIds.default,
+					node
+				});
+				return;
+			}
+			reportIf(context, insideEffectReport);
+		} };
+	};
+}
+/**
+* Finds the nearest ancestor that is a `useEffect`-like call.
+*
+* @param node - The node to search upward from.
+* @returns The enclosing effect call, or `null` when there is none.
+*/
+function findEnclosingEffect(node) {
+	let current = node.parent;
+	while (current !== void 0) {
+		if (core.isUseEffectLikeCall(current)) return current;
+		if (current.type === AST_NODE_TYPES.Program) return null;
+		current = current.parent;
+	}
+	return null;
+}
+/**
+* Reports the "used inside a single useEffect" case when applicable.
+*
+* @param sourceCode - Provides declared-variable and text lookups.
+* @param node - The hook call expression.
+* @param messageId - The message id to report.
+* @returns A report descriptor, or `null` when the case does not apply.
+* @template MessageIds - The rule's message identifiers.
+*/
+function checkForUsageInsideUseEffect(sourceCode, node, messageId) {
+	if (!/use\w*Effect/u.test(sourceCode.text)) return null;
+	const { parent } = node;
+	if (parent.type !== AST_NODE_TYPES.VariableDeclarator || parent.id.type !== AST_NODE_TYPES.Identifier) return null;
+	const usages = (sourceCode.getDeclaredVariables(parent).at(0)?.references ?? []).filter((reference) => reference.init !== true);
+	if (usages.length === 0) return null;
+	const effects = /* @__PURE__ */ new Set();
+	for (const usage of usages) {
+		const effect = findEnclosingEffect(usage.identifier);
+		if (effect === null) return null;
+		effects.add(effect);
+		if (effects.size > 1) return null;
+	}
+	return {
+		data: { name: parent.id.name },
+		messageId,
+		node
+	};
+}
+/**
+* Determines whether a dependency argument is an empty array (directly or via a
+* resolvable identifier).
+*
+* @param sourceCode - Provides scope lookup to resolve identifiers.
+* @param node - The dependency argument node.
+* @returns `true` if the dependencies are empty.
+*/
+function hasEmptyDeps(sourceCode, node) {
+	if (node.type === AST_NODE_TYPES.ArrayExpression) return node.elements.length === 0;
+	if (node.type === AST_NODE_TYPES.Identifier) {
+		const resolved = resolve(sourceCode, node);
+		return resolved?.type === AST_NODE_TYPES.ArrayExpression && resolved.elements.length === 0;
+	}
+	return false;
+}
+/**
+* Collects a scope together with all of its descendant scopes.
+*
+* @param scope - The root scope.
+* @returns The scope and every nested child scope.
+*/
+function flattenScopes(scope) {
+	return scope.childScopes.reduce((accumulator, child) => [...accumulator, ...flattenScopes(child)], [scope]);
+}
+/**
+* Determines whether any reference inside the factory resolves to a binding
+* declared in the component's scope.
+*
+* @param sourceCode - Provides scope lookup for the factory.
+* @param factory - The memoized factory function node.
+* @param component - The enclosing component function node.
+* @returns `true` if the factory reads from the component scope.
+*/
+function referencesComponentScope(sourceCode, factory, component) {
+	return flattenScopes(sourceCode.getScope(factory)).flatMap((scope) => scope.references).some((reference) => reference.resolved?.scope.block === component);
+}
+/**
+* Reports the descriptor when it is present.
+*
+* @param context - The rule context.
+* @param descriptor - The descriptor to report, or `null` to skip.
+* @template MessageIds - The rule's message identifiers.
+*/
+function reportIf(context, descriptor) {
+	if (descriptor !== null) context.report(descriptor);
+}
+/**
+* Resolves the first argument of the hook call to the underlying factory
+* function node, unwrapping a curried arrow (`() => () => ...`) and resolving
+* identifiers to their initializer.
+*
+* @param sourceCode - Provides scope lookup to resolve identifiers.
+* @param node - The first hook argument.
+* @returns The factory function node, or `null` when it is not a function.
+*/
+function resolveFactory(sourceCode, node) {
+	if (node.type === AST_NODE_TYPES.ArrowFunctionExpression) return node.body.type === AST_NODE_TYPES.ArrowFunctionExpression ? node.body : node;
+	if (node.type === AST_NODE_TYPES.FunctionExpression) return node;
+	if (node.type === AST_NODE_TYPES.Identifier) {
+		const resolved = resolve(sourceCode, node);
+		if (resolved?.type === AST_NODE_TYPES.ArrowFunctionExpression || resolved?.type === AST_NODE_TYPES.FunctionExpression) return resolved;
+	}
+	return null;
+}
+//#endregion
+//#region src/rules/no-unnecessary-use-callback/rule.ts
+const RULE_NAME$7 = "no-unnecessary-use-callback";
+const MESSAGE_ID_DEFAULT$1 = "default";
+const MESSAGE_ID_INSIDE_USE_EFFECT$1 = "noUnnecessaryUseCallbackInsideUseEffect";
+const messages$7 = {
+	[MESSAGE_ID_DEFAULT$1]: "An 'useCallback' with empty deps and no references to the component scope may be unnecessary.",
+	[MESSAGE_ID_INSIDE_USE_EFFECT$1]: "'{{name}}' is only used inside 1 useEffect, which may be unnecessary. You can move the computation into useEffect directly and merge the dependency arrays."
+};
+const noUnnecessaryUseCallback = createFlawlessRule({
+	name: RULE_NAME$7,
+	createOnce: createUnnecessaryHookRule({
+		hook: "useCallback",
+		messageIds: {
+			default: MESSAGE_ID_DEFAULT$1,
+			insideUseEffect: MESSAGE_ID_INSIDE_USE_EFFECT$1
+		}
+	}),
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Disallow unnecessary usage of 'useCallback'",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		hasSuggestions: false,
+		messages: messages$7,
+		schema: [],
+		type: "suggestion"
+	}
+});
+//#endregion
+//#region src/rules/no-unnecessary-use-memo/rule.ts
+const RULE_NAME$6 = "no-unnecessary-use-memo";
+const MESSAGE_ID_DEFAULT = "default";
+const MESSAGE_ID_INSIDE_USE_EFFECT = "noUnnecessaryUseMemoInsideUseEffect";
+const messages$6 = {
+	[MESSAGE_ID_DEFAULT]: "An 'useMemo' with empty deps and no references to the component scope may be unnecessary.",
+	[MESSAGE_ID_INSIDE_USE_EFFECT]: "'{{name}}' is only used inside 1 useEffect, which may be unnecessary. You can move the computation into useEffect directly and merge the dependency arrays."
+};
+const noUnnecessaryUseMemo = createFlawlessRule({
+	name: RULE_NAME$6,
+	createOnce: createUnnecessaryHookRule({
+		hook: "useMemo",
+		messageIds: {
+			default: MESSAGE_ID_DEFAULT,
+			insideUseEffect: MESSAGE_ID_INSIDE_USE_EFFECT
+		}
+	}),
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Disallow unnecessary usage of 'useMemo'",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		hasSuggestions: false,
+		messages: messages$6,
+		schema: [],
+		type: "suggestion"
+	}
+});
+//#endregion
+//#region src/rules/prefer-destructuring-assignment/rule.ts
+const RULE_NAME$5 = "prefer-destructuring-assignment";
+const MESSAGE_ID$3 = "default";
+const messages$5 = { [MESSAGE_ID$3]: "Use destructuring assignment for component props." };
+/**
+* Identifiers that cannot be used as a binding name in strict-mode module code.
+* A property may be accessed with such a name (`props.default`), but a shorthand
+* destructuring pattern built from it (`{ default }`) would be a syntax error,
+* so the autofix bails when one is encountered.
+*/
+const RESERVED_WORDS = /* @__PURE__ */ new Set([
+	"arguments",
+	"await",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"interface",
+	"let",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"static",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield"
+]);
+/**
+* Collects the unique accessed property names, in first-seen order, when every
+* member reference is a simple non-computed `props.<identifier>` access.
+*
+* @param memberReferences - The member accesses to inspect.
+* @returns The property names, or `null` when any access is not destructurable
+*   (computed access such as `props[key]`, `props` used as a computed key, or a
+*   property whose name is a reserved word that cannot be a binding).
+*/
+function collectPropertyNames(memberReferences) {
+	const names = [];
+	for (const { member, reference } of memberReferences) {
+		if (member.object !== reference.identifier || member.computed || member.property.type !== AST_NODE_TYPES.Identifier || RESERVED_WORDS.has(member.property.name)) return null;
+		if (!names.includes(member.property.name)) names.push(member.property.name);
+	}
+	return names;
+}
+/**
+* Determines whether rewriting `props.foo` to `foo` would resolve to a different
+* binding than the new destructured parameter at any access site.
+*
+* A name is unsafe when it is already bound in the component scope (other than by
+* the props parameter itself) or in any scope nested between an access and the
+* component, since the rewritten `foo` reference would then resolve to that
+* binding instead of the destructured prop.
+*
+* @param sourceCode - Provides scope lookup for each reference.
+* @param componentScope - The component function's scope.
+* @param propsVariable - The props parameter variable (excluded from the check).
+* @param memberReferences - The member accesses that would be rewritten.
+* @returns `true` if any rewritten name would collide with an existing binding.
+*/
+function wouldShadowExistingBinding(sourceCode, componentScope, propsVariable, memberReferences) {
+	for (const { member, reference } of memberReferences) {
+		const { name } = member.property;
+		let scope = sourceCode.getScope(reference.identifier);
+		while (scope !== null) {
+			if (scope.variables.some((variable) => variable.name === name && variable !== propsVariable)) return true;
+			if (scope === componentScope) break;
+			scope = scope.upper;
+		}
+	}
+	return false;
+}
+/**
+* Reports every `props.<member>` access on a component's props parameter,
+* attaching an autofix when the parameter can be safely destructured.
+*
+* @param context - The rule context.
+* @param scope - The component function's scope.
+* @param propsParameter - The props parameter identifier.
+* @param propertyVariable - The resolved variable for the props parameter.
+*/
+function reportComponent(context, scope, propsParameter, propertyVariable) {
+	const memberReferences = [];
+	let hasNonMemberReference = false;
+	for (const reference of propertyVariable.references) {
+		const { parent } = reference.identifier;
+		if (parent.type === AST_NODE_TYPES.MemberExpression) memberReferences.push({
+			member: parent,
+			reference
+		});
+		else hasNonMemberReference = true;
+	}
+	if (memberReferences.length === 0) return;
+	memberReferences.sort((left, right) => left.member.range[0] - right.member.range[0]);
+	const propertyNames = collectPropertyNames(memberReferences);
+	if (!(!hasNonMemberReference && propertyNames !== null && !wouldShadowExistingBinding(context.sourceCode, scope, propertyVariable, memberReferences))) {
+		for (const { member } of memberReferences) context.report({
+			messageId: MESSAGE_ID$3,
+			node: member
+		});
+		return;
+	}
+	const needsParentheses = propsParameter.parent.type === AST_NODE_TYPES.ArrowFunctionExpression && context.sourceCode.getTokenAfter(propsParameter)?.value === "=>";
+	const destructured = `{ ${propertyNames.join(", ")} }`;
+	const pattern = needsParentheses ? `(${destructured})` : destructured;
+	const nameEnd = propsParameter.typeAnnotation?.range[0] ?? propsParameter.range[1];
+	for (const [index, { member }] of memberReferences.entries()) {
+		const propertyName = member.property.name;
+		context.report({
+			fix(fixer) {
+				const replaceAccess = fixer.replaceText(member, propertyName);
+				if (index === 0) return [fixer.replaceTextRange([propsParameter.range[0], nameEnd], pattern), replaceAccess];
+				return replaceAccess;
+			},
+			messageId: MESSAGE_ID$3,
+			node: member
+		});
+	}
+}
+/**
+* Faithfully ports `react-x/prefer-destructuring-assignment`, removed from
+* `eslint-plugin-react-x` in v5.0.0 (deprecated due to low usage). Component
+* detection is delegated to `@eslint-react/core` so it matches the upstream
+* semantics.
+*
+* Unlike upstream, this port adds an autofix that rewrites the props parameter
+* into a destructuring pattern (`(props) => props.id` becomes `({ id }) => id`).
+* The fix is only offered when it is unambiguously safe; see
+* {@link collectPropertyNames} and {@link wouldShadowExistingBinding}.
+*
+* @param context - The rule context.
+* @returns The rule listener.
+*/
+function createOnce$2(context) {
+	let collector = core.getFunctionComponentCollector(context);
+	const selectorKeys = Object.keys(collector.visitor);
+	const listener = {
+		"before": function() {
+			collector = core.getFunctionComponentCollector(context);
+		},
+		"Program:exit": function(program) {
+			for (const component of collector.api.getAllComponents(program)) {
+				if (component.name === null || component.isExportDefaultDeclaration) continue;
+				const [propsParameter] = component.node.params;
+				if (propsParameter?.type !== AST_NODE_TYPES.Identifier) continue;
+				const scope = context.sourceCode.getScope(component.node);
+				const propertyVariable = scope.variables.find((variable) => variable.name === propsParameter.name);
+				if (propertyVariable === void 0) continue;
+				reportComponent(context, scope, propsParameter, propertyVariable);
+			}
+		}
+	};
+	const handlers = listener;
+	for (const key of selectorKeys) handlers[key] = (node) => {
+		collector.visitor[key]?.(node);
+	};
+	return listener;
+}
+const preferDestructuringAssignment = createFlawlessRule({
+	name: RULE_NAME$5,
+	createOnce: createOnce$2,
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Enforce destructuring assignment for component props",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$5,
+		schema: [],
+		type: "problem"
+	}
+});
+//#endregion
+//#region src/rules/prefer-parameter-destructuring/rule.ts
+const RULE_NAME$4 = "prefer-parameter-destructuring";
+const MESSAGE_ID$2 = "default";
+const messages$4 = { [MESSAGE_ID$2]: "Destructure parameter '{{name}}' in the function signature instead of the body." };
+/**
+* Collects the binding names introduced by a pattern (or parameter), including
+* names nested in object/array patterns, defaults, and rest elements.
+*
+* @param node - The pattern node to walk.
+* @param out - Receives every bound name, in source order.
+*/
+function collectBoundNames(node, out) {
+	switch (node.type) {
+		case AST_NODE_TYPES.ArrayPattern:
+			for (const element of node.elements) if (element !== null) collectBoundNames(element, out);
+			break;
+		case AST_NODE_TYPES.AssignmentPattern:
+			collectBoundNames(node.left, out);
+			break;
+		case AST_NODE_TYPES.Identifier:
+			out.push(node.name);
+			break;
+		case AST_NODE_TYPES.ObjectPattern:
+			for (const property of node.properties) collectBoundNames(property, out);
+			break;
+		case AST_NODE_TYPES.Property:
+			collectBoundNames(node.value, out);
+			break;
+		case AST_NODE_TYPES.RestElement:
+			collectBoundNames(node.argument, out);
+			break;
+		case AST_NODE_TYPES.TSParameterProperty:
+			collectBoundNames(node.parameter, out);
+			break;
+		default: break;
+	}
+}
+/**
+* Collects every top-level-body object destructuring of the parameter, or
+* bails when the parameter has any other reference (member access, call
+* argument, reassignment, a destructure inside a nested block or closure, …) —
+* those mean the parameter is genuinely used and must stay.
+*
+* @param variable - The parameter's resolved scope variable.
+* @param identifier - The parameter identifier (its default-value write
+*   reference is not a use).
+* @param body - The function body; only its direct child declarations qualify.
+* @returns The qualifying destructuring statements in source order, or `null`
+*   when the parameter has a non-destructuring reference.
+*/
+function collectDestructureStatements(variable, identifier, body) {
+	const statements = [];
+	for (const reference of variable.references) {
+		const referenceIdentifier = reference.identifier;
+		if (referenceIdentifier === identifier) continue;
+		const { parent } = referenceIdentifier;
+		if (parent.type === AST_NODE_TYPES.VariableDeclarator && parent.init === referenceIdentifier && parent.id.type === AST_NODE_TYPES.ObjectPattern && parent.parent.parent === body) statements.push({
+			declaration: parent.parent,
+			declarator: parent,
+			pattern: parent.id
+		});
+		else return null;
+	}
+	statements.sort((left, right) => left.declarator.range[0] - right.declarator.range[0]);
+	return statements;
+}
+/**
+* Collects the binding names of every parameter other than the target one, so
+* the fix can avoid creating a duplicate parameter name (a SyntaxError in a
+* non-simple parameter list).
+*
+* @param node - The function whose parameters are inspected.
+* @param parameter - The parameter being rewritten (excluded).
+* @returns The other parameters' bound names.
+*/
+function collectOtherParameterNames(node, parameter) {
+	const names = [];
+	for (const other of node.params) if (other !== parameter) collectBoundNames(other, names);
+	return new Set(names);
+}
+/**
+* A structural check for AST nodes reached through visitor keys.
+*
+* @param value - The child value to test.
+* @returns `true` when the value is an AST node.
+*/
+function isNodeLike(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+/**
+* Checks whether a pattern subtree contains `await` or `yield` (in a computed
+* key or default value). Parameter initializers may not contain either, so no
+* signature form exists and the destructuring is not reported.
+*
+* @param root - The pattern to walk.
+* @param visitorKeys - The parser's visitor keys, used to walk without
+*   following `parent` links.
+* @returns `true` if `await`/`yield` appears anywhere in the pattern.
+*/
+function containsAwaitOrYield(root, visitorKeys) {
+	const stack = [root];
+	for (let current = stack.pop(); current !== void 0; current = stack.pop()) {
+		if (current.type === AST_NODE_TYPES.AwaitExpression || current.type === AST_NODE_TYPES.YieldExpression) return true;
+		for (const key of visitorKeys[current.type] ?? []) {
+			const child = current[key];
+			const children = Array.isArray(child) ? child : [child];
+			for (const item of children) if (isNodeLike(item)) stack.push(item);
+		}
+	}
+	return false;
+}
+/**
+* Extracts the identifier a parameter binds, unwrapping a default value
+* (`obj = {}`); patterns, rest parameters, and TS parameter properties yield
+* `null`.
+*
+* @param parameter - The parameter node.
+* @returns The parameter's identifier, or `null` when it is not a plain one.
+*/
+function getParameterIdentifier(parameter) {
+	if (parameter.type === AST_NODE_TYPES.Identifier) return parameter;
+	if (parameter.type === AST_NODE_TYPES.AssignmentPattern && parameter.left.type === AST_NODE_TYPES.Identifier) return parameter.left;
+	return null;
+}
+/**
+* Determines whether any expression inside the patterns (computed keys,
+* default values, moved type annotations) references a binding that would be
+* out of scope — or in its temporal dead zone — at the parameter position:
+* anything declared in the function body, a parameter at or after the target,
+* or this function's own `arguments`.
+*
+* @param query - The rewrite being planned.
+* @param patterns - The object patterns being moved.
+* @returns `true` when moving the patterns would break a reference.
+*/
+function hasUnsafePatternReferences({ body, identifier, node, scope }, patterns) {
+	function inPattern(range) {
+		return patterns.some((pattern) => range[0] >= pattern.range[0] && range[1] <= pattern.range[1]);
+	}
+	const stack = [scope];
+	for (let current = stack.pop(); current !== void 0; current = stack.pop()) {
+		stack.push(...current.childScopes);
+		for (const reference of current.references) {
+			if (!inPattern(reference.identifier.range)) continue;
+			const { resolved } = reference;
+			if (resolved === null) continue;
+			if (resolved.defs.length === 0) {
+				const blockRange = resolved.scope.block.range;
+				if (blockRange[0] >= node.range[0] && blockRange[1] <= node.range[1]) return true;
+				continue;
+			}
+			if (resolved.defs.some((definition) => {
+				const { range } = definition.name;
+				if (inPattern(range)) return false;
+				if (range[1] <= node.range[0] || range[0] >= node.range[1]) return false;
+				if (range[0] >= body.range[0]) return true;
+				return range[0] >= identifier.range[0];
+			})) return true;
+		}
+	}
+	return false;
+}
+/**
+* Checks whether a function body opens with a `"use strict"` directive. A
+* destructured parameter makes the parameter list non-simple, and a function
+* with a non-simple parameter list may not contain a `"use strict"` directive,
+* so such functions are skipped entirely.
+*
+* @param body - The function body.
+* @returns `true` if the body has a `"use strict"` directive.
+*/
+function hasUseStrictDirective(body) {
+	for (const statement of body.body) {
+		if (statement.type !== AST_NODE_TYPES.ExpressionStatement || typeof statement.directive !== "string") break;
+		if (statement.directive === "use strict") return true;
+	}
+	return false;
+}
+/**
+* Checks whether evaluating the pattern can execute arbitrary code — a default
+* value or a computed key — as opposed to only performing property reads.
+*
+* @param node - The pattern node to walk.
+* @returns `true` when the pattern contains a default value or computed key.
+*/
+function patternExecutesCode(node) {
+	if (node.type === AST_NODE_TYPES.AssignmentPattern) return true;
+	if (node.type === AST_NODE_TYPES.Property) return node.computed || patternExecutesCode(node.value);
+	if (node.type === AST_NODE_TYPES.ObjectPattern) return node.properties.some((property) => patternExecutesCode(property));
+	if (node.type === AST_NODE_TYPES.ArrayPattern) return node.elements.some((element) => element !== null && patternExecutesCode(element));
+	if (node.type === AST_NODE_TYPES.RestElement) return patternExecutesCode(node.argument);
+	return false;
+}
+/**
+* Computes the removal range for a declaration, swallowing the whole line
+* (indentation and trailing newline) when the declaration is alone on it.
+*
+* @param sourceCode - Provides the raw text around the declaration.
+* @param statement - The declaration to remove.
+* @returns The range to delete.
+*/
+function statementRemovalRange({ text }, statement) {
+	const [start, end] = statement.range;
+	const lineStart = text.lastIndexOf("\n", start - 1) + 1;
+	const newlineIndex = text.indexOf("\n", end);
+	const lineEnd = newlineIndex === -1 ? text.length : newlineIndex + 1;
+	const leadingIsBlank = text.slice(lineStart, start).trim().length === 0;
+	const trailingIsBlank = text.slice(end, newlineIndex === -1 ? text.length : newlineIndex).trim().length === 0;
+	if (leadingIsBlank && trailingIsBlank) return [lineStart, lineEnd];
+	return [start, end];
+}
+/**
+* Builds the autofix, or returns `null` when the rewrite is not unambiguously
+* safe: unrelated sibling declarators, unmergeable or annotated patterns,
+* duplicate or colliding binding names, expressions that reference bindings
+* unavailable at the parameter position, a defused temporal dead zone, or —
+* with `allowSideEffectReordering: false` — side effects that would be
+* reordered.
+*
+* @param query - The rewrite being planned.
+* @returns The fix plan, or `null` when only a report should be emitted.
+*/
+function planFix(query) {
+	const { allowSideEffectReordering, body, identifier, node, otherParameterNames, sourceCode, statements } = query;
+	const declaratorSet = new Set(statements.map((statement) => statement.declarator));
+	const declarations = [...new Set(statements.map((statement) => statement.declaration))];
+	if (!declarations.every((declaration) => {
+		return declaration.declarations.every((declarator) => declaratorSet.has(declarator));
+	})) return null;
+	const patterns = statements.map((statement) => statement.pattern);
+	if (!allowSideEffectReordering && patterns.some((pattern) => patternExecutesCode(pattern))) {
+		const leadingStatements = new Set(body.body.slice(0, declarations.length));
+		if (!declarations.every((declaration) => leadingStatements.has(declaration))) return null;
+	}
+	if (declarations.some((declaration) => {
+		return sourceCode.getDeclaredVariables(declaration).some((declared) => {
+			return declared.references.some((reference) => reference.identifier.range[0] < declaration.range[0]);
+		});
+	})) return null;
+	if (patterns.some((pattern) => pattern.typeAnnotation !== void 0) && (patterns.length > 1 || identifier.typeAnnotation !== void 0)) return null;
+	if (patterns.length > 1) {
+		if (patterns.some((pattern) => {
+			return pattern.properties.some((property) => property.type === AST_NODE_TYPES.RestElement);
+		})) return null;
+	}
+	const boundNames = [];
+	for (const pattern of patterns) collectBoundNames(pattern, boundNames);
+	if (new Set(boundNames).size !== boundNames.length) return null;
+	if (boundNames.some((name) => otherParameterNames.has(name))) return null;
+	if (hasUnsafePatternReferences(query, patterns)) return null;
+	const [firstPattern] = patterns;
+	let parameterText;
+	if (patterns.length === 1 && firstPattern !== void 0) parameterText = sourceCode.getText(firstPattern);
+	else {
+		const innerTexts = patterns.map((pattern) => sourceCode.getText(pattern).slice(1, -1).trim().replace(/,$/u, "").trim()).filter((text) => text.length > 0);
+		parameterText = innerTexts.length === 0 ? "{}" : `{ ${innerTexts.join(", ")} }`;
+	}
+	if (node.type === AST_NODE_TYPES.ArrowFunctionExpression && sourceCode.getTokenAfter(identifier)?.value === "=>") parameterText = `(${parameterText})`;
+	const parameterRange = [identifier.range[0], identifier.typeAnnotation?.range[0] ?? identifier.range[1]];
+	const removalRanges = declarations.map((declaration) => {
+		return statementRemovalRange(sourceCode, declaration);
+	});
+	return {
+		parameterRange,
+		parameterText,
+		removalRanges
+	};
+}
+/**
+* Reports body destructuring statements of parameters that have no other use,
+* preferring the pattern in the function signature. The autofix rewrites the
+* parameter (merging multiple statements into one pattern) and removes the
+* statements; it is withheld when the rewrite is not unambiguously safe, see
+* {@link planFix}.
+*
+* @param context - The rule context.
+* @returns The rule listener.
+*/
+function createOnce$1(context) {
+	let allowSideEffectReordering = true;
+	function checkFunction(node) {
+		const { body, params } = node;
+		if (body.type !== AST_NODE_TYPES.BlockStatement || hasUseStrictDirective(body)) return;
+		const scope = context.sourceCode.getScope(node);
+		for (const parameter of params) {
+			const identifier = getParameterIdentifier(parameter);
+			if (identifier === null || identifier.name === "this") continue;
+			const variable = scope.variables.find((candidate) => {
+				return candidate.defs.some((definition) => definition.name === identifier);
+			});
+			if (variable?.defs.length !== 1) continue;
+			const statements = collectDestructureStatements(variable, identifier, body);
+			if (statements === null || statements.length === 0) continue;
+			if (statements.some(({ pattern }) => {
+				return containsAwaitOrYield(pattern, context.sourceCode.visitorKeys);
+			})) continue;
+			const otherParameterNames = collectOtherParameterNames(node, parameter);
+			if (otherParameterNames.has(identifier.name)) continue;
+			const plan = planFix({
+				allowSideEffectReordering,
+				body,
+				identifier,
+				node,
+				otherParameterNames,
+				scope,
+				sourceCode: context.sourceCode,
+				statements
+			});
+			for (const [index, statement] of statements.entries()) context.report({
+				data: { name: identifier.name },
+				fix(fixer) {
+					if (index !== 0 || plan === null) return null;
+					return [fixer.replaceTextRange(plan.parameterRange, plan.parameterText), ...plan.removalRanges.map((range) => fixer.removeRange(range))];
+				},
+				messageId: MESSAGE_ID$2,
+				node: statement.declarator
+			});
+		}
+	}
+	return {
+		ArrowFunctionExpression: checkFunction,
+		before() {
+			allowSideEffectReordering = context.options.at(0)?.allowSideEffectReordering ?? true;
+		},
+		FunctionDeclaration: checkFunction,
+		FunctionExpression: checkFunction
+	};
+}
+const preferParameterDestructuring = createFlawlessRule({
+	name: RULE_NAME$4,
+	createOnce: createOnce$1,
+	defaultOptions: [{ allowSideEffectReordering: true }],
+	meta: {
+		defaultOptions: [{ allowSideEffectReordering: true }],
+		docs: {
+			description: "Enforce destructuring parameters in the function signature",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$4,
+		schema: [{
+			additionalProperties: false,
+			properties: { allowSideEffectReordering: {
+				description: "Whether the autofix may hoist pattern defaults and computed keys past earlier statements, reordering their side effects. Set to false to withhold the fix in those cases.",
+				type: "boolean"
+			} },
+			type: "object"
+		}],
+		type: "suggestion"
+	}
+});
+//#endregion
+//#region node_modules/.pnpm/ts-api-utils@2.5.0_typescript@6.0.3/node_modules/ts-api-utils/lib/index.js
+var [tsMajor, tsMinor] = ts9.versionMajorMinor.split(".").map((raw) => Number.parseInt(raw, 10));
+function isModifierFlagSet(node, flag) {
+	return isFlagSet(ts9.getCombinedModifierFlags(node), flag);
+}
+function isFlagSet(allFlags, flag) {
+	return (allFlags & flag) !== 0;
+}
+function isFlagSetOnObject(obj, flag) {
+	return isFlagSet(obj.flags, flag);
+}
+var isNodeFlagSet = isFlagSetOnObject;
+function isObjectFlagSet(objectType, flag) {
+	return isFlagSet(objectType.objectFlags, flag);
+}
+var isSymbolFlagSet = isFlagSetOnObject;
+function isTransientSymbolLinksFlagSet(links, flag) {
+	return isFlagSet(links.checkFlags, flag);
+}
+var isTypeFlagSet = isFlagSetOnObject;
+function isNumericPropertyName(name) {
+	return String(+name) === name;
+}
+function isEntityNameExpression(node) {
+	return ts9.isIdentifier(node) || isPropertyAccessEntityNameExpression(node);
+}
+function isConstAssertionExpression(node) {
+	return ts9.isTypeReferenceNode(node.type) && ts9.isIdentifier(node.type.typeName) && node.type.typeName.escapedText === "const";
+}
+function isNumericOrStringLikeLiteral(node) {
+	switch (node.kind) {
+		case ts9.SyntaxKind.NoSubstitutionTemplateLiteral:
+		case ts9.SyntaxKind.NumericLiteral:
+		case ts9.SyntaxKind.StringLiteral: return true;
+		default: return false;
+	}
+}
+function isPropertyAccessEntityNameExpression(node) {
+	return ts9.isPropertyAccessExpression(node) && ts9.isIdentifier(node.name) && isEntityNameExpression(node.expression);
+}
+ts9.TypeFlags.Intrinsic ?? ts9.TypeFlags.Any | ts9.TypeFlags.Unknown | ts9.TypeFlags.String | ts9.TypeFlags.Number | ts9.TypeFlags.BigInt | ts9.TypeFlags.Boolean | ts9.TypeFlags.BooleanLiteral | ts9.TypeFlags.ESSymbol | ts9.TypeFlags.Void | ts9.TypeFlags.Undefined | ts9.TypeFlags.Null | ts9.TypeFlags.Never | ts9.TypeFlags.NonPrimitive;
+function isIntersectionType(type) {
+	return isTypeFlagSet(type, ts9.TypeFlags.Intersection);
+}
+function isObjectType(type) {
+	return isTypeFlagSet(type, ts9.TypeFlags.Object);
+}
+function isUnionType(type) {
+	return isTypeFlagSet(type, ts9.TypeFlags.Union);
+}
+function isTupleType(type) {
+	return isObjectType(type) && isObjectFlagSet(type, ts9.ObjectFlags.Tuple);
+}
+function isTypeReference(type) {
+	return isObjectType(type) && isObjectFlagSet(type, ts9.ObjectFlags.Reference);
+}
+function isTupleTypeReference(type) {
+	return isTypeReference(type) && isTupleType(type.target);
+}
+function isBooleanLiteralType(type) {
+	return isTypeFlagSet(type, ts9.TypeFlags.BooleanLiteral);
+}
+function isFalseLiteralType(type) {
+	return isBooleanLiteralType(type) && type.intrinsicName === "false";
+}
+function getPropertyOfType(type, name) {
+	if (!name.startsWith("__")) return type.getProperty(name);
+	return type.getProperties().find((s) => s.escapedName === name);
+}
+function isBindableObjectDefinePropertyCall(node) {
+	return node.arguments.length === 3 && isEntityNameExpression(node.arguments[0]) && isNumericOrStringLikeLiteral(node.arguments[1]) && ts9.isPropertyAccessExpression(node.expression) && node.expression.name.escapedText === "defineProperty" && ts9.isIdentifier(node.expression.expression) && node.expression.expression.escapedText === "Object";
+}
+function isInConstContext(node, typeChecker) {
+	let current = node;
+	while (true) {
+		const parent = current.parent;
+		outer: switch (parent.kind) {
+			case ts9.SyntaxKind.ArrayLiteralExpression:
+			case ts9.SyntaxKind.ObjectLiteralExpression:
+			case ts9.SyntaxKind.ParenthesizedExpression:
+			case ts9.SyntaxKind.TemplateExpression:
+				current = parent;
+				break;
+			case ts9.SyntaxKind.AsExpression:
+			case ts9.SyntaxKind.TypeAssertionExpression: return isConstAssertionExpression(parent);
+			case ts9.SyntaxKind.CallExpression: {
+				if (!ts9.isExpression(current)) return false;
+				const functionSignature = typeChecker.getResolvedSignature(parent);
+				if (functionSignature === void 0) return false;
+				const argumentIndex = parent.arguments.indexOf(current);
+				if (argumentIndex < 0) return false;
+				const parameterSymbol = functionSignature.getParameters()[argumentIndex];
+				if (parameterSymbol === void 0 || !("links" in parameterSymbol)) return false;
+				const propertySymbol = parameterSymbol.links.type?.getProperties()?.[argumentIndex];
+				if (propertySymbol === void 0 || !("links" in propertySymbol)) return false;
+				return !!propertySymbol.links && isTransientSymbolLinksFlagSet(propertySymbol.links, ts9.CheckFlags.Readonly);
+			}
+			case ts9.SyntaxKind.PrefixUnaryExpression:
+				if (current.kind !== ts9.SyntaxKind.NumericLiteral) return false;
+				switch (parent.operator) {
+					case ts9.SyntaxKind.MinusToken:
+					case ts9.SyntaxKind.PlusToken:
+						current = parent;
+						break outer;
+					default: return false;
+				}
+			case ts9.SyntaxKind.PropertyAssignment:
+				if (parent.initializer !== current) return false;
+				current = parent.parent;
+				break;
+			case ts9.SyntaxKind.ShorthandPropertyAssignment:
+				current = parent.parent;
+				break;
+			default: return false;
+		}
+	}
+}
+function intersectionConstituents(type) {
+	return isIntersectionType(type) ? type.types : [type];
+}
+function isPropertyReadonlyInType(type, name, typeChecker) {
+	let seenProperty = false;
+	let seenReadonlySignature = false;
+	for (const subType of unionConstituents(type)) if (getPropertyOfType(subType, name) === void 0) {
+		if (((isNumericPropertyName(name) ? typeChecker.getIndexInfoOfType(subType, ts9.IndexKind.Number) : void 0) ?? typeChecker.getIndexInfoOfType(subType, ts9.IndexKind.String))?.isReadonly) {
+			if (seenProperty) return true;
+			seenReadonlySignature = true;
+		}
+	} else if (seenReadonlySignature || isReadonlyPropertyIntersection(subType, name, typeChecker)) return true;
+	else seenProperty = true;
+	return false;
+}
+function symbolHasReadonlyDeclaration(symbol, typeChecker) {
+	return !!((symbol.flags & ts9.SymbolFlags.Accessor) === ts9.SymbolFlags.GetAccessor || symbol.declarations?.some((node) => isModifierFlagSet(node, ts9.ModifierFlags.Readonly) || ts9.isVariableDeclaration(node) && isNodeFlagSet(node.parent, ts9.NodeFlags.Const) || ts9.isCallExpression(node) && isReadonlyAssignmentDeclaration(node, typeChecker) || ts9.isEnumMember(node) || (ts9.isPropertyAssignment(node) || ts9.isShorthandPropertyAssignment(node)) && isInConstContext(node, typeChecker)));
+}
+function unionConstituents(type) {
+	return isUnionType(type) ? type.types : [type];
+}
+function isReadonlyAssignmentDeclaration(node, typeChecker) {
+	if (!isBindableObjectDefinePropertyCall(node)) return false;
+	const descriptorType = typeChecker.getTypeAtLocation(node.arguments[2]);
+	if (descriptorType.getProperty("value") === void 0) return descriptorType.getProperty("set") === void 0;
+	const writableProp = descriptorType.getProperty("writable");
+	if (writableProp === void 0) return false;
+	return isFalseLiteralType(writableProp.valueDeclaration !== void 0 && ts9.isPropertyAssignment(writableProp.valueDeclaration) ? typeChecker.getTypeAtLocation(writableProp.valueDeclaration.initializer) : typeChecker.getTypeOfSymbolAtLocation(writableProp, node.arguments[2]));
+}
+function isReadonlyPropertyFromMappedType(type, name, typeChecker) {
+	if (!isObjectType(type) || !isObjectFlagSet(type, ts9.ObjectFlags.Mapped)) return;
+	const declaration = type.symbol.declarations[0];
+	if (declaration.readonlyToken !== void 0 && !/^__@[^@]+$/.test(name)) return declaration.readonlyToken.kind !== ts9.SyntaxKind.MinusToken;
+	const { modifiersType } = type;
+	return modifiersType && isPropertyReadonlyInType(modifiersType, name, typeChecker);
+}
+function isReadonlyPropertyIntersection(type, name, typeChecker) {
+	return intersectionConstituents(type).some((constituent) => {
+		const prop = getPropertyOfType(constituent, name);
+		if (prop === void 0) return false;
+		if (prop.flags & ts9.SymbolFlags.Transient) {
+			if (/^(?:[1-9]\d*|0)$/.test(name) && isTupleTypeReference(constituent)) return constituent.target.readonly;
+			switch (isReadonlyPropertyFromMappedType(constituent, name, typeChecker)) {
+				case false: return false;
+				case true: return true;
+			}
+		}
+		return isSymbolFlagSet(prop, ts9.SymbolFlags.ValueModule) || symbolHasReadonlyDeclaration(prop, typeChecker);
+	});
+}
+//#endregion
+//#region src/rules/prefer-read-only-props/readonly-type.ts
+/**
+* Type aliases whose presence guarantees every property is read-only, so the
+* type is treated as fully read-only without inspecting its members.
+*/
+const READONLY_WRAPPER_NAMES = /* @__PURE__ */ new Set([
+	"DeepReadOnly",
+	"DeepReadonly",
+	"Readonly",
+	"ReadonlyArray",
+	"ReadonlyDeep"
+]);
+/**
+* Props React manages itself; they are always effectively read-only from a
+* component's perspective and never need a `readonly` modifier.
+*/
+const REACT_BUILTIN_PROPS = /* @__PURE__ */ new Set([
+	"children",
+	"key",
+	"ref"
+]);
+/**
+* Determines whether every property of a props type is read-only.
+*
+* Ported from `eslint-cease-nonsense-rules`. Union and intersection members are
+* checked recursively, index signatures must be read-only, and base (extended)
+* types are traversed so an inherited `readonly` modifier still counts. A type
+* aliased to a known read-only wrapper (such as `Readonly<T>`) short-circuits to
+* read-only.
+*
+* @param checker - The TypeScript type checker.
+* @param type - The props type to inspect.
+* @param extraWrapperName - An additional alias name (the configured autofix
+*   wrapper, such as `Immutable`) whose presence short-circuits to read-only,
+*   so already-wrapped props are recognized in O(1) without walking members.
+* @returns `true` when the type exposes no mutable properties.
+*/
+function isTypeFullyReadonly(checker, type, extraWrapperName) {
+	const aliasSymbol = type.aliasSymbol ?? type.getSymbol();
+	if (aliasSymbol) {
+		const name = aliasSymbol.getName();
+		if (READONLY_WRAPPER_NAMES.has(name) || name === extraWrapperName) return true;
+	}
+	if (type.isUnion()) return type.types.every((unionType) => {
+		return isTypeFullyReadonly(checker, unionType, extraWrapperName);
+	});
+	if (type.isIntersection()) return type.types.every((intersectionType) => {
+		return isTypeFullyReadonly(checker, intersectionType, extraWrapperName);
+	});
+	const indexInfos = checker.getIndexInfosOfType(type);
+	for (const indexInfo of indexInfos) if (!indexInfo.isReadonly) return false;
+	const properties = checker.getPropertiesOfType(type);
+	if (properties.length === 0) return true;
+	for (const property of properties) if (!isReadonlyPropertiesProperty(checker, type, property)) return false;
+	return true;
+}
+/**
+* Collects the mutable members of a props type so the autofix can add a
+* `readonly` modifier to each. Mirrors {@link isTypeFullyReadonly}'s notion of
+* read-only (React built-ins and inherited `readonly` count as read-only), but
+* gathers the offenders instead of returning a boolean.
+*
+* Union and intersection types are not attributable to a single declaration, so
+* they return `null` — the caller withholds the `readonly`-modifier fix.
+*
+* @param checker - The TypeScript type checker.
+* @param type - The props type to inspect.
+* @returns The mutable members, or `null` when the type is a union/intersection.
+*/
+function collectMutableProperties(checker, type) {
+	if (type.isUnion() || type.isIntersection()) return null;
+	return {
+		indexInfos: checker.getIndexInfosOfType(type).filter((indexInfo) => !indexInfo.isReadonly),
+		properties: checker.getPropertiesOfType(type).filter((property) => !isReadonlyPropertiesProperty(checker, type, property))
+	};
+}
+function isTypePropertyReadonly(checker, type, property) {
+	return isPropertyReadonlyInType(type, property.getEscapedName(), checker);
+}
+function getBaseTypes(type) {
+	return type.getBaseTypes() ?? [];
+}
+function isPropertyReadonlyInBaseType(checker, type, property) {
+	const propertyName = property.getName();
+	const baseTypes = [...getBaseTypes(type)];
+	for (const baseType of baseTypes) {
+		const baseProperty = baseType.getProperty(propertyName);
+		if (baseProperty === void 0) continue;
+		if (isTypePropertyReadonly(checker, baseType, baseProperty)) return true;
+		baseTypes.push(...getBaseTypes(baseType));
+	}
+	return false;
+}
+function isReadonlyPropertiesProperty(checker, type, property) {
+	const propertyName = property.getName();
+	if (REACT_BUILTIN_PROPS.has(propertyName)) return true;
+	if (isTypePropertyReadonly(checker, type, property)) return true;
+	return isPropertyReadonlyInBaseType(checker, type, property);
+}
+//#endregion
+//#region src/rules/prefer-read-only-props/rule.ts
+const RULE_NAME$3 = "prefer-read-only-props";
+const DEFAULT_WRAPPER_TYPE = "Readonly";
+const messages$3 = { preferReadOnlyProps: "A function component's props should be read-only." };
+/** Names of the `React.forwardRef` wrapper whose props are its second type argument. */
+const FORWARD_REF_NAMES = /* @__PURE__ */ new Set(["forwardRef"]);
+/** Names of the `React.memo` wrapper whose props are its first type argument. */
+const MEMO_NAMES = /* @__PURE__ */ new Set(["memo"]);
+/** Named function-component type aliases whose props are their first type argument. */
+const FC_TYPE_NAMES = /* @__PURE__ */ new Set([
+	"FC",
+	"FunctionComponent",
+	"VFC",
+	"VoidFunctionComponent"
+]);
+/**
+* Strips assignment defaults and rest wrappers to reach the binding pattern
+* that may carry a type annotation.
+*
+* @param node - The component's first parameter.
+* @returns The underlying binding pattern.
+*/
+function unwrapParameter(node) {
+	if (node.type === AST_NODE_TYPES.AssignmentPattern) return unwrapParameter(node.left);
+	if (node.type === AST_NODE_TYPES.RestElement) return unwrapParameter(node.argument);
+	return node;
+}
+function getEntityName(typeName) {
+	if (typeName.type === AST_NODE_TYPES.Identifier) return typeName.name;
+	if (typeName.type === AST_NODE_TYPES.TSQualifiedName) return typeName.right.name;
+}
+function getCalleeName(callee) {
+	if (callee.type === AST_NODE_TYPES.MemberExpression && callee.property.type === AST_NODE_TYPES.Identifier) return callee.property.name;
+	if (callee.type === AST_NODE_TYPES.Identifier) return callee.name;
+}
+/**
+* Extracts the props type argument from a `FC<Props>`-style type reference.
+*
+* @param typeNode - The variable's type annotation.
+* @returns The props type argument node, if the reference is a known FC alias.
+*/
+function getFcTypeArgument(typeNode) {
+	if (typeNode.type !== AST_NODE_TYPES.TSTypeReference) return;
+	const { typeArguments, typeName } = typeNode;
+	if (typeArguments === void 0 || typeArguments.params.length === 0) return;
+	const name = getEntityName(typeName);
+	if (name === void 0 || !FC_TYPE_NAMES.has(name)) return;
+	return typeArguments.params[0];
+}
+/**
+* Locates the props type argument of a `forwardRef`/`memo` wrapper call whose
+* callback is the component function.
+*
+* @param functionNode - The component function node.
+* @returns The props type argument node, if present.
+*/
+function getWrapperCallTypeArgument({ parent }) {
+	if (parent?.type !== AST_NODE_TYPES.CallExpression || parent.typeArguments === void 0) return;
+	const name = getCalleeName(parent.callee);
+	if (name === void 0) return;
+	if (FORWARD_REF_NAMES.has(name)) return parent.typeArguments.params[1];
+	if (MEMO_NAMES.has(name)) return parent.typeArguments.params[0];
+}
+/**
+* Finds the source type node expressing a component's props, so it can be
+* wrapped in `Readonly<>`. Prefers an explicit parameter annotation and falls
+* back to an `FC`/`forwardRef`/`memo` type argument.
+*
+* @param functionNode - The component function node.
+* @returns The props type node to wrap, or `undefined` when none is locatable.
+*/
+function findPropsTypeNode(functionNode) {
+	if (functionNode.type !== AST_NODE_TYPES.ArrowFunctionExpression && functionNode.type !== AST_NODE_TYPES.FunctionDeclaration && functionNode.type !== AST_NODE_TYPES.FunctionExpression) return;
+	const [firstParameter] = functionNode.params;
+	if (firstParameter !== void 0) {
+		const binding = unwrapParameter(firstParameter);
+		if ((binding.type === AST_NODE_TYPES.Identifier || binding.type === AST_NODE_TYPES.ObjectPattern || binding.type === AST_NODE_TYPES.ArrayPattern) && binding.typeAnnotation) return binding.typeAnnotation.typeAnnotation;
+	}
+	const { parent } = functionNode;
+	if (parent.type === AST_NODE_TYPES.VariableDeclarator && parent.id.type === AST_NODE_TYPES.Identifier && parent.id.typeAnnotation) {
+		const fromAnnotation = getFcTypeArgument(parent.id.typeAnnotation.typeAnnotation);
+		if (fromAnnotation !== void 0) return fromAnnotation;
+	}
+	return getWrapperCallTypeArgument(functionNode);
+}
+/**
+* Builds a fix that makes `name` importable from `source`, or `undefined` when
+* it is already imported. Merges into an existing named import from the same
+* module when possible, otherwise prepends a fresh `import type` statement.
+*
+* @param fixer - The rule fixer.
+* @param sourceCode - The source code, for locating existing imports.
+* @param name - The type name to import.
+* @param source - The module specifier to import it from.
+* @returns An import fix, or `undefined` when no import is needed.
+*/
+function buildImportFix(fixer, sourceCode, name, source) {
+	const { body } = sourceCode.ast;
+	let matchingImport;
+	for (const statement of body) {
+		if (statement.type !== AST_NODE_TYPES.ImportDeclaration || statement.source.value !== source) continue;
+		matchingImport = statement;
+		for (const specifier of statement.specifiers) if (specifier.type === AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES.Identifier && specifier.imported.name === name) return;
+	}
+	if (matchingImport !== void 0) {
+		const lastNamed = matchingImport.specifiers.filter((specifier) => specifier.type === AST_NODE_TYPES.ImportSpecifier).at(-1);
+		if (lastNamed !== void 0) {
+			const prefix = matchingImport.importKind === "type" ? "" : "type ";
+			return fixer.insertTextAfter(lastNamed, `, ${prefix}${name}`);
+		}
+	}
+	const insertText = `import type { ${name} } from "${source}";\n`;
+	const firstStatement = body.find((statement) => statement.type === AST_NODE_TYPES.ImportDeclaration);
+	if (firstStatement !== void 0) return fixer.insertTextBefore(firstStatement, insertText);
+	if (body[0] !== void 0) return fixer.insertTextBefore(body[0], insertText);
+	return fixer.insertTextBeforeRange([0, 0], insertText);
+}
+function create$2(context) {
+	const services = getParserServices(context, true);
+	if (!services.program) return {};
+	const checker = services.program.getTypeChecker();
+	const { sourceCode } = context;
+	const options = context.options.at(0) ?? {};
+	const wrapperType = options.wrapperType ?? DEFAULT_WRAPPER_TYPE;
+	const fixStyle = options.fixStyle ?? "wrap";
+	const { importSource } = options;
+	const collector = core.getFunctionComponentCollector(context);
+	function getParameterType(parameter) {
+		return checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(parameter));
+	}
+	/**
+	* Maps a member's TypeScript declaration back to its editable AST node.
+	*
+	* @param declaration - The member's declaration, or `undefined` when the
+	*   symbol has none (a synthesized member).
+	* @param expected - The AST node type the declaration must map to.
+	* @returns The AST node, or `undefined` when the declaration is missing, lives
+	*   in another file (absent from this file's node map), or is not the expected
+	*   kind (such as a method signature, which cannot take a `readonly`).
+	*/
+	function resolveMemberNode(declaration, expected) {
+		if (declaration === void 0) return;
+		const node = services.tsNodeToESTreeNodeMap.get(declaration);
+		if (node?.type !== expected) return;
+		return node;
+	}
+	/**
+	* Resolves every mutable member to its editable AST node, so a `readonly`
+	* modifier can be inserted before each.
+	*
+	* @param members - The mutable properties and index signatures of the props.
+	* @returns The member nodes, or `undefined` when any member cannot be edited
+	*   here (cross-file, synthesized, or a method signature) — in which case the
+	*   `"modifier"` fix is withheld.
+	*/
+	function resolveModifierTargets(members) {
+		const nodes = /* @__PURE__ */ new Set();
+		for (const property of members.properties) {
+			const node = resolveMemberNode(property.valueDeclaration, AST_NODE_TYPES.TSPropertySignature);
+			if (node === void 0) return;
+			nodes.add(node);
+		}
+		for (const indexInfo of members.indexInfos) {
+			const node = resolveMemberNode(indexInfo.declaration, AST_NODE_TYPES.TSIndexSignature);
+			if (node === void 0) return;
+			nodes.add(node);
+		}
+		return nodes.size === 0 ? void 0 : [...nodes];
+	}
+	function checkComponent(functionNode) {
+		if (functionNode.type !== AST_NODE_TYPES.ArrowFunctionExpression && functionNode.type !== AST_NODE_TYPES.FunctionDeclaration && functionNode.type !== AST_NODE_TYPES.FunctionExpression) return;
+		const [firstParameter] = functionNode.params;
+		if (firstParameter === void 0) return;
+		const propsType = getParameterType(firstParameter);
+		if (isTypeFullyReadonly(checker, propsType, wrapperType)) return;
+		if (fixStyle === "modifier") {
+			const members = collectMutableProperties(checker, propsType);
+			const targets = members === null ? void 0 : resolveModifierTargets(members);
+			context.report({
+				fix: targets === void 0 ? void 0 : (fixer) => {
+					return targets.map((node) => fixer.insertTextBefore(node, "readonly "));
+				},
+				messageId: "preferReadOnlyProps",
+				node: functionNode
+			});
+			return;
+		}
+		const typeNode = findPropsTypeNode(functionNode);
+		context.report({
+			fix: typeNode === void 0 ? void 0 : (fixer) => {
+				const fixes = [fixer.replaceText(typeNode, `${wrapperType}<${sourceCode.getText(typeNode)}>`)];
+				if (importSource !== void 0) {
+					const importFix = buildImportFix(fixer, sourceCode, wrapperType, importSource);
+					if (importFix !== void 0) fixes.push(importFix);
+				}
+				return fixes;
+			},
+			messageId: "preferReadOnlyProps",
+			node: functionNode
+		});
+	}
+	const { api, visitor } = collector;
+	const collectorExit = visitor["Program:exit"];
+	return {
+		...visitor,
+		"Program:exit": (node) => {
+			collectorExit?.(node);
+			for (const component of api.getAllComponents(node)) checkComponent(component.node);
+		}
+	};
+}
+const preferReadOnlyProps = createEslintRule({
+	name: RULE_NAME$3,
+	create: create$2,
+	defaultOptions: [{}],
+	meta: {
+		defaultOptions: [{}],
+		docs: {
+			description: "Enforce that function component props are read-only",
+			recommended: false,
+			requiresTypeChecking: true
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$3,
+		schema: [{
+			additionalProperties: false,
+			properties: {
+				fixStyle: {
+					description: "How the autofix makes props read-only: \"wrap\" wraps the type in the wrapper (Readonly<> by default); \"modifier\" adds a readonly modifier to each property, but only when every property is inline or declared in the same file, otherwise no fix is offered. \"modifier\" ignores wrapperType/importSource.",
+					enum: ["wrap", "modifier"],
+					type: "string"
+				},
+				importSource: {
+					description: "Module to import `wrapperType` from when the autofix inserts it. Omit when the wrapper is globally available (the default `Readonly` needs no import).",
+					type: "string"
+				},
+				wrapperType: {
+					description: "Utility type the autofix wraps props in. Defaults to `Readonly`; set to a deep-readonly type such as `Immutable` to enforce nested immutability.",
+					type: "string"
+				}
+			},
+			type: "object"
+		}],
+		type: "suggestion"
+	}
+});
+//#endregion
+//#region src/rules/purity/rule.ts
+const RULE_NAME$2 = "purity";
+const MESSAGE_ID$1 = "impureCall";
+/**
+* Non-deterministic Luau / Roblox calls, written as dotted paths matching how
+* they appear in roblox-ts source. `new Random()` is normalized to
+* `"Random.new"` (see the `NewExpression` visitor).
+*/
+const DEFAULT_SIGNATURES = [
+	"DateTime.now",
+	"HttpService.GenerateGUID",
+	"Random.new",
+	"Workspace.GetServerTimeNow",
+	"elapsedTime",
+	"math.random",
+	"math.randomseed",
+	"os.clock",
+	"os.date",
+	"os.time",
+	"tick",
+	"time"
+];
+/**
+* Bare Luau globals for which a matching local binding means the reference is
+* shadowed rather than the ambient global. Service objects are intentionally
+* excluded because they are impure even when imported from `@rbxts/services`.
+*/
+const GUARDED_GLOBALS = /* @__PURE__ */ new Set([
+	"elapsedTime",
+	"math",
+	"os",
+	"tick",
+	"time"
+]);
+const messages$2 = { [MESSAGE_ID$1]: "Do not call '{{name}}' during render. Components and hooks must be pure. Move this call into an event handler, effect, or state initializer." };
+const schema$1 = [{
+	additionalProperties: false,
+	properties: {
+		additionalFunctions: {
+			description: "Extra dotted call signatures to treat as impure (e.g. \"Math.random\").",
+			items: { type: "string" },
+			type: "array",
+			uniqueItems: true
+		},
+		ignore: {
+			description: "Default signatures to exclude (e.g. \"os.date\").",
+			items: { type: "string" },
+			type: "array",
+			uniqueItems: true
+		}
+	},
+	type: "object"
+}];
+/**
+* Strips wrappers that are irrelevant to the callee identity so that
+* `a.b?.()` and `a.b!()` still match.
+*
+* @param node - The node to unwrap.
+* @returns The unwrapped node.
+*/
+function unwrap(node) {
+	let current = node;
+	while (current.type === AST_NODE_TYPES.ChainExpression || current.type === AST_NODE_TYPES.TSNonNullExpression) current = current.expression;
+	return current;
+}
+/**
+* Builds the dotted path for a callee, e.g. `math.random` or `tick`.
+*
+* @param callee - The callee expression.
+* @returns The match, or `null` when the callee cannot be represented as a
+*   simple dotted path (computed access, or an object that is an expression).
+*/
+function dottedCalleePath(callee) {
+	let current = unwrap(callee);
+	const parts = [];
+	while (current.type === AST_NODE_TYPES.MemberExpression) {
+		if (current.computed || current.property.type !== AST_NODE_TYPES.Identifier) return null;
+		parts.unshift(current.property.name);
+		current = unwrap(current.object);
+	}
+	if (current.type !== AST_NODE_TYPES.Identifier) return null;
+	parts.unshift(current.name);
+	return {
+		path: parts.join("."),
+		root: current
+	};
+}
+/**
+* Determines whether an identifier resolves to a real user binding (import,
+* parameter, or local declaration) rather than the ambient Luau global.
+*
+* @param sourceCode - Provides scope lookup.
+* @param node - The identifier node.
+* @returns `true` when the identifier is a user binding rather than the ambient
+*   global.
+*/
+function isUserBinding(sourceCode, node) {
+	let scope = sourceCode.getScope(node);
+	while (scope !== null) {
+		const variable = scope.variables.find((candidate) => candidate.name === node.name);
+		if (variable !== void 0) return variable.defs.length > 0;
+		scope = scope.upper;
+	}
+	return false;
+}
+/**
+* Finds the immediate enclosing function of a node, stopping at the program.
+*
+* @param node - The node to search upward from.
+* @returns The enclosing function, or `null` when the node is at module level.
+*/
+function enclosingFunction(node) {
+	let current = node.parent;
+	while (current !== void 0) {
+		if (ASTUtils.isFunction(current)) return current;
+		if (current.type === AST_NODE_TYPES.Program) return null;
+		current = current.parent;
+	}
+	return null;
+}
+/**
+* Determines whether a function executes during render: a component body, a
+* custom/builtin hook body, or a `useMemo` callback.
+*
+* @param reactContext - The context `@eslint-react/core` predicates expect.
+* @param func - The enclosing function node.
+* @returns `true` when the function runs during render.
+*/
+function isRenderContext(reactContext, func) {
+	if (core.isFunctionComponentDefinition(reactContext, func, core.DEFAULT_COMPONENT_DETECTION_HINT)) return true;
+	if (core.isHookDefinition(func)) return true;
+	const { parent } = func;
+	return parent.type === AST_NODE_TYPES.CallExpression && parent.arguments[0] === func && core.isUseMemoCall(reactContext, parent);
+}
+function createOnce(context) {
+	const reactContext = context;
+	let signatures;
+	function handle(node, match, path) {
+		if (!signatures.has(path)) return;
+		if (path === "Random.new" && node.arguments.length > 0) return;
+		if (GUARDED_GLOBALS.has(match.root.name) && isUserBinding(context.sourceCode, match.root)) return;
+		const func = enclosingFunction(node);
+		if (func === null || !isRenderContext(reactContext, func)) return;
+		context.report({
+			data: { name: path },
+			messageId: MESSAGE_ID$1,
+			node
+		});
+	}
+	return {
+		before() {
+			const options = context.options[0] ?? {};
+			signatures = new Set(DEFAULT_SIGNATURES);
+			for (const signature of options.additionalFunctions ?? []) signatures.add(signature);
+			for (const signature of options.ignore ?? []) signatures.delete(signature);
+		},
+		CallExpression(node) {
+			const match = dottedCalleePath(node.callee);
+			if (match !== null) handle(node, match, match.path);
+		},
+		NewExpression(node) {
+			const match = dottedCalleePath(node.callee);
+			if (match !== null) handle(node, match, `${match.path}.new`);
+		}
+	};
+}
+const purity = createFlawlessRule({
+	name: RULE_NAME$2,
+	createOnce,
+	defaultOptions: [{}],
+	meta: {
+		defaultOptions: [{}],
+		docs: {
+			description: "Disallow impure calls such as `math.random` or `os.clock` during render",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		hasSuggestions: false,
+		messages: messages$2,
+		schema: schema$1,
+		type: "problem"
+	}
+});
+//#endregion
+//#region src/rules/toml-sort-keys/rule.ts
+const RULE_NAME$1 = "toml-sort-keys";
+const MESSAGE_ID = "unsorted";
+const messages$1 = { [MESSAGE_ID]: "Expected {{target}} to follow the configured order." };
+const schema = {
+	items: {
+		additionalProperties: false,
+		properties: {
+			order: { oneOf: [{
+				items: { type: "string" },
+				type: "array"
+			}, {
+				additionalProperties: false,
+				properties: {
+					caseSensitive: { type: "boolean" },
+					natural: { type: "boolean" },
+					type: {
+						enum: ["asc", "desc"],
+						type: "string"
+					}
+				},
+				type: "object"
+			}] },
+			pathPattern: { type: "string" }
+		},
+		required: ["order", "pathPattern"],
+		type: "object"
+	},
+	type: "array"
+};
+function isTable(entry) {
+	return entry.type === "TOMLTable";
+}
+/**
+* The dotted name of an entry, e.g. `settings`, `settings.node`, `_.path`.
+*
+* @param entry - The table header or key-value entry.
+* @returns The dotted key path as a string.
+*/
+function nameOf(entry) {
+	return getStaticTOMLValue(entry.key).join(".");
+}
+/**
+* Builds a rank function from an explicit order list. An entry matches an order
+* item when it equals it or is a dotted child of it (`settings.node` matches
+* `settings`), which keeps sub-tables grouped under their parent's slot.
+*
+* @param order - The configured names in their desired order.
+* @returns A function giving a name's rank, or `Infinity` when unlisted.
+*/
+function makeRank(order) {
+	return (name) => {
+		for (const [index, item] of order.entries()) if (name === item || name.startsWith(`${item}.`)) return index;
+		return Number.POSITIVE_INFINITY;
+	};
+}
+function makeFallback({ caseSensitive = true, natural = false, type = "asc" }) {
+	const sensitivity = caseSensitive ? "variant" : "accent";
+	return (a, b) => {
+		const result = a.localeCompare(b, "en", {
+			numeric: natural,
+			sensitivity
+		});
+		return type === "desc" ? -result : result;
+	};
+}
+/**
+* Builds a comparator for one table body. Explicit-order entries sort first by
+* their listed position, then unlisted entries fall back to a natural/asc sort
+* (mirroring `yaml/sort-keys`). The fallback compares keys as written in
+* source, so quotes participate in the order and quoted keys (e.g.
+* `"github:owner/repo"`) group before bare keys. At the top level, bare
+* key-values are always kept before any `[table]` header, since TOML would
+* otherwise re-scope them.
+*
+* @param order - The order configuration for this table's path.
+* @param isTopLevel - Whether the body is the top-level table.
+* @param rawName - Returns an entry's key exactly as written in source.
+* @returns A comparator over two entries.
+*/
+function makeComparator(order, isTopLevel, rawName) {
+	const rank = Array.isArray(order) ? makeRank(order) : void 0;
+	const fallback = makeFallback(Array.isArray(order) ? {
+		natural: true,
+		type: "asc"
+	} : order);
+	return (a, b) => {
+		if (isTopLevel) {
+			const aRank = isTable(a) ? 1 : 0;
+			const bRank = isTable(b) ? 1 : 0;
+			if (aRank !== bRank) return aRank - bRank;
+		}
+		if (rank !== void 0) {
+			const aRank = rank(nameOf(a));
+			const bRank = rank(nameOf(b));
+			if (aRank !== bRank) {
+				if (aRank === Number.POSITIVE_INFINITY) return 1;
+				if (bRank === Number.POSITIVE_INFINITY) return -1;
+				return aRank - bRank;
+			}
+		}
+		return fallback(rawName(a), rawName(b));
+	};
+}
+function create$1(context) {
+	const { options, sourceCode } = context;
+	if (sourceCode.parserServices.isTOML !== true) return {};
+	const specs = options.map(({ order, pathPattern }) => {
+		return {
+			order,
+			pattern: new RegExp(pathPattern, "u")
+		};
+	});
+	if (specs.length === 0) return {};
+	function resolveOrder(path) {
+		for (const spec of specs) if (spec.pattern.test(path)) return spec.order;
+	}
+	/**
+	* A comment counts as attached to an entry when it sits on its own line
+	* directly above it (no blank line, no trailing code). Such comments travel
+	* with the entry when it moves.
+	*
+	* @param comment - The comment to classify.
+	* @returns Whether the comment stands alone on its line.
+	*/
+	function isOwnLineComment(comment) {
+		const before = sourceCode.getTokenBefore(comment, { includeComments: true });
+		return before === null || before.loc.end.line < comment.loc.start.line;
+	}
+	function leadingStart(entry) {
+		const comments = sourceCode.getCommentsBefore(entry);
+		let start = entry.range[0];
+		let boundaryLine = entry.loc.start.line;
+		for (let index = comments.length - 1; index >= 0; index -= 1) {
+			const comment = comments[index];
+			if (comment === void 0) break;
+			if (comment.loc.end.line !== boundaryLine - 1 || !isOwnLineComment(comment)) break;
+			start = comment.range[0];
+			boundaryLine = comment.loc.start.line;
+		}
+		return start;
+	}
+	function trailingEnd(entry) {
+		const [comment] = sourceCode.getCommentsAfter(entry);
+		if (comment?.loc.start.line === entry.loc.end.line) return comment.range[1];
+		return entry.range[1];
+	}
+	function buildFix(entries, target) {
+		const text = sourceCode.getText();
+		const blocks = entries.map((entry) => {
+			return {
+				end: trailingEnd(entry),
+				entry,
+				start: leadingStart(entry)
+			};
+		});
+		for (let index = 1; index < blocks.length; index += 1) {
+			const previous = blocks[index - 1];
+			const current = blocks[index];
+			if (previous === void 0 || current === void 0) return;
+			if (/\S/u.test(text.slice(previous.end, current.start))) return;
+		}
+		const first = blocks[0];
+		const last = blocks[blocks.length - 1];
+		if (first === void 0 || last === void 0) return;
+		const textByEntry = new Map(blocks.map((block) => [block.entry, text.slice(block.start, block.end)]));
+		const parts = [];
+		for (const [index, entry] of target.entries()) {
+			const previous = target[index - 1];
+			if (previous !== void 0) parts.push(isTable(entry) || isTable(previous) ? "\n\n" : "\n");
+			parts.push(textByEntry.get(entry) ?? "");
+		}
+		const sortedText = parts.join("");
+		return (fixer) => fixer.replaceTextRange([first.start, last.end], sortedText);
+	}
+	function verify(path, body, isTopLevel) {
+		if (body.length < 2) return;
+		const order = resolveOrder(path);
+		if (order === void 0) return;
+		const entries = [...body];
+		const target = [...entries].sort(makeComparator(order, isTopLevel, (entry) => sourceCode.getText(entry.key)));
+		let outOfPlace;
+		for (const [index, entry] of entries.entries()) if (entry !== target[index]) {
+			outOfPlace = entry;
+			break;
+		}
+		if (outOfPlace === void 0) return;
+		context.report({
+			data: { target: path === "" ? "top-level tables" : `keys in "${path}"` },
+			fix: buildFix(entries, target),
+			loc: outOfPlace.key.loc,
+			messageId: MESSAGE_ID
+		});
+	}
+	return {
+		TOMLTable(node) {
+			verify(getStaticTOMLValue(node.key).join("."), node.body, false);
+		},
+		TOMLTopLevelTable(node) {
+			verify("", node.body, true);
+		}
+	};
+}
+const tomlSortKeys = createEslintRule({
+	name: RULE_NAME$1,
+	create: create$1,
+	defaultOptions: [],
+	meta: {
+		defaultOptions: [],
+		docs: {
+			description: "Enforce a configured sort order for TOML keys and tables",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$1,
+		schema,
+		type: "layout"
+	}
+});
+//#endregion
+//#region src/rules/yaml-block-key-blank-lines/rule.ts
+const RULE_NAME = "yaml-block-key-blank-lines";
+const messages = { blankLine: "Expected {{count}} blank line(s) around this top-level key." };
+/**
+* Determines whether a pair value is a block collection (block mapping or block
+* sequence). Flow collections (`{ ... }` / `[ ... ]`) count as scalars.
+*
+* @param value - The value node of a YAML pair.
+* @returns True if the value is a block mapping or block sequence.
+*/
+function isBlock(value) {
+	return value !== null && (value.type === "YAMLMapping" || value.type === "YAMLSequence") && value.style === "block";
+}
+function create(context) {
+	const { sourceCode } = context;
+	if (sourceCode.parserServices.isYAML !== true) return {};
+	return { YAMLMapping(yamlNode) {
+		if (yamlNode.parent.type !== "YAMLDocument") return;
+		const { pairs } = yamlNode;
+		for (let index = 1; index < pairs.length; index += 1) {
+			const previous = pairs[index - 1];
+			const current = pairs[index];
+			if (previous === void 0 || current === void 0) continue;
+			const left = sourceCode.getLastToken(previous);
+			const right = sourceCode.getFirstToken(current);
+			if (sourceCode.commentsExistBetween(left, right)) continue;
+			const blanks = right.loc.start.line - left.loc.end.line - 1;
+			const want = isBlock(previous.value) || isBlock(current.value) ? 1 : 0;
+			if (blanks === want) continue;
+			context.report({
+				data: { count: want },
+				fix(fixer) {
+					return fixer.replaceTextRange([left.range[1], right.range[0]], "\n".repeat(want + 1));
+				},
+				loc: (current.key ?? current).loc,
+				messageId: "blankLine"
+			});
+		}
+	} };
+}
+const yamlBlockKeyBlankLines = createEslintRule({
+	name: RULE_NAME,
+	create,
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Enforce blank lines around top-level YAML block collection keys",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		messages,
+		schema: [],
+		type: "layout"
+	}
+});
+//#endregion
+//#region src/plugin.ts
+const PLUGIN_NAME = name.replace(/^eslint-plugin-/, "");
+/**
+* Generates a rules record where all plugin rules are set to "error".
+*
+* @param pluginName - The plugin identifier used to prefix rule names.
+* @param rules - The rules record to transform.
+* @returns A Linter.RulesRecord with all rules enabled.
+*/
+function getRules(pluginName, rules) {
+	return Object.fromEntries(Object.keys(rules).map((ruleName) => [`${pluginName}/${ruleName}`, "error"]));
+}
+const plugin = {
+	meta: {
+		name: PLUGIN_NAME,
+		version
+	},
+	rules: {
+		"arrow-return-style": arrowReturnStyle,
+		"jsx-shorthand-boolean": jsxShorthandBoolean,
+		"jsx-shorthand-fragment": jsxShorthandFragment,
+		"naming-convention": namingConvention,
+		"no-export-default-arrow": noExportDefaultArrow,
+		"no-unnecessary-use-callback": noUnnecessaryUseCallback,
+		"no-unnecessary-use-memo": noUnnecessaryUseMemo,
+		"prefer-destructuring-assignment": preferDestructuringAssignment,
+		"prefer-parameter-destructuring": preferParameterDestructuring,
+		"prefer-read-only-props": preferReadOnlyProps,
+		"purity": purity,
+		"toml-sort-keys": tomlSortKeys,
+		"yaml-block-key-blank-lines": yamlBlockKeyBlankLines
+	}
+};
+getRules(PLUGIN_NAME, plugin.rules);
+//#endregion
+export { plugin as n, PLUGIN_NAME as t };