@vitest/eslint-plugin 1.1.4 → 1.1.6

package/dist/index.mjs

@@ -4,7 +4,7 @@ import { isAbsolute, posix } from 'node:path';
 import ts from 'typescript';
 import { createRequire } from 'node:module';
 
-const version = "1.1.3";
+const version = "1.1.5";
 
 function createEslintRule(rule) {
   const createRule = ESLintUtils.RuleCreator(
@@ -341,12 +341,12 @@ const getFirstMatcherArg = (expectFnCall) => {
   const [firstArg] = expectFnCall.args;
   if (firstArg.type === AST_NODE_TYPES.SpreadElement)
     return firstArg;
-  return followTypeAssertionChain(firstArg);
+  return followTypeAssertionChain$1(firstArg);
 };
-const isTypeCastExpression = (node) => node.type === AST_NODE_TYPES.TSAsExpression || node.type === AST_NODE_TYPES.TSTypeAssertion;
-const followTypeAssertionChain = (expression) => isTypeCastExpression(expression) ? followTypeAssertionChain(expression.expression) : expression;
+const isTypeCastExpression$1 = (node) => node.type === AST_NODE_TYPES.TSAsExpression || node.type === AST_NODE_TYPES.TSTypeAssertion;
+const followTypeAssertionChain$1 = (expression) => isTypeCastExpression$1(expression) ? followTypeAssertionChain$1(expression.expression) : expression;
 
-const RULE_NAME$X = "prefer-lowercase-title";
+const RULE_NAME$Y = "prefer-lowercase-title";
 const hasStringAsFirstArgument = (node) => node.arguments[0] && isStringNode(node.arguments[0]);
 const populateIgnores = (ignore) => {
   const ignores = [];
@@ -365,7 +365,7 @@ const populateIgnores = (ignore) => {
   return ignores;
 };
 const lowerCaseTitle = createEslintRule({
-  name: RULE_NAME$X,
+  name: RULE_NAME$Y,
   meta: {
     type: "problem",
     docs: {
@@ -462,9 +462,9 @@ const lowerCaseTitle = createEslintRule({
   }
 });
 
-const RULE_NAME$W = "max-nested-describe";
+const RULE_NAME$X = "max-nested-describe";
 const maxNestedDescribe = createEslintRule({
-  name: RULE_NAME$W,
+  name: RULE_NAME$X,
   meta: {
     type: "problem",
     docs: {
@@ -522,13 +522,13 @@ const maxNestedDescribe = createEslintRule({
   }
 });
 
-const RULE_NAME$V = "no-identical-title";
+const RULE_NAME$W = "no-identical-title";
 const newDescribeContext = () => ({
   describeTitles: [],
   testTitles: []
 });
 const noIdenticalTitle = createEslintRule({
-  name: RULE_NAME$V,
+  name: RULE_NAME$W,
   meta: {
     type: "problem",
     docs: {
@@ -586,7 +586,7 @@ const noIdenticalTitle = createEslintRule({
   }
 });
 
-const RULE_NAME$U = "no-focused-tests";
+const RULE_NAME$V = "no-focused-tests";
 const isTestOrDescribe = (node) => {
   return node.type === "Identifier" && ["it", "test", "describe"].includes(node.name);
 };
@@ -594,7 +594,7 @@ const isOnly = (node) => {
   return node.type === "Identifier" && node.name === "only";
 };
 const noFocusedTests = createEslintRule({
-  name: RULE_NAME$U,
+  name: RULE_NAME$V,
   meta: {
     type: "problem",
     docs: {
@@ -666,9 +666,9 @@ const noFocusedTests = createEslintRule({
   }
 });
 
-const RULE_NAME$T = "no-conditional-tests";
+const RULE_NAME$U = "no-conditional-tests";
 const noConditionalTest = createEslintRule({
-  name: RULE_NAME$T,
+  name: RULE_NAME$U,
   meta: {
     type: "problem",
     docs: {
@@ -708,7 +708,7 @@ function parsePluginSettings(settings) {
   };
 }
 
-const RULE_NAME$S = "expect-expect";
+const RULE_NAME$T = "expect-expect";
 function matchesAssertFunctionName(nodeName, patterns) {
   return patterns.some(
     (p) => new RegExp(
@@ -722,7 +722,7 @@ function matchesAssertFunctionName(nodeName, patterns) {
   );
 }
 const expectExpect = createEslintRule({
-  name: RULE_NAME$S,
+  name: RULE_NAME$T,
   meta: {
     type: "suggestion",
     docs: {
@@ -798,7 +798,7 @@ const expectExpect = createEslintRule({
   }
 });
 
-const RULE_NAME$R = "consistent-test-it";
+const RULE_NAME$S = "consistent-test-it";
 const buildFixer = (callee, nodeName, preferredTestKeyword) => (fixer) => [
   fixer.replaceText(
     callee.type === AST_NODE_TYPES.MemberExpression ? callee.object : callee,
@@ -816,7 +816,7 @@ function getOppositeTestKeyword(test) {
   return TestCaseName.test;
 }
 const consistentTestIt = createEslintRule({
-  name: RULE_NAME$R,
+  name: RULE_NAME$S,
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -914,7 +914,7 @@ const consistentTestIt = createEslintRule({
   }
 });
 
-const RULE_NAME$Q = "prefer-to-be";
+const RULE_NAME$R = "prefer-to-be";
 const isNullLiteral = (node) => node.type === AST_NODE_TYPES.Literal && node.value === null;
 const isNullEqualityMatcher = (expectFnCall) => isNullLiteral(getFirstMatcherArg(expectFnCall));
 const isFirstArgumentIdentifier = (expectFnCall, name) => isIdentifier(getFirstMatcherArg(expectFnCall), name);
@@ -950,7 +950,7 @@ const reportPreferToBe = (context, whatToBe, expectFnCall, func, modifierNode) =
   });
 };
 const preferToBe = createEslintRule({
-  name: RULE_NAME$Q,
+  name: RULE_NAME$R,
   meta: {
     type: "suggestion",
     docs: {
@@ -1002,9 +1002,9 @@ const preferToBe = createEslintRule({
   }
 });
 
-const RULE_NAME$P = "no-hooks";
+const RULE_NAME$Q = "no-hooks";
 const noHooks = createEslintRule({
-  name: RULE_NAME$P,
+  name: RULE_NAME$Q,
   meta: {
     type: "suggestion",
     docs: {
@@ -1043,9 +1043,9 @@ const noHooks = createEslintRule({
   }
 });
 
-const RULE_NAME$O = "no-restricted-vi-methods";
+const RULE_NAME$P = "no-restricted-vi-methods";
 const noRestrictedViMethods = createEslintRule({
-  name: RULE_NAME$O,
+  name: RULE_NAME$P,
   meta: {
     type: "suggestion",
     docs: {
@@ -1085,11 +1085,11 @@ const noRestrictedViMethods = createEslintRule({
   }
 });
 
-const RULE_NAME$N = "consistent-test-filename";
+const RULE_NAME$O = "consistent-test-filename";
 const defaultPattern = /.*\.test\.[tj]sx?$/;
 const defaultTestsPattern = /.*\.(test|spec)\.[tj]sx?$/;
 const consistentTestFilename = createEslintRule({
-  name: RULE_NAME$N,
+  name: RULE_NAME$O,
   meta: {
     type: "problem",
     docs: {
@@ -1144,9 +1144,9 @@ const consistentTestFilename = createEslintRule({
   }
 });
 
-const RULE_NAME$M = "max-expects";
+const RULE_NAME$N = "max-expects";
 const maxExpect = createEslintRule({
-  name: RULE_NAME$M,
+  name: RULE_NAME$N,
   meta: {
     docs: {
       requiresTypeChecking: false,
@@ -1202,9 +1202,9 @@ const maxExpect = createEslintRule({
   }
 });
 
-const RULE_NAME$L = "no-alias-methods";
+const RULE_NAME$M = "no-alias-methods";
 const noAliasMethod = createEslintRule({
-  name: RULE_NAME$L,
+  name: RULE_NAME$M,
   meta: {
     docs: {
       description: "disallow alias methods",
@@ -1254,12 +1254,12 @@ const noAliasMethod = createEslintRule({
   }
 });
 
-const RULE_NAME$K = "no-commented-out-tests";
+const RULE_NAME$L = "no-commented-out-tests";
 function hasTests(node) {
   return /^\s*[xf]?(test|it|describe)(\.\w+|\[['"]\w+['"]\])?\s*\(/mu.test(node.value);
 }
 const noCommentedOutTests = createEslintRule({
-  name: RULE_NAME$K,
+  name: RULE_NAME$L,
   meta: {
     docs: {
       description: "disallow commented out tests",
@@ -1289,10 +1289,10 @@ const noCommentedOutTests = createEslintRule({
   }
 });
 
-const RULE_NAME$J = "no-conditional-expect";
+const RULE_NAME$K = "no-conditional-expect";
 const isCatchCall = (node) => node.callee.type === AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property, "catch");
 const noConditionalExpect = createEslintRule({
-  name: RULE_NAME$J,
+  name: RULE_NAME$K,
   meta: {
     type: "problem",
     docs: {
@@ -1358,9 +1358,9 @@ const noConditionalExpect = createEslintRule({
   }
 });
 
-const RULE_NAME$I = "no-import-node-test";
+const RULE_NAME$J = "no-import-node-test";
 const noImportNodeTest = createEslintRule({
-  name: RULE_NAME$I,
+  name: RULE_NAME$J,
   meta: {
     docs: {
       description: "disallow importing `node:test`",
@@ -1392,9 +1392,9 @@ const noImportNodeTest = createEslintRule({
   }
 });
 
-const RULE_NAME$H = "no-conditional-in-test";
+const RULE_NAME$I = "no-conditional-in-test";
 const noConditionalInTest = createEslintRule({
-  name: RULE_NAME$H,
+  name: RULE_NAME$I,
   meta: {
     docs: {
       description: "disallow conditional tests",
@@ -1422,9 +1422,9 @@ const noConditionalInTest = createEslintRule({
   }
 });
 
-const RULE_NAME$G = "no-disabled-tests";
+const RULE_NAME$H = "no-disabled-tests";
 const noDisabledTests = createEslintRule({
-  name: RULE_NAME$G,
+  name: RULE_NAME$H,
   meta: {
     type: "suggestion",
     docs: {
@@ -1493,7 +1493,7 @@ const noDisabledTests = createEslintRule({
   }
 });
 
-const RULE_NAME$F = "no-done-callback";
+const RULE_NAME$G = "no-done-callback";
 const findCallbackArg = (node, isVitestEach, context) => {
   if (isVitestEach)
     return node.arguments[1];
@@ -1505,7 +1505,7 @@ const findCallbackArg = (node, isVitestEach, context) => {
   return null;
 };
 const noDoneCallback = createEslintRule({
-  name: RULE_NAME$F,
+  name: RULE_NAME$G,
   meta: {
     type: "suggestion",
     docs: {
@@ -1605,9 +1605,9 @@ const noDoneCallback = createEslintRule({
   }
 });
 
-const RULE_NAME$E = "no-duplicate-hooks";
+const RULE_NAME$F = "no-duplicate-hooks";
 const noDuplicateHooks = createEslintRule({
-  name: RULE_NAME$E,
+  name: RULE_NAME$F,
   meta: {
     docs: {
       recommended: false,
@@ -1650,7 +1650,7 @@ const noDuplicateHooks = createEslintRule({
   }
 });
 
-const RULE_NAME$D = "no-large-snapshots";
+const RULE_NAME$E = "no-large-snapshots";
 const reportOnViolation = (context, node, { maxSize: lineLimit = 50, allowedSnapshots = {} }) => {
   const startLine = node.loc.start.line;
   const endLine = node.loc.end.line;
@@ -1683,7 +1683,7 @@ const reportOnViolation = (context, node, { maxSize: lineLimit = 50, allowedSnap
   }
 };
 const noLargeSnapshots = createEslintRule({
-  name: RULE_NAME$D,
+  name: RULE_NAME$E,
   meta: {
     docs: {
       description: "disallow large snapshots",
@@ -1741,9 +1741,9 @@ const noLargeSnapshots = createEslintRule({
   }
 });
 
-const RULE_NAME$C = "no-interpolation-in-snapshots";
+const RULE_NAME$D = "no-interpolation-in-snapshots";
 const nonInterpolationInSnapShots = createEslintRule({
-  name: RULE_NAME$C,
+  name: RULE_NAME$D,
   meta: {
     type: "problem",
     docs: {
@@ -1784,9 +1784,9 @@ const nonInterpolationInSnapShots = createEslintRule({
 const mocksDirName = "__mocks__";
 const isMockPath = (path) => path.split(posix.sep).includes(mocksDirName);
 const isMockImportLiteral = (expression) => isStringNode(expression) && isMockPath(getStringValue(expression));
-const RULE_NAME$B = "no-mocks-import";
+const RULE_NAME$C = "no-mocks-import";
 const noMocksImport = createEslintRule({
-  name: RULE_NAME$B,
+  name: RULE_NAME$C,
   meta: {
     type: "problem",
     docs: {
@@ -1814,14 +1814,14 @@ const noMocksImport = createEslintRule({
   }
 });
 
-const RULE_NAME$A = "no-restricted-matchers";
+const RULE_NAME$B = "no-restricted-matchers";
 const isChainRestricted = (chain, restriction) => {
   if (ModifierName.hasOwnProperty(restriction) || restriction.endsWith(".not"))
     return chain.startsWith(restriction);
   return chain === restriction;
 };
 const noRestrictedMatchers = createEslintRule({
-  name: RULE_NAME$A,
+  name: RULE_NAME$B,
   meta: {
     docs: {
       description: "disallow the use of certain matchers",
@@ -1867,7 +1867,7 @@ const noRestrictedMatchers = createEslintRule({
   }
 });
 
-const RULE_NAME$z = "no-standalone-expect";
+const RULE_NAME$A = "no-standalone-expect";
 const getBlockType = (statement, context) => {
   const func = statement.parent;
   if (!func)
@@ -1884,7 +1884,7 @@ const getBlockType = (statement, context) => {
   return null;
 };
 const noStandaloneExpect = createEslintRule({
-  name: RULE_NAME$z,
+  name: RULE_NAME$A,
   meta: {
     docs: {
       description: "disallow using `expect` outside of `it` or `test` blocks",
@@ -1957,9 +1957,9 @@ const noStandaloneExpect = createEslintRule({
   }
 });
 
-const RULE_NAME$y = "no-test-prefixes";
+const RULE_NAME$z = "no-test-prefixes";
 const noTestPrefixes = createEslintRule({
-  name: RULE_NAME$y,
+  name: RULE_NAME$z,
   meta: {
     docs: {
       description: "disallow using `test` as a prefix",
@@ -1998,7 +1998,7 @@ const noTestPrefixes = createEslintRule({
   }
 });
 
-const RULE_NAME$x = "no-test-return-statement";
+const RULE_NAME$y = "no-test-return-statement";
 const getBody = (args) => {
   const [, secondArg] = args;
   if (secondArg && isFunction(secondArg) && secondArg.body.type === AST_NODE_TYPES.BlockStatement)
@@ -2006,7 +2006,7 @@ const getBody = (args) => {
   return [];
 };
 const noTestReturnStatement = createEslintRule({
-  name: RULE_NAME$x,
+  name: RULE_NAME$y,
   meta: {
     type: "problem",
     docs: {
@@ -2044,9 +2044,9 @@ const noTestReturnStatement = createEslintRule({
   }
 });
 
-const RULE_NAME$w = "prefer-called-with";
+const RULE_NAME$x = "prefer-called-with";
 const preferCalledWith = createEslintRule({
-  name: RULE_NAME$w,
+  name: RULE_NAME$x,
   meta: {
     docs: {
       description: "enforce using `toBeCalledWith()` or `toHaveBeenCalledWith()`",
@@ -2085,7 +2085,7 @@ const preferCalledWith = createEslintRule({
   }
 });
 
-const RULE_NAME$v = "valid-title";
+const RULE_NAME$w = "valid-title";
 const trimFXPrefix = (word) => ["f", "x"].includes(word.charAt(0)) ? word.substring(1) : word;
 const quoteStringValue = (node) => node.type === AST_NODE_TYPES.TemplateLiteral ? `\`${node.quasis[0].value.raw}\`` : node.raw;
 const MatcherAndMessageSchema = {
@@ -2135,7 +2135,7 @@ const doesBinaryExpressionContainStringNode = (binaryExp) => {
   return isStringNode(binaryExp.left);
 };
 const validTitle = createEslintRule({
-  name: RULE_NAME$v,
+  name: RULE_NAME$w,
   meta: {
     docs: {
       description: "enforce valid titles",
@@ -2315,7 +2315,7 @@ const validTitle = createEslintRule({
   }
 });
 
-const RULE_NAME$u = "valid-expect";
+const RULE_NAME$v = "valid-expect";
 const defaultAsyncMatchers = ["toReject", "toResolve"];
 const getPromiseCallExpressionNode = (node) => {
   if (node.type === AST_NODE_TYPES.ArrayExpression && node.parent && node.parent.type === AST_NODE_TYPES.CallExpression)
@@ -2345,7 +2345,7 @@ const isAcceptableReturnNode = (node, allowReturn) => {
   ].includes(node.type);
 };
 const validExpect = createEslintRule({
-  name: RULE_NAME$u,
+  name: RULE_NAME$v,
   meta: {
     docs: {
       description: "enforce valid `expect()` usage",
@@ -2519,9 +2519,9 @@ const isBooleanEqualityMatcher = (expectFnCall) => {
 const isInstanceOfBinaryExpression = (node, className) => node.type === AST_NODE_TYPES.BinaryExpression && node.operator === "instanceof" && isSupportedAccessor(node.right, className);
 const hasOnlyOneArgument = (call) => call.arguments.length === 1;
 
-const RULE_NAME$t = "prefer-to-be-object";
+const RULE_NAME$u = "prefer-to-be-object";
 const preferToBeObject = createEslintRule({
-  name: RULE_NAME$t,
+  name: RULE_NAME$u,
   meta: {
     type: "suggestion",
     docs: {
@@ -2575,7 +2575,7 @@ const preferToBeObject = createEslintRule({
             if (vitestFnCall.args.length) {
               const [matcherArg] = vitestFnCall.args;
               fixes.push(fixer.remove(matcherArg));
-              invertCondition = matcherArg.type === AST_NODE_TYPES.Literal && followTypeAssertionChain(matcherArg).value === false;
+              invertCondition = matcherArg.type === AST_NODE_TYPES.Literal && followTypeAssertionChain$1(matcherArg).value === false;
             }
             if (invertCondition) {
               const notModifier = vitestFnCall.modifiers.find((node2) => getAccessorValue(node2) === "not");
@@ -2594,10 +2594,10 @@ const preferToBeObject = createEslintRule({
   }
 });
 
-const RULE_NAME$s = "prefer-to-be-truthy";
+const RULE_NAME$t = "prefer-to-be-truthy";
 const isTrueLiteral = (node) => node.type === AST_NODE_TYPES.Literal && node.value === true;
 const preferToBeTruthy = createEslintRule({
-  name: RULE_NAME$s,
+  name: RULE_NAME$t,
   meta: {
     type: "suggestion",
     docs: {
@@ -2632,10 +2632,10 @@ const preferToBeTruthy = createEslintRule({
   }
 });
 
-const RULE_NAME$r = "prefer-to-be-falsy";
+const RULE_NAME$s = "prefer-to-be-falsy";
 const isFalseLiteral = (node) => node.type === AST_NODE_TYPES.Literal && node.value === false;
 const preferToBeFalsy = createEslintRule({
-  name: RULE_NAME$r,
+  name: RULE_NAME$s,
   meta: {
     type: "suggestion",
     docs: {
@@ -2670,9 +2670,9 @@ const preferToBeFalsy = createEslintRule({
   }
 });
 
-const RULE_NAME$q = "prefer-to-have-length";
+const RULE_NAME$r = "prefer-to-have-length";
 const preferToHaveLength = createEslintRule({
-  name: RULE_NAME$q,
+  name: RULE_NAME$r,
   meta: {
     type: "suggestion",
     docs: {
@@ -2720,9 +2720,9 @@ const preferToHaveLength = createEslintRule({
   }
 });
 
-const RULE_NAME$p = "prefer-equality-matcher";
+const RULE_NAME$q = "prefer-equality-matcher";
 const preferEqualityMatcher = createEslintRule({
-  name: RULE_NAME$p,
+  name: RULE_NAME$q,
   meta: {
     type: "suggestion",
     docs: {
@@ -2794,9 +2794,9 @@ const preferEqualityMatcher = createEslintRule({
   }
 });
 
-const RULE_NAME$o = "prefer-strict-equal";
+const RULE_NAME$p = "prefer-strict-equal";
 const preferStrictEqual = createEslintRule({
-  name: RULE_NAME$o,
+  name: RULE_NAME$p,
   meta: {
     type: "suggestion",
     docs: {
@@ -2837,9 +2837,9 @@ const preferStrictEqual = createEslintRule({
   }
 });
 
-const RULE_NAME$n = "prefer-expect-resolves";
+const RULE_NAME$o = "prefer-expect-resolves";
 const preferExpectResolves = createEslintRule({
-  name: RULE_NAME$n,
+  name: RULE_NAME$o,
   meta: {
     type: "suggestion",
     docs: {
@@ -2882,9 +2882,9 @@ const preferExpectResolves = createEslintRule({
   })
 });
 
-const RULE_NAME$m = "prefer-each";
+const RULE_NAME$n = "prefer-each";
 const preferEach = createEslintRule({
-  name: RULE_NAME$m,
+  name: RULE_NAME$n,
   meta: {
     type: "suggestion",
     docs: {
@@ -2943,9 +2943,9 @@ const preferEach = createEslintRule({
   }
 });
 
-const RULE_NAME$l = "prefer-hooks-on-top";
+const RULE_NAME$m = "prefer-hooks-on-top";
 const preferHooksOnTop = createEslintRule({
-  name: RULE_NAME$l,
+  name: RULE_NAME$m,
   meta: {
     type: "suggestion",
     docs: {
@@ -2979,10 +2979,10 @@ const preferHooksOnTop = createEslintRule({
   }
 });
 
-const RULE_NAME$k = "prefer-hooks-in-order";
+const RULE_NAME$l = "prefer-hooks-in-order";
 const HooksOrder = ["beforeAll", "beforeEach", "afterEach", "afterAll"];
 const preferHooksInOrder = createEslintRule({
-  name: RULE_NAME$k,
+  name: RULE_NAME$l,
   meta: {
     type: "suggestion",
     docs: {
@@ -3037,7 +3037,7 @@ const preferHooksInOrder = createEslintRule({
   }
 });
 
-const RULE_NAME$j = "prefer-mock-promise-shorthand";
+const RULE_NAME$k = "prefer-mock-promise-shorthand";
 const withOnce = (name, addOnce) => {
   return `${name}${addOnce ? "Once" : ""}`;
 };
@@ -3049,7 +3049,7 @@ const findSingleReturnArgumentNode = (fnNode) => {
   return null;
 };
 const preferMockPromiseShorthand = createEslintRule({
-  name: RULE_NAME$j,
+  name: RULE_NAME$k,
   meta: {
     type: "suggestion",
     docs: {
@@ -3110,6 +3110,99 @@ const preferMockPromiseShorthand = createEslintRule({
   }
 });
 
+const require = createRequire(import.meta.url);
+const eslintRequire = createRequire(require.resolve("eslint"));
+eslintRequire.resolve("espree");
+const STATEMENT_LIST_PARENTS = /* @__PURE__ */ new Set([
+  AST_NODE_TYPES.Program,
+  AST_NODE_TYPES.BlockStatement,
+  AST_NODE_TYPES.SwitchCase,
+  AST_NODE_TYPES.SwitchStatement
+]);
+const isValidParent = (parentType) => {
+  return STATEMENT_LIST_PARENTS.has(parentType);
+};
+const isTokenASemicolon = (token) => token.value === ";" && token.type === AST_TOKEN_TYPES.Punctuator;
+const getActualLastToken = (sourceCode, node) => {
+  const semiToken = sourceCode.getLastToken(node);
+  const prevToken = sourceCode.getTokenBefore(semiToken);
+  const nextToken = sourceCode.getTokenAfter(semiToken);
+  const isSemicolonLessStyle = Boolean(
+    prevToken && nextToken && prevToken.range[0] >= node.range[0] && isTokenASemicolon(semiToken) && semiToken.loc.start.line !== prevToken.loc.end.line && semiToken.loc.end.line === nextToken.loc.start.line
+  );
+  return isSemicolonLessStyle ? prevToken : semiToken;
+};
+const getPaddingLineSequences = (prevNode, nextNode, sourceCode) => {
+  const pairs = [];
+  const includeComments = true;
+  let prevToken = getActualLastToken(sourceCode, prevNode);
+  if (nextNode.loc.start.line - prevNode.loc.end.line >= 2) {
+    do {
+      const token = sourceCode.getTokenAfter(prevToken, { includeComments });
+      if (token.loc.start.line - prevToken.loc.end.line >= 2) {
+        pairs.push([prevToken, token]);
+      }
+      prevToken = token;
+    } while (prevToken.range[0] < nextNode.range[0]);
+  }
+  return pairs;
+};
+const areTokensOnSameLine = (left, right) => left.loc.end.line === right.loc.start.line;
+const isTypeCastExpression = (node) => node.type === AST_NODE_TYPES.TSAsExpression || node.type === AST_NODE_TYPES.TSTypeAssertion;
+const followTypeAssertionChain = (expression) => isTypeCastExpression(expression) ? followTypeAssertionChain(expression.expression) : expression;
+
+const RULE_NAME$j = "prefer-vi-mocked";
+const mockTypes = ["Mock", "MockedFunction", "MockedClass", "MockedObject"];
+const preferViMocked = createEslintRule({
+  name: RULE_NAME$j,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefer `vi.mocked()` over `fn as Mock`",
+      requiresTypeChecking: true,
+      recommended: false
+    },
+    fixable: "code",
+    messages: {
+      useViMocked: "Prefer `vi.mocked()`"
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    function check(node) {
+      const { typeAnnotation } = node;
+      if (typeAnnotation.type !== AST_NODE_TYPES.TSTypeReference)
+        return;
+      const { typeName } = typeAnnotation;
+      if (typeName.type !== AST_NODE_TYPES.Identifier)
+        return;
+      if (!mockTypes.includes(typeName.name))
+        return;
+      const fnName = context.sourceCode.text.slice(
+        ...followTypeAssertionChain(node.expression).range
+      );
+      context.report({
+        node,
+        messageId: "useViMocked",
+        fix(fixer) {
+          return fixer.replaceText(node, `vi.mocked(${fnName})`);
+        }
+      });
+    }
+    return {
+      TSAsExpression(node) {
+        if (node.parent.type === AST_NODE_TYPES.TSAsExpression)
+          return;
+        check(node);
+      },
+      TSTypeAssertion(node) {
+        check(node);
+      }
+    };
+  }
+});
+
 const RULE_NAME$i = "prefer-snapshot-hint";
 const snapshotMatchers = ["toMatchSnapshot", "toThrowErrorMatchingSnapshot"];
 const snapshotMatcherNames = snapshotMatchers;
@@ -4009,45 +4102,6 @@ const preferExpectAssertions = createEslintRule({
   }
 });
 
-const require = createRequire(import.meta.url);
-const eslintRequire = createRequire(require.resolve("eslint"));
-eslintRequire.resolve("espree");
-const STATEMENT_LIST_PARENTS = /* @__PURE__ */ new Set([
-  AST_NODE_TYPES.Program,
-  AST_NODE_TYPES.BlockStatement,
-  AST_NODE_TYPES.SwitchCase,
-  AST_NODE_TYPES.SwitchStatement
-]);
-const isValidParent = (parentType) => {
-  return STATEMENT_LIST_PARENTS.has(parentType);
-};
-const isTokenASemicolon = (token) => token.value === ";" && token.type === AST_TOKEN_TYPES.Punctuator;
-const getActualLastToken = (sourceCode, node) => {
-  const semiToken = sourceCode.getLastToken(node);
-  const prevToken = sourceCode.getTokenBefore(semiToken);
-  const nextToken = sourceCode.getTokenAfter(semiToken);
-  const isSemicolonLessStyle = Boolean(
-    prevToken && nextToken && prevToken.range[0] >= node.range[0] && isTokenASemicolon(semiToken) && semiToken.loc.start.line !== prevToken.loc.end.line && semiToken.loc.end.line === nextToken.loc.start.line
-  );
-  return isSemicolonLessStyle ? prevToken : semiToken;
-};
-const getPaddingLineSequences = (prevNode, nextNode, sourceCode) => {
-  const pairs = [];
-  const includeComments = true;
-  let prevToken = getActualLastToken(sourceCode, prevNode);
-  if (nextNode.loc.start.line - prevNode.loc.end.line >= 2) {
-    do {
-      const token = sourceCode.getTokenAfter(prevToken, { includeComments });
-      if (token.loc.start.line - prevToken.loc.end.line >= 2) {
-        pairs.push([prevToken, token]);
-      }
-      prevToken = token;
-    } while (prevToken.range[0] < nextNode.range[0]);
-  }
-  return pairs;
-};
-const areTokensOnSameLine = (left, right) => left.loc.end.line === right.loc.start.line;
-
 var PaddingType = /* @__PURE__ */ ((PaddingType2) => {
   PaddingType2[PaddingType2["Any"] = 0] = "Any";
   PaddingType2[PaddingType2["Always"] = 1] = "Always";
@@ -4412,17 +4466,18 @@ const createConfigLegacy = (rules) => ({
   }, {})
 });
 const allRules = {
+  [RULE_NAME$Y]: "warn",
   [RULE_NAME$X]: "warn",
-  [RULE_NAME$W]: "warn",
+  [RULE_NAME$V]: "warn",
   [RULE_NAME$U]: "warn",
-  [RULE_NAME$T]: "warn",
-  [RULE_NAME$R]: "warn",
+  [RULE_NAME$S]: "warn",
+  [RULE_NAME$Q]: "warn",
   [RULE_NAME$P]: "warn",
   [RULE_NAME$O]: "warn",
   [RULE_NAME$N]: "warn",
   [RULE_NAME$M]: "warn",
-  [RULE_NAME$L]: "warn",
-  [RULE_NAME$J]: "warn",
+  [RULE_NAME$K]: "warn",
+  [RULE_NAME$I]: "warn",
   [RULE_NAME$H]: "warn",
   [RULE_NAME$G]: "warn",
   [RULE_NAME$F]: "warn",
@@ -4434,10 +4489,10 @@ const allRules = {
   [RULE_NAME$z]: "warn",
   [RULE_NAME$y]: "warn",
   [RULE_NAME$x]: "warn",
-  [RULE_NAME$w]: "warn",
-  [RULE_NAME$r]: "warn",
-  [RULE_NAME$t]: "warn",
   [RULE_NAME$s]: "warn",
+  [RULE_NAME$u]: "warn",
+  [RULE_NAME$t]: "warn",
+  [RULE_NAME$r]: "warn",
   [RULE_NAME$q]: "warn",
   [RULE_NAME$p]: "warn",
   [RULE_NAME$o]: "warn",
@@ -4455,7 +4510,7 @@ const allRules = {
   [RULE_NAME$a]: "warn",
   [RULE_NAME$9]: "warn",
   [RULE_NAME$8]: "warn",
-  [RULE_NAME$Q]: "warn",
+  [RULE_NAME$R]: "warn",
   [RULE_NAME$7]: "warn",
   [RULE_NAME$6]: "warn",
   [RULE_NAME]: "warn",
@@ -4466,14 +4521,14 @@ const allRules = {
   [RULE_NAME$1]: "warn"
 };
 const recommended = {
-  [RULE_NAME$S]: "error",
-  [RULE_NAME$V]: "error",
-  [RULE_NAME$K]: "error",
+  [RULE_NAME$T]: "error",
+  [RULE_NAME$W]: "error",
+  [RULE_NAME$L]: "error",
+  [RULE_NAME$w]: "error",
   [RULE_NAME$v]: "error",
-  [RULE_NAME$u]: "error",
   [RULE_NAME$h]: "error",
   [RULE_NAME$d]: "error",
-  [RULE_NAME$I]: "error"
+  [RULE_NAME$J]: "error"
 };
 const plugin = {
   meta: {
@@ -4481,48 +4536,49 @@ const plugin = {
     version
   },
   rules: {
-    [RULE_NAME$X]: lowerCaseTitle,
-    [RULE_NAME$W]: maxNestedDescribe,
-    [RULE_NAME$V]: noIdenticalTitle,
-    [RULE_NAME$U]: noFocusedTests,
-    [RULE_NAME$T]: noConditionalTest,
-    [RULE_NAME$S]: expectExpect,
-    [RULE_NAME$R]: consistentTestIt,
-    [RULE_NAME$Q]: preferToBe,
-    [RULE_NAME$P]: noHooks,
-    [RULE_NAME$O]: noRestrictedViMethods,
-    [RULE_NAME$N]: consistentTestFilename,
-    [RULE_NAME$M]: maxExpect,
-    [RULE_NAME$L]: noAliasMethod,
-    [RULE_NAME$K]: noCommentedOutTests,
-    [RULE_NAME$J]: noConditionalExpect,
-    [RULE_NAME$H]: noConditionalInTest,
-    [RULE_NAME$G]: noDisabledTests,
-    [RULE_NAME$F]: noDoneCallback,
-    [RULE_NAME$E]: noDuplicateHooks,
-    [RULE_NAME$D]: noLargeSnapshots,
-    [RULE_NAME$C]: nonInterpolationInSnapShots,
-    [RULE_NAME$B]: noMocksImport,
-    [RULE_NAME$A]: noRestrictedMatchers,
-    [RULE_NAME$z]: noStandaloneExpect,
-    [RULE_NAME$y]: noTestPrefixes,
-    [RULE_NAME$x]: noTestReturnStatement,
-    [RULE_NAME$I]: noImportNodeTest,
-    [RULE_NAME$w]: preferCalledWith,
-    [RULE_NAME$v]: validTitle,
-    [RULE_NAME$u]: validExpect,
-    [RULE_NAME$r]: preferToBeFalsy,
-    [RULE_NAME$t]: preferToBeObject,
-    [RULE_NAME$s]: preferToBeTruthy,
-    [RULE_NAME$q]: preferToHaveLength,
-    [RULE_NAME$p]: preferEqualityMatcher,
-    [RULE_NAME$o]: preferStrictEqual,
-    [RULE_NAME$n]: preferExpectResolves,
-    [RULE_NAME$m]: preferEach,
-    [RULE_NAME$l]: preferHooksOnTop,
-    [RULE_NAME$k]: preferHooksInOrder,
+    [RULE_NAME$Y]: lowerCaseTitle,
+    [RULE_NAME$X]: maxNestedDescribe,
+    [RULE_NAME$W]: noIdenticalTitle,
+    [RULE_NAME$V]: noFocusedTests,
+    [RULE_NAME$U]: noConditionalTest,
+    [RULE_NAME$T]: expectExpect,
+    [RULE_NAME$S]: consistentTestIt,
+    [RULE_NAME$R]: preferToBe,
+    [RULE_NAME$Q]: noHooks,
+    [RULE_NAME$P]: noRestrictedViMethods,
+    [RULE_NAME$O]: consistentTestFilename,
+    [RULE_NAME$N]: maxExpect,
+    [RULE_NAME$M]: noAliasMethod,
+    [RULE_NAME$L]: noCommentedOutTests,
+    [RULE_NAME$K]: noConditionalExpect,
+    [RULE_NAME$I]: noConditionalInTest,
+    [RULE_NAME$H]: noDisabledTests,
+    [RULE_NAME$G]: noDoneCallback,
+    [RULE_NAME$F]: noDuplicateHooks,
+    [RULE_NAME$E]: noLargeSnapshots,
+    [RULE_NAME$D]: nonInterpolationInSnapShots,
+    [RULE_NAME$C]: noMocksImport,
+    [RULE_NAME$B]: noRestrictedMatchers,
+    [RULE_NAME$A]: noStandaloneExpect,
+    [RULE_NAME$z]: noTestPrefixes,
+    [RULE_NAME$y]: noTestReturnStatement,
+    [RULE_NAME$J]: noImportNodeTest,
+    [RULE_NAME$x]: preferCalledWith,
+    [RULE_NAME$w]: validTitle,
+    [RULE_NAME$v]: validExpect,
+    [RULE_NAME$s]: preferToBeFalsy,
+    [RULE_NAME$u]: preferToBeObject,
+    [RULE_NAME$t]: preferToBeTruthy,
+    [RULE_NAME$r]: preferToHaveLength,
+    [RULE_NAME$q]: preferEqualityMatcher,
+    [RULE_NAME$p]: preferStrictEqual,
+    [RULE_NAME$o]: preferExpectResolves,
+    [RULE_NAME$n]: preferEach,
+    [RULE_NAME$m]: preferHooksOnTop,
+    [RULE_NAME$l]: preferHooksInOrder,
     [RULE_NAME$d]: requireLocalTestContextForConcurrentSnapshots,
-    [RULE_NAME$j]: preferMockPromiseShorthand,
+    [RULE_NAME$k]: preferMockPromiseShorthand,
+    [RULE_NAME$j]: preferViMocked,
     [RULE_NAME$i]: preferSnapshotHint,
     [RULE_NAME$h]: validDescribeCallback,
     [RULE_NAME$g]: requireTopLevelDescribe,