npm - @vitest/eslint-plugin - Versions diffs - 1.6.7 → 1.6.9 - Mend

@vitest/eslint-plugin 1.6.7 → 1.6.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/index.cjs +349 -377
package/dist/{index.js → index.mjs} +102 -103
package/package.json +34 -31
/package/dist/{index.d.ts → index.d.mts} +0 -0

package/dist/index.cjs CHANGED Viewed

@@ -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.7";
+var version = "1.6.9";
 //#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
@@ -1931,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;
@@ -1995,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(", ");
@@ -2009,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({
@@ -2077,10 +2050,10 @@ var consistent_vitest_vi_default = createEslintRule({
 		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,
@@ -2106,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: {
@@ -2169,8 +2142,8 @@ var expect_expect_default = createEslintRule({
 		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;
@@ -2179,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));
 			},
@@ -2236,21 +2209,21 @@ var hoisted_apis_on_top_default = createEslintRule({
 		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"() {
@@ -2259,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");
@@ -2306,7 +2279,7 @@ var max_expects_default = createEslintRule({
 	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,
@@ -2315,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,
@@ -2461,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: {
@@ -2691,17 +2664,17 @@ var no_done_callback_default = createEslintRule({
 	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"
@@ -2737,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;
@@ -3015,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
@@ -3136,7 +3109,7 @@ var no_interpolation_in_snapshots_default = createEslintRule({
 			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
 				});
@@ -3153,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);
@@ -3278,7 +3251,7 @@ var no_restricted_matchers_default = createEslintRule({
 		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",
@@ -3347,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;
 };
@@ -3381,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,
@@ -3390,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);
@@ -3404,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();
@@ -3438,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,
@@ -3454,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({
@@ -3472,7 +3445,7 @@ var no_test_return_statement_default = createEslintRule({
 		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",
@@ -3481,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",
@@ -3497,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.
 *
@@ -3533,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;
@@ -3611,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;
 	};
@@ -3642,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);
 };
@@ -3729,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
@@ -3738,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
@@ -3752,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
@@ -3766,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
@@ -3785,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: [
@@ -3802,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,
@@ -3839,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: [
@@ -3865,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
@@ -3891,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(", ");
@@ -3905,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) => {
@@ -3919,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) => {
@@ -3939,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: {
@@ -3951,7 +3924,7 @@ var prefer_called_exactly_once_with_default = createEslintRule({
 	},
 	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();
@@ -4009,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: {
@@ -4094,7 +4067,7 @@ var prefer_called_with_default = createEslintRule({
 		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({
@@ -4109,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`.
@@ -4121,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);
@@ -4168,11 +4141,11 @@ var prefer_comparison_matcher_default = createEslintRule({
 			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);
@@ -4215,9 +4188,9 @@ var prefer_describe_function_title_default = createEslintRule({
 			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",
@@ -4227,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,
@@ -4323,16 +4296,16 @@ var prefer_equality_matcher_default = createEslintRule({
 			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}`;
@@ -4351,7 +4324,7 @@ var prefer_equality_matcher_default = createEslintRule({
 				].map((equalityMatcher) => ({
 					messageId: "suggestEqualityMatcher",
 					data: { equalityMatcher },
-					fix: buildFixer$1(equalityMatcher)
+					fix: buildFixer(equalityMatcher)
 				})),
 				node: matcher
 			});
@@ -4365,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");
@@ -4453,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
@@ -4480,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;
 					}
@@ -4503,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();`]);
 				}
@@ -4539,9 +4512,9 @@ var prefer_expect_resolves_default = createEslintRule({
 		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) {
@@ -4584,14 +4557,14 @@ var prefer_expect_type_of_default = createEslintRule({
 		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];
@@ -4729,12 +4702,12 @@ var prefer_import_in_mock_default = createEslintRule({
 	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,
@@ -4898,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)];
 					}
 				});
@@ -4919,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({
@@ -4937,7 +4910,7 @@ var prefer_mock_promise_shorthand_default = createEslintRule({
 	},
 	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);
@@ -4953,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]);
@@ -4973,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({
@@ -4991,7 +4964,7 @@ var prefer_mock_return_shorthand_default = createEslintRule({
 	},
 	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");
@@ -5000,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({
@@ -5100,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()";
@@ -5131,14 +5104,14 @@ var prefer_spy_on_default = createEslintRule({
 	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("),
@@ -5226,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: {
@@ -5280,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({
@@ -5292,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;
@@ -5308,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: {
@@ -5337,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({
@@ -5383,7 +5356,7 @@ var prefer_to_be_default = createEslintRule({
 			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;
@@ -5409,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: {
@@ -5427,11 +5400,11 @@ var prefer_to_contain_default = createEslintRule({
 			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) {
@@ -5470,10 +5443,10 @@ var prefer_to_have_length_default = createEslintRule({
 			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",
@@ -5495,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");
@@ -5560,9 +5533,9 @@ var prefer_vi_mocked_default = createEslintRule({
 	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({
@@ -5575,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) {
@@ -5608,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",
@@ -5624,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;
 }
@@ -5641,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;
@@ -5686,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);
 			}
 		};
@@ -5721,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;
@@ -5740,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)
@@ -5751,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,
@@ -5759,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,
@@ -5801,8 +5774,8 @@ var require_local_test_context_for_concurrent_snapshots_default = createEslintRu
 			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",
@@ -5811,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,
@@ -5977,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
@@ -6004,7 +5977,7 @@ var valid_describe_callback_default = createEslintRule({
 		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
@@ -6023,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({
@@ -6040,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);
 		} };
 	}
 });
@@ -6053,7 +6026,7 @@ var valid_describe_callback_default = createEslintRule({
 //#region src/rules/valid-expect-in-promise.ts
 const RULE_NAME$5 = "valid-expect-in-promise";
 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;
@@ -6067,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;
@@ -6075,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);
 	}
@@ -6091,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;
 };
@@ -6103,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;
@@ -6116,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;
@@ -6133,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);
@@ -6146,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 */
@@ -6170,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;
 	}
@@ -6214,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({
@@ -6246,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,
@@ -6330,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;
 			}
@@ -6341,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",
@@ -6363,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 = {
@@ -6390,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;
@@ -6417,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)) {
@@ -6445,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));
@@ -6463,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" },
@@ -6496,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({
@@ -6562,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
 				});
@@ -6678,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({
@@ -6698,7 +6671,7 @@ var no_unneeded_async_expect_function_default = createEslintRule({
 			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);
@@ -6732,13 +6705,13 @@ var prefer_to_have_been_called_times_default = createEslintRule({
 			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,
@@ -6838,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]
 		};
 	}, {})
 });
@@ -7018,7 +6991,6 @@ const plugin = {
 		}
 	}
 };
-var src_default = plugin;
 //#endregion
-module.exports = src_default;
+module.exports = plugin;