eslint-plugin-flawless 0.1.12 → 1.0.0

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

@@ -1,19 +1,21 @@
+import { createRequire } from "node:module";
 import { ASTUtils, AST_NODE_TYPES, ESLintUtils, TSESLint } from "@typescript-eslint/utils";
-import { existsSync } from "node:fs";
+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.12";
+var version = "1.0.0";
 var repository = {
 	"url": "git+https://github.com/christopher-buss/eslint-plugin-flawless.git",
 	"type": "git"
@@ -83,11 +85,11 @@ function createFlawlessRule({ createOnce, ...meta }) {
 }
 //#endregion
 //#region src/rules/arrow-return-style/rule.ts
-const RULE_NAME$12 = "arrow-return-style";
+const RULE_NAME$15 = "arrow-return-style";
 const IMPLICIT = "useImplicitReturn";
 const EXPLICIT = "useExplicitReturn";
 const COMPLEX_EXPLICIT = "useExplicitReturnComplex";
-const DEFAULTS = {
+const DEFAULTS$1 = {
 	jsxAlwaysUseExplicitReturn: false,
 	maxLen: 80,
 	maxObjectProperties: 4,
@@ -231,9 +233,9 @@ function collectArrows(root) {
 	return arrows.sort((a, b) => a.range[0] - b.range[0]);
 }
 const arrowReturnStyle = createFlawlessRule({
-	name: RULE_NAME$12,
+	name: RULE_NAME$15,
 	createOnce(context) {
-		let config = DEFAULTS;
+		let config = DEFAULTS$1;
 		let sourceCode;
 		let lines;
 		let pendingConsults;
@@ -288,38 +290,50 @@ const arrowReturnStyle = createFlawlessRule({
 			};
 		}
 		/**
+		* 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 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.
+		* 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 nodes = pendingConsults;
+			const consults = 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) {
@@ -338,7 +352,10 @@ const arrowReturnStyle = createFlawlessRule({
 				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);
+				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);
 			}
 		}
 		/**
@@ -365,6 +382,28 @@ const arrowReturnStyle = createFlawlessRule({
 			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.
@@ -396,8 +435,9 @@ const arrowReturnStyle = createFlawlessRule({
 			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], bodyEnd.range[1]], replacement),
+				fix: (fixer) => fixer.replaceTextRange([arrowToken.range[1], end], replacement),
 				messageId,
 				node
 			});
@@ -432,7 +472,20 @@ const arrowReturnStyle = createFlawlessRule({
 			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);
+			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;
@@ -461,8 +514,15 @@ const arrowReturnStyle = createFlawlessRule({
 				return;
 			}
 			if (width(lineOf(bodyStart.loc.start.line)) > limit()) {
-				if (config.useOxfmt !== false) pendingConsults.push(node);
-				else reportExplicit(node, EXPLICIT);
+				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);
@@ -474,7 +534,7 @@ const arrowReturnStyle = createFlawlessRule({
 			},
 			"before": function() {
 				config = {
-					...DEFAULTS,
+					...DEFAULTS$1,
 					...context.options[0]
 				};
 				({sourceCode} = context);
@@ -486,7 +546,7 @@ const arrowReturnStyle = createFlawlessRule({
 			}
 		};
 	},
-	defaultOptions: [DEFAULTS],
+	defaultOptions: [DEFAULTS$1],
 	meta: {
 		docs: {
 			description: "Enforce arrow function return style based on line length",
@@ -539,23 +599,23 @@ const arrowReturnStyle = createFlawlessRule({
 });
 //#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) {
+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$5,
+			messageId: MESSAGE_ID$7,
 			node
 		});
 	} };
 }
 const jsxShorthandBoolean = createFlawlessRule({
-	name: RULE_NAME$11,
-	createOnce: createOnce$7,
+	name: RULE_NAME$14,
+	createOnce: createOnce$9,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -565,23 +625,23 @@ const jsxShorthandBoolean = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$11,
+		messages: messages$14,
 		schema: [],
 		type: "suggestion"
 	}
 });
 //#endregion
 //#region src/rules/jsx-shorthand-fragment/rule.ts
-const RULE_NAME$10 = "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$10 = {
+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: {
@@ -613,7 +673,7 @@ function jsxNameToString(node) {
 	}
 	return null;
 }
-function createOnce$6(context) {
+function createOnce$8(context) {
 	let mode;
 	let fragmentName;
 	let namedFragments;
@@ -660,8 +720,8 @@ function createOnce$6(context) {
 	};
 }
 const jsxShorthandFragment = createFlawlessRule({
-	name: RULE_NAME$10,
-	createOnce: createOnce$6,
+	name: RULE_NAME$13,
+	createOnce: createOnce$8,
 	defaultOptions: [{
 		fragmentName: DEFAULT_FRAGMENT_NAME,
 		mode: DEFAULT_MODE
@@ -678,7 +738,328 @@ const jsxShorthandFragment = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$10,
+		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"
 	}
@@ -1843,8 +2224,8 @@ const SCHEMA = {
 };
 //#endregion
 //#region src/rules/naming-convention/rule.ts
-const RULE_NAME$9 = "naming-convention";
-const messages$9 = {
+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}}",
@@ -1874,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() ?? {};
@@ -2192,8 +2573,8 @@ function create$3(contextWithoutDefaults) {
 	}));
 }
 const namingConvention = createEslintRule({
-	name: RULE_NAME$9,
-	create: create$3,
+	name: RULE_NAME$11,
+	create: create$4,
 	defaultOptions: camelCaseNamingConfig,
 	meta: {
 		docs: {
@@ -2203,7 +2584,7 @@ const namingConvention = createEslintRule({
 		},
 		fixable: void 0,
 		hasSuggestions: false,
-		messages: messages$9,
+		messages: messages$11,
 		schema: SCHEMA,
 		type: "suggestion"
 	}
@@ -2234,9 +2615,9 @@ function requiresQuoting$1(node, 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." };
+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`).
@@ -2314,7 +2695,7 @@ function createFixFunction({ arrowFunction, context, exportDeclaration, sourceCo
 * @param context - The rule context.
 * @returns The rule listener.
 */
-function createOnce$5(context) {
+function createOnce$6(context) {
 	return { ArrowFunctionExpression(node) {
 		const { parent } = node;
 		if (parent.type !== AST_NODE_TYPES.ExportDefaultDeclaration) return;
@@ -2325,14 +2706,14 @@ function createOnce$5(context) {
 				exportDeclaration: parent,
 				sourceCode: context.sourceCode
 			}),
-			messageId: MESSAGE_ID$4,
+			messageId: MESSAGE_ID$6,
 			node
 		});
 	} };
 }
 const noExportDefaultArrow = createFlawlessRule({
-	name: RULE_NAME$8,
-	createOnce: createOnce$5,
+	name: RULE_NAME$10,
+	createOnce: createOnce$6,
 	defaultOptions: [],
 	meta: {
 		docs: {
@@ -2342,7 +2723,391 @@ const noExportDefaultArrow = createFlawlessRule({
 		},
 		fixable: "code",
 		hasSuggestions: false,
-		messages: messages$8,
+		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"
 	}
@@ -2585,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: {
@@ -2609,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: {
@@ -2640,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";
@@ -4209,10 +5094,13 @@ const plugin = {
 		"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,