eslint-plugin-flawless 0.1.11 → 1.0.0

package/dist/{plugin-BvQt8gSt.mjs → plugin-DFLOyhkl.mjs}

@@ -1,15 +1,21 @@
-import { RuleCreator, getParserServices } from "@typescript-eslint/utils/eslint-utils";
+import { createRequire } from "node:module";
 import { ASTUtils, AST_NODE_TYPES, ESLintUtils, TSESLint } from "@typescript-eslint/utils";
+import { existsSync, readFileSync, statSync } 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 { findVariable, isArrowToken, isOpeningParenToken } from "@typescript-eslint/utils/ast-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 { getStaticJSONValue, parseForESLint } from "jsonc-eslint-parser";
 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.11";
+var version = "1.0.0";
 var repository = {
 	"url": "git+https://github.com/christopher-buss/eslint-plugin-flawless.git",
 	"type": "git"
@@ -78,24 +84,538 @@ function createFlawlessRule({ createOnce, ...meta }) {
 	return Object.assign(module, { createOnce });
 }
 //#endregion
+//#region src/rules/arrow-return-style/rule.ts
+const RULE_NAME$15 = "arrow-return-style";
+const IMPLICIT = "useImplicitReturn";
+const EXPLICIT = "useExplicitReturn";
+const COMPLEX_EXPLICIT = "useExplicitReturnComplex";
+const DEFAULTS$1 = {
+	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$15,
+	createOnce(context) {
+		let config = DEFAULTS$1;
+		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
+			};
+		}
+		/**
+		* Prepares the oxfmt question for `node`: how would the formatter render
+		* the enclosing statement once the candidate fix is applied? `collapse`
+		* supplies the implicit-direction candidate (the block body textually
+		* replaced by its collapsed expression); omitting it asks about the
+		* statement as written.
+		*
+		* @param node - The arrow function in question.
+		* @param collapse - The implicit-direction candidate, if any.
+		* @returns The consult, or `null` when the arrow cannot be located.
+		*/
+		function buildConsult(node, collapse) {
+			const statement = statementOf(node);
+			const arrowIndex = collectArrows(statement).findIndex((arrow) => arrow.range[0] === node.range[0]);
+			if (arrowIndex === -1) return null;
+			const offset = statement.range[0];
+			const source = sourceCode.getText(statement);
+			const snippet = collapse === void 0 ? source : source.slice(0, collapse.block.range[0] - offset) + collapse.replacement + source.slice(collapse.block.range[1] - offset);
+			const request = {
+				arrowIndex,
+				code: `${snippet}\n`,
+				printWidth: printWidth(),
+				tabWidth: config.tabWidth
+			};
+			return {
+				baseIndent: leadingWhitespace(lineOf(statement.loc.start.line)),
+				cacheKey: `${arrowIndex}${request.printWidth}${request.tabWidth}${snippet}`,
+				node,
+				request
+			};
+		}
+		/**
+		* Resolves every deferred oxfmt consult with a single worker round-trip:
+		* would the formatter render each candidate arrow (params through body) on
+		* a single line that fits `maxLen`? Explicit consults report when it
+		* cannot, implicit consults report when it can. 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 consults = pendingConsults;
+			pendingConsults = [];
+			const worker = getFormatSync();
+			if (worker === null) return;
+			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;
+				const fits = response.singleLine && width(consult.baseIndent) + width(response.lineText) <= config.maxLen;
+				if (consult.kind === "implicit") {
+					if (fits) reportImplicit(consult.node, consult.block, consult.replacement);
+				} else if (!fits) 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 ? "  " : "	";
+		}
+		/**
+		* The `)` of a wrapped sole-argument call whose trailing comma the fix
+		* should absorb. `foo(() =>\n\tbody,\n)` only carries that comma because
+		* the argument was wrapped; once the block body hugs the call again the
+		* comma is debris (`},\n)` where the formatter writes `})`).
+		*
+		* @param node - The arrow function being converted.
+		* @param bodyEnd - The body's last token or node (including parens).
+		* @returns The closing paren to absorb up to, or `null`.
+		*/
+		function danglingCloser(node, bodyEnd) {
+			const { loc, parent } = node;
+			if (!(parent.type === AST_NODE_TYPES.CallExpression || parent.type === AST_NODE_TYPES.NewExpression) || parent.arguments.length !== 1 || parent.arguments[0] !== node) return null;
+			const opener = sourceCode.getTokenBefore(node);
+			if (opener?.value !== "(" || opener.loc.end.line !== loc.start.line) return null;
+			const comma = sourceCode.getTokenAfter(bodyEnd);
+			if (comma?.value !== ",") return null;
+			const closer = sourceCode.getTokenAfter(comma);
+			if (closer?.value !== ")" || closer.range[1] !== parent.range[1]) return null;
+			if (sourceCode.getCommentsBefore(closer).length > 0) return null;
+			return closer;
+		}
+		/**
+		* 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}}`;
+			const end = danglingCloser(node, bodyEnd)?.range[0] ?? bodyEnd.range[1];
+			context.report({
+				fix: (fixer) => fixer.replaceTextRange([arrowToken.range[1], end], 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;
+			if (statementOf(node).loc.end.line === block.loc.end.line || config.useOxfmt === false) {
+				reportImplicit(node, block, collapsed);
+				return;
+			}
+			const consult = buildConsult(node, {
+				block,
+				replacement: collapsed
+			});
+			if (consult !== null) pendingConsults.push({
+				...consult,
+				block,
+				kind: "implicit",
+				replacement: 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) {
+					reportExplicit(node, EXPLICIT);
+					return;
+				}
+				const consult = buildConsult(node);
+				if (consult !== null) pendingConsults.push({
+					...consult,
+					kind: "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$1,
+					...context.options[0]
+				};
+				({sourceCode} = context);
+				lines = [...sourceCode.lines];
+				pendingConsults = [];
+			},
+			"Program:exit": function() {
+				resolvePendingConsults();
+			}
+		};
+	},
+	defaultOptions: [DEFAULTS$1],
+	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$10 = "jsx-shorthand-boolean";
-const MESSAGE_ID$4 = "setAttributeValue";
-const messages$10 = { [MESSAGE_ID$4]: "Set an explicit value for boolean attribute '{{name}}'." };
-function createOnce$6(context) {
+const RULE_NAME$14 = "jsx-shorthand-boolean";
+const MESSAGE_ID$7 = "setAttributeValue";
+const messages$14 = { [MESSAGE_ID$7]: "Set an explicit value for boolean attribute '{{name}}'." };
+function createOnce$9(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$4,
+			messageId: MESSAGE_ID$7,
 			node
 		});
 	} };
 }
 const jsxShorthandBoolean = createFlawlessRule({
-	name: RULE_NAME$10,
-	createOnce: createOnce$6,
+	name: RULE_NAME$14,
+	createOnce: createOnce$9,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -105,23 +625,23 @@ const jsxShorthandBoolean = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$10,
+		messages: messages$14,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/jsx-shorthand-fragment/rule.ts
-const RULE_NAME$9 = "jsx-shorthand-fragment";
+const RULE_NAME$13 = "jsx-shorthand-fragment";
 const MESSAGE_ID_NAMED = "useNamedFragment";
 const MESSAGE_ID_SHORTHAND = "useShorthandFragment";
 const DEFAULT_MODE = "syntax";
 const DEFAULT_FRAGMENT_NAME = "Fragment";
-const messages$9 = {
+const messages$13 = {
 	[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 = [{
+const schema$3 = [{
 	additionalProperties: false,
 	properties: {
 		fragmentName: {
@@ -153,7 +673,7 @@ function jsxNameToString(node) {
 	}
 	return null;
 }
-function createOnce$5(context) {
+function createOnce$8(context) {
 	let mode;
 	let fragmentName;
 	let namedFragments;
@@ -200,8 +720,8 @@ function createOnce$5(context) {
 	};
 }
 const jsxShorthandFragment = createFlawlessRule({
-	name: RULE_NAME$9,
-	createOnce: createOnce$5,
+	name: RULE_NAME$13,
+	createOnce: createOnce$8,
 	defaultOptions: [{
 		fragmentName: DEFAULT_FRAGMENT_NAME,
 		mode: DEFAULT_MODE
@@ -218,7 +738,328 @@ const jsxShorthandFragment = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$9,
+		messages: messages$13,
+		schema: schema$3,
+		type: "suggestion"
+	}
+});
+//#endregion
+//#region src/rules/max-lines-per-function/core-ast-utils.ts
+/**
+* @file Helpers ported from ESLint core's `lib/rules/utils/ast-utils.js` and
+* `lib/shared/string-utils.js`, so this rule's diagnostics read and point
+* identically to core's `max-lines-per-function`. `@typescript-eslint/utils`
+* re-exports `@eslint-community/eslint-utils` equivalents
+* (`getFunctionNameWithKind`, `getFunctionHeadLocation`), but those diverge from
+* core — they name variable-bound functions (`const f = () => {}` →
+* `arrow function 'f'`) and bracket computed keys — so the port is what keeps
+* parity with core, not availability. ESLint is MIT licensed — Copyright OpenJS
+* Foundation and other contributors.
+*/
+/**
+* Describes a function by name and kind, as core does, so diagnostics read the
+* same. Examples: `function 'foo'`, `arrow function`, `constructor`,
+* `static async generator method 'foo'`, `private method #foo`.
+*
+* Core's `TSPropertySignature` / `TSMethodSignature` branches are omitted: this
+* rule only visits the three function node types, so a signature node can never
+* reach here.
+*
+* @param node - The function to describe.
+* @returns The space-joined description.
+*/
+function getFunctionNameWithKind({ id, async, generator, parent, type }) {
+	const tokens = [];
+	if (parent.type === AST_NODE_TYPES.MethodDefinition || parent.type === AST_NODE_TYPES.PropertyDefinition) {
+		if (parent.static) tokens.push("static");
+		if (!parent.computed && parent.key.type === AST_NODE_TYPES.PrivateIdentifier) tokens.push("private");
+	}
+	if (async) tokens.push("async");
+	if (generator) tokens.push("generator");
+	if (parent.type === AST_NODE_TYPES.Property || parent.type === AST_NODE_TYPES.MethodDefinition) {
+		if (parent.kind === "constructor") return "constructor";
+		if (parent.kind === "get") tokens.push("getter");
+		else if (parent.kind === "set") tokens.push("setter");
+		else tokens.push("method");
+	} else if (parent.type === AST_NODE_TYPES.PropertyDefinition) tokens.push("method");
+	else {
+		if (type === AST_NODE_TYPES.ArrowFunctionExpression) tokens.push("arrow");
+		tokens.push("function");
+	}
+	if (parent.type === AST_NODE_TYPES.Property || parent.type === AST_NODE_TYPES.MethodDefinition || parent.type === AST_NODE_TYPES.PropertyDefinition) if (!parent.computed && parent.key.type === AST_NODE_TYPES.PrivateIdentifier) tokens.push(`#${parent.key.name}`);
+	else {
+		const name = getStaticPropertyName(parent);
+		if (name !== null) tokens.push(`'${name}'`);
+		else if (id !== null) tokens.push(`'${id.name}'`);
+	}
+	else if (id !== null) tokens.push(`'${id.name}'`);
+	return tokens.join(" ");
+}
+/**
+* Locates the head of a function — the part worth underlining in a diagnostic,
+* rather than the function's whole multi-line body. For example the
+* `function foo` of a declaration, or the `=>` of an arrow function.
+*
+* Core's `TSPropertySignature` / `TSMethodSignature` branches are omitted for
+* the same reason as in {@link getFunctionNameWithKind}: those nodes never
+* reach here.
+*
+* @param node - The function to locate.
+* @param sourceCode - The source code being linted.
+* @returns The location of the function's head.
+*/
+function getFunctionHeadLoc(node, sourceCode) {
+	const { body, loc, parent, type } = node;
+	if (parent.type === AST_NODE_TYPES.Property || parent.type === AST_NODE_TYPES.MethodDefinition || parent.type === AST_NODE_TYPES.PropertyDefinition) return {
+		end: getOpeningParenOfParameters(node, sourceCode)?.loc.start ?? loc.end,
+		start: parent.loc.start
+	};
+	if (type === AST_NODE_TYPES.ArrowFunctionExpression) {
+		const arrowToken = sourceCode.getTokenBefore(body, isArrowToken);
+		if (arrowToken !== null) return {
+			end: arrowToken.loc.end,
+			start: arrowToken.loc.start
+		};
+	}
+	return {
+		end: getOpeningParenOfParameters(node, sourceCode)?.loc.start ?? loc.end,
+		start: loc.start
+	};
+}
+/**
+* Upper-cases the first character of a string.
+*
+* @param value - The string to convert.
+* @returns The converted string.
+*/
+function upperCaseFirst(value) {
+	return `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+}
+/**
+* Reads the statically known string value of a property key.
+*
+* @param node - The key node.
+* @returns The value as a string, or `null` when it is not statically known.
+*/
+function getStaticStringValue(node) {
+	if (node.type === AST_NODE_TYPES.Literal) return node.value === null ? node.raw : String(node.value);
+	if (node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0 && node.quasis.length === 1) return node.quasis[0]?.value.cooked ?? null;
+	return null;
+}
+/**
+* Reads the property name of a member definition.
+*
+* @param node - The member whose key to read.
+* @returns The property name, or `null` when the key is computed from a
+*   dynamic expression.
+*/
+function getStaticPropertyName(node) {
+	if (!node.computed && node.key.type === AST_NODE_TYPES.Identifier) return node.key.name;
+	return getStaticStringValue(node.key);
+}
+/**
+* Finds the token opening a function's parameter list.
+*
+* @param node - The function whose parameters to locate.
+* @param sourceCode - The source code being linted.
+* @returns The opening paren, or — for an arrow function with a single
+*   parameter written without parentheses — that parameter's first token.
+*   `null` when neither can be found.
+*/
+function getOpeningParenOfParameters(node, sourceCode) {
+	const [firstParameter] = node.params;
+	if (node.type === AST_NODE_TYPES.ArrowFunctionExpression && node.params.length === 1 && firstParameter !== void 0) {
+		const argumentToken = sourceCode.getFirstToken(firstParameter);
+		if (argumentToken === null) return null;
+		const maybeParenToken = sourceCode.getTokenBefore(argumentToken);
+		return maybeParenToken !== null && isOpeningParenToken(maybeParenToken) ? maybeParenToken : argumentToken;
+	}
+	return node.id === null ? sourceCode.getFirstToken(node, isOpeningParenToken) : sourceCode.getTokenAfter(node.id, isOpeningParenToken);
+}
+//#endregion
+//#region src/rules/max-lines-per-function/rule.ts
+const RULE_NAME$12 = "max-lines-per-function";
+const MESSAGE_ID_EXCEED = "exceed";
+/** A line that is empty or holds only whitespace. */
+const BLANK_LINE = /^\s*$/u;
+const DEFAULTS = {
+	countFrom: "body",
+	IIFEs: false,
+	max: 50,
+	skipBlankLines: false,
+	skipComments: false
+};
+const messages$12 = { [MESSAGE_ID_EXCEED]: "{{name}} has too many lines ({{lineCount}}). Maximum allowed is {{maxLines}}." };
+const schema$2 = [{
+	additionalProperties: false,
+	properties: {
+		countFrom: {
+			description: "Where the counted range begins: \"body\" (default) excludes the signature, \"function\" counts the whole node like ESLint core.",
+			enum: ["body", "function"],
+			type: "string"
+		},
+		IIFEs: {
+			description: "Whether immediately-invoked function expressions are measured.",
+			type: "boolean"
+		},
+		max: {
+			description: "The maximum number of lines a function may span.",
+			minimum: 0,
+			type: "integer"
+		},
+		skipBlankLines: {
+			description: "Whether lines containing only whitespace are excluded from the count.",
+			type: "boolean"
+		},
+		skipComments: {
+			description: "Whether lines consisting solely of a comment are excluded from the count.",
+			type: "boolean"
+		}
+	},
+	type: "object"
+}];
+/**
+* Indexes comments by every source line they occupy, so a line can be tested
+* for comment-only status in constant time.
+*
+* @param comments - Every comment in the file.
+* @returns A map from one-indexed line number to the comment on that line.
+*/
+function getCommentLineNumbers(comments) {
+	const map = /* @__PURE__ */ new Map();
+	for (const comment of comments) for (let { line } = comment.loc.start; line <= comment.loc.end.line; line += 1) map.set(line, comment);
+	return map;
+}
+/**
+* Determines whether a comment occupies a whole line, leaving no code beside
+* it.
+*
+* @param line - The source text of the line.
+* @param lineNumber - The one-indexed number of that line.
+* @param comment - The comment occupying part of the line.
+* @returns `true` when nothing but the comment appears on the line.
+*/
+function isFullLineComment(line, lineNumber, comment) {
+	const { end, start } = comment.loc;
+	const isFirstTokenOnLine = start.line === lineNumber && line.slice(0, start.column).trim() === "";
+	const isLastTokenOnLine = end.line === lineNumber && line.slice(end.column).trim() === "";
+	return (start.line < lineNumber || isFirstTokenOnLine) && (end.line > lineNumber || isLastTokenOnLine);
+}
+/**
+* Determines whether a function is the callee of its own call expression.
+*
+* @param node - The node to test.
+* @returns `true` when the node is immediately invoked.
+*/
+function isIIFE(node) {
+	if (node.type !== AST_NODE_TYPES.ArrowFunctionExpression && node.type !== AST_NODE_TYPES.FunctionExpression) return false;
+	const { parent } = node;
+	return parent.type === AST_NODE_TYPES.CallExpression && parent.callee === node;
+}
+/**
+* Determines whether a function is the value of a class method or of an object
+* shorthand method or accessor. In that case the enclosing member — not the
+* bare function expression — is the unit measured and reported.
+*
+* @param node - The function to test.
+* @returns `true` when the function is embedded in a member definition.
+*/
+function isEmbedded(node) {
+	const { parent } = node;
+	if (parent.type === AST_NODE_TYPES.MethodDefinition) return parent.value === node;
+	if (parent.type === AST_NODE_TYPES.Property) return parent.value === node && (parent.method || parent.kind === "get" || parent.kind === "set");
+	return false;
+}
+/**
+* Selects the source range whose lines are counted for a function.
+*
+* Under `"body"` this is the function's body — the braces themselves for a
+* block body, or the expression for a concise arrow body — so the signature is
+* excluded. Under `"function"` it is the reported node, matching ESLint core.
+*
+* @param countFrom - Which range to measure.
+* @param funcNode - The function being measured.
+* @param reportNode - The node the diagnostic attaches to: the enclosing member
+*   for an embedded method, otherwise `funcNode` itself.
+* @returns The location whose line span is counted.
+*/
+function getCountedLoc(countFrom, funcNode, reportNode) {
+	return countFrom === "function" ? reportNode.loc : funcNode.body.loc;
+}
+/**
+* Builds the rule's per-file listener.
+*
+* @param context - The rule context.
+* @returns The visitors measuring each function.
+*/
+function createOnce$7(context) {
+	let commentLineNumbers;
+	let config;
+	let lines;
+	let sourceCode;
+	/**
+	* Counts a function's lines and reports it when it exceeds the maximum.
+	*
+	* @param funcNode - The function to measure.
+	*/
+	function processFunction(funcNode) {
+		const node = isEmbedded(funcNode) ? funcNode.parent : funcNode;
+		if (!config.IIFEs && isIIFE(node)) return;
+		const { end, start } = getCountedLoc(config.countFrom, funcNode, node);
+		let lineCount = 0;
+		for (let index = start.line - 1; index < end.line; index += 1) {
+			const line = lines[index] ?? "";
+			const lineNumber = index + 1;
+			if (config.skipComments) {
+				const comment = commentLineNumbers.get(lineNumber);
+				if (comment !== void 0 && isFullLineComment(line, lineNumber, comment)) continue;
+			}
+			if (config.skipBlankLines && BLANK_LINE.test(line)) continue;
+			lineCount += 1;
+		}
+		if (lineCount > config.max) context.report({
+			data: {
+				name: upperCaseFirst(getFunctionNameWithKind(funcNode)),
+				lineCount,
+				maxLines: config.max
+			},
+			loc: getFunctionHeadLoc(funcNode, sourceCode),
+			messageId: MESSAGE_ID_EXCEED,
+			node
+		});
+	}
+	return {
+		ArrowFunctionExpression: processFunction,
+		before() {
+			const options = context.options[0];
+			config = {
+				countFrom: options?.countFrom ?? DEFAULTS.countFrom,
+				IIFEs: options?.IIFEs ?? DEFAULTS.IIFEs,
+				max: options?.max ?? DEFAULTS.max,
+				skipBlankLines: options?.skipBlankLines ?? DEFAULTS.skipBlankLines,
+				skipComments: options?.skipComments ?? DEFAULTS.skipComments
+			};
+			({sourceCode} = context);
+			lines = [...sourceCode.lines];
+			commentLineNumbers = config.skipComments ? getCommentLineNumbers(sourceCode.getAllComments()) : /* @__PURE__ */ new Map();
+		},
+		FunctionDeclaration: processFunction,
+		FunctionExpression: processFunction
+	};
+}
+const maxLinesPerFunction = createFlawlessRule({
+	name: RULE_NAME$12,
+	createOnce: createOnce$7,
+	defaultOptions: [DEFAULTS],
+	meta: {
+		defaultOptions: [DEFAULTS],
+		docs: {
+			description: "Enforce a maximum number of lines of code in a function",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		hasSuggestions: false,
+		messages: messages$12,
 		schema: schema$2,
 		type: "suggestion"
 	}
@@ -1383,8 +2224,8 @@ const SCHEMA = {
 };
 //#endregion
 //#region src/rules/naming-convention/rule.ts
-const RULE_NAME$8 = "naming-convention";
-const messages$8 = {
+const RULE_NAME$11 = "naming-convention";
+const messages$11 = {
 	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}}",
@@ -1414,7 +2255,7 @@ const camelCaseNamingConfig = [
 		selector: "typeLike"
 	}
 ];
-function create$3(contextWithoutDefaults) {
+function create$4(contextWithoutDefaults) {
 	const context = contextWithoutDefaults.options.length > 0 ? contextWithoutDefaults : Object.setPrototypeOf({ options: camelCaseNamingConfig }, contextWithoutDefaults);
 	const validators = parseOptions(context);
 	const compilerOptions = getParserServices(context, true).program?.getCompilerOptions() ?? {};
@@ -1732,8 +2573,8 @@ function create$3(contextWithoutDefaults) {
 	}));
 }
 const namingConvention = createEslintRule({
-	name: RULE_NAME$8,
-	create: create$3,
+	name: RULE_NAME$11,
+	create: create$4,
 	defaultOptions: camelCaseNamingConfig,
 	meta: {
 		docs: {
@@ -1743,7 +2584,7 @@ const namingConvention = createEslintRule({
 		},
 		fixable: void 0,
 		hasSuggestions: false,
-		messages: messages$8,
+		messages: messages$11,
 		schema: SCHEMA,
 		type: "suggestion"
 	}
@@ -1773,6 +2614,505 @@ 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$10 = "no-export-default-arrow";
+const MESSAGE_ID$6 = "disallowExportDefaultArrow";
+const messages$10 = { [MESSAGE_ID$6]: "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$6(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$6,
+			node
+		});
+	} };
+}
+const noExportDefaultArrow = createFlawlessRule({
+	name: RULE_NAME$10,
+	createOnce: createOnce$6,
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Disallow anonymous arrow functions as export default declarations",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$10,
+		schema: [],
+		type: "suggestion"
+	}
+});
+//#endregion
+//#region src/rules/no-redundant-tsconfig-options/resolve-extends.ts
+const TOP_LEVEL_KEYS = [
+	"include",
+	"exclude",
+	"files"
+];
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Resolves one `extends` specifier to an absolute config path, or `undefined`
+* when it cannot be found. Path specifiers resolve against the extending file's
+* directory (appending `.json` or `/tsconfig.json` as TypeScript does); package
+* specifiers go through `require.resolve`, which honours the package `exports`
+* map (so `@scope/pkg/subpath` maps correctly).
+*
+* @param spec - The raw `extends` specifier.
+* @param fromFile - The absolute path of the config doing the extending.
+* @returns The resolved absolute path, or `undefined`.
+*/
+function resolveExtendsTarget(spec, fromFile) {
+	if (isPathSpecifier(spec)) {
+		const base = path.resolve(path.dirname(fromFile), spec);
+		return (base.endsWith(".json") ? [base] : [`${base}.json`, path.join(base, "tsconfig.json")]).find((candidate) => fileExists(candidate));
+	}
+	const require = createRequire(fromFile);
+	for (const candidate of [
+		spec,
+		`${spec}.json`,
+		`${spec}/tsconfig.json`
+	]) try {
+		return require.resolve(candidate);
+	} catch {}
+}
+/**
+* Builds the config a child inherits from its `extends` targets alone (the child
+* itself excluded). Later targets in an `extends` array override earlier ones,
+* matching TypeScript's precedence.
+*
+* @param childFile - The absolute path of the config being linted.
+* @param extendsField - The child's raw `extends` value (string or array).
+* @returns The inherited config, or `undefined` when nothing resolves.
+*/
+function buildInheritedConfig(childFile, extendsField) {
+	const context = {
+		cache: /* @__PURE__ */ new Map(),
+		stack: /* @__PURE__ */ new Set([childFile])
+	};
+	const result = emptyConfig();
+	let resolvedAny = false;
+	for (const spec of normalizeExtends(extendsField)) {
+		const target = resolveExtendsTarget(spec, childFile);
+		if (target === void 0) continue;
+		resolvedAny = true;
+		mergeParent(result, flatten(target, context));
+	}
+	return resolvedAny ? result : void 0;
+}
+/**
+* Whether an `extends` specifier is a filesystem path (relative or absolute)
+* rather than a package specifier. Matches TypeScript: a leading `.` or a rooted
+* path is a path; anything else resolves through node module resolution.
+*
+* @param spec - The raw `extends` specifier.
+* @returns True when the specifier should resolve against the filesystem.
+*/
+function isPathSpecifier(spec) {
+	return spec.startsWith(".") || path.isAbsolute(spec);
+}
+function fileExists(candidate) {
+	try {
+		return statSync(candidate).isFile();
+	} catch {
+		return false;
+	}
+}
+function normalizeExtends(value) {
+	if (typeof value === "string") return [value];
+	if (Array.isArray(value)) return value.filter((entry) => typeof entry === "string");
+	return [];
+}
+function emptyConfig() {
+	return {
+		compilerOptions: /* @__PURE__ */ new Map(),
+		topLevel: /* @__PURE__ */ new Map()
+	};
+}
+function mergeInto(target, source) {
+	for (const [key, entry] of source) target.set(key, entry);
+}
+function mergeParent(into, parent) {
+	mergeInto(into.compilerOptions, parent.compilerOptions);
+	mergeInto(into.topLevel, parent.topLevel);
+}
+function parseTsconfig(file) {
+	try {
+		const { ast } = parseForESLint(readFileSync(file, "utf8"), {});
+		const statement = ast.body.at(0);
+		if (statement?.expression.type !== "JSONObjectExpression") return;
+		const value = getStaticJSONValue(statement.expression);
+		return isRecord(value) ? value : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Reads and parses a parent tsconfig from disk. Returns `undefined` for any
+* failure — missing file, unreadable, invalid JSONC, or a top level that is not
+* an object — so a broken ancestor never crashes the lint.
+*
+* @param file - The absolute path of the config to read.
+* @param cache - Per-resolution parse cache, keyed by absolute path.
+* @returns The parsed config subset, or `undefined`.
+*/
+function readTsconfig(file, cache) {
+	if (cache.has(file)) return cache.get(file);
+	const parsed = parseTsconfig(file);
+	cache.set(file, parsed);
+	return parsed;
+}
+function overlay(target, options, source) {
+	if (!isRecord(options)) return;
+	for (const [key, value] of Object.entries(options)) target.set(key, {
+		source,
+		value
+	});
+}
+/**
+* Flattens the effective config a file resolves to — its own extends chain,
+* overlaid by its own values (a file's own options win over what it extends).
+* The `visited` set guards against circular `extends`.
+*
+* @param file - The absolute path of the config to flatten.
+* @param context - The shared cycle stack and parse cache.
+* @returns The flattened config, with each entry's `source` naming its definer.
+*/
+function flatten(file, context) {
+	const result = emptyConfig();
+	if (context.stack.has(file)) return result;
+	context.stack.add(file);
+	try {
+		const config = readTsconfig(file, context.cache);
+		if (config === void 0) return result;
+		for (const spec of normalizeExtends(config.extends)) {
+			const target = resolveExtendsTarget(spec, file);
+			if (target !== void 0) mergeParent(result, flatten(target, context));
+		}
+		overlay(result.compilerOptions, config.compilerOptions, file);
+		for (const key of TOP_LEVEL_KEYS) if (config[key] !== void 0) result.topLevel.set(key, {
+			source: file,
+			value: config[key]
+		});
+		return result;
+	} finally {
+		context.stack.delete(file);
+	}
+}
+//#endregion
+//#region src/rules/no-redundant-tsconfig-options/rule.ts
+const RULE_NAME$9 = "no-redundant-tsconfig-options";
+const MESSAGE_ID$5 = "redundant";
+/**
+* Compiler options TypeScript resolves case-insensitively; a child that re-sets
+* one differing only in case is still redundant.
+*/
+const ENUM_SCALAR_KEYS = /* @__PURE__ */ new Set([
+	"jsx",
+	"module",
+	"moduleDetection",
+	"moduleResolution",
+	"newLine",
+	"target"
+]);
+/**
+* Array-valued options TypeScript treats as unordered sets, so a reordered but
+* otherwise identical value is still redundant.
+*/
+const SET_KEYS = /* @__PURE__ */ new Set(["lib", "types"]);
+/**
+* `compilerOptions` keys whose values are resolved as paths relative to the
+* config that declares them. An identical value repeated in a child in a
+* different directory means a different path, so these are only redundant when
+* the value is location-independent (see {@link isLocationIndependent}).
+*/
+const PATH_KEYS = /* @__PURE__ */ new Set([
+	"baseUrl",
+	"declarationDir",
+	"outDir",
+	"outFile",
+	"paths",
+	"rootDir",
+	"rootDirs",
+	"tsBuildInfoFile",
+	"typeRoots"
+]);
+const messages$9 = { [MESSAGE_ID$5]: "'{{option}}' is redundant: it is already set to this value by {{source}}. Remove it." };
+/**
+* Structural equality between two static JSON values. Strings compare
+* case-insensitively when `caseInsensitive` is set (used for enum-valued
+* options and `lib` entries, which TypeScript itself folds).
+*
+* @param a - The child's value.
+* @param b - The inherited value.
+* @param caseInsensitive - Whether string scalars compare case-insensitively.
+* @returns Whether the two values are equal.
+*/
+function equalValues(a, b, caseInsensitive) {
+	if (typeof a === "string" && typeof b === "string") return caseInsensitive ? a.toLowerCase() === b.toLowerCase() : a === b;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((item, index) => equalValues(item, b[index], caseInsensitive));
+	if (isRecord(a) && isRecord(b)) {
+		const aKeys = Object.keys(a);
+		const bKeys = Object.keys(b);
+		return aKeys.length === bKeys.length && aKeys.every((key) => key in b && equalValues(a[key], b[key], caseInsensitive));
+	}
+	return a === b;
+}
+/**
+* Set equality for two arrays: same length and every element of one has a
+* distinct equal counterpart in the other, ignoring order.
+*
+* @param a - The child's array.
+* @param b - The inherited array.
+* @param caseInsensitive - Whether string elements compare case-insensitively.
+* @returns Whether the arrays hold the same elements regardless of order.
+*/
+function equalUnordered(a, b, caseInsensitive) {
+	if (a.length !== b.length) return false;
+	const remaining = [...b];
+	for (const item of a) {
+		const index = remaining.findIndex((other) => equalValues(item, other, caseInsensitive));
+		if (index === -1) return false;
+		remaining.splice(index, 1);
+	}
+	return true;
+}
+/**
+* Whether a path-valued option is location-independent — every path string it
+* contains is either `${configDir}`-anchored (re-anchored to the extending
+* config, so an identical value resolves to the same files) or absolute. Only
+* then is repeating a path option genuinely redundant.
+*
+* @param value - The option value.
+* @returns Whether the value resolves the same regardless of config location.
+*/
+function isLocationIndependent(value) {
+	if (typeof value === "string") return value.includes("${configDir}") || path.isAbsolute(value);
+	if (Array.isArray(value)) return value.every((item) => isLocationIndependent(item));
+	if (isRecord(value)) return Object.values(value).every((item) => isLocationIndependent(item));
+	return true;
+}
+/**
+* Whether a child option re-setting `inherited` to `childValue` is redundant:
+* the values are equal and, for path-valued options, location-independent.
+*
+* @param key - The option name.
+* @param childValue - The value the child sets.
+* @param inherited - The inherited value.
+* @param isPathKey - Whether the key is path-valued.
+* @returns Whether the child option is redundant.
+*/
+function isRedundant(key, childValue, inherited, isPathKey) {
+	const caseInsensitive = key === "lib" || ENUM_SCALAR_KEYS.has(key);
+	if (!(SET_KEYS.has(key) && Array.isArray(childValue) && Array.isArray(inherited) ? equalUnordered(childValue, inherited, caseInsensitive) : equalValues(childValue, inherited, caseInsensitive))) return false;
+	return !isPathKey || isLocationIndependent(childValue);
+}
+function keyName({ key }) {
+	return key.type === "JSONIdentifier" ? key.name : String(getStaticJSONValue(key));
+}
+function findProperty(object, name) {
+	return object.properties.find((property) => keyName(property) === name);
+}
+/**
+* Reads a node's static value, returning `undefined` when it cannot be evaluated
+* (such as an exotic non-JSON node), so an odd value never crashes the rule. The
+* result is boxed so a genuine `undefined` value stays distinguishable.
+*
+* @param node - The value node to evaluate.
+* @returns A box holding the value, or `undefined` on failure.
+*/
+function safeStaticValue(node) {
+	try {
+		return { value: getStaticJSONValue(node) };
+	} catch {
+		return;
+	}
+}
+function create$3(context) {
+	const { sourceCode } = context;
+	if (sourceCode.parserServices.isJSON !== true) return {};
+	const { filename } = context;
+	if (!path.isAbsolute(filename)) return {};
+	/**
+	* Reports a redundant property, removing it (with its delimiter comma) unless
+	* a comment is attached, in which case it reports without a fix to avoid
+	* stranding the comment.
+	*
+	* @param property - The redundant property node.
+	* @param name - The property's key name (already computed by the caller).
+	* @param entry - The inherited value and the config that defined it.
+	*/
+	function report(property, name, entry) {
+		const relative = path.relative(path.dirname(filename), entry.source) || entry.source;
+		context.report({
+			data: {
+				option: name,
+				source: relative.split(path.sep).join("/")
+			},
+			fix: buildFix(property),
+			loc: property.key.loc,
+			messageId: MESSAGE_ID$5
+		});
+	}
+	function buildFix(property) {
+		const node = property;
+		const before = sourceCode.getTokenBefore(node);
+		const after = sourceCode.getTokenAfter(node);
+		const leading = sourceCode.getCommentsBefore(node);
+		const between = sourceCode.getCommentsAfter(node);
+		const trailing = after?.value === "," ? sourceCode.getCommentsAfter(after).filter((comment) => comment.loc.start.line === after.loc.end.line) : [];
+		if (leading.length > 0 || between.length > 0 || trailing.length > 0) return;
+		let start;
+		let end;
+		if (after?.value === ",") {
+			start = before?.range[1] ?? property.range[0];
+			end = after.range[1];
+		} else if (before?.value === ",") {
+			start = before.range[0];
+			end = property.range[1];
+		} else {
+			start = before?.range[1] ?? property.range[0];
+			end = property.range[1];
+		}
+		return (fixer) => fixer.removeRange([start, end]);
+	}
+	function checkObject(object, lookup, isPathKey) {
+		for (const property of object.properties) {
+			const name = keyName(property);
+			const entry = lookup(name);
+			if (entry === void 0) continue;
+			const childValue = safeStaticValue(property.value);
+			if (childValue !== void 0 && isRedundant(name, childValue.value, entry.value, isPathKey(name))) report(property, name, entry);
+		}
+	}
+	return { Program() {
+		const statement = sourceCode.ast.body.at(0);
+		if (statement?.expression.type !== "JSONObjectExpression") return;
+		const root = statement.expression;
+		const extendsProperty = findProperty(root, "extends");
+		if (extendsProperty === void 0) return;
+		const extendsValue = safeStaticValue(extendsProperty.value);
+		if (extendsValue === void 0) return;
+		const inherited = buildInheritedConfig(filename, extendsValue.value);
+		if (inherited === void 0) return;
+		const compilerOptions = findProperty(root, "compilerOptions");
+		if (compilerOptions?.value.type === "JSONObjectExpression") checkObject(compilerOptions.value, (name) => {
+			return inherited.compilerOptions.get(name);
+		}, (name) => {
+			return PATH_KEYS.has(name);
+		});
+		checkObject(root, (name) => {
+			return inherited.topLevel.get(name);
+		}, () => {
+			return true;
+		});
+	} };
+}
+const noRedundantTsconfigOptions = createEslintRule({
+	name: RULE_NAME$9,
+	create: create$3,
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Disallow tsconfig options that redundantly re-set a value already provided by an extended config",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		messages: messages$9,
+		schema: [],
+		type: "suggestion"
+	}
+});
+//#endregion
 //#region src/utils/nested-expressions.ts
 /**
 * Determines whether the given AST subtree contains a call or `new`
@@ -2010,15 +3350,15 @@ function resolveFactory(sourceCode, node) {
 }
 //#endregion
 //#region src/rules/no-unnecessary-use-callback/rule.ts
-const RULE_NAME$7 = "no-unnecessary-use-callback";
+const RULE_NAME$8 = "no-unnecessary-use-callback";
 const MESSAGE_ID_DEFAULT$1 = "default";
 const MESSAGE_ID_INSIDE_USE_EFFECT$1 = "noUnnecessaryUseCallbackInsideUseEffect";
-const messages$7 = {
+const messages$8 = {
 	[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,
+	name: RULE_NAME$8,
 	createOnce: createUnnecessaryHookRule({
 		hook: "useCallback",
 		messageIds: {
@@ -2034,22 +3374,22 @@ const noUnnecessaryUseCallback = createFlawlessRule({
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$7,
+		messages: messages$8,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/no-unnecessary-use-memo/rule.ts
-const RULE_NAME$6 = "no-unnecessary-use-memo";
+const RULE_NAME$7 = "no-unnecessary-use-memo";
 const MESSAGE_ID_DEFAULT = "default";
 const MESSAGE_ID_INSIDE_USE_EFFECT = "noUnnecessaryUseMemoInsideUseEffect";
-const messages$6 = {
+const messages$7 = {
 	[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,
+	name: RULE_NAME$7,
 	createOnce: createUnnecessaryHookRule({
 		hook: "useMemo",
 		messageIds: {
@@ -2065,12 +3405,132 @@ const noUnnecessaryUseMemo = createFlawlessRule({
 			requiresTypeChecking: false
 		},
 		hasSuggestions: false,
-		messages: messages$6,
+		messages: messages$7,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
+//#region src/rules/padding-after-expect-assertions/rule.ts
+const RULE_NAME$6 = "padding-after-expect-assertions";
+const MESSAGE_ID$4 = "missingPadding";
+const messages$6 = { [MESSAGE_ID$4]: "Expected a blank line after '{{name}}'." };
+/**
+* Matches a statement that declares the expected assertion count at the top of
+* a test: `expect.assertions(n)` or `expect.hasAssertions()`.
+*
+* Detection is purely syntactic (a non-computed `expect.assertions` /
+* `expect.hasAssertions` call) with no scope analysis, mirroring the deliberate
+* looseness of `@vitest/eslint-plugin`'s own padding rules. A shadowed local
+* `expect` is vanishingly rare, and the only consequence is a harmless blank
+* line.
+*
+* @param node - The expression statement to inspect.
+* @returns The matched member name (`expect.assertions` / `expect.hasAssertions`)
+*   for the message, or `undefined` when the statement is not an assertion count.
+*/
+function getAssertionName({ expression }) {
+	if (expression.type !== AST_NODE_TYPES.CallExpression) return;
+	const { callee } = expression;
+	if (callee.type !== AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES.Identifier || callee.object.name !== "expect" || callee.property.type !== AST_NODE_TYPES.Identifier) return;
+	const { name } = callee.property;
+	if (name !== "assertions" && name !== "hasAssertions") return;
+	return `expect.${name}`;
+}
+/**
+* Returns the statement list that directly contains a node, so its following
+* sibling can be found. The assertion count opens an `it`/`test` callback body
+* (a `BlockStatement`) or, at worst, sits at the top level (`Program`).
+*
+* @param node - The node whose containing list is wanted.
+* @returns The sibling statements, or `undefined` when the parent holds no list.
+*/
+function getContainingList({ parent }) {
+	if (parent.type === AST_NODE_TYPES.BlockStatement || parent.type === AST_NODE_TYPES.Program) return parent.body;
+}
+/**
+* Locates the two tokens the padding is measured and inserted between: the last
+* token of the assertion statement (advanced past any trailing comment on the
+* same line) and the first token of the following statement (a leading comment
+* included). This mirrors ESLint core's `padding-line-between-statements`, so a
+* trailing `// note` does not defeat the rule and the fix lands in the right
+* place. Note that `yaml-block-key-blank-lines` deliberately takes the opposite
+* stance and bails on comments, since rewriting there would re-attach them.
+*
+* @param sourceCode - The source code, for token lookups.
+* @param node - The assertion statement.
+* @param nextNode - The statement that follows it.
+* @returns The anchor tokens, or `undefined` when either cannot be resolved.
+*/
+function findPaddingAnchor(sourceCode, node, nextNode) {
+	const lastToken = sourceCode.getLastToken(node);
+	if (lastToken === null) return;
+	let previousToken = lastToken;
+	const nextToken = sourceCode.getFirstTokenBetween(previousToken, nextNode, {
+		filter(token) {
+			if (ASTUtils.isTokenOnSameLine(previousToken, token)) {
+				previousToken = token;
+				return false;
+			}
+			return true;
+		},
+		includeComments: true
+	}) ?? sourceCode.getFirstToken(nextNode);
+	if (nextToken === null) return;
+	return {
+		nextToken,
+		previousToken
+	};
+}
+/**
+* Requires a blank line after the assertion count that opens a test, keeping the
+* bookkeeping visually separate from the expectations that follow.
+*
+* @param context - The rule context.
+* @returns The rule listener.
+*/
+function createOnce$3(context) {
+	return { ExpressionStatement(node) {
+		const name = getAssertionName(node);
+		if (name === void 0) return;
+		const list = getContainingList(node);
+		if (list === void 0) return;
+		const nextNode = list[list.indexOf(node) + 1];
+		if (nextNode === void 0) return;
+		const { sourceCode } = context;
+		const anchor = findPaddingAnchor(sourceCode, node, nextNode);
+		if (anchor === void 0) return;
+		const { nextToken, previousToken } = anchor;
+		const gap = nextToken.loc.start.line - previousToken.loc.end.line;
+		if (gap > 1) return;
+		context.report({
+			data: { name },
+			fix(fixer) {
+				return fixer.insertTextAfter(previousToken, gap === 0 ? "\n\n" : "\n");
+			},
+			loc: node.loc,
+			messageId: MESSAGE_ID$4
+		});
+	} };
+}
+const paddingAfterExpectAssertions = createFlawlessRule({
+	name: RULE_NAME$6,
+	createOnce: createOnce$3,
+	defaultOptions: [],
+	meta: {
+		docs: {
+			description: "Enforce a blank line after `expect.assertions` and `expect.hasAssertions`",
+			recommended: false,
+			requiresTypeChecking: false
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		messages: messages$6,
+		schema: [],
+		type: "layout"
+	}
+});
+//#endregion
 //#region src/rules/prefer-destructuring-assignment/rule.ts
 const RULE_NAME$5 = "prefer-destructuring-assignment";
 const MESSAGE_ID$3 = "default";
@@ -3631,11 +5091,16 @@ const plugin = {
 		version
 	},
 	rules: {
+		"arrow-return-style": arrowReturnStyle,
 		"jsx-shorthand-boolean": jsxShorthandBoolean,
 		"jsx-shorthand-fragment": jsxShorthandFragment,
+		"max-lines-per-function": maxLinesPerFunction,
 		"naming-convention": namingConvention,
+		"no-export-default-arrow": noExportDefaultArrow,
+		"no-redundant-tsconfig-options": noRedundantTsconfigOptions,
 		"no-unnecessary-use-callback": noUnnecessaryUseCallback,
 		"no-unnecessary-use-memo": noUnnecessaryUseMemo,
+		"padding-after-expect-assertions": paddingAfterExpectAssertions,
 		"prefer-destructuring-assignment": preferDestructuringAssignment,
 		"prefer-parameter-destructuring": preferParameterDestructuring,
 		"prefer-read-only-props": preferReadOnlyProps,