@vitest/eslint-plugin 1.6.6 → 1.6.8

package/dist/index.cjs

@@ -1,50 +1,23 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-let __typescript_eslint_utils = require("@typescript-eslint/utils");
-__typescript_eslint_utils = __toESM(__typescript_eslint_utils);
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
 let node_module = require("node:module");
-node_module = __toESM(node_module);
 let node_path = require("node:path");
-node_path = __toESM(node_path);
-let __typescript_eslint_scope_manager = require("@typescript-eslint/scope-manager");
-__typescript_eslint_scope_manager = __toESM(__typescript_eslint_scope_manager);
+let _typescript_eslint_scope_manager = require("@typescript-eslint/scope-manager");
 
 //#region package.json
-var version = "1.6.6";
+var version = "1.6.8";
 
 //#endregion
 //#region src/utils/index.ts
-const createEslintRule = __typescript_eslint_utils.ESLintUtils.RuleCreator((name) => `https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/${name}.md`);
+const createEslintRule = _typescript_eslint_utils.ESLintUtils.RuleCreator((name) => `https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/${name}.md`);
 const joinNames = (a, b) => a && b ? `${a}.${b}` : null;
-const isFunction = (node) => node.type === __typescript_eslint_utils.AST_NODE_TYPES.FunctionExpression || node.type === __typescript_eslint_utils.AST_NODE_TYPES.ArrowFunctionExpression;
+const isFunction = (node) => node.type === _typescript_eslint_utils.AST_NODE_TYPES.FunctionExpression || node.type === _typescript_eslint_utils.AST_NODE_TYPES.ArrowFunctionExpression;
 function getNodeName(node) {
 	if (isSupportedAccessor(node)) return getAccessorValue(node);
 	switch (node.type) {
-		case __typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression: return getNodeName(node.tag);
-		case __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression: return joinNames(getNodeName(node.object), getNodeName(node.property));
-		case __typescript_eslint_utils.AST_NODE_TYPES.NewExpression:
-		case __typescript_eslint_utils.AST_NODE_TYPES.CallExpression: return getNodeName(node.callee);
+		case _typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression: return getNodeName(node.tag);
+		case _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression: return joinNames(getNodeName(node.object), getNodeName(node.property));
+		case _typescript_eslint_utils.AST_NODE_TYPES.NewExpression:
+		case _typescript_eslint_utils.AST_NODE_TYPES.CallExpression: return getNodeName(node.callee);
 	}
 	return null;
 }
@@ -58,7 +31,7 @@ const isSupportedAccessor = (node, value) => {
 * the `name` will be compared to that of the `identifier`.
 */
 const isIdentifier = (node, name) => {
-	return node.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier && (name === void 0 || node.name === name);
+	return node.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && (name === void 0 || node.name === name);
 };
 /**
 * Checks if the given `node` is a `TemplateLiteral`.
@@ -69,7 +42,7 @@ const isIdentifier = (node, name) => {
 * the `value` will be compared to that of the `TemplateLiteral`.
 */
 const isTemplateLiteral = (node, value) => {
-	return node.type === __typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral && node.quasis.length === 1 && (value === void 0 || node.quasis[0].value.raw === value);
+	return node.type === _typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral && node.quasis.length === 1 && (value === void 0 || node.quasis[0].value.raw === value);
 };
 /**
 * Checks if the given `node` is a `StringLiteral`.
@@ -77,7 +50,7 @@ const isTemplateLiteral = (node, value) => {
 * If a `value` is provided & the `node` is a `StringLiteral`,
 * the `value` will be compared to that of the `StringLiteral`.
 */
-const isStringLiteral = (node, value) => node.type === __typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof node.value === "string" && (value === void 0 || node.value === value);
+const isStringLiteral = (node, value) => node.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof node.value === "string" && (value === void 0 || node.value === value);
 /**
 * Checks if the given `node` is a {@link StringNode}.
 */
@@ -86,16 +59,16 @@ const isStringNode = (node, specifics) => isStringLiteral(node, specifics) || is
 * Gets the value of the given `AccessorNode`,
 * account for the different node types.
 */
-const getAccessorValue = (accessor) => accessor.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier ? accessor.name : getStringValue(accessor);
+const getAccessorValue = (accessor) => accessor.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier ? accessor.name : getStringValue(accessor);
 /**
 * Gets the value of the given `StringNode`.
 *
 * If the `node` is a `TemplateLiteral`, the `raw` value is used;
 * otherwise, `value` is returned instead.
 */
-const getStringValue = (node) => node?.type === __typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral ? node.quasis[0].value.raw : node?.value;
+const getStringValue = (node) => node?.type === _typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral ? node.quasis[0].value.raw : node?.value;
 const replaceAccessorFixer = (fixer, node, text) => {
-	return fixer.replaceText(node, node.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier ? text : `'${text}'`);
+	return fixer.replaceText(node, node.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier ? text : `'${text}'`);
 };
 const removeExtraArgumentsFixer = (fixer, context, func, from) => {
 	const firstArg = func.arguments[from];
@@ -115,55 +88,55 @@ const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__
 
 //#endregion
 //#region src/utils/types.ts
-let UtilName = /* @__PURE__ */ function(UtilName$1) {
-	UtilName$1["vi"] = "vi";
-	UtilName$1["vitest"] = "vitest";
-	return UtilName$1;
+let UtilName = /* @__PURE__ */ function(UtilName) {
+	UtilName["vi"] = "vi";
+	UtilName["vitest"] = "vitest";
+	return UtilName;
 }({});
-let DescribeAlias = /* @__PURE__ */ function(DescribeAlias$1) {
-	DescribeAlias$1["describe"] = "describe";
-	DescribeAlias$1["fdescribe"] = "fdescribe";
-	DescribeAlias$1["xdescribe"] = "xdescribe";
-	return DescribeAlias$1;
+let DescribeAlias = /* @__PURE__ */ function(DescribeAlias) {
+	DescribeAlias["describe"] = "describe";
+	DescribeAlias["fdescribe"] = "fdescribe";
+	DescribeAlias["xdescribe"] = "xdescribe";
+	return DescribeAlias;
 }({});
-let TestCaseName = /* @__PURE__ */ function(TestCaseName$1) {
-	TestCaseName$1["fit"] = "fit";
-	TestCaseName$1["it"] = "it";
-	TestCaseName$1["test"] = "test";
-	TestCaseName$1["xit"] = "xit";
-	TestCaseName$1["xtest"] = "xtest";
-	TestCaseName$1["bench"] = "bench";
-	return TestCaseName$1;
+let TestCaseName = /* @__PURE__ */ function(TestCaseName) {
+	TestCaseName["fit"] = "fit";
+	TestCaseName["it"] = "it";
+	TestCaseName["test"] = "test";
+	TestCaseName["xit"] = "xit";
+	TestCaseName["xtest"] = "xtest";
+	TestCaseName["bench"] = "bench";
+	return TestCaseName;
 }({});
-let HookName = /* @__PURE__ */ function(HookName$1) {
-	HookName$1["beforeAll"] = "beforeAll";
-	HookName$1["beforeEach"] = "beforeEach";
-	HookName$1["afterAll"] = "afterAll";
-	HookName$1["afterEach"] = "afterEach";
-	return HookName$1;
+let HookName = /* @__PURE__ */ function(HookName) {
+	HookName["beforeAll"] = "beforeAll";
+	HookName["beforeEach"] = "beforeEach";
+	HookName["afterAll"] = "afterAll";
+	HookName["afterEach"] = "afterEach";
+	return HookName;
 }({});
-let ModifierName = /* @__PURE__ */ function(ModifierName$1) {
-	ModifierName$1["to"] = "to";
-	ModifierName$1["have"] = "have";
-	ModifierName$1["not"] = "not";
-	ModifierName$1["rejects"] = "rejects";
-	ModifierName$1["resolves"] = "resolves";
-	ModifierName$1["returns"] = "returns";
-	ModifierName$1["branded"] = "branded";
-	ModifierName$1["asserts"] = "asserts";
-	ModifierName$1["constructorParameters"] = "constructorParameters";
-	ModifierName$1["parameters"] = "parameters";
-	ModifierName$1["thisParameter"] = "thisParameter";
-	ModifierName$1["guards"] = "guards";
-	ModifierName$1["instance"] = "instance";
-	ModifierName$1["items"] = "items";
-	return ModifierName$1;
+let ModifierName = /* @__PURE__ */ function(ModifierName) {
+	ModifierName["to"] = "to";
+	ModifierName["have"] = "have";
+	ModifierName["not"] = "not";
+	ModifierName["rejects"] = "rejects";
+	ModifierName["resolves"] = "resolves";
+	ModifierName["returns"] = "returns";
+	ModifierName["branded"] = "branded";
+	ModifierName["asserts"] = "asserts";
+	ModifierName["constructorParameters"] = "constructorParameters";
+	ModifierName["parameters"] = "parameters";
+	ModifierName["thisParameter"] = "thisParameter";
+	ModifierName["guards"] = "guards";
+	ModifierName["instance"] = "instance";
+	ModifierName["items"] = "items";
+	return ModifierName;
 }({});
-let EqualityMatcher = /* @__PURE__ */ function(EqualityMatcher$1) {
-	EqualityMatcher$1["toBe"] = "toBe";
-	EqualityMatcher$1["toEqual"] = "toEqual";
-	EqualityMatcher$1["toStrictEqual"] = "toStrictEqual";
-	return EqualityMatcher$1;
+let EqualityMatcher = /* @__PURE__ */ function(EqualityMatcher) {
+	EqualityMatcher["toBe"] = "toBe";
+	EqualityMatcher["toEqual"] = "toEqual";
+	EqualityMatcher["toStrictEqual"] = "toStrictEqual";
+	return EqualityMatcher;
 }({});
 function isClassOrFunctionType(type) {
 	if (type.getCallSignatures().length > 0) return true;
@@ -1605,7 +1578,7 @@ const determineVitestFnType = (name) => {
 const findModifiersAndMatcher = (members) => {
 	const modifiers = [];
 	for (const member of members) {
-		if (member.parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && member.parent.parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return {
+		if (member.parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && member.parent.parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return {
 			matcher: member,
 			args: member.parent.parent.arguments,
 			modifiers
@@ -1635,12 +1608,12 @@ const findTopMostCallExpression = (node) => {
 	let topMostCallExpression = node;
 	let { parent } = node;
 	while (parent) {
-		if (parent.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) {
+		if (parent.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) {
 			topMostCallExpression = parent;
 			parent = parent.parent;
 			continue;
 		}
-		if (parent.type !== __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) break;
+		if (parent.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) break;
 		parent = parent.parent;
 	}
 	return topMostCallExpression;
@@ -1651,9 +1624,9 @@ const parseVitestFnCallWithReasonInner = (node, context) => {
 	const [first, ...rest] = chain;
 	const lastLink = getAccessorValue(chain[chain.length - 1]);
 	if (lastLink === "each") {
-		if (node.callee.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression && node.callee.type !== __typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression) return null;
+		if (node.callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression && node.callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression) return null;
 	}
-	if (node.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression && lastLink !== "each") return null;
+	if (node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression && lastLink !== "each") return null;
 	const resolved = resolveVitestFn(context, node, getAccessorValue(first));
 	if (!resolved) return null;
 	const name = resolved.original ?? resolved.local;
@@ -1672,12 +1645,12 @@ const parseVitestFnCallWithReasonInner = (node, context) => {
 		const result = parseVitestExpectCall(parsedVitestFnCall, type);
 		if (typeof result === "string" && findTopMostCallExpression(node) !== node) return null;
 		if (result === "matcher-not-found") {
-			if (node.parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return "matcher-not-called";
+			if (node.parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return "matcher-not-called";
 		}
 		return result;
 	}
-	if (chain.slice(0, chain.length - 1).some((node$1) => node$1.parent?.type !== __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression)) return null;
-	if (node.parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression || node.parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return null;
+	if (chain.slice(0, chain.length - 1).some((node) => node.parent?.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression)) return null;
+	if (node.parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression || node.parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return null;
 	return {
 		...parsedVitestFnCall,
 		type
@@ -1687,9 +1660,9 @@ const joinChains = (a, b) => a && b ? [...a, ...b] : null;
 function getNodeChain(node) {
 	if (isSupportedAccessor(node)) return [node];
 	switch (node.type) {
-		case __typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression: return getNodeChain(node.tag);
-		case __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression: return joinChains(getNodeChain(node.object), getNodeChain(node.property));
-		case __typescript_eslint_utils.AST_NODE_TYPES.CallExpression: return getNodeChain(node.callee);
+		case _typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression: return getNodeChain(node.tag);
+		case _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression: return joinChains(getNodeChain(node.object), getNodeChain(node.property));
+		case _typescript_eslint_utils.AST_NODE_TYPES.CallExpression: return getNodeChain(node.callee);
 	}
 	return null;
 }
@@ -1723,7 +1696,7 @@ const resolvePossibleAliasedGlobal = (global, context) => {
 	return null;
 };
 const isAncestorTestCaseCall = ({ parent }) => {
-	return parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression && parent.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier && Object.prototype.hasOwnProperty.call(TestCaseName, parent.callee.name);
+	return parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression && parent.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && Object.prototype.hasOwnProperty.call(TestCaseName, parent.callee.name);
 };
 const resolveScope = (scope, identifier) => {
 	let currentScope = scope;
@@ -1731,13 +1704,13 @@ const resolveScope = (scope, identifier) => {
 		const ref = currentScope.set.get(identifier);
 		if (ref && ref.defs.length > 0) {
 			const def = ref.defs[ref.defs.length - 1];
-			const objectParam = isFunction(def.node) ? def.node.params.find((params) => params.type === __typescript_eslint_utils.AST_NODE_TYPES.ObjectPattern) : void 0;
+			const objectParam = isFunction(def.node) ? def.node.params.find((params) => params.type === _typescript_eslint_utils.AST_NODE_TYPES.ObjectPattern) : void 0;
 			if (objectParam) {
-				const property = objectParam.properties.find((property$1) => property$1.type === __typescript_eslint_utils.AST_NODE_TYPES.Property);
-				if ((property?.key.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier ? property.key : void 0)?.name === identifier) return "testContext";
+				const property = objectParam.properties.find((property) => property.type === _typescript_eslint_utils.AST_NODE_TYPES.Property);
+				if ((property?.key.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier ? property.key : void 0)?.name === identifier) return "testContext";
 			}
 			/** if detect test function is created with `.extend()` */
-			if (def.node.type === __typescript_eslint_utils.AST_NODE_TYPES.VariableDeclarator && def.node.id.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier && def.node.init?.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression && def.node.init.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isIdentifier(def.node.init.callee.property, "extend")) {
+			if (def.node.type === _typescript_eslint_utils.AST_NODE_TYPES.VariableDeclarator && def.node.id.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && def.node.init?.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression && def.node.init.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isIdentifier(def.node.init.callee.property, "extend")) {
 				const rootName = getNodeName(def.node.init.callee.object)?.split(".")[0];
 				if (rootName && rootName !== identifier) {
 					const resolved = resolveScope(currentScope, rootName);
@@ -1747,7 +1720,7 @@ const resolveScope = (scope, identifier) => {
 					};
 				}
 			}
-			const namedParam = isFunction(def.node) ? def.node.params.find((params) => params.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier) : void 0;
+			const namedParam = isFunction(def.node) ? def.node.params.find((params) => params.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) : void 0;
 			if (namedParam && isAncestorTestCaseCall(namedParam.parent)) return "testContext";
 			const importDetails = describePossibleImportDef(def);
 			if (importDetails?.local === identifier) return importDetails;
@@ -1765,17 +1738,17 @@ const resolveScope = (scope, identifier) => {
 * like an import), then `null` is returned instead.
 */
 const findImportSourceNode = (node) => {
-	if (node.type === __typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression) {
-		if (node.argument.type === __typescript_eslint_utils.AST_NODE_TYPES.ImportExpression) return node.argument.source;
+	if (node.type === _typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression) {
+		if (node.argument.type === _typescript_eslint_utils.AST_NODE_TYPES.ImportExpression) return node.argument.source;
 		return null;
 	}
-	if (node.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression && isIdentifier(node.callee, "require")) return node.arguments[0] ?? null;
+	if (node.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression && isIdentifier(node.callee, "require")) return node.arguments[0] ?? null;
 	return null;
 };
 const describeImportDefAsImport = (def) => {
-	if (def.parent.type === __typescript_eslint_utils.AST_NODE_TYPES.TSImportEqualsDeclaration) return null;
-	if (def.node.type !== __typescript_eslint_utils.AST_NODE_TYPES.ImportSpecifier) return null;
-	if (def.node.imported.type != __typescript_eslint_utils.AST_NODE_TYPES.Identifier) return null;
+	if (def.parent.type === _typescript_eslint_utils.AST_NODE_TYPES.TSImportEqualsDeclaration) return null;
+	if (def.node.type !== _typescript_eslint_utils.AST_NODE_TYPES.ImportSpecifier) return null;
+	if (def.node.imported.type != _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return null;
 	if (def.parent.importKind === "type") return null;
 	return {
 		source: def.parent.source.value,
@@ -1792,7 +1765,7 @@ const describeVariableDefAsImport = (def) => {
 	if (!def.node.init) return null;
 	const sourceNode = findImportSourceNode(def.node.init);
 	if (!sourceNode || !isStringNode(sourceNode)) return null;
-	if (def.name.parent?.type !== __typescript_eslint_utils.AST_NODE_TYPES.Property) return null;
+	if (def.name.parent?.type !== _typescript_eslint_utils.AST_NODE_TYPES.Property) return null;
 	if (!isSupportedAccessor(def.name.parent.key)) return null;
 	return {
 		source: getStringValue(sourceNode),
@@ -1801,14 +1774,14 @@ const describeVariableDefAsImport = (def) => {
 	};
 };
 const getTestCallExpressionsFromDeclaredVariables = (declaredVariables, context) => {
-	return declaredVariables.reduce((acc, { references }) => acc.concat(references.map(({ identifier }) => identifier.parent).filter((node) => node?.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression && isTypeOfVitestFnCall(node, context, ["test"]))), []);
+	return declaredVariables.reduce((acc, { references }) => acc.concat(references.map(({ identifier }) => identifier.parent).filter((node) => node?.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression && isTypeOfVitestFnCall(node, context, ["test"]))), []);
 };
 const getFirstMatcherArg = (expectFnCall) => {
 	const [firstArg] = expectFnCall.args;
-	if (firstArg.type === __typescript_eslint_utils.AST_NODE_TYPES.SpreadElement) return firstArg;
+	if (firstArg.type === _typescript_eslint_utils.AST_NODE_TYPES.SpreadElement) return firstArg;
 	return followTypeAssertionChain$1(firstArg);
 };
-const isTypeCastExpression$1 = (node) => node.type === __typescript_eslint_utils.AST_NODE_TYPES.TSAsExpression || node.type === __typescript_eslint_utils.AST_NODE_TYPES.TSTypeAssertion;
+const isTypeCastExpression$1 = (node) => node.type === _typescript_eslint_utils.AST_NODE_TYPES.TSAsExpression || node.type === _typescript_eslint_utils.AST_NODE_TYPES.TSTypeAssertion;
 const followTypeAssertionChain$1 = (expression) => isTypeCastExpression$1(expression) ? followTypeAssertionChain$1(expression.expression) : expression;
 
 //#endregion
@@ -1853,7 +1826,6 @@ var consistent_each_for_default = createEslintRule({
 		}],
 		defaultOptions: [{}]
 	},
-	defaultOptions: [{}],
 	create(context, [options]) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
@@ -1900,21 +1872,19 @@ var consistent_test_filename_default = createEslintRule({
 			properties: {
 				pattern: {
 					type: "string",
-					format: "regex",
-					default: defaultPattern.source
+					format: "regex"
 				},
 				allTestPattern: {
 					type: "string",
-					format: "regex",
-					default: defaultTestsPattern.source
+					format: "regex"
 				}
 			}
+		}],
+		defaultOptions: [{
+			pattern: defaultPattern.source,
+			allTestPattern: defaultTestsPattern.source
 		}]
 	},
-	defaultOptions: [{
-		pattern: defaultPattern.source,
-		allTestPattern: defaultTestsPattern.source
-	}],
 	create: (context, options) => {
 		const { pattern: patternRaw, allTestPattern: allTestPatternRaw } = options[0];
 		const pattern = new RegExp(patternRaw);
@@ -1934,7 +1904,7 @@ var consistent_test_filename_default = createEslintRule({
 //#endregion
 //#region src/rules/consistent-test-it.ts
 const RULE_NAME$78 = "consistent-test-it";
-const buildFixer = (callee, nodeName, preferredTestKeyword) => (fixer) => [fixer.replaceText(callee.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression ? callee.object : callee, getPreferredNodeName(nodeName, preferredTestKeyword))];
+const buildFixer = (callee, nodeName, preferredTestKeyword) => (fixer) => [fixer.replaceText(callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression ? callee.object : callee, getPreferredNodeName(nodeName, preferredTestKeyword))];
 function getPreferredNodeName(nodeName, preferredTestKeyword) {
 	if (nodeName === TestCaseName.fit) return "test.only";
 	return nodeName.startsWith("f") || nodeName.startsWith("x") ? nodeName.charAt(0) + preferredTestKeyword : preferredTestKeyword;
@@ -1969,9 +1939,9 @@ var consistent_test_it_default = createEslintRule({
 				}
 			},
 			additionalProperties: false
-		}]
+		}],
+		defaultOptions: [{}]
 	},
-	defaultOptions: [{}],
 	create(context, options) {
 		const { fn, withinDescribe } = options[0];
 		const testFnKeyWork = fn || TestCaseName.test;
@@ -1998,7 +1968,7 @@ var consistent_test_it_default = createEslintRule({
 						fix: (fixer) => {
 							const remainingSpecifiers = node.specifiers.filter((spec) => spec !== specifier);
 							if (remainingSpecifiers.length > 0) {
-								const hasPreferredSpecifier = remainingSpecifiers.some((spec) => spec.type === __typescript_eslint_utils.AST_NODE_TYPES.ImportSpecifier && spec.imported.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier && spec.imported.name === testFnDisabled);
+								const hasPreferredSpecifier = remainingSpecifiers.some((spec) => spec.type === _typescript_eslint_utils.AST_NODE_TYPES.ImportSpecifier && spec.imported.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && spec.imported.name === testFnDisabled);
 								const importNames = remainingSpecifiers.map((spec) => sourceCode.getText(spec));
 								if (!hasPreferredSpecifier) importNames.push(testFnDisabled);
 								const importText = importNames.join(", ");
@@ -2012,14 +1982,14 @@ var consistent_test_it_default = createEslintRule({
 				}
 			},
 			CallExpression(node) {
-				if (node.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier && node.callee.name === "bench") return;
+				if (node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && node.callee.name === "bench") return;
 				const vitestFnCall = parseVitestFnCall(node, context);
 				if (!vitestFnCall) return;
 				if (vitestFnCall.type === "describe") {
 					describeNestingLevel++;
 					return;
 				}
-				const funcNode = node.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
+				const funcNode = node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
 				if (vitestFnCall.type === "test" && describeNestingLevel === 0 && !vitestFnCall.name.endsWith(testFnKeyWork)) {
 					const oppositeTestKeyword = getOppositeTestKeyword(testFnKeyWork);
 					context.report({
@@ -2069,22 +2039,21 @@ var consistent_vitest_vi_default = createEslintRule({
 			type: "object",
 			properties: { fn: {
 				type: "string",
-				enum: [UtilName.vi, UtilName.vitest],
-				default: UtilName.vi
+				enum: [UtilName.vi, UtilName.vitest]
 			} },
 			additionalProperties: false
-		}]
+		}],
+		defaultOptions: [{ fn: UtilName.vi }]
 	},
-	defaultOptions: [{ fn: UtilName.vi }],
 	create(context, options) {
 		const utilKeyword = options[0].fn;
 		const oppositeUtilKeyword = getOppositeVitestUtilKeyword(utilKeyword);
 		return {
 			ImportDeclaration(node) {
-				if (node.source.type !== __typescript_eslint_utils.AST_NODE_TYPES.Literal || node.source.value !== "vitest") return;
+				if (node.source.type !== _typescript_eslint_utils.AST_NODE_TYPES.Literal || node.source.value !== "vitest") return;
 				for (const specifier of node.specifiers) {
-					if (specifier.type !== __typescript_eslint_utils.AST_NODE_TYPES.ImportSpecifier) continue;
-					if (specifier.imported.type !== __typescript_eslint_utils.AST_NODE_TYPES.Identifier) continue;
+					if (specifier.type !== _typescript_eslint_utils.AST_NODE_TYPES.ImportSpecifier) continue;
+					if (specifier.imported.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) continue;
 					if (specifier.local.name !== specifier.imported.name) continue;
 					if (specifier.imported.name === oppositeUtilKeyword) context.report({
 						node: specifier,
@@ -2110,7 +2079,7 @@ var consistent_vitest_vi_default = createEslintRule({
 				const vitestFnCall = parseVitestFnCall(node, context);
 				if (vitestFnCall?.type !== "vi") return;
 				if (!isSupportedAccessor(vitestFnCall.head.node, oppositeUtilKeyword)) return;
-				const replaceNode = node.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression ? node.callee.object : node.callee;
+				const replaceNode = node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression ? node.callee.object : node.callee;
 				context.report({
 					node: replaceNode,
 					data: {
@@ -2167,18 +2136,14 @@ var expect_expect_default = createEslintRule({
 		}],
 		messages: { noAssertions: "Test has no assertions" }
 	},
-	defaultOptions: [{
-		assertFunctionNames: ["expect", "assert"],
-		additionalTestBlockFunctions: []
-	}],
 	create(context, [{ assertFunctionNames = ["expect"], additionalTestBlockFunctions = [] }]) {
 		const unchecked = [];
 		if (parsePluginSettings(context.settings).typecheck) assertFunctionNames.push("expectTypeOf", "assertType");
 		const assertFunctionRegexps = assertFunctionNames.map(buildPatternRegexp);
 		function checkCallExpression(nodes) {
 			for (const node of nodes) {
-				const index = node.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression ? unchecked.indexOf(node) : -1;
-				if (node.type === __typescript_eslint_utils.AST_NODE_TYPES.FunctionDeclaration) checkCallExpression(getTestCallExpressionsFromDeclaredVariables(context.sourceCode.getDeclaredVariables(node), context));
+				const index = node.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression ? unchecked.indexOf(node) : -1;
+				if (node.type === _typescript_eslint_utils.AST_NODE_TYPES.FunctionDeclaration) checkCallExpression(getTestCallExpressionsFromDeclaredVariables(context.sourceCode.getDeclaredVariables(node), context));
 				if (index !== -1) {
 					unchecked.splice(index, 1);
 					break;
@@ -2187,15 +2152,15 @@ var expect_expect_default = createEslintRule({
 		}
 		return {
 			CallExpression(node) {
-				if (node.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier && node.callee.name === "bench") return;
-				if (node?.callee?.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && node.callee.property.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier && [
+				if (node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && node.callee.name === "bench") return;
+				if (node?.callee?.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && node.callee.property.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && [
 					"skip",
 					"extend",
 					"scoped"
 				].includes(node.callee.property.name)) return;
 				const name = getNodeName(node) ?? "";
 				if (isTypeOfVitestFnCall(node, context, ["test"]) || additionalTestBlockFunctions.includes(name)) {
-					if (node.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property, "todo")) return;
+					if (node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property, "todo")) return;
 					unchecked.push(node);
 				} else if (assertFunctionRegexps.some((p) => p.test(name))) checkCallExpression(context.sourceCode.getAncestors(node));
 			},
@@ -2239,27 +2204,26 @@ var hoisted_apis_on_top_default = createEslintRule({
 		},
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		let lastImportEnd = null;
 		const nodesToReport = [];
 		return {
 			ImportDeclaration(node) {
-				if (node.parent.type !== __typescript_eslint_utils.AST_NODE_TYPES.Program) return;
+				if (node.parent.type !== _typescript_eslint_utils.AST_NODE_TYPES.Program) return;
 				lastImportEnd = node.range[1];
 			},
 			CallExpression(node) {
-				if (node.callee.type !== __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return;
+				if (node.callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return;
 				const { object, property } = node.callee;
-				if (object.type !== __typescript_eslint_utils.AST_NODE_TYPES.Identifier || object.name !== "vi" || property.type !== __typescript_eslint_utils.AST_NODE_TYPES.Identifier) return;
+				if (object.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier || object.name !== "vi" || property.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return;
 				const apiName = property.name;
 				if (!hoistedAPIs.includes(apiName)) return;
 				if (apiName === "hoisted") {
 					let parent = node.parent;
-					if (parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression) parent = parent.parent;
-					if (parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.VariableDeclarator) parent = parent.parent;
-					if ((parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement || parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.VariableDeclaration) && parent.parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.Program) return;
-				} else if (node.parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement && node.parent.parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.Program) return;
+					if (parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression) parent = parent.parent;
+					if (parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.VariableDeclarator) parent = parent.parent;
+					if ((parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement || parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.VariableDeclaration) && parent.parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.Program) return;
+				} else if (node.parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement && node.parent.parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.Program) return;
 				nodesToReport.push(node);
 			},
 			"Program:exit"() {
@@ -2268,7 +2232,7 @@ var hoisted_apis_on_top_default = createEslintRule({
 					suggestions.push({
 						messageId: "suggestMoveHoistedApiToTop",
 						*fix(fixer) {
-							if (node.parent.type === __typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement) yield fixer.remove(node);
+							if (node.parent.type === _typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement) yield fixer.remove(node);
 							else yield fixer.replaceText(node, "undefined");
 							if (lastImportEnd != null) yield fixer.insertTextAfterRange([lastImportEnd, lastImportEnd], "\n" + context.sourceCode.getText(node) + ";");
 							else yield fixer.insertTextAfterRange([0, 0], context.sourceCode.getText(node) + ";\n");
@@ -2309,13 +2273,13 @@ var max_expects_default = createEslintRule({
 			type: "object",
 			properties: { max: { type: "number" } },
 			additionalProperties: false
-		}]
+		}],
+		defaultOptions: [{ max: 5 }]
 	},
-	defaultOptions: [{ max: 5 }],
 	create(context, [{ max }]) {
 		let assertsCount = 0;
 		const resetAssertCount = (node) => {
-			if (node.parent?.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression || isTypeOfVitestFnCall(node.parent, context, ["test"])) assertsCount = 0;
+			if (node.parent?.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression || isTypeOfVitestFnCall(node.parent, context, ["test"])) assertsCount = 0;
 		};
 		return {
 			FunctionExpression: resetAssertCount,
@@ -2324,7 +2288,7 @@ var max_expects_default = createEslintRule({
 			"ArrowFunctionExpression:exit": resetAssertCount,
 			CallExpression(node) {
 				const vitestFnCall = parseVitestFnCall(node, context);
-				if (vitestFnCall?.type !== "expect" || vitestFnCall.head.node.parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return;
+				if (vitestFnCall?.type !== "expect" || vitestFnCall.head.node.parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return;
 				assertsCount += 1;
 				if (assertsCount > max) context.report({
 					node,
@@ -2355,9 +2319,9 @@ var max_nested_describe_default = createEslintRule({
 			properties: { max: { type: "number" } },
 			additionalProperties: false
 		}],
-		messages: { maxNestedDescribe: "Nested describe block should be less than set max value" }
+		messages: { maxNestedDescribe: "Nested describe block should be less than set max value" },
+		defaultOptions: [{ max: 5 }]
 	},
-	defaultOptions: [{ max: 5 }],
 	create(context, [{ max }]) {
 		const stack = [];
 		function pushStack(node) {
@@ -2399,7 +2363,6 @@ var no_alias_methods_default = createEslintRule({
 		fixable: "code",
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		const methodNames = {
 			toBeCalled: "toHaveBeenCalled",
@@ -2453,7 +2416,6 @@ var no_commented_out_tests_default = createEslintRule({
 		schema: [],
 		type: "suggestion"
 	},
-	defaultOptions: [],
 	create(context) {
 		const { sourceCode } = context;
 		function checkNodeForCommentedOutTests(node) {
@@ -2472,7 +2434,7 @@ var no_commented_out_tests_default = createEslintRule({
 //#endregion
 //#region src/rules/no-conditional-expect.ts
 const RULE_NAME$70 = "no-conditional-expect";
-const isCatchCall = (node) => node.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property, "catch");
+const isCatchCall = (node) => node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property, "catch");
 var no_conditional_expect_default = createEslintRule({
 	name: RULE_NAME$70,
 	meta: {
@@ -2490,9 +2452,9 @@ var no_conditional_expect_default = createEslintRule({
 				description: "Enable/disable whether expect.assertions() is taken into account",
 				type: "boolean"
 			} }
-		}]
+		}],
+		defaultOptions: [{ expectAssertions: false }]
 	},
-	defaultOptions: [{ expectAssertions: false }],
 	create(context, [options]) {
 		let conditionalDepth = 0;
 		let inTestCase = false;
@@ -2565,7 +2527,6 @@ var no_conditional_in_test_default = createEslintRule({
 		schema: [],
 		type: "problem"
 	},
-	defaultOptions: [],
 	create(context) {
 		return { IfStatement(node) {
 			if (node.parent?.parent?.parent?.type === "CallExpression" && isTypeOfVitestFnCall(node.parent?.parent?.parent, context, ["test", "it"])) context.report({
@@ -2590,7 +2551,6 @@ var no_conditional_tests_default = createEslintRule({
 		schema: [],
 		messages: { noConditionalTests: "Avoid using if conditions in a test" }
 	},
-	defaultOptions: [],
 	create(context) {
 		return { Identifier: function(node) {
 			if ([
@@ -2628,7 +2588,6 @@ var no_disabled_tests_default = createEslintRule({
 		},
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		let suiteDepth = 0;
 		let testDepth = 0;
@@ -2702,21 +2661,20 @@ var no_done_callback_default = createEslintRule({
 		},
 		hasSuggestions: true
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const isVitestEach = /\.each$|\.for$|\.concurrent$/.test(getNodeName(node.callee) ?? "");
-			if (isVitestEach && node.callee.type !== __typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression) return;
+			if (isVitestEach && node.callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression) return;
 			if (context.sourceCode.getAncestors(node).some((ancestor) => {
-				if (ancestor.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return false;
+				if (ancestor.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return false;
 				if (!isTypeOfVitestFnCall(ancestor, context, ["describe", "test"])) return false;
-				return ancestor.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(ancestor.callee.property, "concurrent");
+				return ancestor.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(ancestor.callee.property, "concurrent");
 			})) return;
 			const callback = findCallbackArg(node, isVitestEach, context);
 			const callbackArgIndex = Number(isVitestEach);
 			if (!callback || !isFunction(callback) || callback.params.length !== 1 + callbackArgIndex) return;
 			const argument = callback.params[callbackArgIndex];
-			if (argument.type !== __typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
+			if (argument.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
 				context.report({
 					node: argument,
 					messageId: "noDoneCallback"
@@ -2752,7 +2710,7 @@ var no_done_callback_default = createEslintRule({
 						let beforeReplacement = `new Promise(${argument.name} => `;
 						let afterReplacement = ")";
 						let replaceBefore = true;
-						if (body.type === __typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) {
+						if (body.type === _typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) {
 							beforeReplacement = `return ${beforeReplacement}{`;
 							afterReplacement += "}";
 							replaceBefore = false;
@@ -2784,7 +2742,6 @@ var no_duplicate_hooks_default = createEslintRule({
 		schema: [],
 		type: "suggestion"
 	},
-	defaultOptions: [],
 	create(context) {
 		const hooksContexts = [{}];
 		return {
@@ -2832,15 +2789,12 @@ var no_focused_tests_default = createEslintRule({
 		fixable: "code",
 		schema: [{
 			type: "object",
-			properties: { fixable: {
-				type: "boolean",
-				default: true
-			} },
+			properties: { fixable: { type: "boolean" } },
 			additionalProperties: false
 		}],
-		messages: { noFocusedTests: "Focused tests are not allowed" }
+		messages: { noFocusedTests: "Focused tests are not allowed" },
+		defaultOptions: [{ fixable: true }]
 	},
-	defaultOptions: [{ fixable: true }],
 	create: (context, options) => {
 		const fixable = options[0].fixable;
 		return {
@@ -2910,9 +2864,9 @@ var no_hooks_default = createEslintRule({
 			} },
 			additionalProperties: false
 		}],
-		messages: { unexpectedHook: "Unexpected '{{ hookName }}' hook" }
+		messages: { unexpectedHook: "Unexpected '{{ hookName }}' hook" },
+		defaultOptions: [{ allow: [] }]
 	},
-	defaultOptions: [{ allow: [] }],
 	create(context, [{ allow = [] }]) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
@@ -2947,7 +2901,6 @@ var no_identical_title_default = createEslintRule({
 			multipleDescribeTitle: "Describe is used multiple times in the same describe(suite) block"
 		}
 	},
-	defaultOptions: [],
 	create(context) {
 		const stack = [newDescribeContext()];
 		return {
@@ -2996,7 +2949,6 @@ var no_import_node_test_default = createEslintRule({
 		fixable: "code",
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return { ImportDeclaration(node) {
 			if (node.source.value === "node:test") context.report({
@@ -3036,21 +2988,21 @@ const isVitestImport = (node) => {
 	return node.source.value === "vitest";
 };
 const isVitestGlobalsImportSpecifier = (specifier) => {
-	return specifier.type === __typescript_eslint_utils.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier && VITEST_GLOBALS.has(specifier.imported.name);
+	return specifier.type === _typescript_eslint_utils.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && VITEST_GLOBALS.has(specifier.imported.name);
 };
 const isVitestGlobalsProperty = (prop) => {
-	return prop.type === __typescript_eslint_utils.AST_NODE_TYPES.Property && prop.key.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier && VITEST_GLOBALS.has(prop.key.name);
+	return prop.type === _typescript_eslint_utils.AST_NODE_TYPES.Property && prop.key.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && VITEST_GLOBALS.has(prop.key.name);
 };
 const isVitestGlobalsFunction = (node) => {
-	return node.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier && VITEST_GLOBALS.has(node.callee.name);
+	return node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && VITEST_GLOBALS.has(node.callee.name);
 };
 const isRequireVitestCall = (node) => {
-	if (node?.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression || node.callee.type !== __typescript_eslint_utils.AST_NODE_TYPES.Identifier || node.callee.name !== "require") return false;
+	if (node?.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression || node.callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier || node.callee.name !== "require") return false;
 	const args = node.arguments;
-	return args.length === 1 && args[0].type === __typescript_eslint_utils.AST_NODE_TYPES.Literal && args[0].value === "vitest";
+	return args.length === 1 && args[0].type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && args[0].value === "vitest";
 };
 const isObjectPattern = (node) => {
-	return node.type === __typescript_eslint_utils.AST_NODE_TYPES.ObjectPattern;
+	return node.type === _typescript_eslint_utils.AST_NODE_TYPES.ObjectPattern;
 };
 
 //#endregion
@@ -3098,7 +3050,6 @@ var no_importing_vitest_globals_default = createEslintRule({
 		fixable: "code",
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return {
 			ImportDeclaration(node) {
@@ -3153,13 +3104,12 @@ var no_interpolation_in_snapshots_default = createEslintRule({
 		schema: [],
 		messages: { noInterpolationInSnapshots: "Do not use string interpolation in snapshots" }
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
 			if (vitestFnCall?.type !== "expect") return;
 			if (["toMatchInlineSnapshot", "toThrowErrorMatchingInlineSnapshot"].includes(getAccessorValue(vitestFnCall.matcher))) vitestFnCall.args.forEach((argument) => {
-				if (argument.type === __typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral && argument.expressions.length > 0) context.report({
+				if (argument.type === _typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral && argument.expressions.length > 0) context.report({
 					messageId: "noInterpolationInSnapshots",
 					node: argument
 				});
@@ -3176,7 +3126,7 @@ const reportOnViolation = (context, node, { maxSize: lineLimit = 50, allowedSnap
 	const lineCount = node.loc.end.line - startLine;
 	if (!Object.keys(allowedSnapshots).every(node_path.isAbsolute)) throw new Error("All paths for allowedSnapshots must be absolute. You can use JS config and `path.resolve`");
 	let isAllowed = false;
-	if (node.type === __typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement && "left" in node.expression && node.expression.left.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.expression.left.property)) {
+	if (node.type === _typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement && "left" in node.expression && node.expression.left.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.expression.left.property)) {
 		const allowedSnapshotsInFile = allowedSnapshots[context.filename];
 		if (allowedSnapshotsInFile) {
 			const snapshotName = getAccessorValue(node.expression.left.property);
@@ -3218,9 +3168,9 @@ var no_large_snapshots_default = createEslintRule({
 				}
 			},
 			additionalProperties: false
-		}]
+		}],
+		defaultOptions: [{}]
 	},
-	defaultOptions: [{}],
 	create(context, [options]) {
 		if (context.filename.endsWith(".snap")) return { ExpressionStatement(node) {
 			reportOnViolation(context, node, options);
@@ -3253,7 +3203,6 @@ var no_mocks_import_default = createEslintRule({
 		messages: { noMocksImport: `Mocks should not be manually imported from a ${mocksDirName} directory. Instead use \`vi.mock\` and import from the original module path` },
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return {
 			ImportDeclaration(node) {
@@ -3292,18 +3241,17 @@ var no_restricted_matchers_default = createEslintRule({
 			type: "object",
 			additionalProperties: { type: ["string", "null"] }
 		}],
-		defaultOptions: [],
+		defaultOptions: [{}],
 		messages: {
 			restrictedChain: "use of {{ restriction }} is disallowed",
 			restrictedChainWithMessage: "{{ message }}"
 		}
 	},
-	defaultOptions: [{}],
 	create(context, [restrictedChains]) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
 			if (vitestFnCall?.type !== "expect") return;
-			const chain = vitestFnCall.members.map((node$1) => getAccessorValue(node$1)).join(".");
+			const chain = vitestFnCall.members.map((node) => getAccessorValue(node)).join(".");
 			for (const [restriction, message] of Object.entries(restrictedChains)) if (isChainRestricted(chain, restriction)) {
 				context.report({
 					messageId: message ? "restrictedChainWithMessage" : "restrictedChain",
@@ -3340,9 +3288,9 @@ var no_restricted_vi_methods_default = createEslintRule({
 		messages: {
 			restrictedViMethod: "Use of `{{ restriction }}` is disallowed",
 			restrictedViMethodWithMessage: "{{ message }}"
-		}
+		},
+		defaultOptions: [{}]
 	},
-	defaultOptions: [{}],
 	create(context, [restrictedMethods]) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
@@ -3372,11 +3320,11 @@ const RULE_NAME$54 = "no-standalone-expect";
 const getBlockType = (statement, context) => {
 	const func = statement.parent;
 	if (!func) throw new Error("Unexpected block statement. If you feel like this is a bug report https://github.com/veritem/eslint-plugin-vitest/issues/new");
-	if (func.type === __typescript_eslint_utils.AST_NODE_TYPES.FunctionDeclaration) return "function";
+	if (func.type === _typescript_eslint_utils.AST_NODE_TYPES.FunctionDeclaration) return "function";
 	if (isFunction(func) && func.parent) {
 		const expr = func.parent;
-		if (expr.type === __typescript_eslint_utils.AST_NODE_TYPES.VariableDeclarator) return "function";
-		if (expr.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression && isTypeOfVitestFnCall(expr, context, ["describe"])) return "describe";
+		if (expr.type === _typescript_eslint_utils.AST_NODE_TYPES.VariableDeclarator) return "function";
+		if (expr.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression && isTypeOfVitestFnCall(expr, context, ["describe"])) return "describe";
 	}
 	return null;
 };
@@ -3397,9 +3345,8 @@ var no_standalone_expect_default = createEslintRule({
 			} },
 			additionalProperties: false
 		}],
-		defaultOptions: []
+		defaultOptions: [{ additionalTestBlockFunctions: [] }]
 	},
-	defaultOptions: [{ additionalTestBlockFunctions: [] }],
 	create(context, [{ additionalTestBlockFunctions = [] }]) {
 		const callStack = [];
 		const isCustomTestBlockFunction = (node) => additionalTestBlockFunctions.includes(getNodeName(node) || "");
@@ -3407,7 +3354,7 @@ var no_standalone_expect_default = createEslintRule({
 			CallExpression(node) {
 				const vitestFnCall = parseVitestFnCall(node, context);
 				if (vitestFnCall?.type === "expect") {
-					if (vitestFnCall.head.node.parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && vitestFnCall.members.length === 1 && !["assertions", "hasAssertions"].includes(getAccessorValue(vitestFnCall.members[0]))) return;
+					if (vitestFnCall.head.node.parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && vitestFnCall.members.length === 1 && !["assertions", "hasAssertions"].includes(getAccessorValue(vitestFnCall.members[0]))) return;
 					const parent = callStack[callStack.length - 1];
 					if (!parent || parent === DescribeAlias.describe) context.report({
 						node,
@@ -3416,11 +3363,11 @@ var no_standalone_expect_default = createEslintRule({
 					return;
 				}
 				if (vitestFnCall?.type === "test" || isCustomTestBlockFunction(node)) callStack.push("test");
-				if (node.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression) callStack.push("template");
+				if (node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression) callStack.push("template");
 			},
 			"CallExpression:exit"(node) {
 				const top = callStack[callStack.length - 1];
-				if (top === "test" && (isTypeOfVitestFnCall(node, context, ["test"]) || isCustomTestBlockFunction(node)) && node.callee.type !== __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression || top === "template" && node.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression) callStack.pop();
+				if (top === "test" && (isTypeOfVitestFnCall(node, context, ["test"]) || isCustomTestBlockFunction(node)) && node.callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression || top === "template" && node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression) callStack.pop();
 			},
 			BlockStatement(statement) {
 				const blockType = getBlockType(statement, context);
@@ -3430,7 +3377,7 @@ var no_standalone_expect_default = createEslintRule({
 				if (getBlockType(statement, context)) callStack.pop();
 			},
 			ArrowFunctionExpression(node) {
-				if (node.parent?.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) callStack.push("arrow");
+				if (node.parent?.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) callStack.push("arrow");
 			},
 			"ArrowFunctionExpression:exit"() {
 				if (callStack[callStack.length - 1] === "arrow") callStack.pop();
@@ -3454,7 +3401,6 @@ var no_test_prefixes_default = createEslintRule({
 		fixable: "code",
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
@@ -3465,7 +3411,7 @@ var no_test_prefixes_default = createEslintRule({
 				vitestFnCall.name[0] === "f" ? "only" : "skip",
 				...vitestFnCall.members.map((m) => getAccessorValue(m))
 			].join(".");
-			const funcNode = node.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
+			const funcNode = node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression ? node.callee.tag : node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression ? node.callee.callee : node.callee;
 			context.report({
 				messageId: "usePreferredName",
 				node: node.callee,
@@ -3481,7 +3427,7 @@ var no_test_prefixes_default = createEslintRule({
 const RULE_NAME$52 = "no-test-return-statement";
 const getBody = (args) => {
 	const [, secondArg] = args;
-	if (secondArg && isFunction(secondArg) && secondArg.body.type === __typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) return secondArg.body.body;
+	if (secondArg && isFunction(secondArg) && secondArg.body.type === _typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) return secondArg.body.body;
 	return [];
 };
 var no_test_return_statement_default = createEslintRule({
@@ -3495,12 +3441,11 @@ var no_test_return_statement_default = createEslintRule({
 		schema: [],
 		messages: { noTestReturnStatement: "Return statements are not allowed in tests" }
 	},
-	defaultOptions: [],
 	create(context) {
 		return {
 			CallExpression(node) {
 				if (!isTypeOfVitestFnCall(node, context, ["test"])) return;
-				const returnStmt = getBody(node.arguments).find((stmt) => stmt.type === __typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement);
+				const returnStmt = getBody(node.arguments).find((stmt) => stmt.type === _typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement);
 				if (!returnStmt) return;
 				context.report({
 					messageId: "noTestReturnStatement",
@@ -3509,7 +3454,7 @@ var no_test_return_statement_default = createEslintRule({
 			},
 			FunctionDeclaration(node) {
 				if (getTestCallExpressionsFromDeclaredVariables(context.sourceCode.getDeclaredVariables(node), context).length === 0) return;
-				const returnStmt = node.body.body.find((stmt) => stmt.type === __typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement);
+				const returnStmt = node.body.body.find((stmt) => stmt.type === _typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement);
 				if (!returnStmt) return;
 				context.report({
 					messageId: "noTestReturnStatement",
@@ -3525,15 +3470,15 @@ var no_test_return_statement_default = createEslintRule({
 const eslintRequire = (0, node_module.createRequire)((0, node_module.createRequire)(require("url").pathToFileURL(__filename).href).resolve("eslint"));
 const espreeParser = eslintRequire.resolve("espree");
 const STATEMENT_LIST_PARENTS = new Set([
-	__typescript_eslint_utils.AST_NODE_TYPES.Program,
-	__typescript_eslint_utils.AST_NODE_TYPES.BlockStatement,
-	__typescript_eslint_utils.AST_NODE_TYPES.SwitchCase,
-	__typescript_eslint_utils.AST_NODE_TYPES.SwitchStatement
+	_typescript_eslint_utils.AST_NODE_TYPES.Program,
+	_typescript_eslint_utils.AST_NODE_TYPES.BlockStatement,
+	_typescript_eslint_utils.AST_NODE_TYPES.SwitchCase,
+	_typescript_eslint_utils.AST_NODE_TYPES.SwitchStatement
 ]);
 const isValidParent = (parentType) => {
 	return STATEMENT_LIST_PARENTS.has(parentType);
 };
-const isTokenASemicolon = (token) => token.value === ";" && token.type === __typescript_eslint_utils.AST_TOKEN_TYPES.Punctuator;
+const isTokenASemicolon = (token) => token.value === ";" && token.type === _typescript_eslint_utils.AST_TOKEN_TYPES.Punctuator;
 /**
 * Gets the actual last token.
 *
@@ -3561,33 +3506,33 @@ const getPaddingLineSequences = (prevNode, nextNode, sourceCode) => {
 	return pairs;
 };
 const areTokensOnSameLine = (left, right) => left.loc.end.line === right.loc.start.line;
-const isTypeCastExpression = (node) => node.type === __typescript_eslint_utils.AST_NODE_TYPES.TSAsExpression || node.type === __typescript_eslint_utils.AST_NODE_TYPES.TSTypeAssertion;
+const isTypeCastExpression = (node) => node.type === _typescript_eslint_utils.AST_NODE_TYPES.TSAsExpression || node.type === _typescript_eslint_utils.AST_NODE_TYPES.TSTypeAssertion;
 const followTypeAssertionChain = (expression) => isTypeCastExpression(expression) ? followTypeAssertionChain(expression.expression) : expression;
 
 //#endregion
 //#region src/utils/padding.ts
-let PaddingType = /* @__PURE__ */ function(PaddingType$1) {
-	PaddingType$1[PaddingType$1["Any"] = 0] = "Any";
-	PaddingType$1[PaddingType$1["Always"] = 1] = "Always";
-	return PaddingType$1;
+let PaddingType = /* @__PURE__ */ function(PaddingType) {
+	PaddingType[PaddingType["Any"] = 0] = "Any";
+	PaddingType[PaddingType["Always"] = 1] = "Always";
+	return PaddingType;
 }({});
-let StatementType = /* @__PURE__ */ function(StatementType$1) {
-	StatementType$1[StatementType$1["Any"] = 0] = "Any";
-	StatementType$1[StatementType$1["AfterAllToken"] = 1] = "AfterAllToken";
-	StatementType$1[StatementType$1["AfterEachToken"] = 2] = "AfterEachToken";
-	StatementType$1[StatementType$1["BeforeAllToken"] = 3] = "BeforeAllToken";
-	StatementType$1[StatementType$1["BeforeEachToken"] = 4] = "BeforeEachToken";
-	StatementType$1[StatementType$1["DescribeToken"] = 5] = "DescribeToken";
-	StatementType$1[StatementType$1["ExpectToken"] = 6] = "ExpectToken";
-	StatementType$1[StatementType$1["ExpectTypeOfToken"] = 7] = "ExpectTypeOfToken";
-	StatementType$1[StatementType$1["FdescribeToken"] = 8] = "FdescribeToken";
-	StatementType$1[StatementType$1["FitToken"] = 9] = "FitToken";
-	StatementType$1[StatementType$1["ItToken"] = 10] = "ItToken";
-	StatementType$1[StatementType$1["TestToken"] = 11] = "TestToken";
-	StatementType$1[StatementType$1["XdescribeToken"] = 12] = "XdescribeToken";
-	StatementType$1[StatementType$1["XitToken"] = 13] = "XitToken";
-	StatementType$1[StatementType$1["XtestToken"] = 14] = "XtestToken";
-	return StatementType$1;
+let StatementType = /* @__PURE__ */ function(StatementType) {
+	StatementType[StatementType["Any"] = 0] = "Any";
+	StatementType[StatementType["AfterAllToken"] = 1] = "AfterAllToken";
+	StatementType[StatementType["AfterEachToken"] = 2] = "AfterEachToken";
+	StatementType[StatementType["BeforeAllToken"] = 3] = "BeforeAllToken";
+	StatementType[StatementType["BeforeEachToken"] = 4] = "BeforeEachToken";
+	StatementType[StatementType["DescribeToken"] = 5] = "DescribeToken";
+	StatementType[StatementType["ExpectToken"] = 6] = "ExpectToken";
+	StatementType[StatementType["ExpectTypeOfToken"] = 7] = "ExpectTypeOfToken";
+	StatementType[StatementType["FdescribeToken"] = 8] = "FdescribeToken";
+	StatementType[StatementType["FitToken"] = 9] = "FitToken";
+	StatementType[StatementType["ItToken"] = 10] = "ItToken";
+	StatementType[StatementType["TestToken"] = 11] = "TestToken";
+	StatementType[StatementType["XdescribeToken"] = 12] = "XdescribeToken";
+	StatementType[StatementType["XitToken"] = 13] = "XitToken";
+	StatementType[StatementType["XtestToken"] = 14] = "XtestToken";
+	return StatementType;
 }({});
 const paddingAlwaysTester = (prevNode, nextNode, paddingContext) => {
 	const { sourceCode, ruleContext } = paddingContext;
@@ -3639,10 +3584,10 @@ const createScopeInfo = () => {
 const createTokenTester = (tokenName) => {
 	return (node, sourceCode) => {
 		let activeNode = node;
-		if (activeNode.type === __typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement) {
-			if (activeNode.expression.type === __typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression) activeNode = activeNode.expression.argument;
+		if (activeNode.type === _typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement) {
+			if (activeNode.expression.type === _typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression) activeNode = activeNode.expression.argument;
 			const token = sourceCode.getFirstToken(activeNode);
-			return token?.type === __typescript_eslint_utils.AST_TOKEN_TYPES.Identifier && token.value === tokenName;
+			return token?.type === _typescript_eslint_utils.AST_TOKEN_TYPES.Identifier && token.value === tokenName;
 		}
 		return false;
 	};
@@ -3670,7 +3615,7 @@ const statementTesters = {
 const nodeMatchesType = (node, statementType, paddingContext) => {
 	let innerStatementNode = node;
 	const { sourceCode } = paddingContext;
-	while (innerStatementNode.type === __typescript_eslint_utils.AST_NODE_TYPES.LabeledStatement) innerStatementNode = innerStatementNode.body;
+	while (innerStatementNode.type === _typescript_eslint_utils.AST_NODE_TYPES.LabeledStatement) innerStatementNode = innerStatementNode.body;
 	if (Array.isArray(statementType)) return statementType.some((type) => nodeMatchesType(innerStatementNode, type, paddingContext));
 	return statementTesters[statementType](innerStatementNode, sourceCode);
 };
@@ -3725,9 +3670,9 @@ const createPaddingRule = (name, description, configs, deprecated = false) => {
 			deprecated,
 			messages: { missingPadding: "expect blank line before this statement" },
 			schema: [],
-			type: "suggestion"
+			type: "suggestion",
+			defaultOptions: []
 		},
-		defaultOptions: [],
 		create(context) {
 			const paddingContext = {
 				ruleContext: context,
@@ -3757,7 +3702,7 @@ const createPaddingRule = (name, description, configs, deprecated = false) => {
 //#endregion
 //#region src/rules/padding-around-after-all-blocks.ts
 const RULE_NAME$51 = "padding-around-after-all-blocks";
-const config = [{
+const config$6 = [{
 	paddingType: PaddingType.Always,
 	prevStatementType: StatementType.Any,
 	nextStatementType: StatementType.AfterAllToken
@@ -3766,12 +3711,12 @@ const config = [{
 	prevStatementType: StatementType.AfterAllToken,
 	nextStatementType: StatementType.Any
 }];
-var padding_around_after_all_blocks_default = createPaddingRule(RULE_NAME$51, "Enforce padding around `afterAll` blocks", config);
+var padding_around_after_all_blocks_default = createPaddingRule(RULE_NAME$51, "Enforce padding around `afterAll` blocks", config$6);
 
 //#endregion
 //#region src/rules/padding-around-after-each-blocks.ts
 const RULE_NAME$50 = "padding-around-after-each-blocks";
-const config$1 = [{
+const config$5 = [{
 	paddingType: PaddingType.Always,
 	prevStatementType: StatementType.Any,
 	nextStatementType: StatementType.AfterEachToken
@@ -3780,12 +3725,12 @@ const config$1 = [{
 	prevStatementType: StatementType.AfterEachToken,
 	nextStatementType: StatementType.Any
 }];
-var padding_around_after_each_blocks_default = createPaddingRule(RULE_NAME$50, "Enforce padding around `afterEach` blocks", config$1);
+var padding_around_after_each_blocks_default = createPaddingRule(RULE_NAME$50, "Enforce padding around `afterEach` blocks", config$5);
 
 //#endregion
 //#region src/rules/padding-around-before-all-blocks.ts
 const RULE_NAME$49 = "padding-around-before-all-blocks";
-const config$2 = [{
+const config$4 = [{
 	paddingType: PaddingType.Always,
 	prevStatementType: StatementType.Any,
 	nextStatementType: StatementType.BeforeAllToken
@@ -3794,7 +3739,7 @@ const config$2 = [{
 	prevStatementType: StatementType.BeforeAllToken,
 	nextStatementType: StatementType.Any
 }];
-var padding_around_before_all_blocks_default = createPaddingRule(RULE_NAME$49, "Enforce padding around `beforeAll` blocks", config$2);
+var padding_around_before_all_blocks_default = createPaddingRule(RULE_NAME$49, "Enforce padding around `beforeAll` blocks", config$4);
 
 //#endregion
 //#region src/rules/padding-around-before-each-blocks.ts
@@ -3813,7 +3758,7 @@ var padding_around_before_each_blocks_default = createPaddingRule(RULE_NAME$48,
 //#endregion
 //#region src/rules/padding-around-describe-blocks.ts
 const RULE_NAME$47 = "padding-around-describe-blocks";
-const config$4 = [{
+const config$2 = [{
 	paddingType: PaddingType.Always,
 	prevStatementType: StatementType.Any,
 	nextStatementType: [
@@ -3830,12 +3775,12 @@ const config$4 = [{
 	],
 	nextStatementType: StatementType.Any
 }];
-var padding_around_describe_blocks_default = createPaddingRule(RULE_NAME$47, "Enforce padding around `describe` blocks", config$4);
+var padding_around_describe_blocks_default = createPaddingRule(RULE_NAME$47, "Enforce padding around `describe` blocks", config$2);
 
 //#endregion
 //#region src/rules/padding-around-expect-groups.ts
 const RULE_NAME$46 = "padding-around-expect-groups";
-const config$5 = [
+const config$1 = [
 	{
 		paddingType: PaddingType.Always,
 		prevStatementType: StatementType.Any,
@@ -3867,12 +3812,12 @@ const config$5 = [
 		nextStatementType: StatementType.ExpectTypeOfToken
 	}
 ];
-var padding_around_expect_groups_default = createPaddingRule(RULE_NAME$46, "Enforce padding around `expect` groups", config$5);
+var padding_around_expect_groups_default = createPaddingRule(RULE_NAME$46, "Enforce padding around `expect` groups", config$1);
 
 //#endregion
 //#region src/rules/padding-around-test-blocks.ts
 const RULE_NAME$45 = "padding-around-test-blocks";
-const config$6 = [{
+const config = [{
 	paddingType: PaddingType.Always,
 	prevStatementType: StatementType.Any,
 	nextStatementType: [
@@ -3893,19 +3838,19 @@ const config$6 = [{
 	],
 	nextStatementType: StatementType.Any
 }];
-var padding_around_test_blocks_default = createPaddingRule(RULE_NAME$45, "Enforce padding around `test` blocks", config$6);
+var padding_around_test_blocks_default = createPaddingRule(RULE_NAME$45, "Enforce padding around `test` blocks", config);
 
 //#endregion
 //#region src/rules/padding-around-all.ts
 const RULE_NAME$44 = "padding-around-all";
 var padding_around_all_default = createPaddingRule(RULE_NAME$44, "Enforce padding around vitest functions", [
-	...config,
-	...config$1,
-	...config$2,
-	...config$3,
-	...config$4,
+	...config$6,
 	...config$5,
-	...config$6
+	...config$4,
+	...config$3,
+	...config$2,
+	...config$1,
+	...config
 ]);
 
 //#endregion
@@ -3919,7 +3864,7 @@ const MOCK_CALL_RESET_METHODS = [
 ];
 const hasMatchersToCombine = (target) => MATCHERS_TO_COMBINE.some((matcher) => matcher === target);
 const getExpectText = (callee, source) => {
-	if (callee.type !== __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return null;
+	if (callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return null;
 	return source.getText(callee.object);
 };
 const getArgumentsText = (callExpression, source) => callExpression.arguments.map((arg) => source.getText(arg)).join(", ");
@@ -3933,11 +3878,11 @@ const getMatcherName = (vitestFnCall) => {
 	return validExpectCall ? getAccessorValue(validExpectCall.matcher) : null;
 };
 const getExpectArgText = ({ callee }) => {
-	if (callee.type !== __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return null;
+	if (callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return null;
 	const { object } = callee;
-	if (object.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return null;
+	if (object.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return null;
 	const [firstArgument] = object.arguments;
-	if (firstArgument.type !== __typescript_eslint_utils.AST_NODE_TYPES.Identifier) return null;
+	if (firstArgument.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return null;
 	return firstArgument.name;
 };
 const getSharedExpectArgText = (firstCallExpression, secondCallExpression) => {
@@ -3947,16 +3892,16 @@ const getSharedExpectArgText = (firstCallExpression, secondCallExpression) => {
 	return firstArgText;
 };
 const isTargetMockResetCall = (statement, expectArgText, minLine, maxLine) => {
-	if (statement.type !== __typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement) return false;
-	if (statement.expression.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return false;
+	if (statement.type !== _typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement) return false;
+	if (statement.expression.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return false;
 	const statementLine = statement.loc.start.line;
 	if (statementLine <= minLine || statementLine >= maxLine) return false;
 	const { callee } = statement.expression;
-	if (callee.type !== __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return false;
+	if (callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return false;
 	const { object, property } = callee;
-	if (object.type !== __typescript_eslint_utils.AST_NODE_TYPES.Identifier) return false;
+	if (object.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return false;
 	if (object.name !== expectArgText) return false;
-	if (property.type !== __typescript_eslint_utils.AST_NODE_TYPES.Identifier) return false;
+	if (property.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return false;
 	return MOCK_CALL_RESET_METHODS.some((method) => method === property.name);
 };
 const hasMockResetBetween = (body, firstCallExpression, secondCallExpression) => {
@@ -3967,7 +3912,7 @@ const hasMockResetBetween = (body, firstCallExpression, secondCallExpression) =>
 	if (!expectArgText) return false;
 	return body.some((statement) => isTargetMockResetCall(statement, expectArgText, minLine, maxLine));
 };
-const getMemberProperty = (expression) => expression.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression ? expression.callee.property : null;
+const getMemberProperty = (expression) => expression.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression ? expression.callee.property : null;
 var prefer_called_exactly_once_with_default = createEslintRule({
 	name: RULE_NAME$43,
 	meta: {
@@ -3977,10 +3922,9 @@ var prefer_called_exactly_once_with_default = createEslintRule({
 		fixable: "code",
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		const { sourceCode } = context;
-		const getCallExpressions = (body) => body.filter((node) => node.type === __typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement).flatMap((node) => node.expression.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression ? node.expression : []);
+		const getCallExpressions = (body) => body.filter((node) => node.type === _typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement).flatMap((node) => node.expression.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression ? node.expression : []);
 		const checkBlockBody = (body) => {
 			const callExpressions = getCallExpressions(body);
 			const expectMatcherMap = /* @__PURE__ */ new Map();
@@ -4038,7 +3982,7 @@ var prefer_called_exactly_once_with_default = createEslintRule({
 //#endregion
 //#region src/rules/prefer-called-once.ts
 const RULE_NAME$42 = "prefer-called-once";
-const isOneLiteral = (node) => node.type === __typescript_eslint_utils.AST_NODE_TYPES.Literal && node.value === 1;
+const isOneLiteral = (node) => node.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && node.value === 1;
 var prefer_called_once_default = createEslintRule({
 	name: RULE_NAME$42,
 	meta: {
@@ -4051,7 +3995,6 @@ var prefer_called_once_default = createEslintRule({
 		fixable: "code",
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
@@ -4086,7 +4029,6 @@ var prefer_called_times_default = createEslintRule({
 		fixable: "code",
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
@@ -4121,12 +4063,11 @@ var prefer_called_with_default = createEslintRule({
 		fixable: "code",
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
 			if (vitestFnCall?.type !== "expect") return;
-			if (vitestFnCall.modifiers.some((node$1) => getAccessorValue(node$1) === "not")) return;
+			if (vitestFnCall.modifiers.some((node) => getAccessorValue(node) === "not")) return;
 			const { matcher } = vitestFnCall;
 			const matcherName = getAccessorValue(matcher);
 			if (["toBeCalled", "toHaveBeenCalled"].includes(matcherName)) context.report({
@@ -4141,7 +4082,7 @@ var prefer_called_with_default = createEslintRule({
 
 //#endregion
 //#region src/utils/msc.ts
-const isBooleanLiteral = (node) => node.type === __typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof node.value === "boolean";
+const isBooleanLiteral = (node) => node.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof node.value === "boolean";
 /**
 * Checks if the given `ParsedExpectMatcher` is either a call to one of the equality matchers,
 * with a boolean` literal as the sole argument, *or* is a call to `toBeTruthy` or `toBeFalsy`.
@@ -4153,14 +4094,14 @@ const isBooleanEqualityMatcher = (expectFnCall) => {
 	const arg = getFirstMatcherArg(expectFnCall);
 	return Object.prototype.hasOwnProperty.call(EqualityMatcher, matcherName) && isBooleanLiteral(arg);
 };
-const isInstanceOfBinaryExpression = (node, className) => node.type === __typescript_eslint_utils.AST_NODE_TYPES.BinaryExpression && node.operator === "instanceof" && isSupportedAccessor(node.right, className);
+const isInstanceOfBinaryExpression = (node, className) => node.type === _typescript_eslint_utils.AST_NODE_TYPES.BinaryExpression && node.operator === "instanceof" && isSupportedAccessor(node.right, className);
 const hasOnlyOneArgument = (call) => call.arguments.length === 1;
 
 //#endregion
 //#region src/rules/prefer-comparison-matcher.ts
 const RULE_NAME$39 = "prefer-comparison-matcher";
 const isString = (node) => {
-	return isStringNode(node) || node?.type === __typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral;
+	return isStringNode(node) || node?.type === _typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral;
 };
 const isComparingToString = (expression) => {
 	return isString(expression.left) || isString(expression.right);
@@ -4195,17 +4136,16 @@ var prefer_comparison_matcher_default = createEslintRule({
 		fixable: "code",
 		messages: { useToBeComparison: "Prefer using `{{ preferredMatcher }}` instead" }
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
 			if (vitestFnCall?.type !== "expect" || vitestFnCall.args.length === 0) return;
 			const { parent: expect } = vitestFnCall.head.node;
-			if (expect?.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
+			if (expect?.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
 			const { arguments: [comparison], range: [, expectCallEnd] } = expect;
 			const { matcher } = vitestFnCall;
 			const matcherArg = getFirstMatcherArg(vitestFnCall);
-			if (comparison?.type !== __typescript_eslint_utils.AST_NODE_TYPES.BinaryExpression || isComparingToString(comparison) || !Object.prototype.hasOwnProperty.call(EqualityMatcher, getAccessorValue(matcher)) || !isBooleanLiteral(matcherArg)) return;
+			if (comparison?.type !== _typescript_eslint_utils.AST_NODE_TYPES.BinaryExpression || isComparingToString(comparison) || !Object.prototype.hasOwnProperty.call(EqualityMatcher, getAccessorValue(matcher)) || !isBooleanLiteral(matcherArg)) return;
 			const [modifier] = vitestFnCall.modifiers;
 			const hasNot = vitestFnCall.modifiers.some((nod) => getAccessorValue(nod) === "not");
 			const preferredMatcher = determineMatcher(comparison.operator, matcherArg.value === hasNot);
@@ -4243,15 +4183,14 @@ var prefer_describe_function_title_default = createEslintRule({
 		schema: [],
 		messages: { preferFunction: "Enforce using a function over an equivalent string" }
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			if (node.arguments.length < 2) return;
 			const scope = getModuleScope(context, node);
 			const [argument] = node.arguments;
-			if (argument.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && argument.object.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier && argument.property.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
+			if (argument.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && argument.object.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && argument.property.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
 				const identifierName = argument.object.name;
-				if ((scope?.set.get(identifierName)?.defs[0])?.type !== __typescript_eslint_scope_manager.DefinitionType.ImportBinding || argument.property.name !== "name") return;
+				if ((scope?.set.get(identifierName)?.defs[0])?.type !== _typescript_eslint_scope_manager.DefinitionType.ImportBinding || argument.property.name !== "name") return;
 				context.report({
 					node: argument,
 					messageId: "preferFunction",
@@ -4261,13 +4200,13 @@ var prefer_describe_function_title_default = createEslintRule({
 				});
 				return;
 			}
-			if (argument.type !== __typescript_eslint_utils.AST_NODE_TYPES.Literal || typeof argument.value !== "string") return;
+			if (argument.type !== _typescript_eslint_utils.AST_NODE_TYPES.Literal || typeof argument.value !== "string") return;
 			const describedTitle = argument.value;
 			if (parseVitestFnCall(node, context)?.type !== "describe") return;
 			const scopedFunction = scope?.set.get(describedTitle)?.defs[0];
-			if (scopedFunction?.type !== __typescript_eslint_scope_manager.DefinitionType.ImportBinding) return;
+			if (scopedFunction?.type !== _typescript_eslint_scope_manager.DefinitionType.ImportBinding) return;
 			if (parsePluginSettings(context.settings).typecheck) {
-				if (!isClassOrFunctionType(__typescript_eslint_utils.ESLintUtils.getParserServices(context).getTypeAtLocation(scopedFunction.node))) return;
+				if (!isClassOrFunctionType(_typescript_eslint_utils.ESLintUtils.getParserServices(context).getTypeAtLocation(scopedFunction.node))) return;
 			}
 			context.report({
 				node: argument,
@@ -4294,7 +4233,6 @@ var prefer_each_default = createEslintRule({
 		schema: [],
 		messages: { preferEach: "Prefer using `{{ fn }}.each` rather than a manual loop" }
 	},
-	defaultOptions: [],
 	create(context) {
 		const vitestFnCalls = [];
 		let inTestCaseCall = false;
@@ -4353,22 +4291,21 @@ var prefer_equality_matcher_default = createEslintRule({
 		hasSuggestions: true,
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
 			if (vitestFnCall?.type !== "expect" || vitestFnCall.args.length === 0) return;
 			const { parent: expect } = vitestFnCall.head.node;
-			if (expect?.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
+			if (expect?.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
 			const { arguments: [comparison], range: [, expectCallEnd] } = expect;
 			const { matcher } = vitestFnCall;
 			const matcherArg = getFirstMatcherArg(vitestFnCall);
-			if (comparison?.type !== __typescript_eslint_utils.AST_NODE_TYPES.BinaryExpression || comparison.operator !== "===" && comparison.operator !== "!==" || !Object.prototype.hasOwnProperty.call(EqualityMatcher, getAccessorValue(matcher)) || !isBooleanLiteral(matcherArg)) return;
+			if (comparison?.type !== _typescript_eslint_utils.AST_NODE_TYPES.BinaryExpression || comparison.operator !== "===" && comparison.operator !== "!==" || !Object.prototype.hasOwnProperty.call(EqualityMatcher, getAccessorValue(matcher)) || !isBooleanLiteral(matcherArg)) return;
 			const matcherValue = matcherArg.value;
 			const [modifier] = vitestFnCall.modifiers;
 			const hasNot = vitestFnCall.modifiers.some((nod) => getAccessorValue(nod) === "not");
 			const addNotModifier = (comparison.operator === "!==" ? !matcherValue : matcherValue) === hasNot;
-			const buildFixer$1 = (equalityMatcher) => (fixer) => {
+			const buildFixer = (equalityMatcher) => (fixer) => {
 				const { sourceCode } = context;
 				let modifierText = modifier && getAccessorValue(modifier) !== "not" ? `.${getAccessorValue(modifier)}` : "";
 				if (addNotModifier) modifierText += `.${ModifierName.not}`;
@@ -4387,7 +4324,7 @@ var prefer_equality_matcher_default = createEslintRule({
 				].map((equalityMatcher) => ({
 					messageId: "suggestEqualityMatcher",
 					data: { equalityMatcher },
-					fix: buildFixer$1(equalityMatcher)
+					fix: buildFixer(equalityMatcher)
 				})),
 				node: matcher
 			});
@@ -4401,8 +4338,8 @@ const RULE_NAME$35 = "prefer-expect-assertions";
 const isFirstStatement = (node) => {
 	let parent = node;
 	while (parent) {
-		if (parent.parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) return parent.parent.body[0] === parent;
-		if (parent.parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.ArrowFunctionExpression) return true;
+		if (parent.parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) return parent.parent.body[0] === parent;
+		if (parent.parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.ArrowFunctionExpression) return true;
 		parent = parent.parent;
 	}
 	throw new Error("Could not find parent block statement");
@@ -4438,13 +4375,12 @@ var prefer_expect_assertions_default = createEslintRule({
 			},
 			additionalProperties: false
 		}],
-		defaultOptions: []
+		defaultOptions: [{
+			onlyFunctionsWithAsyncKeyword: false,
+			onlyFunctionsWithExpectInCallback: false,
+			onlyFunctionsWithExpectInLoop: false
+		}]
 	},
-	defaultOptions: [{
-		onlyFunctionsWithAsyncKeyword: false,
-		onlyFunctionsWithExpectInCallback: false,
-		onlyFunctionsWithExpectInLoop: false
-	}],
 	create(context, [options]) {
 		let expressionDepth = 0;
 		let hasExpectInCallBack = false;
@@ -4490,7 +4426,7 @@ var prefer_expect_assertions_default = createEslintRule({
 				return;
 			}
 			const [arg] = expectFnCall.args;
-			if (arg.type === __typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof arg.value === "number" && Number.isInteger(arg.value)) return;
+			if (arg.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof arg.value === "number" && Number.isInteger(arg.value)) return;
 			context.report({
 				messageId: "assertionsRequiresNumberArgument",
 				node: arg
@@ -4517,9 +4453,9 @@ var prefer_expect_assertions_default = createEslintRule({
 					inTestCaseCall = true;
 					return;
 				}
-				if (vitestFnCall?.head.type === "testContext" && vitestFnCall.members[0] && vitestFnCall.members[0].type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier && vitestFnCall.members[0].name === "expect") testContextName = `${vitestFnCall.head.local}`;
+				if (vitestFnCall?.head.type === "testContext" && vitestFnCall.members[0] && vitestFnCall.members[0].type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && vitestFnCall.members[0].name === "expect") testContextName = `${vitestFnCall.head.local}`;
 				if (vitestFnCall?.type === "expect" && inTestCaseCall) {
-					if (expressionDepth === 1 && isFirstStatement(node) && vitestFnCall.head.node.parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && vitestFnCall.members.length === 1 && ["assertions", "hasAssertions"].includes(getAccessorValue(vitestFnCall.members[0]))) {
+					if (expressionDepth === 1 && isFirstStatement(node) && vitestFnCall.head.node.parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && vitestFnCall.members.length === 1 && ["assertions", "hasAssertions"].includes(getAccessorValue(vitestFnCall.members[0]))) {
 						checkExpectHasAssertions(vitestFnCall, node);
 						hasExpectAssertAsFirstStatement = true;
 					}
@@ -4540,7 +4476,7 @@ var prefer_expect_assertions_default = createEslintRule({
 					return;
 				}
 				const suggestions = [];
-				if (secondArg.body.type === __typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) {
+				if (secondArg.body.type === _typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) {
 					const prefix = testContextName ? `${testContextName}.` : "";
 					suggestions.push(["suggestAddingHasAssertions", `${prefix}expect.hasAssertions();`], ["suggestAddingAssertions", `${prefix}expect.assertions();`]);
 				}
@@ -4572,14 +4508,13 @@ var prefer_expect_resolves_default = createEslintRule({
 		messages: { expectResolves: "Use `expect().resolves` instead" },
 		schema: []
 	},
-	defaultOptions: [],
 	create: (context) => ({ CallExpression(node) {
 		const vitestFnCall = parseVitestFnCall(node, context);
 		if (vitestFnCall?.type !== "expect") return;
 		const { parent } = vitestFnCall.head.node;
-		if (parent?.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
+		if (parent?.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
 		const [awaitNode] = parent.arguments;
-		if (awaitNode?.type === __typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression) context.report({
+		if (awaitNode?.type === _typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression) context.report({
 			node: awaitNode,
 			messageId: "expectResolves",
 			fix(fixer) {
@@ -4618,19 +4553,18 @@ var prefer_expect_type_of_default = createEslintRule({
 		fixable: "code",
 		messages: { preferExpectTypeOf: "Use `expectTypeOf({{ value }}).{{ matcher }}()` instead of `expect(typeof {{ value }}).toBe(\"{{ type }}\")`" }
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
 			if (vitestFnCall?.type !== "expect") return;
-			if (vitestFnCall.head.node.parent?.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
+			if (vitestFnCall.head.node.parent?.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
 			const [firstArg] = vitestFnCall.head.node.parent.arguments;
-			if (!firstArg || firstArg.type !== __typescript_eslint_utils.AST_NODE_TYPES.UnaryExpression) return;
+			if (!firstArg || firstArg.type !== _typescript_eslint_utils.AST_NODE_TYPES.UnaryExpression) return;
 			if (firstArg.operator !== "typeof") return;
 			const matcherName = getAccessorValue(vitestFnCall.matcher);
 			if (matcherName !== "toBe" && matcherName !== "toEqual") return;
 			const [matcherArg] = vitestFnCall.args;
-			if (!matcherArg || matcherArg.type !== __typescript_eslint_utils.AST_NODE_TYPES.Literal) return;
+			if (!matcherArg || matcherArg.type !== _typescript_eslint_utils.AST_NODE_TYPES.Literal) return;
 			if (typeof matcherArg.value !== "string") return;
 			const typeString = matcherArg.value;
 			const expectTypeOfMatcher = typeMatchers[typeString];
@@ -4674,7 +4608,6 @@ var prefer_hooks_in_order_default = createEslintRule({
 		messages: { reorderHooks: "`{{ currentHook }}` hooks should be before any `{{ previousHook }}` hooks" },
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		let previousHookIndex = -1;
 		let inHook = false;
@@ -4729,7 +4662,6 @@ var prefer_hooks_on_top_default = createEslintRule({
 		messages: { noHookOnTop: "Hooks should come before test cases" },
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		const hooksContext = [false];
 		return {
@@ -4762,23 +4694,20 @@ var prefer_import_in_mock_default = createEslintRule({
 		messages: { preferImport: "Replace '{{path}}' with import('{{path}}')" },
 		schema: [{
 			type: "object",
-			properties: { fixable: {
-				type: "boolean",
-				default: true
-			} },
+			properties: { fixable: { type: "boolean" } },
 			additionalProperties: false
-		}]
+		}],
+		defaultOptions: [{ fixable: true }]
 	},
-	defaultOptions: [{ fixable: true }],
 	create(context, options) {
 		const fixable = options[0].fixable;
 		return { CallExpression(node) {
-			if (node.callee.type !== __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return;
+			if (node.callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return;
 			if (parseVitestFnCall(node, context)?.type !== "vi") return false;
 			const { property } = node.callee;
-			if (property.type != __typescript_eslint_utils.AST_NODE_TYPES.Identifier || property.name != "mock") return;
+			if (property.type != _typescript_eslint_utils.AST_NODE_TYPES.Identifier || property.name != "mock") return;
 			const pathArg = node.arguments[0];
-			if (pathArg && pathArg.type === __typescript_eslint_utils.AST_NODE_TYPES.Literal) context.report({
+			if (pathArg && pathArg.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal) context.report({
 				messageId: "preferImport",
 				data: { path: pathArg.value },
 				node,
@@ -4806,7 +4735,6 @@ var prefer_importing_vitest_globals_default = createEslintRule({
 		schema: [],
 		fixable: "code"
 	},
-	defaultOptions: [],
 	create(context) {
 		const importedNames = /* @__PURE__ */ new Set();
 		let vitestImportSpecifiers;
@@ -4909,24 +4837,18 @@ var prefer_lowercase_title_default = createEslintRule({
 					items: { type: "string" },
 					additionalItems: false
 				},
-				ignoreTopLevelDescribe: {
-					type: "boolean",
-					default: false
-				},
-				lowercaseFirstCharacterOnly: {
-					type: "boolean",
-					default: true
-				}
+				ignoreTopLevelDescribe: { type: "boolean" },
+				lowercaseFirstCharacterOnly: { type: "boolean" }
 			},
 			additionalProperties: false
+		}],
+		defaultOptions: [{
+			ignore: [],
+			allowedPrefixes: [],
+			ignoreTopLevelDescribe: false,
+			lowercaseFirstCharacterOnly: true
 		}]
 	},
-	defaultOptions: [{
-		ignore: [],
-		allowedPrefixes: [],
-		ignoreTopLevelDescribe: false,
-		lowercaseFirstCharacterOnly: true
-	}],
 	create: (context, [{ ignore = [], allowedPrefixes = [], ignoreTopLevelDescribe = false, lowercaseFirstCharacterOnly = false }]) => {
 		const ignores = populateIgnores(ignore);
 		let numberOfDescribeBlocks = 0;
@@ -4949,9 +4871,9 @@ var prefer_lowercase_title_default = createEslintRule({
 					node: node.arguments[0],
 					data: { method: vitestFnCall.name },
 					fix: (fixer) => {
-						const description$1 = getStringValue(firstArgument);
+						const description = getStringValue(firstArgument);
 						const rangeIgnoreQuotes = [firstArgument.range[0] + 1, firstArgument.range[1] - 1];
-						const newDescription = lowercaseFirstCharacterOnly ? description$1.substring(0, 1).toLowerCase() + description$1.substring(1) : description$1.toLowerCase();
+						const newDescription = lowercaseFirstCharacterOnly ? description.substring(0, 1).toLowerCase() + description.substring(1) : description.toLowerCase();
 						return [fixer.replaceTextRange(rangeIgnoreQuotes, newDescription)];
 					}
 				});
@@ -4970,8 +4892,8 @@ const withOnce$1 = (name, addOnce) => {
 	return `${name}${addOnce ? "Once" : ""}`;
 };
 const findSingleReturnArgumentNode$1 = (fnNode) => {
-	if (fnNode.body.type !== __typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) return fnNode.body;
-	if (fnNode.body.body[0]?.type === __typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement) return fnNode.body.body[0].argument;
+	if (fnNode.body.type !== _typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) return fnNode.body;
+	if (fnNode.body.body[0]?.type === _typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement) return fnNode.body.body[0].argument;
 	return null;
 };
 var prefer_mock_promise_shorthand_default = createEslintRule({
@@ -4986,10 +4908,9 @@ var prefer_mock_promise_shorthand_default = createEslintRule({
 		schema: [],
 		fixable: "code"
 	},
-	defaultOptions: [],
 	create(context) {
 		const report = (property, isOnce, outerArgNode, innerArgNode = outerArgNode) => {
-			if (innerArgNode?.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
+			if (innerArgNode?.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
 			const argName = getNodeName(innerArgNode);
 			if (argName !== "Promise.resolve" && argName !== "Promise.reject") return;
 			const replacement = withOnce$1(argName.endsWith("reject") ? "mockRejectedValue" : "mockResolvedValue", isOnce);
@@ -5005,7 +4926,7 @@ var prefer_mock_promise_shorthand_default = createEslintRule({
 			});
 		};
 		return { CallExpression(node) {
-			if (node.callee.type !== __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression || !isSupportedAccessor(node.callee.property) || node.arguments.length === 0) return;
+			if (node.callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression || !isSupportedAccessor(node.callee.property) || node.arguments.length === 0) return;
 			const mockFnName = getAccessorValue(node.callee.property);
 			const isOnce = mockFnName.endsWith("Once");
 			if (mockFnName === withOnce$1("mockReturnValue", isOnce)) report(node.callee.property, isOnce, node.arguments[0]);
@@ -5025,8 +4946,8 @@ const withOnce = (name, addOnce) => {
 	return `${name}${addOnce ? "Once" : ""}`;
 };
 const findSingleReturnArgumentNode = (fnNode) => {
-	if (fnNode.body.type !== __typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) return fnNode.body;
-	if (fnNode.body.body[0]?.type === __typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement) return fnNode.body.body[0].argument;
+	if (fnNode.body.type !== _typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) return fnNode.body;
+	if (fnNode.body.body[0]?.type === _typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement) return fnNode.body.body[0].argument;
 	return null;
 };
 var prefer_mock_return_shorthand_default = createEslintRule({
@@ -5041,10 +4962,9 @@ var prefer_mock_return_shorthand_default = createEslintRule({
 		type: "suggestion",
 		fixable: "code"
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
-			if (node.callee.type !== __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression || !isSupportedAccessor(node.callee.property) || node.arguments.length === 0) return;
+			if (node.callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression || !isSupportedAccessor(node.callee.property) || node.arguments.length === 0) return;
 			const { property } = node.callee;
 			const mockFnName = getAccessorValue(property);
 			const isOnce = mockFnName.endsWith("Once");
@@ -5053,8 +4973,8 @@ var prefer_mock_return_shorthand_default = createEslintRule({
 			if (!isFunction(arg) || arg.params.length !== 0 || arg.async) return;
 			const replacement = withOnce("mockReturnValue", isOnce);
 			const returnNode = findSingleReturnArgumentNode(arg);
-			if (!returnNode || returnNode.type === __typescript_eslint_utils.AST_NODE_TYPES.UpdateExpression) return;
-			if (returnNode.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
+			if (!returnNode || returnNode.type === _typescript_eslint_utils.AST_NODE_TYPES.UpdateExpression) return;
+			if (returnNode.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
 				if (context.sourceCode.getScope(returnNode).through.some((v) => v.resolved?.defs.some((n) => n.type === "Variable" && n.parent.kind !== "const"))) return;
 			}
 			context.report({
@@ -5093,9 +5013,8 @@ var prefer_snapshot_hint_default = createEslintRule({
 			type: "string",
 			enum: ["always", "multi"]
 		}],
-		defaultOptions: []
+		defaultOptions: ["multi"]
 	},
-	defaultOptions: ["multi"],
 	create(context, [mode]) {
 		const snapshotMatchers = [];
 		let expressionDepth = 0;
@@ -5154,18 +5073,18 @@ var prefer_snapshot_hint_default = createEslintRule({
 const RULE_NAME$24 = "prefer-spy-on";
 const findNodeObject = (node) => {
 	if ("object" in node) return node.object;
-	if (node.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return node.callee.object;
+	if (node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return node.callee.object;
 	return null;
 };
 const getVitestFnCall = (node) => {
-	if (node.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression && node.type !== __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return null;
+	if (node.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression && node.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return null;
 	const obj = findNodeObject(node);
 	if (!obj) return null;
-	if (obj.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier) return node.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression && getNodeName(node.callee) === "vi.fn" ? node : null;
+	if (obj.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return node.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression && getNodeName(node.callee) === "vi.fn" ? node : null;
 	return getVitestFnCall(obj);
 };
 const getAutoFixMockImplementation = (vitestFnCall, context) => {
-	if (vitestFnCall.parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && vitestFnCall.parent.property.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier && vitestFnCall.parent.property.name === "mockImplementation") return "";
+	if (vitestFnCall.parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && vitestFnCall.parent.property.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && vitestFnCall.parent.property.name === "mockImplementation") return "";
 	const [arg] = vitestFnCall.arguments;
 	const argSource = arg && context.sourceCode.getText(arg);
 	return argSource ? `.mockImplementation(${argSource})` : ".mockImplementation()";
@@ -5182,18 +5101,17 @@ var prefer_spy_on_default = createEslintRule({
 		fixable: "code",
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return { AssignmentExpression(node) {
 			const { left, right } = node;
-			if (left.type !== __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return;
+			if (left.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return;
 			const vitestFnCall = getVitestFnCall(right);
 			if (!vitestFnCall) return;
 			context.report({
 				node,
 				messageId: "useViSpayOn",
 				fix(fixer) {
-					const lefPropQuote = left.property.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier && !left.computed ? "'" : "";
+					const lefPropQuote = left.property.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && !left.computed ? "'" : "";
 					const mockImplementation = getAutoFixMockImplementation(vitestFnCall, context);
 					return [
 						fixer.insertTextBefore(left, "vi.spyOn("),
@@ -5224,7 +5142,6 @@ var prefer_strict_boolean_matchers_default = createEslintRule({
 		fixable: "code",
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
@@ -5262,7 +5179,6 @@ var prefer_strict_equal_default = createEslintRule({
 		schema: [],
 		hasSuggestions: true
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
@@ -5283,7 +5199,7 @@ var prefer_strict_equal_default = createEslintRule({
 //#endregion
 //#region src/rules/prefer-to-be-falsy.ts
 const RULE_NAME$21 = "prefer-to-be-falsy";
-const isFalseLiteral = (node) => node.type === __typescript_eslint_utils.AST_NODE_TYPES.Literal && node.value === false;
+const isFalseLiteral = (node) => node.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && node.value === false;
 var prefer_to_be_falsy_default = createEslintRule({
 	name: RULE_NAME$21,
 	meta: {
@@ -5296,7 +5212,6 @@ var prefer_to_be_falsy_default = createEslintRule({
 		schema: [],
 		messages: { preferToBeFalsy: "Prefer using toBeFalsy()" }
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
@@ -5325,7 +5240,6 @@ var prefer_to_be_object_default = createEslintRule({
 		messages: { preferToBeObject: "Prefer toBeObject() to test if a value is an object" },
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
@@ -5339,7 +5253,7 @@ var prefer_to_be_object_default = createEslintRule({
 				return;
 			}
 			const { parent: expectTypeOf } = vitestFnCall.head.node;
-			if (expectTypeOf?.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
+			if (expectTypeOf?.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
 			const [expectTypeOfArgs] = expectTypeOf.arguments;
 			if (!expectTypeOfArgs || !isBooleanEqualityMatcher(vitestFnCall) || !isInstanceOfBinaryExpression(expectTypeOfArgs, "Object")) return;
 			context.report({
@@ -5351,10 +5265,10 @@ var prefer_to_be_object_default = createEslintRule({
 					if (vitestFnCall.args.length) {
 						const [matcherArg] = vitestFnCall.args;
 						fixes.push(fixer.remove(matcherArg));
-						invertCondition = matcherArg.type === __typescript_eslint_utils.AST_NODE_TYPES.Literal && followTypeAssertionChain$1(matcherArg).value === false;
+						invertCondition = matcherArg.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && followTypeAssertionChain$1(matcherArg).value === false;
 					}
 					if (invertCondition) {
-						const notModifier = vitestFnCall.modifiers.find((node$1) => getAccessorValue(node$1) === "not");
+						const notModifier = vitestFnCall.modifiers.find((node) => getAccessorValue(node) === "not");
 						fixes.push(notModifier ? fixer.removeRange([notModifier.range[0] - 1, notModifier.range[1]]) : fixer.insertTextBefore(vitestFnCall.matcher, "not."));
 					}
 					return fixes;
@@ -5367,7 +5281,7 @@ var prefer_to_be_object_default = createEslintRule({
 //#endregion
 //#region src/rules/prefer-to-be-truthy.ts
 const RULE_NAME$19 = "prefer-to-be-truthy";
-const isTrueLiteral = (node) => node.type === __typescript_eslint_utils.AST_NODE_TYPES.Literal && node.value === true;
+const isTrueLiteral = (node) => node.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && node.value === true;
 var prefer_to_be_truthy_default = createEslintRule({
 	name: RULE_NAME$19,
 	meta: {
@@ -5380,7 +5294,6 @@ var prefer_to_be_truthy_default = createEslintRule({
 		fixable: "code",
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
@@ -5397,16 +5310,16 @@ var prefer_to_be_truthy_default = createEslintRule({
 //#endregion
 //#region src/rules/prefer-to-be.ts
 const RULE_NAME$18 = "prefer-to-be";
-const isNullLiteral = (node) => node.type === __typescript_eslint_utils.AST_NODE_TYPES.Literal && node.value === null;
+const isNullLiteral = (node) => node.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && node.value === null;
 const isNullEqualityMatcher = (expectFnCall) => isNullLiteral(getFirstMatcherArg(expectFnCall));
 const isFirstArgumentIdentifier = (expectFnCall, name) => isIdentifier(getFirstMatcherArg(expectFnCall), name);
 const isFloat = (v) => Math.floor(v) !== Math.ceil(v);
 const shouldUseToBe = (expectFnCall) => {
 	let firstArg = getFirstMatcherArg(expectFnCall);
-	if (firstArg.type === __typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof firstArg.value === "number" && isFloat(firstArg.value)) return false;
-	if (firstArg.type === __typescript_eslint_utils.AST_NODE_TYPES.UnaryExpression && firstArg.operator === "-") firstArg = firstArg.argument;
-	if (firstArg.type === __typescript_eslint_utils.AST_NODE_TYPES.Literal) return !("regex" in firstArg);
-	return firstArg.type === __typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral;
+	if (firstArg.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof firstArg.value === "number" && isFloat(firstArg.value)) return false;
+	if (firstArg.type === _typescript_eslint_utils.AST_NODE_TYPES.UnaryExpression && firstArg.operator === "-") firstArg = firstArg.argument;
+	if (firstArg.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal) return !("regex" in firstArg);
+	return firstArg.type === _typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral;
 };
 const reportPreferToBe = (context, whatToBe, expectFnCall, func, modifierNode) => {
 	context.report({
@@ -5438,13 +5351,12 @@ var prefer_to_be_default = createEslintRule({
 			useToBeNaN: "Use `toBeNaN()` instead"
 		}
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
 			if (vitestFnCall?.type !== "expect") return;
 			const matcherName = getAccessorValue(vitestFnCall.matcher);
-			const notModifier = vitestFnCall.modifiers.find((node$1) => getAccessorValue(node$1) === "not");
+			const notModifier = vitestFnCall.modifiers.find((node) => getAccessorValue(node) === "not");
 			if (notModifier && ["toBeUndefined", "toBeDefined"].includes(matcherName)) {
 				reportPreferToBe(context, matcherName === "toBeDefined" ? "Undefined" : "Defined", vitestFnCall, node, notModifier);
 				return;
@@ -5470,7 +5382,7 @@ var prefer_to_be_default = createEslintRule({
 //#endregion
 //#region src/rules/prefer-to-contain.ts
 const RULE_NAME$17 = "prefer-to-contain";
-const isFixableIncludesCallExpression = (node) => node.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression && node.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property, "includes") && hasOnlyOneArgument(node) && node.arguments[0].type !== __typescript_eslint_utils.AST_NODE_TYPES.SpreadElement;
+const isFixableIncludesCallExpression = (node) => node.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression && node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property, "includes") && hasOnlyOneArgument(node) && node.arguments[0].type !== _typescript_eslint_utils.AST_NODE_TYPES.SpreadElement;
 var prefer_to_contain_default = createEslintRule({
 	name: RULE_NAME$17,
 	meta: {
@@ -5483,17 +5395,16 @@ var prefer_to_contain_default = createEslintRule({
 		type: "suggestion",
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
 			if (vitestFnCall?.type !== "expect" || vitestFnCall.args.length === 0) return;
 			const { parent: expect } = vitestFnCall.head.node;
-			if (expect?.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
+			if (expect?.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
 			const { arguments: [includesCall], range: [, expectCallEnd] } = expect;
 			const { matcher } = vitestFnCall;
 			const matcherArg = getFirstMatcherArg(vitestFnCall);
-			if (!includesCall || matcherArg.type === __typescript_eslint_utils.AST_NODE_TYPES.SpreadElement || !Object.prototype.hasOwnProperty.call(EqualityMatcher, getAccessorValue(matcher)) || !isBooleanLiteral(matcherArg) || !isFixableIncludesCallExpression(includesCall)) return;
+			if (!includesCall || matcherArg.type === _typescript_eslint_utils.AST_NODE_TYPES.SpreadElement || !Object.prototype.hasOwnProperty.call(EqualityMatcher, getAccessorValue(matcher)) || !isBooleanLiteral(matcherArg) || !isFixableIncludesCallExpression(includesCall)) return;
 			const hasNot = vitestFnCall.modifiers.some((nod) => getAccessorValue(nod) === "not");
 			context.report({
 				fix(fixer) {
@@ -5527,16 +5438,15 @@ var prefer_to_have_length_default = createEslintRule({
 		messages: { preferToHaveLength: "Prefer toHaveLength()" },
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
 			if (vitestFnCall?.type !== "expect") return;
 			const { parent: expect } = vitestFnCall.head.node;
-			if (expect?.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
+			if (expect?.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
 			const [argument] = expect.arguments;
 			const { matcher } = vitestFnCall;
-			if (!Object.prototype.hasOwnProperty.call(EqualityMatcher, getAccessorValue(matcher)) || argument?.type !== __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression || !isSupportedAccessor(argument.property, "length")) return;
+			if (!Object.prototype.hasOwnProperty.call(EqualityMatcher, getAccessorValue(matcher)) || argument?.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression || !isSupportedAccessor(argument.property, "length")) return;
 			context.report({
 				node: matcher,
 				messageId: "preferToHaveLength",
@@ -5558,7 +5468,7 @@ const isTargetedTestCase = (vitestFnCall) => {
 };
 function isEmptyFunction(node) {
 	if (!isFunction(node)) return false;
-	return node.body.type === __typescript_eslint_utils.AST_NODE_TYPES.BlockStatement && !node.body.body.length;
+	return node.body.type === _typescript_eslint_utils.AST_NODE_TYPES.BlockStatement && !node.body.body.length;
 }
 function createTodoFixer(vitestFnCall, fixer) {
 	if (vitestFnCall.members.length) return replaceAccessorFixer(fixer, vitestFnCall.members[0], "todo");
@@ -5579,7 +5489,6 @@ var prefer_todo_default = createEslintRule({
 		fixable: "code",
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const [title, callback] = node.arguments;
@@ -5621,13 +5530,12 @@ var prefer_vi_mocked_default = createEslintRule({
 		messages: { useViMocked: "Prefer `vi.mocked()`" },
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		function check(node) {
 			const { typeAnnotation } = node;
-			if (typeAnnotation.type !== __typescript_eslint_utils.AST_NODE_TYPES.TSTypeReference) return;
+			if (typeAnnotation.type !== _typescript_eslint_utils.AST_NODE_TYPES.TSTypeReference) return;
 			const { typeName } = typeAnnotation;
-			if (typeName.type !== __typescript_eslint_utils.AST_NODE_TYPES.Identifier) return;
+			if (typeName.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return;
 			if (!mockTypes.includes(typeName.name)) return;
 			const fnName = context.sourceCode.text.slice(...followTypeAssertionChain(node.expression).range);
 			context.report({
@@ -5640,7 +5548,7 @@ var prefer_vi_mocked_default = createEslintRule({
 		}
 		return {
 			TSAsExpression(node) {
-				if (node.parent.type === __typescript_eslint_utils.AST_NODE_TYPES.TSAsExpression) return;
+				if (node.parent.type === _typescript_eslint_utils.AST_NODE_TYPES.TSAsExpression) return;
 				check(node);
 			},
 			TSTypeAssertion(node) {
@@ -5665,7 +5573,6 @@ var require_awaited_expect_poll_default = createEslintRule({
 		type: "problem",
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		const reported = /* @__PURE__ */ new Set();
 		return { CallExpression(node) {
@@ -5674,7 +5581,7 @@ var require_awaited_expect_poll_default = createEslintRule({
 			const nodeToReport = vitestFnCall.members[0].parent;
 			if (reported.has(nodeToReport)) return;
 			const topMostNode = skipSequenceExpressions(skipMatchersAndModifiers(vitestFnCall.head.node));
-			if (topMostNode.parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression || topMostNode.parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement) return;
+			if (topMostNode.parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression || topMostNode.parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement) return;
 			context.report({
 				node: nodeToReport,
 				messageId: "notAwaited",
@@ -5690,12 +5597,12 @@ function memberRequiresAwait(member) {
 }
 function skipMatchersAndModifiers(node) {
 	let currentNode = node;
-	while (currentNode.parent.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression || currentNode.parent.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) currentNode = currentNode.parent;
+	while (currentNode.parent.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression || currentNode.parent.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) currentNode = currentNode.parent;
 	return currentNode;
 }
 function skipSequenceExpressions(node) {
 	let currentNode = node;
-	while (currentNode.parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.SequenceExpression && currentNode.parent.expressions.at(-1) === currentNode) currentNode = currentNode.parent;
+	while (currentNode.parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.SequenceExpression && currentNode.parent.expressions.at(-1) === currentNode) currentNode = currentNode.parent;
 	return currentNode;
 }
 
@@ -5707,13 +5614,13 @@ const isVitestFnCall = (node, context) => {
 	return !!getNodeName(node)?.startsWith("vi");
 };
 const isNullOrUndefined = (node) => {
-	return node.type === __typescript_eslint_utils.AST_NODE_TYPES.Literal && node.value === null || isIdentifier(node, "undefined");
+	return node.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && node.value === null || isIdentifier(node, "undefined");
 };
 const shouldBeInHook = (node, context, allowedFunctionCalls = []) => {
 	switch (node.type) {
-		case __typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement: return shouldBeInHook(node.expression, context, allowedFunctionCalls);
-		case __typescript_eslint_utils.AST_NODE_TYPES.CallExpression: return !(isVitestFnCall(node, context) || allowedFunctionCalls.includes(getNodeName(node)));
-		case __typescript_eslint_utils.AST_NODE_TYPES.VariableDeclaration:
+		case _typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement: return shouldBeInHook(node.expression, context, allowedFunctionCalls);
+		case _typescript_eslint_utils.AST_NODE_TYPES.CallExpression: return !(isVitestFnCall(node, context) || allowedFunctionCalls.includes(getNodeName(node)));
+		case _typescript_eslint_utils.AST_NODE_TYPES.VariableDeclaration:
 			if (node.kind === "const") return false;
 			return node.declarations.some(({ init }) => init !== null && !isNullOrUndefined(init));
 		default: return false;
@@ -5735,9 +5642,9 @@ var require_hook_default = createEslintRule({
 				items: { type: "string" }
 			} },
 			additionalProperties: false
-		}]
+		}],
+		defaultOptions: [{ allowedFunctionCalls: [] }]
 	},
-	defaultOptions: [{ allowedFunctionCalls: [] }],
 	create(context, options) {
 		const checkBlockBody = (body) => {
 			for (const statement of body) if (shouldBeInHook(statement, context, options[0].allowedFunctionCalls)) context.report({
@@ -5752,7 +5659,7 @@ var require_hook_default = createEslintRule({
 			CallExpression(node) {
 				if (!isTypeOfVitestFnCall(node, context, ["describe"]) || node.arguments.length < 2) return;
 				const [, testFn] = node.arguments;
-				if (!isFunction(testFn) || testFn.body.type !== __typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) return;
+				if (!isFunction(testFn) || testFn.body.type !== _typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) return;
 				checkBlockBody(testFn.body.body);
 			}
 		};
@@ -5773,7 +5680,6 @@ var require_test_timeout_default = createEslintRule({
 		messages: { missingTimeout: "Test is missing a timeout. Add an explicit timeout." },
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		/**
 		* Track positions (character offsets) of vi.setConfig({ testTimeout })
@@ -5788,10 +5694,10 @@ var require_test_timeout_default = createEslintRule({
 				const firstMember = vitestFnCall.members[0];
 				if (firstMember && getAccessorValue(firstMember) === "setConfig") {
 					const arg = node.arguments[0];
-					if (arg && arg.type === __typescript_eslint_utils.AST_NODE_TYPES.ObjectExpression) {
-						for (const prop of arg.properties) if (prop.type === __typescript_eslint_utils.AST_NODE_TYPES.Property) {
+					if (arg && arg.type === _typescript_eslint_utils.AST_NODE_TYPES.ObjectExpression) {
+						for (const prop of arg.properties) if (prop.type === _typescript_eslint_utils.AST_NODE_TYPES.Property) {
 							const key = prop.key;
-							if ((key.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier && key.name === "testTimeout" || key.type === __typescript_eslint_utils.AST_NODE_TYPES.Literal && key.value === "testTimeout") && prop.value.type === __typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof prop.value.value === "number" && prop.value.value >= 0) {
+							if ((key.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && key.name === "testTimeout" || key.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && key.value === "testTimeout") && prop.value.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof prop.value.value === "number" && prop.value.value >= 0) {
 								const endOffset = node.range ? node.range[1] : 0;
 								setConfigPositions.push(endOffset);
 								break;
@@ -5807,7 +5713,7 @@ var require_test_timeout_default = createEslintRule({
 				return v === "todo" || v === "skip";
 			}) || vitestFnCall.name.startsWith("x")) return;
 			const args = node.arguments;
-			if (!args.some((a) => a.type === __typescript_eslint_utils.AST_NODE_TYPES.FunctionExpression || a.type === __typescript_eslint_utils.AST_NODE_TYPES.ArrowFunctionExpression)) return;
+			if (!args.some((a) => a.type === _typescript_eslint_utils.AST_NODE_TYPES.FunctionExpression || a.type === _typescript_eslint_utils.AST_NODE_TYPES.ArrowFunctionExpression)) return;
 			/**
 			* If there is a setConfig call *before* this test that sets testTimeout,
 			* exempt this test. Note: we compare source positions (character offsets)
@@ -5818,7 +5724,7 @@ var require_test_timeout_default = createEslintRule({
 			let foundNumericTimeout = false;
 			let foundObjectTimeout = false;
 			for (const a of args) {
-				if (a.type === __typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof a.value === "number") if (a.value >= 0) foundNumericTimeout = true;
+				if (a.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof a.value === "number") if (a.value >= 0) foundNumericTimeout = true;
 				else {
 					context.report({
 						node,
@@ -5826,10 +5732,10 @@ var require_test_timeout_default = createEslintRule({
 					});
 					return;
 				}
-				if (a.type === __typescript_eslint_utils.AST_NODE_TYPES.ObjectExpression) for (const prop of a.properties) {
-					if (prop.type !== __typescript_eslint_utils.AST_NODE_TYPES.Property) continue;
+				if (a.type === _typescript_eslint_utils.AST_NODE_TYPES.ObjectExpression) for (const prop of a.properties) {
+					if (prop.type !== _typescript_eslint_utils.AST_NODE_TYPES.Property) continue;
 					const key = prop.key;
-					if (key.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier && key.name === "timeout" || key.type === __typescript_eslint_utils.AST_NODE_TYPES.Literal && key.value === "timeout") if (prop.value.type === __typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof prop.value.value === "number" && prop.value.value >= 0) foundObjectTimeout = true;
+					if (key.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && key.name === "timeout" || key.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && key.value === "timeout") if (prop.value.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof prop.value.value === "number" && prop.value.value >= 0) foundObjectTimeout = true;
 					else {
 						context.report({
 							node,
@@ -5862,15 +5768,14 @@ var require_local_test_context_for_concurrent_snapshots_default = createEslintRu
 		type: "problem",
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
 			if (vitestFnCall === null) return;
 			if (vitestFnCall.type !== "expect") return;
 			if (vitestFnCall.type === "expect" && vitestFnCall.head.type === "testContext") return;
-			if (node.callee.type !== __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return;
-			if (node.callee.property.type !== __typescript_eslint_utils.AST_NODE_TYPES.Identifier) return;
+			if (node.callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return;
+			if (node.callee.property.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return;
 			if (![
 				"toMatchSnapshot",
 				"toMatchInlineSnapshot",
@@ -5879,9 +5784,9 @@ var require_local_test_context_for_concurrent_snapshots_default = createEslintRu
 				"toThrowErrorMatchingInlineSnapshot"
 			].includes(node.callee.property.name)) return;
 			if (!context.sourceCode.getAncestors(node).some((ancestor) => {
-				if (ancestor.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return false;
+				if (ancestor.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return false;
 				if (!isTypeOfVitestFnCall(ancestor, context, ["describe", "test"])) return false;
-				return ancestor.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(ancestor.callee.property, "concurrent");
+				return ancestor.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(ancestor.callee.property, "concurrent");
 			})) return;
 			context.report({
 				node,
@@ -5909,9 +5814,8 @@ var require_mock_type_parameters_default = createEslintRule({
 			properties: { checkImportFunctions: { type: "boolean" } },
 			additionalProperties: false
 		}],
-		defaultOptions: []
+		defaultOptions: [{ checkImportFunctions: false }]
 	},
-	defaultOptions: [{ checkImportFunctions: false }],
 	create(context, [options]) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
@@ -5945,7 +5849,6 @@ var require_to_throw_message_default = createEslintRule({
 		schema: [],
 		messages: { addErrorMessage: "Add an error message to {{ matcherName }}()" }
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
@@ -5981,13 +5884,12 @@ var require_top_level_describe_default = createEslintRule({
 			type: "object",
 			properties: { maxNumberOfTopLevelDescribes: {
 				type: "number",
-				minimum: 1,
-				default: Infinity
+				minimum: 1
 			} },
 			additionalProperties: false
-		}]
+		}],
+		defaultOptions: [{ maxNumberOfTopLevelDescribes: Infinity }]
 	},
-	defaultOptions: [{ maxNumberOfTopLevelDescribes: Infinity }],
 	create(context, options) {
 		const maxNumberOfTopLevelDescribes = options[0].maxNumberOfTopLevelDescribes;
 		let numberOfTopLevelDescribeBlocks = 0;
@@ -6048,7 +5950,7 @@ const hasNonEachMembersAndParams = (vitestFnCall, functionExpression) => {
 };
 const reportUnexpectedReturnInDescribe = (blockStatement, context) => {
 	blockStatement.body.forEach((node) => {
-		if (node.type !== __typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement) return;
+		if (node.type !== _typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement) return;
 		context.report({
 			messageId: "unexpectedReturnInDescribe",
 			node
@@ -6071,12 +5973,11 @@ var valid_describe_callback_default = createEslintRule({
 		},
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
 			if (vitestFnCall?.type !== "describe") return;
-			if (vitestFnCall?.members[0]?.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier && vitestFnCall.members[0].name === "todo") return;
+			if (vitestFnCall?.members[0]?.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && vitestFnCall.members[0].name === "todo") return;
 			if (node.arguments.length < 1) return context.report({
 				messageId: "nameAndCallback",
 				loc: node.loc
@@ -6095,11 +5996,11 @@ var valid_describe_callback_default = createEslintRule({
 						messageId: "unexpectedDescribeArgument",
 						node: arg3
 					});
-					if (arg3.body.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) context.report({
+					if (arg3.body.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) context.report({
 						messageId: "unexpectedReturnInDescribe",
 						node: arg3
 					});
-					if (arg3.body.type === __typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) reportUnexpectedReturnInDescribe(arg3.body, context);
+					if (arg3.body.type === _typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) reportUnexpectedReturnInDescribe(arg3.body, context);
 					return;
 				}
 				context.report({
@@ -6112,11 +6013,11 @@ var valid_describe_callback_default = createEslintRule({
 				messageId: "unexpectedDescribeArgument",
 				node: arg2
 			});
-			if (arg2.body.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) context.report({
+			if (arg2.body.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) context.report({
 				messageId: "unexpectedReturnInDescribe",
 				node: arg2
 			});
-			if (arg2.body.type === __typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) reportUnexpectedReturnInDescribe(arg2.body, context);
+			if (arg2.body.type === _typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) reportUnexpectedReturnInDescribe(arg2.body, context);
 		} };
 	}
 });
@@ -6124,9 +6025,8 @@ var valid_describe_callback_default = createEslintRule({
 //#endregion
 //#region src/rules/valid-expect-in-promise.ts
 const RULE_NAME$5 = "valid-expect-in-promise";
-const defaultAsyncMatchers$1 = ["toRejectWith", "toResolveWith"];
 const isPromiseChainCall = (node) => {
-	if (node.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression && node.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property)) {
+	if (node.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression && node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property)) {
 		if (node.arguments.length === 0) return false;
 		switch (getAccessorValue(node.callee.property)) {
 			case "then": return node.arguments.length < 3;
@@ -6140,7 +6040,7 @@ const isTestCaseCallWithCallbackArg = (node, context) => {
 	const vitestCallFn = parseVitestFnCall(node, context);
 	if (vitestCallFn?.type !== "test") return false;
 	const isVitestEach = vitestCallFn.members.some((s) => getAccessorValue(s) === "each");
-	if (isVitestEach && node.callee.type !== __typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression) return true;
+	if (isVitestEach && node.callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.TaggedTemplateExpression) return true;
 	const [, callback] = node.arguments;
 	const callbackArgIndex = Number(isVitestEach);
 	return callback && isFunction(callback) && callback.params.length === 1 + callbackArgIndex;
@@ -6148,11 +6048,11 @@ const isTestCaseCallWithCallbackArg = (node, context) => {
 const isPromiseMethodThatUsesValue = (node, identifier) => {
 	const { name } = identifier;
 	if (node.argument === null) return false;
-	if (node.argument.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression && node.argument.arguments.length > 0) {
+	if (node.argument.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression && node.argument.arguments.length > 0) {
 		const nodeName = getNodeName(node.argument);
 		if (["Promise.all", "Promise.allSettled"].includes(nodeName)) {
 			const [firstArg] = node.argument.arguments;
-			if (firstArg.type === __typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression && firstArg.elements.some((nod) => nod && isIdentifier(nod, name))) return true;
+			if (firstArg.type === _typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression && firstArg.elements.some((nod) => nod && isIdentifier(nod, name))) return true;
 		}
 		if (["Promise.resolve", "Promise.reject"].includes(nodeName) && node.argument.arguments.length === 1) return isIdentifier(node.argument.arguments[0], name);
 	}
@@ -6164,8 +6064,8 @@ const isPromiseMethodThatUsesValue = (node, identifier) => {
 */
 const isValueAwaitedInElements = (name, elements) => {
 	for (const element of elements) {
-		if (element?.type === __typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression && isIdentifier(element.argument, name)) return true;
-		if (element?.type === __typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression && isValueAwaitedInElements(name, element.elements)) return true;
+		if (element?.type === _typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression && isIdentifier(element.argument, name)) return true;
+		if (element?.type === _typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression && isValueAwaitedInElements(name, element.elements)) return true;
 	}
 	return false;
 };
@@ -6176,11 +6076,11 @@ const isValueAwaitedInElements = (name, elements) => {
 const isValueAwaitedInArguments = (name, call) => {
 	let node = call;
 	while (node) {
-		if (node.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) {
+		if (node.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) {
 			if (isValueAwaitedInElements(name, node.arguments)) return true;
 			node = node.callee;
 		}
-		if (node.type !== __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) break;
+		if (node.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) break;
 		node = node.object;
 	}
 	return false;
@@ -6189,11 +6089,11 @@ const getLeftMostCallExpression = (call) => {
 	let leftMostCallExpression = call;
 	let node = call;
 	while (node) {
-		if (node.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) {
+		if (node.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) {
 			leftMostCallExpression = node;
 			node = node.callee;
 		}
-		if (node.type !== __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) break;
+		if (node.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) break;
 		node = node.object;
 	}
 	return leftMostCallExpression;
@@ -6206,9 +6106,9 @@ const isValueAwaitedOrReturned = (identifier, body, context) => {
 	const { name } = identifier;
 	for (const node of body) {
 		if (node.range[0] <= identifier.range[0]) continue;
-		if (node.type === __typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement) return isPromiseMethodThatUsesValue(node, identifier);
-		if (node.type === __typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement) {
-			if (node.expression.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) {
+		if (node.type === _typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement) return isPromiseMethodThatUsesValue(node, identifier);
+		if (node.type === _typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement) {
+			if (node.expression.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) {
 				if (isValueAwaitedInArguments(name, node.expression)) return true;
 				const leftMostCall = getLeftMostCallExpression(node.expression);
 				const vitestFnCall = parseVitestFnCall(node.expression, context);
@@ -6219,20 +6119,20 @@ const isValueAwaitedOrReturned = (identifier, body, context) => {
 					})) return true;
 				}
 			}
-			if (node.expression.type === __typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression && isPromiseMethodThatUsesValue(node.expression, identifier)) return true;
-			if (node.expression.type === __typescript_eslint_utils.AST_NODE_TYPES.AssignmentExpression) {
+			if (node.expression.type === _typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression && isPromiseMethodThatUsesValue(node.expression, identifier)) return true;
+			if (node.expression.type === _typescript_eslint_utils.AST_NODE_TYPES.AssignmentExpression) {
 				if (isIdentifier(node.expression.left, name) && getNodeName(node.expression.right)?.startsWith(`${name}.`) && isPromiseChainCall(node.expression.right)) continue;
 				break;
 			}
 		}
-		if (node.type === __typescript_eslint_utils.AST_NODE_TYPES.BlockStatement && isValueAwaitedOrReturned(identifier, node.body, context)) return true;
+		if (node.type === _typescript_eslint_utils.AST_NODE_TYPES.BlockStatement && isValueAwaitedOrReturned(identifier, node.body, context)) return true;
 	}
 	return false;
 };
 const findFirstBlockBodyUp = (node) => {
 	let parent = node;
 	while (parent) {
-		if (parent.type === __typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) return parent.body;
+		if (parent.type === _typescript_eslint_utils.AST_NODE_TYPES.BlockStatement) return parent.body;
 		parent = parent.parent;
 	}
 	/* istanbul ignore next */
@@ -6243,7 +6143,7 @@ const isDirectlyWithinTestCaseCall = (node, context) => {
 	while (parent) {
 		if (isFunction(parent)) {
 			parent = parent.parent;
-			return parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression && isTypeOfVitestFnCall(parent, context, ["test"]);
+			return parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression && isTypeOfVitestFnCall(parent, context, ["test"]);
 		}
 		parent = parent.parent;
 	}
@@ -6262,12 +6162,6 @@ var valid_expect_in_promise_default = createEslintRule({
 		type: "suggestion",
 		schema: []
 	},
-	defaultOptions: [{
-		alwaysAwait: false,
-		asyncMatchers: defaultAsyncMatchers$1,
-		minArgs: 1,
-		maxArgs: 1
-	}],
 	create(context) {
 		let inTestCaseWithDoneCallback = false;
 		const chains = [];
@@ -6293,15 +6187,15 @@ var valid_expect_in_promise_default = createEslintRule({
 				const { parent } = findTopMostCallExpression(node);
 				if (!parent || !isDirectlyWithinTestCaseCall(parent, context)) return;
 				switch (parent.type) {
-					case __typescript_eslint_utils.AST_NODE_TYPES.VariableDeclarator:
+					case _typescript_eslint_utils.AST_NODE_TYPES.VariableDeclarator:
 						if (isVariableAwaitedOrReturned(parent, context)) return;
 						break;
-					case __typescript_eslint_utils.AST_NODE_TYPES.AssignmentExpression:
-						if (parent.left.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier && isValueAwaitedOrReturned(parent.left, findFirstBlockBodyUp(parent), context)) return;
+					case _typescript_eslint_utils.AST_NODE_TYPES.AssignmentExpression:
+						if (parent.left.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && isValueAwaitedOrReturned(parent.left, findFirstBlockBodyUp(parent), context)) return;
 						break;
-					case __typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement: break;
-					case __typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement:
-					case __typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression:
+					case _typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement: break;
+					case _typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement:
+					case _typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression:
 					default: return;
 				}
 				context.report({
@@ -6325,29 +6219,29 @@ const defaultAsyncMatchers = ["toReject", "toResolve"];
 * @Returns CallExpressionNode
 */
 const getPromiseCallExpressionNode = (node) => {
-	if (node.type === __typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression && node.parent && node.parent.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) node = node.parent;
-	if (node.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression && node.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.object, "Promise") && node.parent) return node;
+	if (node.type === _typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression && node.parent && node.parent.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) node = node.parent;
+	if (node.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression && node.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.object, "Promise") && node.parent) return node;
 	return null;
 };
 const promiseArrayExceptionKey = ({ start, end }) => `${start.line}:${start.column}-${end.line}:${end.column}`;
 const getNormalizeFunctionExpression = (functionExpression) => {
-	if (functionExpression.parent.type === __typescript_eslint_utils.AST_NODE_TYPES.Property && functionExpression.type === __typescript_eslint_utils.AST_NODE_TYPES.FunctionExpression) return functionExpression.parent;
+	if (functionExpression.parent.type === _typescript_eslint_utils.AST_NODE_TYPES.Property && functionExpression.type === _typescript_eslint_utils.AST_NODE_TYPES.FunctionExpression) return functionExpression.parent;
 	return functionExpression;
 };
 function getParentIfThenified(node) {
 	const grandParentNode = node.parent?.parent;
-	if (grandParentNode && grandParentNode.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression && grandParentNode.callee.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(grandParentNode.callee.property) && ["then", "catch"].includes(getAccessorValue(grandParentNode.callee.property)) && grandParentNode.parent) return getParentIfThenified(grandParentNode);
+	if (grandParentNode && grandParentNode.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression && grandParentNode.callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(grandParentNode.callee.property) && ["then", "catch"].includes(getAccessorValue(grandParentNode.callee.property)) && grandParentNode.parent) return getParentIfThenified(grandParentNode);
 	return node;
 }
-const findPromiseCallExpressionNode = (node) => node.parent?.parent && [__typescript_eslint_utils.AST_NODE_TYPES.CallExpression, __typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression].includes(node.parent.type) ? getPromiseCallExpressionNode(node.parent) : null;
+const findPromiseCallExpressionNode = (node) => node.parent?.parent && [_typescript_eslint_utils.AST_NODE_TYPES.CallExpression, _typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression].includes(node.parent.type) ? getPromiseCallExpressionNode(node.parent) : null;
 const findFirstFunctionExpression = ({ parent }) => {
 	if (!parent) return null;
 	return isFunction(parent) ? parent : findFirstFunctionExpression(parent);
 };
 const isAcceptableReturnNode = (node, allowReturn) => {
-	if (allowReturn && node.type === __typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement) return true;
-	if (node.type === __typescript_eslint_utils.AST_NODE_TYPES.ConditionalExpression && node.parent) return isAcceptableReturnNode(node.parent, allowReturn);
-	return [__typescript_eslint_utils.AST_NODE_TYPES.ArrowFunctionExpression, __typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression].includes(node.type);
+	if (allowReturn && node.type === _typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement) return true;
+	if (node.type === _typescript_eslint_utils.AST_NODE_TYPES.ConditionalExpression && node.parent) return isAcceptableReturnNode(node.parent, allowReturn);
+	return [_typescript_eslint_utils.AST_NODE_TYPES.ArrowFunctionExpression, _typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression].includes(node.type);
 };
 var valid_expect_default = createEslintRule({
 	name: RULE_NAME$4,
@@ -6370,10 +6264,7 @@ var valid_expect_default = createEslintRule({
 		schema: [{
 			type: "object",
 			properties: {
-				alwaysAwait: {
-					type: "boolean",
-					default: false
-				},
+				alwaysAwait: { type: "boolean" },
 				asyncMatchers: {
 					type: "array",
 					items: { type: "string" }
@@ -6388,14 +6279,14 @@ var valid_expect_default = createEslintRule({
 				}
 			},
 			additionalProperties: false
+		}],
+		defaultOptions: [{
+			alwaysAwait: false,
+			asyncMatchers: defaultAsyncMatchers,
+			minArgs: 1,
+			maxArgs: 1
 		}]
 	},
-	defaultOptions: [{
-		alwaysAwait: false,
-		asyncMatchers: defaultAsyncMatchers,
-		minArgs: 1,
-		maxArgs: 1
-	}],
 	create: (context, [{ alwaysAwait, asyncMatchers = defaultAsyncMatchers, minArgs = 1, maxArgs = 1 }]) => {
 		const arrayExceptions = /* @__PURE__ */ new Set();
 		const descriptors = [];
@@ -6412,7 +6303,7 @@ var valid_expect_default = createEslintRule({
 			let topMostMemberExpression = node;
 			let { parent } = node;
 			while (parent) {
-				if (parent.type !== __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) break;
+				if (parent.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) break;
 				topMostMemberExpression = parent;
 				parent = parent.parent;
 			}
@@ -6423,7 +6314,7 @@ var valid_expect_default = createEslintRule({
 				const vitestFnCall = parseVitestFnCallWithReason(node, context);
 				const settings = parsePluginSettings(context.settings);
 				if (typeof vitestFnCall === "string") {
-					const reportingNode = node.parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression ? findTopMostMemberExpression(node.parent).property : node;
+					const reportingNode = node.parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression ? findTopMostMemberExpression(node.parent).property : node;
 					if (vitestFnCall === "matcher-not-found") {
 						context.report({
 							messageId: "matcherNotFound",
@@ -6445,9 +6336,9 @@ var valid_expect_default = createEslintRule({
 					return;
 				} else if (vitestFnCall?.type === "expectTypeOf" && settings.typecheck) return;
 				else if (vitestFnCall?.type !== "expect") return;
-				else if (vitestFnCall.modifiers.some((mod) => mod.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier && mod.name == "to")) return;
+				else if (vitestFnCall.modifiers.some((mod) => mod.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && mod.name == "to")) return;
 				const { parent: expect } = vitestFnCall.head.node;
-				if (expect?.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
+				if (expect?.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
 				if (expect.arguments.length < minArgs) {
 					const expectLength = getAccessorValue(vitestFnCall.head.node).length;
 					const loc = {
@@ -6472,8 +6363,8 @@ var valid_expect_default = createEslintRule({
 				}
 				if (expect.arguments.length > maxArgs) {
 					if (expect.arguments.length === 2) {
-						const isSecondArgString = expect.arguments[1].type === __typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof expect.arguments[1].value === "string";
-						const isSecondArgTemplateLiteral = expect.arguments[1].type === __typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral;
+						const isSecondArgString = expect.arguments[1].type === _typescript_eslint_utils.AST_NODE_TYPES.Literal && typeof expect.arguments[1].value === "string";
+						const isSecondArgTemplateLiteral = expect.arguments[1].type === _typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral;
 						if (isSecondArgString || isSecondArgTemplateLiteral) return;
 					}
 					const { start } = expect.arguments[maxArgs].loc;
@@ -6499,7 +6390,7 @@ var valid_expect_default = createEslintRule({
 				const parentNode = matcher.parent.parent;
 				const shouldBeAwaited = vitestFnCall.modifiers.some((nod) => getAccessorValue(nod) !== "not") || asyncMatchers.includes(getAccessorValue(matcher));
 				if (!parentNode?.parent || !shouldBeAwaited) return;
-				const isParentArrayExpression = parentNode.parent.type === __typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression;
+				const isParentArrayExpression = parentNode.parent.type === _typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression;
 				const targetNode = getParentIfThenified(parentNode);
 				const finalNode = findPromiseCallExpressionNode(targetNode) || targetNode;
 				if (finalNode.parent && !isAcceptableReturnNode(finalNode.parent, !alwaysAwait) && !promiseArrayExceptionExists(finalNode.loc)) {
@@ -6527,7 +6418,7 @@ var valid_expect_default = createEslintRule({
 								const targetFunction = getNormalizeFunctionExpression(functionExpression);
 								fixes.push(fixer.insertTextBefore(targetFunction, "async "));
 							}
-							const returnStatement = node.parent?.type === __typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement ? node.parent : null;
+							const returnStatement = node.parent?.type === _typescript_eslint_utils.AST_NODE_TYPES.ReturnStatement ? node.parent : null;
 							if (alwaysAwait && returnStatement) {
 								const replacedText = context.sourceCode.getText(returnStatement).replace("return", "await");
 								fixes.push(fixer.replaceText(returnStatement, replacedText));
@@ -6545,7 +6436,7 @@ var valid_expect_default = createEslintRule({
 //#region src/rules/valid-title.ts
 const RULE_NAME$3 = "valid-title";
 const trimFXPrefix = (word) => ["f", "x"].includes(word.charAt(0)) ? word.substring(1) : word;
-const quoteStringValue = (node) => node.type === __typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral ? `\`${node.quasis[0].value.raw}\`` : node.raw;
+const quoteStringValue = (node) => node.type === _typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral ? `\`${node.quasis[0].value.raw}\`` : node.raw;
 const MatcherAndMessageSchema = {
 	type: "array",
 	items: { type: "string" },
@@ -6578,7 +6469,7 @@ const compileMatcherPatterns = (matchers) => {
 };
 const doesBinaryExpressionContainStringNode = (binaryExp) => {
 	if (isStringNode(binaryExp.right)) return true;
-	if (binaryExp.left.type === __typescript_eslint_utils.AST_NODE_TYPES.BinaryExpression) return doesBinaryExpressionContainStringNode(binaryExp.left);
+	if (binaryExp.left.type === _typescript_eslint_utils.AST_NODE_TYPES.BinaryExpression) return doesBinaryExpressionContainStringNode(binaryExp.left);
 	return isStringNode(binaryExp.left);
 };
 var valid_title_default = createEslintRule({
@@ -6603,14 +6494,8 @@ var valid_title_default = createEslintRule({
 		schema: [{
 			type: "object",
 			properties: {
-				ignoreTypeOfDescribeName: {
-					type: "boolean",
-					default: false
-				},
-				allowArguments: {
-					type: "boolean",
-					default: false
-				},
+				ignoreTypeOfDescribeName: { type: "boolean" },
+				allowArguments: { type: "boolean" },
 				disallowedWords: {
 					type: "array",
 					items: { type: "string" }
@@ -6634,14 +6519,13 @@ var valid_title_default = createEslintRule({
 			] } },
 			additionalProperties: false
 		}],
-		defaultOptions: [],
+		defaultOptions: [{
+			ignoreTypeOfDescribeName: false,
+			allowArguments: false,
+			disallowedWords: []
+		}],
 		fixable: "code"
 	},
-	defaultOptions: [{
-		ignoreTypeOfDescribeName: false,
-		allowArguments: false,
-		disallowedWords: []
-	}],
 	create(context, [{ ignoreTypeOfDescribeName, allowArguments, disallowedWords = [], mustNotMatch, mustMatch }]) {
 		const disallowedWordsRegexp = new RegExp(`\\b(${disallowedWords.join("|")})\\b`, "iu");
 		const mustNotMatchPatterns = compileMatcherPatterns(mustNotMatch ?? {});
@@ -6651,24 +6535,24 @@ var valid_title_default = createEslintRule({
 			const vitestFnCall = parseVitestFnCall(node, context);
 			if (vitestFnCall?.type !== "describe" && vitestFnCall?.type !== "test" && vitestFnCall?.type !== "it") return;
 			if (vitestFnCall.members.some((member) => ["extend", "scoped"].includes(getAccessorValue(member)))) return;
-			const reportEmptyTitle = (node$1) => {
+			const reportEmptyTitle = (node) => {
 				context.report({
 					messageId: "emptyTitle",
 					data: { functionName: vitestFnCall.type === "describe" ? DescribeAlias.describe : TestCaseName.test },
-					node: node$1
+					node
 				});
 			};
 			const [argument] = node.arguments;
 			const getArgumentType = () => {
 				if (!settings.typecheck) return null;
-				return __typescript_eslint_utils.ESLintUtils.getParserServices(context).getTypeAtLocation(argument);
+				return _typescript_eslint_utils.ESLintUtils.getParserServices(context).getTypeAtLocation(argument);
 			};
 			const type = getArgumentType();
 			if (type && isClassOrFunctionType(type)) return;
-			if (!argument || allowArguments && argument.type === __typescript_eslint_utils.AST_NODE_TYPES.Identifier) return;
+			if (!argument || allowArguments && argument.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return;
 			if (!isStringNode(argument)) {
-				if (argument.type === __typescript_eslint_utils.AST_NODE_TYPES.BinaryExpression && doesBinaryExpressionContainStringNode(argument) || type && isStringLikeType(type)) return;
-				if (argument.type !== __typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral && !(ignoreTypeOfDescribeName && vitestFnCall.type === "describe")) context.report({
+				if (argument.type === _typescript_eslint_utils.AST_NODE_TYPES.BinaryExpression && doesBinaryExpressionContainStringNode(argument) || type && isStringLikeType(type)) return;
+				if (argument.type !== _typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral && !(ignoreTypeOfDescribeName && vitestFnCall.type === "describe")) context.report({
 					messageId: "titleMustBeString",
 					loc: argument.loc
 				});
@@ -6748,7 +6632,6 @@ var warn_todo_default = createEslintRule({
 		type: "suggestion",
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
@@ -6768,10 +6651,10 @@ var warn_todo_default = createEslintRule({
 const RULE_NAME$1 = "no-unneeded-async-expect-function";
 const getAwaitedCallExpression = (expression) => {
 	if (!expression.async) return null;
-	if (expression.type === __typescript_eslint_utils.AST_NODE_TYPES.ArrowFunctionExpression && expression.body.type === __typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression && expression.body.argument.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return expression.body.argument;
-	if (expression.body.type !== __typescript_eslint_utils.AST_NODE_TYPES.BlockStatement || expression.body.body.length !== 1) return null;
+	if (expression.type === _typescript_eslint_utils.AST_NODE_TYPES.ArrowFunctionExpression && expression.body.type === _typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression && expression.body.argument.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return expression.body.argument;
+	if (expression.body.type !== _typescript_eslint_utils.AST_NODE_TYPES.BlockStatement || expression.body.body.length !== 1) return null;
 	const [callback] = expression.body.body;
-	if (callback.type === __typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement && callback.expression.type === __typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression && callback.expression.argument.type === __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return callback.expression.argument;
+	if (callback.type === _typescript_eslint_utils.AST_NODE_TYPES.ExpressionStatement && callback.expression.type === _typescript_eslint_utils.AST_NODE_TYPES.AwaitExpression && callback.expression.argument.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return callback.expression.argument;
 	return null;
 };
 var no_unneeded_async_expect_function_default = createEslintRule({
@@ -6783,13 +6666,12 @@ var no_unneeded_async_expect_function_default = createEslintRule({
 		schema: [],
 		type: "suggestion"
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
 			if (vitestFnCall?.type !== "expect") return;
 			const { parent } = vitestFnCall.head.node;
-			if (parent?.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
+			if (parent?.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
 			const [awaitNode] = parent.arguments;
 			if (!awaitNode || !isFunction(awaitNode)) return;
 			const innerAsyncFuncCall = getAwaitedCallExpression(awaitNode);
@@ -6818,19 +6700,18 @@ var prefer_to_have_been_called_times_default = createEslintRule({
 		type: "suggestion",
 		schema: []
 	},
-	defaultOptions: [],
 	create(context) {
 		return { CallExpression(node) {
 			const vitestFnCall = parseVitestFnCall(node, context);
 			if (vitestFnCall?.type !== "expect") return;
 			const { parent: expect } = vitestFnCall.head.node;
-			if (expect?.type !== __typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
+			if (expect?.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
 			const { matcher } = vitestFnCall;
 			if (!isSupportedAccessor(matcher, "toHaveLength")) return;
 			const [argument] = expect.arguments;
-			if (argument?.type !== __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression || !isSupportedAccessor(argument.property, "calls")) return;
+			if (argument?.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression || !isSupportedAccessor(argument.property, "calls")) return;
 			const { object } = argument;
-			if (object.type !== __typescript_eslint_utils.AST_NODE_TYPES.MemberExpression || !isSupportedAccessor(object.property, "mock")) return;
+			if (object.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression || !isSupportedAccessor(object.property, "mock")) return;
 			context.report({
 				messageId: "preferMatcher",
 				node: matcher,
@@ -6930,18 +6811,18 @@ const rules = {
 
 //#endregion
 //#region src/index.ts
-const createConfig = (rules$1) => Object.keys(rules$1).reduce((acc, ruleName) => {
+const createConfig = (rules) => Object.keys(rules).reduce((acc, ruleName) => {
 	return {
 		...acc,
-		[`vitest/${ruleName}`]: rules$1[ruleName]
+		[`vitest/${ruleName}`]: rules[ruleName]
 	};
 }, {});
-const createConfigLegacy = (rules$1) => ({
+const createConfigLegacy = (rules) => ({
 	plugins: ["@vitest"],
-	rules: Object.keys(rules$1).reduce((acc, ruleName) => {
+	rules: Object.keys(rules).reduce((acc, ruleName) => {
 		return {
 			...acc,
-			[`@vitest/${ruleName}`]: rules$1[ruleName]
+			[`@vitest/${ruleName}`]: rules[ruleName]
 		};
 	}, {})
 });
@@ -7110,7 +6991,6 @@ const plugin = {
 		}
 	}
 };
-var src_default = plugin;
 
 //#endregion
-module.exports = src_default;
+module.exports = plugin;