import{ESLintUtils as ie,AST_NODE_TYPES as i,AST_TOKEN_TYPES as $t}from"@typescript-eslint/utils";import U from"typescript";import{isAbsolute as js,posix as _s}from"node:path";import{createRequire as Ot}from"node:module";import{DefinitionType as Rt}from"@typescript-eslint/scope-manager";const Ds="1.3.8",d=ie.RuleCreator(e=>`https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/${e}.md`),Ws=(e,s)=>e&&s?`${e}.${s}`:null,M=e=>e.type===i.FunctionExpression||e.type===i.ArrowFunctionExpression;function R(e){if(C(e))return y(e);switch(e.type){case i.TaggedTemplateExpression:return R(e.tag);case i.MemberExpression:return Ws(R(e.object),R(e.property));case i.NewExpression:case i.CallExpression:return R(e.callee)}return null}const C=(e,s)=>L(e,s)||B(e,s),L=(e,s)=>e.type===i.Identifier&&(s===void 0||e.name===s),Hs=(e,s)=>e.type===i.TemplateLiteral&&e.quasis.length===1&&(s===void 0||e.quasis[0].value.raw===s),Vs=(e,s)=>e.type===i.Literal&&typeof e.value=="string"&&(s===void 0||e.value===s),B=(e,s)=>Vs(e,s)||Hs(e,s),y=e=>e.type===i.Identifier?e.name:j(e),j=e=>e?.type===i.TemplateLiteral?e.quasis[0].value.raw:e?.value,G=(e,s,t)=>e.replaceText(s,s.type===i.Identifier?t:`'${t}'`),Nt=(e,s,t,n)=>{const o=t.arguments[n],r=t.arguments[t.arguments.length-1],{sourceCode:a}=s;let c=a.getTokenAfter(r);return c.value===","&&(c=a.getTokenAfter(c)),e.removeRange([o.range[0],c.range[0]])},Ks=(e,s)=>y(e.matcher)==="toBeInstanceOf"&&e.args.length===1&&C(e.args[0],s);var _=(e=>(e.vi="vi",e.vitest="vitest",e))(_||{}),H=(e=>(e.describe="describe",e.fdescribe="fdescribe",e.xdescribe="xdescribe",e))(H||{}),E=(e=>(e.fit="fit",e.it="it",e.test="test",e.xit="xit",e.xtest="xtest",e.bench="bench",e))(E||{}),Bt=(e=>(e.beforeAll="beforeAll",e.beforeEach="beforeEach",e.afterAll="afterAll",e.afterEach="afterEach",e))(Bt||{}),N=(e=>(e.to="to",e.have="have",e.not="not",e.rejects="rejects",e.resolves="resolves",e.returns="returns",e.branded="branded",e.asserts="asserts",e.constructorParameters="constructorParameters",e.parameters="parameters",e.thisParameter="thisParameter",e.guards="guards",e.instance="instance",e.items="items",e))(N||{}),F=(e=>(e.toBe="toBe",e.toEqual="toEqual",e.toStrictEqual="toStrictEqual",e))(F||{});function Lt(e){return e.getCallSignatures().length>0?!0:e.getSymbol()?.getDeclarations()?.some(s=>U.isArrowFunction(s)||U.isClassDeclaration(s)||U.isClassExpression(s)||U.isFunctionDeclaration(s)||U.isFunctionExpression(s)||U.isMethodDeclaration(s)||U.isFunctionTypeNode(s))??!1}const Gs=new Set(["beforeEach","beforeAll","afterEach","afterAll","it","it.skip","it.only","it.concurrent","it.sequential","it.todo","it.fails","it.extend","it.skipIf","it.runIf","it.each","it.skip.only","it.skip.concurrent","it.skip.sequential","it.skip.todo","it.skip.fails","it.only.skip","it.only.concurrent","it.only.sequential","it.only.todo","it.only.fails","it.concurrent.skip","it.concurrent.only","it.concurrent.sequential","it.concurrent.todo","it.concurrent.fails","it.sequential.skip","it.sequential.only","it.sequential.concurrent","it.sequential.todo","it.sequential.fails","it.todo.skip","it.todo.only","it.todo.concurrent","it.todo.sequential","it.todo.fails","it.fails.skip","it.fails.only","it.fails.concurrent","it.fails.sequential","it.fails.todo","it.extend.skip","it.extend.only","it.extend.concurrent","it.extend.sequential","it.extend.todo","it.extend.fails","it.skipIf.skip","it.skipIf.only","it.skipIf.concurrent","it.skipIf.sequential","it.skipIf.todo","it.skipIf.fails","it.runIf.skip","it.runIf.only","it.runIf.concurrent","it.runIf.sequential","it.runIf.todo","it.runIf.fails","it.skip.each","it.only.each","it.concurrent.each","it.sequential.each","it.todo.each","it.fails.each","it.extend.skipIf","it.extend.runIf","it.extend.each","it.skipIf.each","it.runIf.each","it.skip.only.concurrent","it.skip.only.sequential","it.skip.only.todo","it.skip.only.fails","it.skip.concurrent.only","it.skip.concurrent.sequential","it.skip.concurrent.todo","it.skip.concurrent.fails","it.skip.sequential.only","it.skip.sequential.concurrent","it.skip.sequential.todo","it.skip.sequential.fails","it.skip.todo.only","it.skip.todo.concurrent","it.skip.todo.sequential","it.skip.todo.fails","it.skip.fails.only","it.skip.fails.concurrent","it.skip.fails.sequential","it.skip.fails.todo","it.only.skip.concurrent","it.only.skip.sequential","it.only.skip.todo","it.only.skip.fails","it.only.concurrent.skip","it.only.concurrent.sequential","it.only.concurrent.todo","it.only.concurrent.fails","it.only.sequential.skip","it.only.sequential.concurrent","it.only.sequential.todo","it.only.sequential.fails","it.only.todo.skip","it.only.todo.concurrent","it.only.todo.sequential","it.only.todo.fails","it.only.fails.skip","it.only.fails.concurrent","it.only.fails.sequential","it.only.fails.todo","it.concurrent.skip.only","it.concurrent.skip.sequential","it.concurrent.skip.todo","it.concurrent.skip.fails","it.concurrent.only.skip","it.concurrent.only.sequential","it.concurrent.only.todo","it.concurrent.only.fails","it.concurrent.sequential.skip","it.concurrent.sequential.only","it.concurrent.sequential.todo","it.concurrent.sequential.fails","it.concurrent.todo.skip","it.concurrent.todo.only","it.concurrent.todo.sequential","it.concurrent.todo.fails","it.concurrent.fails.skip","it.concurrent.fails.only","it.concurrent.fails.sequential","it.concurrent.fails.todo","it.sequential.skip.only","it.sequential.skip.concurrent","it.sequential.skip.todo","it.sequential.skip.fails","it.sequential.only.skip","it.sequential.only.concurrent","it.sequential.only.todo","it.sequential.only.fails","it.sequential.concurrent.skip","it.sequential.concurrent.only","it.sequential.concurrent.todo","it.sequential.concurrent.fails","it.sequential.todo.skip","it.sequential.todo.only","it.sequential.todo.concurrent","it.sequential.todo.fails","it.sequential.fails.skip","it.sequential.fails.only","it.sequential.fails.concurrent","it.sequential.fails.todo","it.todo.skip.only","it.todo.skip.concurrent","it.todo.skip.sequential","it.todo.skip.fails","it.todo.only.skip","it.todo.only.concurrent","it.todo.only.sequential","it.todo.only.fails","it.todo.concurrent.skip","it.todo.concurrent.only","it.todo.concurrent.sequential","it.todo.concurrent.fails","it.todo.sequential.skip","it.todo.sequential.only","it.todo.sequential.concurrent","it.todo.sequential.fails","it.todo.fails.skip","it.todo.fails.only","it.todo.fails.concurrent","it.todo.fails.sequential","it.fails.skip.only","it.fails.skip.concurrent","it.fails.skip.sequential","it.fails.skip.todo","it.fails.only.skip","it.fails.only.concurrent","it.fails.only.sequential","it.fails.only.todo","it.fails.concurrent.skip","it.fails.concurrent.only","it.fails.concurrent.sequential","it.fails.concurrent.todo","it.fails.sequential.skip","it.fails.sequential.only","it.fails.sequential.concurrent","it.fails.sequential.todo","it.fails.todo.skip","it.fails.todo.only","it.fails.todo.concurrent","it.fails.todo.sequential","it.extend.skip.only","it.extend.skip.concurrent","it.extend.skip.sequential","it.extend.skip.todo","it.extend.skip.fails","it.extend.only.skip","it.extend.only.concurrent","it.extend.only.sequential","it.extend.only.todo","it.extend.only.fails","it.extend.concurrent.skip","it.extend.concurrent.only","it.extend.concurrent.sequential","it.extend.concurrent.todo","it.extend.concurrent.fails","it.extend.sequential.skip","it.extend.sequential.only","it.extend.sequential.concurrent","it.extend.sequential.todo","it.extend.sequential.fails","it.extend.todo.skip","it.extend.todo.only","it.extend.todo.concurrent","it.extend.todo.sequential","it.extend.todo.fails","it.extend.fails.skip","it.extend.fails.only","it.extend.fails.concurrent","it.extend.fails.sequential","it.extend.fails.todo","it.skipIf.skip.only","it.skipIf.skip.concurrent","it.skipIf.skip.sequential","it.skipIf.skip.todo","it.skipIf.skip.fails","it.skipIf.only.skip","it.skipIf.only.concurrent","it.skipIf.only.sequential","it.skipIf.only.todo","it.skipIf.only.fails","it.skipIf.concurrent.skip","it.skipIf.concurrent.only","it.skipIf.concurrent.sequential","it.skipIf.concurrent.todo","it.skipIf.concurrent.fails","it.skipIf.sequential.skip","it.skipIf.sequential.only","it.skipIf.sequential.concurrent","it.skipIf.sequential.todo","it.skipIf.sequential.fails","it.skipIf.todo.skip","it.skipIf.todo.only","it.skipIf.todo.concurrent","it.skipIf.todo.sequential","it.skipIf.todo.fails","it.skipIf.fails.skip","it.skipIf.fails.only","it.skipIf.fails.concurrent","it.skipIf.fails.sequential","it.skipIf.fails.todo","it.runIf.skip.only","it.runIf.skip.concurrent","it.runIf.skip.sequential","it.runIf.skip.todo","it.runIf.skip.fails","it.runIf.only.skip","it.runIf.only.concurrent","it.runIf.only.sequential","it.runIf.only.todo","it.runIf.only.fails","it.runIf.concurrent.skip","it.runIf.concurrent.only","it.runIf.concurrent.sequential","it.runIf.concurrent.todo","it.runIf.concurrent.fails","it.runIf.sequential.skip","it.runIf.sequential.only","it.runIf.sequential.concurrent","it.runIf.sequential.todo","it.runIf.sequential.fails","it.runIf.todo.skip","it.runIf.todo.only","it.runIf.todo.concurrent","it.runIf.todo.sequential","it.runIf.todo.fails","it.runIf.fails.skip","it.runIf.fails.only","it.runIf.fails.concurrent","it.runIf.fails.sequential","it.runIf.fails.todo","it.skip.only.each","it.skip.concurrent.each","it.skip.sequential.each","it.skip.todo.each","it.skip.fails.each","it.only.skip.each","it.only.concurrent.each","it.only.sequential.each","it.only.todo.each","it.only.fails.each","it.concurrent.skip.each","it.concurrent.only.each","it.concurrent.sequential.each","it.concurrent.todo.each","it.concurrent.fails.each","it.sequential.skip.each","it.sequential.only.each","it.sequential.concurrent.each","it.sequential.todo.each","it.sequential.fails.each","it.todo.skip.each","it.todo.only.each","it.todo.concurrent.each","it.todo.sequential.each","it.todo.fails.each","it.fails.skip.each","it.fails.only.each","it.fails.concurrent.each","it.fails.sequential.each","it.fails.todo.each","it.extend.skipIf.skip","it.extend.skipIf.only","it.extend.skipIf.concurrent","it.extend.skipIf.sequential","it.extend.skipIf.todo","it.extend.skipIf.fails","it.extend.runIf.skip","it.extend.runIf.only","it.extend.runIf.concurrent","it.extend.runIf.sequential","it.extend.runIf.todo","it.extend.runIf.fails","it.extend.skip.each","it.extend.only.each","it.extend.concurrent.each","it.extend.sequential.each","it.extend.todo.each","it.extend.fails.each","it.skipIf.skip.each","it.skipIf.only.each","it.skipIf.concurrent.each","it.skipIf.sequential.each","it.skipIf.todo.each","it.skipIf.fails.each","it.runIf.skip.each","it.runIf.only.each","it.runIf.concurrent.each","it.runIf.sequential.each","it.runIf.todo.each","it.runIf.fails.each","it.extend.skipIf.each","it.extend.runIf.each","test","test.skip","test.only","test.concurrent","test.sequential","test.todo","test.fails","test.extend","test.skipIf","test.runIf","test.each","test.skip.only","test.skip.concurrent","test.skip.sequential","test.skip.todo","test.skip.fails","test.only.skip","test.only.concurrent","test.only.sequential","test.only.todo","test.only.fails","test.concurrent.skip","test.concurrent.only","test.concurrent.sequential","test.concurrent.todo","test.concurrent.fails","test.sequential.skip","test.sequential.only","test.sequential.concurrent","test.sequential.todo","test.sequential.fails","test.todo.skip","test.todo.only","test.todo.concurrent","test.todo.sequential","test.todo.fails","test.fails.skip","test.fails.only","test.fails.concurrent","test.fails.sequential","test.fails.todo","test.extend.skip","test.extend.only","test.extend.concurrent","test.extend.sequential","test.extend.todo","test.extend.fails","test.skipIf.skip","test.skipIf.only","test.skipIf.concurrent","test.skipIf.sequential","test.skipIf.todo","test.skipIf.fails","test.runIf.skip","test.runIf.only","test.runIf.concurrent","test.runIf.sequential","test.runIf.todo","test.runIf.fails","test.skip.each","test.only.each","test.concurrent.each","test.sequential.each","test.todo.each","test.fails.each","test.extend.skipIf","test.extend.runIf","test.extend.each","test.skipIf.each","test.runIf.each","test.skip.only.concurrent","test.skip.only.sequential","test.skip.only.todo","test.skip.only.fails","test.skip.concurrent.only","test.skip.concurrent.sequential","test.skip.concurrent.todo","test.skip.concurrent.fails","test.skip.sequential.only","test.skip.sequential.concurrent","test.skip.sequential.todo","test.skip.sequential.fails","test.skip.todo.only","test.skip.todo.concurrent","test.skip.todo.sequential","test.skip.todo.fails","test.skip.fails.only","test.skip.fails.concurrent","test.skip.fails.sequential","test.skip.fails.todo","test.only.skip.concurrent","test.only.skip.sequential","test.only.skip.todo","test.only.skip.fails","test.only.concurrent.skip","test.only.concurrent.sequential","test.only.concurrent.todo","test.only.concurrent.fails","test.only.sequential.skip","test.only.sequential.concurrent","test.only.sequential.todo","test.only.sequential.fails","test.only.todo.skip","test.only.todo.concurrent","test.only.todo.sequential","test.only.todo.fails","test.only.fails.skip","test.only.fails.concurrent","test.only.fails.sequential","test.only.fails.todo","test.concurrent.skip.only","test.concurrent.skip.sequential","test.concurrent.skip.todo","test.concurrent.skip.fails","test.concurrent.only.skip","test.concurrent.only.sequential","test.concurrent.only.todo","test.concurrent.only.fails","test.concurrent.sequential.skip","test.concurrent.sequential.only","test.concurrent.sequential.todo","test.concurrent.sequential.fails","test.concurrent.todo.skip","test.concurrent.todo.only","test.concurrent.todo.sequential","test.concurrent.todo.fails","test.concurrent.fails.skip","test.concurrent.fails.only","test.concurrent.fails.sequential","test.concurrent.fails.todo","test.sequential.skip.only","test.sequential.skip.concurrent","test.sequential.skip.todo","test.sequential.skip.fails","test.sequential.only.skip","test.sequential.only.concurrent","test.sequential.only.todo","test.sequential.only.fails","test.sequential.concurrent.skip","test.sequential.concurrent.only","test.sequential.concurrent.todo","test.sequential.concurrent.fails","test.sequential.todo.skip","test.sequential.todo.only","test.sequential.todo.concurrent","test.sequential.todo.fails","test.sequential.fails.skip","test.sequential.fails.only","test.sequential.fails.concurrent","test.sequential.fails.todo","test.todo.skip.only","test.todo.skip.concurrent","test.todo.skip.sequential","test.todo.skip.fails","test.todo.only.skip","test.todo.only.concurrent","test.todo.only.sequential","test.todo.only.fails","test.todo.concurrent.skip","test.todo.concurrent.only","test.todo.concurrent.sequential","test.todo.concurrent.fails","test.todo.sequential.skip","test.todo.sequential.only","test.todo.sequential.concurrent","test.todo.sequential.fails","test.todo.fails.skip","test.todo.fails.only","test.todo.fails.concurrent","test.todo.fails.sequential","test.fails.skip.only","test.fails.skip.concurrent","test.fails.skip.sequential","test.fails.skip.todo","test.fails.only.skip","test.fails.only.concurrent","test.fails.only.sequential","test.fails.only.todo","test.fails.concurrent.skip","test.fails.concurrent.only","test.fails.concurrent.sequential","test.fails.concurrent.todo","test.fails.sequential.skip","test.fails.sequential.only","test.fails.sequential.concurrent","test.fails.sequential.todo","test.fails.todo.skip","test.fails.todo.only","test.fails.todo.concurrent","test.fails.todo.sequential","test.extend.skip.only","test.extend.skip.concurrent","test.extend.skip.sequential","test.extend.skip.todo","test.extend.skip.fails","test.extend.only.skip","test.extend.only.concurrent","test.extend.only.sequential","test.extend.only.todo","test.extend.only.fails","test.extend.concurrent.skip","test.extend.concurrent.only","test.extend.concurrent.sequential","test.extend.concurrent.todo","test.extend.concurrent.fails","test.extend.sequential.skip","test.extend.sequential.only","test.extend.sequential.concurrent","test.extend.sequential.todo","test.extend.sequential.fails","test.extend.todo.skip","test.extend.todo.only","test.extend.todo.concurrent","test.extend.todo.sequential","test.extend.todo.fails","test.extend.fails.skip","test.extend.fails.only","test.extend.fails.concurrent","test.extend.fails.sequential","test.extend.fails.todo","test.skipIf.skip.only","test.skipIf.skip.concurrent","test.skipIf.skip.sequential","test.skipIf.skip.todo","test.skipIf.skip.fails","test.skipIf.only.skip","test.skipIf.only.concurrent","test.skipIf.only.sequential","test.skipIf.only.todo","test.skipIf.only.fails","test.skipIf.concurrent.skip","test.skipIf.concurrent.only","test.skipIf.concurrent.sequential","test.skipIf.concurrent.todo","test.skipIf.concurrent.fails","test.skipIf.sequential.skip","test.skipIf.sequential.only","test.skipIf.sequential.concurrent","test.skipIf.sequential.todo","test.skipIf.sequential.fails","test.skipIf.todo.skip","test.skipIf.todo.only","test.skipIf.todo.concurrent","test.skipIf.todo.sequential","test.skipIf.todo.fails","test.skipIf.fails.skip","test.skipIf.fails.only","test.skipIf.fails.concurrent","test.skipIf.fails.sequential","test.skipIf.fails.todo","test.runIf.skip.only","test.runIf.skip.concurrent","test.runIf.skip.sequential","test.runIf.skip.todo","test.runIf.skip.fails","test.runIf.only.skip","test.runIf.only.concurrent","test.runIf.only.sequential","test.runIf.only.todo","test.runIf.only.fails","test.runIf.concurrent.skip","test.runIf.concurrent.only","test.runIf.concurrent.sequential","test.runIf.concurrent.todo","test.runIf.concurrent.fails","test.runIf.sequential.skip","test.runIf.sequential.only","test.runIf.sequential.concurrent","test.runIf.sequential.todo","test.runIf.sequential.fails","test.runIf.todo.skip","test.runIf.todo.only","test.runIf.todo.concurrent","test.runIf.todo.sequential","test.runIf.todo.fails","test.runIf.fails.skip","test.runIf.fails.only","test.runIf.fails.concurrent","test.runIf.fails.sequential","test.runIf.fails.todo","test.skip.only.each","test.skip.concurrent.each","test.skip.sequential.each","test.skip.todo.each","test.skip.fails.each","test.only.skip.each","test.only.concurrent.each","test.only.sequential.each","test.only.todo.each","test.only.fails.each","test.concurrent.skip.each","test.concurrent.only.each","test.concurrent.sequential.each","test.concurrent.todo.each","test.concurrent.fails.each","test.sequential.skip.each","test.sequential.only.each","test.sequential.concurrent.each","test.sequential.todo.each","test.sequential.fails.each","test.todo.skip.each","test.todo.only.each","test.todo.concurrent.each","test.todo.sequential.each","test.todo.fails.each","test.fails.skip.each","test.fails.only.each","test.fails.concurrent.each","test.fails.sequential.each","test.fails.todo.each","test.extend.skipIf.skip","test.extend.skipIf.only","test.extend.skipIf.concurrent","test.extend.skipIf.sequential","test.extend.skipIf.todo","test.extend.skipIf.fails","test.extend.runIf.skip","test.extend.runIf.only","test.extend.runIf.concurrent","test.extend.runIf.sequential","test.extend.runIf.todo","test.extend.runIf.fails","test.extend.skip.each","test.extend.only.each","test.extend.concurrent.each","test.extend.sequential.each","test.extend.todo.each","test.extend.fails.each","test.skipIf.skip.each","test.skipIf.only.each","test.skipIf.concurrent.each","test.skipIf.sequential.each","test.skipIf.todo.each","test.skipIf.fails.each","test.runIf.skip.each","test.runIf.only.each","test.runIf.concurrent.each","test.runIf.sequential.each","test.runIf.todo.each","test.runIf.fails.each","test.extend.skipIf.each","test.extend.runIf.each","bench","bench.skip","bench.only","bench.todo","bench.skipIf","bench.runIf","bench.skip.only","bench.skip.todo","bench.only.skip","bench.only.todo","bench.todo.skip","bench.todo.only","bench.skipIf.skip","bench.skipIf.only","bench.skipIf.todo","bench.runIf.skip","bench.runIf.only","bench.runIf.todo","bench.skip.only.todo","bench.skip.todo.only","bench.only.skip.todo","bench.only.todo.skip","bench.todo.skip.only","bench.todo.only.skip","bench.skipIf.skip.only","bench.skipIf.skip.todo","bench.skipIf.only.skip","bench.skipIf.only.todo","bench.skipIf.todo.skip","bench.skipIf.todo.only","bench.runIf.skip.only","bench.runIf.skip.todo","bench.runIf.only.skip","bench.runIf.only.todo","bench.runIf.todo.skip","bench.runIf.todo.only","describe","describe.skip","describe.only","describe.concurrent","describe.sequential","describe.shuffle","describe.todo","describe.skipIf","describe.runIf","describe.each","describe.skip.only","describe.skip.concurrent","describe.skip.sequential","describe.skip.shuffle","describe.skip.todo","describe.only.skip","describe.only.concurrent","describe.only.sequential","describe.only.shuffle","describe.only.todo","describe.concurrent.skip","describe.concurrent.only","describe.concurrent.sequential","describe.concurrent.shuffle","describe.concurrent.todo","describe.sequential.skip","describe.sequential.only","describe.sequential.concurrent","describe.sequential.shuffle","describe.sequential.todo","describe.shuffle.skip","describe.shuffle.only","describe.shuffle.concurrent","describe.shuffle.sequential","describe.shuffle.todo","describe.todo.skip","describe.todo.only","describe.todo.concurrent","describe.todo.sequential","describe.todo.shuffle","describe.skipIf.skip","describe.skipIf.only","describe.skipIf.concurrent","describe.skipIf.sequential","describe.skipIf.shuffle","describe.skipIf.todo","describe.runIf.skip","describe.runIf.only","describe.runIf.concurrent","describe.runIf.sequential","describe.runIf.shuffle","describe.runIf.todo","describe.skip.each","describe.only.each","describe.concurrent.each","describe.sequential.each","describe.shuffle.each","describe.todo.each","describe.skipIf.each","describe.runIf.each","describe.skip.only.concurrent","describe.skip.only.sequential","describe.skip.only.shuffle","describe.skip.only.todo","describe.skip.concurrent.only","describe.skip.concurrent.sequential","describe.skip.concurrent.shuffle","describe.skip.concurrent.todo","describe.skip.sequential.only","describe.skip.sequential.concurrent","describe.skip.sequential.shuffle","describe.skip.sequential.todo","describe.skip.shuffle.only","describe.skip.shuffle.concurrent","describe.skip.shuffle.sequential","describe.skip.shuffle.todo","describe.skip.todo.only","describe.skip.todo.concurrent","describe.skip.todo.sequential","describe.skip.todo.shuffle","describe.only.skip.concurrent","describe.only.skip.sequential","describe.only.skip.shuffle","describe.only.skip.todo","describe.only.concurrent.skip","describe.only.concurrent.sequential","describe.only.concurrent.shuffle","describe.only.concurrent.todo","describe.only.sequential.skip","describe.only.sequential.concurrent","describe.only.sequential.shuffle","describe.only.sequential.todo","describe.only.shuffle.skip","describe.only.shuffle.concurrent","describe.only.shuffle.sequential","describe.only.shuffle.todo","describe.only.todo.skip","describe.only.todo.concurrent","describe.only.todo.sequential","describe.only.todo.shuffle","describe.concurrent.skip.only","describe.concurrent.skip.sequential","describe.concurrent.skip.shuffle","describe.concurrent.skip.todo","describe.concurrent.only.skip","describe.concurrent.only.sequential","describe.concurrent.only.shuffle","describe.concurrent.only.todo","describe.concurrent.sequential.skip","describe.concurrent.sequential.only","describe.concurrent.sequential.shuffle","describe.concurrent.sequential.todo","describe.concurrent.shuffle.skip","describe.concurrent.shuffle.only","describe.concurrent.shuffle.sequential","describe.concurrent.shuffle.todo","describe.concurrent.todo.skip","describe.concurrent.todo.only","describe.concurrent.todo.sequential","describe.concurrent.todo.shuffle","describe.sequential.skip.only","describe.sequential.skip.concurrent","describe.sequential.skip.shuffle","describe.sequential.skip.todo","describe.sequential.only.skip","describe.sequential.only.concurrent","describe.sequential.only.shuffle","describe.sequential.only.todo","describe.sequential.concurrent.skip","describe.sequential.concurrent.only","describe.sequential.concurrent.shuffle","describe.sequential.concurrent.todo","describe.sequential.shuffle.skip","describe.sequential.shuffle.only","describe.sequential.shuffle.concurrent","describe.sequential.shuffle.todo","describe.sequential.todo.skip","describe.sequential.todo.only","describe.sequential.todo.concurrent","describe.sequential.todo.shuffle","describe.shuffle.skip.only","describe.shuffle.skip.concurrent","describe.shuffle.skip.sequential","describe.shuffle.skip.todo","describe.shuffle.only.skip","describe.shuffle.only.concurrent","describe.shuffle.only.sequential","describe.shuffle.only.todo","describe.shuffle.concurrent.skip","describe.shuffle.concurrent.only","describe.shuffle.concurrent.sequential","describe.shuffle.concurrent.todo","describe.shuffle.sequential.skip","describe.shuffle.sequential.only","describe.shuffle.sequential.concurrent","describe.shuffle.sequential.todo","describe.shuffle.todo.skip","describe.shuffle.todo.only","describe.shuffle.todo.concurrent","describe.shuffle.todo.sequential","describe.todo.skip.only","describe.todo.skip.concurrent","describe.todo.skip.sequential","describe.todo.skip.shuffle","describe.todo.only.skip","describe.todo.only.concurrent","describe.todo.only.sequential","describe.todo.only.shuffle","describe.todo.concurrent.skip","describe.todo.concurrent.only","describe.todo.concurrent.sequential","describe.todo.concurrent.shuffle","describe.todo.sequential.skip","describe.todo.sequential.only","describe.todo.sequential.concurrent","describe.todo.sequential.shuffle","describe.todo.shuffle.skip","describe.todo.shuffle.only","describe.todo.shuffle.concurrent","describe.todo.shuffle.sequential","describe.skipIf.skip.only","describe.skipIf.skip.concurrent","describe.skipIf.skip.sequential","describe.skipIf.skip.shuffle","describe.skipIf.skip.todo","describe.skipIf.only.skip","describe.skipIf.only.concurrent","describe.skipIf.only.sequential","describe.skipIf.only.shuffle","describe.skipIf.only.todo","describe.skipIf.concurrent.skip","describe.skipIf.concurrent.only","describe.skipIf.concurrent.sequential","describe.skipIf.concurrent.shuffle","describe.skipIf.concurrent.todo","describe.skipIf.sequential.skip","describe.skipIf.sequential.only","describe.skipIf.sequential.concurrent","describe.skipIf.sequential.shuffle","describe.skipIf.sequential.todo","describe.skipIf.shuffle.skip","describe.skipIf.shuffle.only","describe.skipIf.shuffle.concurrent","describe.skipIf.shuffle.sequential","describe.skipIf.shuffle.todo","describe.skipIf.todo.skip","describe.skipIf.todo.only","describe.skipIf.todo.concurrent","describe.skipIf.todo.sequential","describe.skipIf.todo.shuffle","describe.runIf.skip.only","describe.runIf.skip.concurrent","describe.runIf.skip.sequential","describe.runIf.skip.shuffle","describe.runIf.skip.todo","describe.runIf.only.skip","describe.runIf.only.concurrent","describe.runIf.only.sequential","describe.runIf.only.shuffle","describe.runIf.only.todo","describe.runIf.concurrent.skip","describe.runIf.concurrent.only","describe.runIf.concurrent.sequential","describe.runIf.concurrent.shuffle","describe.runIf.concurrent.todo","describe.runIf.sequential.skip","describe.runIf.sequential.only","describe.runIf.sequential.concurrent","describe.runIf.sequential.shuffle","describe.runIf.sequential.todo","describe.runIf.shuffle.skip","describe.runIf.shuffle.only","describe.runIf.shuffle.concurrent","describe.runIf.shuffle.sequential","describe.runIf.shuffle.todo","describe.runIf.todo.skip","describe.runIf.todo.only","describe.runIf.todo.concurrent","describe.runIf.todo.sequential","describe.runIf.todo.shuffle","describe.skip.only.each","describe.skip.concurrent.each","describe.skip.sequential.each","describe.skip.shuffle.each","describe.skip.todo.each","describe.only.skip.each","describe.only.concurrent.each","describe.only.sequential.each","describe.only.shuffle.each","describe.only.todo.each","describe.concurrent.skip.each","describe.concurrent.only.each","describe.concurrent.sequential.each","describe.concurrent.shuffle.each","describe.concurrent.todo.each","describe.sequential.skip.each","describe.sequential.only.each","describe.sequential.concurrent.each","describe.sequential.shuffle.each","describe.sequential.todo.each","describe.shuffle.skip.each","describe.shuffle.only.each","describe.shuffle.concurrent.each","describe.shuffle.sequential.each","describe.shuffle.todo.each","describe.todo.skip.each","describe.todo.only.each","describe.todo.concurrent.each","describe.todo.sequential.each","describe.todo.shuffle.each","describe.skipIf.skip.each","describe.skipIf.only.each","describe.skipIf.concurrent.each","describe.skipIf.sequential.each","describe.skipIf.shuffle.each","describe.skipIf.todo.each","describe.runIf.skip.each","describe.runIf.only.each","describe.runIf.concurrent.each","describe.runIf.sequential.each","describe.runIf.shuffle.each","describe.runIf.todo.each","suite","suite.skip","suite.only","suite.concurrent","suite.sequential","suite.shuffle","suite.todo","suite.skipIf","suite.runIf","suite.each","suite.skip.only","suite.skip.concurrent","suite.skip.sequential","suite.skip.shuffle","suite.skip.todo","suite.only.skip","suite.only.concurrent","suite.only.sequential","suite.only.shuffle","suite.only.todo","suite.concurrent.skip","suite.concurrent.only","suite.concurrent.sequential","suite.concurrent.shuffle","suite.concurrent.todo","suite.sequential.skip","suite.sequential.only","suite.sequential.concurrent","suite.sequential.shuffle","suite.sequential.todo","suite.shuffle.skip","suite.shuffle.only","suite.shuffle.concurrent","suite.shuffle.sequential","suite.shuffle.todo","suite.todo.skip","suite.todo.only","suite.todo.concurrent","suite.todo.sequential","suite.todo.shuffle","suite.skipIf.skip","suite.skipIf.only","suite.skipIf.concurrent","suite.skipIf.sequential","suite.skipIf.shuffle","suite.skipIf.todo","suite.runIf.skip","suite.runIf.only","suite.runIf.concurrent","suite.runIf.sequential","suite.runIf.shuffle","suite.runIf.todo","suite.skip.each","suite.only.each","suite.concurrent.each","suite.sequential.each","suite.shuffle.each","suite.todo.each","suite.skipIf.each","suite.runIf.each","suite.skip.only.concurrent","suite.skip.only.sequential","suite.skip.only.shuffle","suite.skip.only.todo","suite.skip.concurrent.only","suite.skip.concurrent.sequential","suite.skip.concurrent.shuffle","suite.skip.concurrent.todo","suite.skip.sequential.only","suite.skip.sequential.concurrent","suite.skip.sequential.shuffle","suite.skip.sequential.todo","suite.skip.shuffle.only","suite.skip.shuffle.concurrent","suite.skip.shuffle.sequential","suite.skip.shuffle.todo","suite.skip.todo.only","suite.skip.todo.concurrent","suite.skip.todo.sequential","suite.skip.todo.shuffle","suite.only.skip.concurrent","suite.only.skip.sequential","suite.only.skip.shuffle","suite.only.skip.todo","suite.only.concurrent.skip","suite.only.concurrent.sequential","suite.only.concurrent.shuffle","suite.only.concurrent.todo","suite.only.sequential.skip","suite.only.sequential.concurrent","suite.only.sequential.shuffle","suite.only.sequential.todo","suite.only.shuffle.skip","suite.only.shuffle.concurrent","suite.only.shuffle.sequential","suite.only.shuffle.todo","suite.only.todo.skip","suite.only.todo.concurrent","suite.only.todo.sequential","suite.only.todo.shuffle","suite.concurrent.skip.only","suite.concurrent.skip.sequential","suite.concurrent.skip.shuffle","suite.concurrent.skip.todo","suite.concurrent.only.skip","suite.concurrent.only.sequential","suite.concurrent.only.shuffle","suite.concurrent.only.todo","suite.concurrent.sequential.skip","suite.concurrent.sequential.only","suite.concurrent.sequential.shuffle","suite.concurrent.sequential.todo","suite.concurrent.shuffle.skip","suite.concurrent.shuffle.only","suite.concurrent.shuffle.sequential","suite.concurrent.shuffle.todo","suite.concurrent.todo.skip","suite.concurrent.todo.only","suite.concurrent.todo.sequential","suite.concurrent.todo.shuffle","suite.sequential.skip.only","suite.sequential.skip.concurrent","suite.sequential.skip.shuffle","suite.sequential.skip.todo","suite.sequential.only.skip","suite.sequential.only.concurrent","suite.sequential.only.shuffle","suite.sequential.only.todo","suite.sequential.concurrent.skip","suite.sequential.concurrent.only","suite.sequential.concurrent.shuffle","suite.sequential.concurrent.todo","suite.sequential.shuffle.skip","suite.sequential.shuffle.only","suite.sequential.shuffle.concurrent","suite.sequential.shuffle.todo","suite.sequential.todo.skip","suite.sequential.todo.only","suite.sequential.todo.concurrent","suite.sequential.todo.shuffle","suite.shuffle.skip.only","suite.shuffle.skip.concurrent","suite.shuffle.skip.sequential","suite.shuffle.skip.todo","suite.shuffle.only.skip","suite.shuffle.only.concurrent","suite.shuffle.only.sequential","suite.shuffle.only.todo","suite.shuffle.concurrent.skip","suite.shuffle.concurrent.only","suite.shuffle.concurrent.sequential","suite.shuffle.concurrent.todo","suite.shuffle.sequential.skip","suite.shuffle.sequential.only","suite.shuffle.sequential.concurrent","suite.shuffle.sequential.todo","suite.shuffle.todo.skip","suite.shuffle.todo.only","suite.shuffle.todo.concurrent","suite.shuffle.todo.sequential","suite.todo.skip.only","suite.todo.skip.concurrent","suite.todo.skip.sequential","suite.todo.skip.shuffle","suite.todo.only.skip","suite.todo.only.concurrent","suite.todo.only.sequential","suite.todo.only.shuffle","suite.todo.concurrent.skip","suite.todo.concurrent.only","suite.todo.concurrent.sequential","suite.todo.concurrent.shuffle","suite.todo.sequential.skip","suite.todo.sequential.only","suite.todo.sequential.concurrent","suite.todo.sequential.shuffle","suite.todo.shuffle.skip","suite.todo.shuffle.only","suite.todo.shuffle.concurrent","suite.todo.shuffle.sequential","suite.skipIf.skip.only","suite.skipIf.skip.concurrent","suite.skipIf.skip.sequential","suite.skipIf.skip.shuffle","suite.skipIf.skip.todo","suite.skipIf.only.skip","suite.skipIf.only.concurrent","suite.skipIf.only.sequential","suite.skipIf.only.shuffle","suite.skipIf.only.todo","suite.skipIf.concurrent.skip","suite.skipIf.concurrent.only","suite.skipIf.concurrent.sequential","suite.skipIf.concurrent.shuffle","suite.skipIf.concurrent.todo","suite.skipIf.sequential.skip","suite.skipIf.sequential.only","suite.skipIf.sequential.concurrent","suite.skipIf.sequential.shuffle","suite.skipIf.sequential.todo","suite.skipIf.shuffle.skip","suite.skipIf.shuffle.only","suite.skipIf.shuffle.concurrent","suite.skipIf.shuffle.sequential","suite.skipIf.shuffle.todo","suite.skipIf.todo.skip","suite.skipIf.todo.only","suite.skipIf.todo.concurrent","suite.skipIf.todo.sequential","suite.skipIf.todo.shuffle","suite.runIf.skip.only","suite.runIf.skip.concurrent","suite.runIf.skip.sequential","suite.runIf.skip.shuffle","suite.runIf.skip.todo","suite.runIf.only.skip","suite.runIf.only.concurrent","suite.runIf.only.sequential","suite.runIf.only.shuffle","suite.runIf.only.todo","suite.runIf.concurrent.skip","suite.runIf.concurrent.only","suite.runIf.concurrent.sequential","suite.runIf.concurrent.shuffle","suite.runIf.concurrent.todo","suite.runIf.sequential.skip","suite.runIf.sequential.only","suite.runIf.sequential.concurrent","suite.runIf.sequential.shuffle","suite.runIf.sequential.todo","suite.runIf.shuffle.skip","suite.runIf.shuffle.only","suite.runIf.shuffle.concurrent","suite.runIf.shuffle.sequential","suite.runIf.shuffle.todo","suite.runIf.todo.skip","suite.runIf.todo.only","suite.runIf.todo.concurrent","suite.runIf.todo.sequential","suite.runIf.todo.shuffle","suite.skip.only.each","suite.skip.concurrent.each","suite.skip.sequential.each","suite.skip.shuffle.each","suite.skip.todo.each","suite.only.skip.each","suite.only.concurrent.each","suite.only.sequential.each","suite.only.shuffle.each","suite.only.todo.each","suite.concurrent.skip.each","suite.concurrent.only.each","suite.concurrent.sequential.each","suite.concurrent.shuffle.each","suite.concurrent.todo.each","suite.sequential.skip.each","suite.sequential.only.each","suite.sequential.concurrent.each","suite.sequential.shuffle.each","suite.sequential.todo.each","suite.shuffle.skip.each","suite.shuffle.only.each","suite.shuffle.concurrent.each","suite.shuffle.sequential.each","suite.shuffle.todo.each","suite.todo.skip.each","suite.todo.only.each","suite.todo.concurrent.each","suite.todo.sequential.each","suite.todo.shuffle.each","suite.skipIf.skip.each","suite.skipIf.only.each","suite.skipIf.concurrent.each","suite.skipIf.sequential.each","suite.skipIf.shuffle.each","suite.skipIf.todo.each","suite.runIf.skip.each","suite.runIf.only.each","suite.runIf.concurrent.each","suite.runIf.sequential.each","suite.runIf.shuffle.each","suite.runIf.todo.each","xtest","xtest.each","xit","xit.each","fit","xdescribe","xdescribe.each","fdescribe"]);function ae(e,s){return e.sourceCode.getScope?e.sourceCode.getScope(s):e.getScope()}function Xs(e,s){let t=ae(e,s);for(;t;){if(t.type==="module")return t;t=t.upper}return t}const q=(e,s,t)=>{const n=h(e,s);return n!==null&&t.includes(n.type)},h=(e,s)=>{const t=Pt(e,s);return typeof t=="string"?null:t},Ft=new WeakMap,Pt=(e,s)=>{let t=Ft.get(e);return t||(t=Qs(e,s),Ft.set(e,t),t)},zs=e=>e==="expect"?"expect":e==="expectTypeOf"?"expectTypeOf":e==="vi"?"vi":e==="vitest"?"vitest":H.hasOwnProperty(e)?"describe":E.hasOwnProperty(e)?"test":Bt.hasOwnProperty(e)?"hook":"unknown",Ys=e=>{const s=[];for(const t of e){if(t.parent?.type===i.MemberExpression&&t.parent.parent?.type===i.CallExpression)return{matcher:t,args:t.parent.parent.arguments,modifiers:s};const n=y(t);if(s.length===0){if(!N.hasOwnProperty(n))return"modifier-unknown"}else if(s.length===1){if(n!==N.not&&n!=N.have)return"modifier-unknown";const o=y(s[0]);if(o!==N.resolves&&o!==N.rejects&&o!==N.to)return"modifier-unknown"}else return"modifier-unknown";s.push(t)}return"matcher-not-found"},Js=(e,s)=>{const t=Ys(e.members);return typeof t=="string"?t:{...e,type:s,...t}},Ut=e=>{let s=e,{parent:t}=e;for(;t;){if(t.type===i.CallExpression){s=t,t=t.parent;continue}if(t.type!==i.MemberExpression)break;t=t.parent}return s},Qs=(e,s)=>{const t=V(e);if(!t?.length)return null;const[n,...o]=t,r=y(t[t.length-1]);if(r==="each"&&e.callee.type!==i.CallExpression&&e.callee.type!==i.TaggedTemplateExpression||e.callee.type===i.TaggedTemplateExpression&&r!=="each")return null;const a=en(s,e,y(n));if(!a)return null;const c=a.original??a.local,l=[c,...o.map(y)];if(a.type!=="testContext"&&c!=="vi"&&c!=="vitest"&&c!=="expect"&&c!=="expectTypeOf"&&!Gs.has(l.join(".")))return null;const p={name:c,head:{...a,node:n},members:o},f=zs(c);if(f==="expect"||f==="expectTypeOf"){const u=Js(p,f);return typeof u=="string"&&Ut(e)!==e?null:u==="matcher-not-found"&&e.parent?.type===i.MemberExpression?"matcher-not-called":u}return t.slice(0,t.length-1).some(u=>u.parent?.type!==i.MemberExpression)||e.parent?.type===i.CallExpression||e.parent?.type===i.MemberExpression?null:{...p,type:f}},Zs=(e,s)=>e&&s?[...e,...s]:null;function V(e){if(C(e))return[e];switch(e.type){case i.TaggedTemplateExpression:return V(e.tag);case i.MemberExpression:return Zs(V(e.object),V(e.property));case i.CallExpression:return V(e.callee)}return null}const en=(e,s,t)=>{const n=ae(e,s),o=jt(n,t);return o==="local"?null:o==="testContext"?{local:t,original:null,type:"testContext"}:o?o.source==="vitest"?{original:o.imported,local:o.local,type:"import"}:null:{original:tn(t,e),local:t,type:"global"}},tn=(e,s)=>{const t=s.settings.vitest?.globalAliases??{},n=Object.entries(t).find(([o,r])=>r.includes(e));return n?n[0]:null},sn=({parent:e})=>{if(e?.type===i.CallExpression&&e.callee.type===i.Identifier)return E.hasOwnProperty(e.callee.name)},jt=(e,s)=>{let t=e;for(;t!==null;){const n=t.set.get(s);if(n&&n.defs.length>0){const o=n.defs[n.defs.length-1],r=M(o.node)?o.node.params.find(l=>l.type===i.ObjectPattern):void 0;if(r){const l=r.properties.find(p=>p.type===i.Property);if((l?.key.type===i.Identifier?l.key:void 0)?.name===s)return"testContext"}const a=M(o.node)?o.node.params.find(l=>l.type===i.Identifier):void 0;if(a&&sn(a.parent))return"testContext";const c=rn(o);return c?.local===s?c:"local"}t=t.upper}return null},nn=e=>e.type===i.AwaitExpression?e.argument.type===i.ImportExpression?e.argument.source:null:e.type===i.CallExpression&&L(e.callee,"require")?e.arguments[0]??null:null,on=e=>e.parent.type===i.TSImportEqualsDeclaration||e.node.type!==i.ImportSpecifier||e.node.imported.type!=i.Identifier||e.parent.importKind==="type"?null:{source:e.parent.source.value,imported:e.node.imported.name,local:e.node.local.name},rn=e=>e.type==="Variable"?an(e):e.type==="ImportBinding"?on(e):null,an=e=>{if(!e.node.init)return null;const s=nn(e.node.init);return!s||!B(s)||e.name.parent?.type!==i.Property||!C(e.name.parent.key)?null:{source:j(s),imported:y(e.name.parent.key),local:e.name.name}},ce=(e,s)=>e.reduce((t,{references:n})=>t.concat(n.map(({identifier:o})=>o.parent).filter(o=>o?.type===i.CallExpression&&q(o,s,["test"]))),[]),P=e=>{const[s]=e.args;return s.type===i.SpreadElement?s:le(s)},cn=e=>e.type===i.TSAsExpression||e.type===i.TSTypeAssertion,le=e=>cn(e)?le(e.expression):e,ue="prefer-lowercase-title",ln=e=>e.arguments[0]&&B(e.arguments[0]),un=e=>{const s=[];return e.includes(H.describe)&&s.push(...Object.keys(H)),e.includes(E.test)&&s.push(...Object.keys(E).filter(t=>t.endsWith(E.test))),e.includes(E.it)&&s.push(...Object.keys(E).filter(t=>t.endsWith(E.it))),s},pn=d({name:ue,meta:{type:"problem",docs:{description:"enforce lowercase titles",recommended:!1},fixable:"code",messages:{lowerCaseTitle:"`{{ method }}`s should begin with lowercase",fullyLowerCaseTitle:"`{{ method }}`s should be lowercase"},schema:[{type:"object",properties:{ignore:{type:"array",items:{type:"string",enum:[H.describe,E.test,E.it]}},allowedPrefixes:{type:"array",items:{type:"string"},additionalItems:!1},ignoreTopLevelDescribe:{type:"boolean",default:!1},lowercaseFirstCharacterOnly:{type:"boolean",default:!0}},additionalProperties:!1}]},defaultOptions:[{ignore:[],allowedPrefixes:[],ignoreTopLevelDescribe:!1,lowercaseFirstCharacterOnly:!0}],create:(e,[{ignore:s=[],allowedPrefixes:t=[],ignoreTopLevelDescribe:n=!1,lowercaseFirstCharacterOnly:o=!1}])=>{const r=un(s);let a=0;return{CallExpression(c){const l=h(c,e);if(!l||!ln)return;if(l?.type==="describe"){if(a++,n&&a===1)return}else if(l?.type!=="test")return;const[p]=c.arguments,f=j(p);if(typeof f!="string"||t.some(b=>f.startsWith(b)))return;const u=f.charAt(0);r.includes(l.name)||o&&(!u||u===u.toLowerCase())||!o&&f===f.toLowerCase()||e.report({messageId:o?"lowerCaseTitle":"fullyLowerCaseTitle",node:c.arguments[0],data:{method:l.name},fix:b=>{const m=j(p),I=[p.range[0]+1,p.range[1]-1],k=o?m.substring(0,1).toLowerCase()+m.substring(1):m.toLowerCase();return[b.replaceTextRange(I,k)]}})},"CallExpression:exit"(c){q(c,e,["describe"])&&a--}}}}),pe="max-nested-describe",dn=d({name:pe,meta:{type:"problem",docs:{description:"require describe block to be less than set max value or default value",recommended:!1},schema:[{type:"object",properties:{max:{type:"number"}},additionalProperties:!1}],messages:{maxNestedDescribe:"Nested describe block should be less than set max value"}},defaultOptions:[{max:5}],create(e,[{max:s}]){const t=[];function n(r){r.parent?.type==="CallExpression"&&(r.parent.callee.type!=="Identifier"||r.parent.callee.name!=="describe"||(t.push(0),t.length>s&&e.report({node:r.parent,messageId:"maxNestedDescribe"})))}function o(r){r.parent?.type==="CallExpression"&&(r.parent.callee.type!=="Identifier"||r.parent.callee.name!=="describe"||t.pop())}return{FunctionExpression:n,"FunctionExpression:exit":o,ArrowFunctionExpression:n,"ArrowFunctionExpression:exit":o}}}),X="no-identical-title",_t=()=>({describeTitles:[],testTitles:[]}),fn=d({name:X,meta:{type:"problem",docs:{description:"disallow identical titles",recommended:!1},fixable:"code",schema:[],messages:{multipleTestTitle:"Test is used multiple times in the same describe(suite) block",multipleDescribeTitle:"Describe is used multiple times in the same describe(suite) block"}},defaultOptions:[],create(e){const s=[_t()];return{CallExpression(t){const n=s[s.length-1],o=h(t,e);if(!o||((o.name==="describe"||o.name==="suite")&&s.push(_t()),o.members.find(c=>C(c,"each"))))return;const[r]=t.arguments;if(!r||!B(r))return;const a=j(r);o.type==="test"&&(n?.testTitles.includes(a)&&e.report({node:t,messageId:"multipleTestTitle"}),n?.testTitles.push(a)),o.type==="describe"&&(n?.describeTitles.includes(a)&&e.report({node:t,messageId:"multipleDescribeTitle"}),n?.describeTitles.push(a))},"CallExpression:exit"(t){q(t,e,["describe"])&&s.pop()}}}}),de="no-focused-tests",fe=e=>e.type==="Identifier"&&["it","test","describe"].includes(e.name),me=e=>e.type==="Identifier"&&e.name==="only",mn=d({name:de,meta:{type:"problem",docs:{description:"disallow focused tests",recommended:!1},fixable:"code",schema:[{type:"object",properties:{fixable:{type:"boolean",default:!0}},additionalProperties:!1}],messages:{noFocusedTests:"Focused tests are not allowed"}},defaultOptions:[{fixable:!0}],create:e=>{const s=e.options[0]?.fixable;return{ExpressionStatement(t){if(t.expression.type==="CallExpression"){const{callee:n}=t.expression;if(n.type==="MemberExpression"&&fe(n.object)&&me(n.property)&&e.report({node:n.property,messageId:"noFocusedTests",fix:o=>s?o.removeRange([n.property.range[0]-1,n.property.range[1]]):null}),n.type==="TaggedTemplateExpression"){const o=n.tag.type==="MemberExpression"?n.tag.object:null;if(!o)return;o.type==="MemberExpression"&&fe(o.object)&&me(o.property)&&e.report({node:o.property,messageId:"noFocusedTests",fix:r=>s?r.removeRange([o.property.range[0]-1,o.property.range[1]]):null})}}},CallExpression(t){if(t.callee.type==="CallExpression"){const{callee:n}=t.callee;if(n.type==="MemberExpression"&&n.object.type==="MemberExpression"&&fe(n.object.object)&&me(n.object.property)&&n.property.type==="Identifier"&&n.property.name==="each"){const o=n.object.property;e.report({node:n.object.property,messageId:"noFocusedTests",fix:r=>s?r.removeRange([o.range[0]-1,o.range[1]]):null})}}}}}}),ye="no-conditional-tests",yn=d({name:ye,meta:{type:"problem",docs:{description:"disallow conditional tests",recommended:!1},schema:[],messages:{noConditionalTests:"Avoid using if conditions in a test"}},defaultOptions:[],create(e){return{Identifier:function(s){["test","it","describe"].includes(s.name)&&s.parent?.parent?.parent?.parent?.type==="IfStatement"&&e.report({node:s,messageId:"noConditionalTests"})}}}}),hn={typecheck:!1};function z(e){const s=typeof e.vitest!="object"||e.vitest===null?{}:e.vitest;return{...hn,...s}}const Y="expect-expect",gn=d({name:Y,meta:{type:"suggestion",docs:{description:"enforce having expectation in test body",recommended:!1},schema:[{type:"object",properties:{assertFunctionNames:{type:"array",items:{type:"string"}},additionalTestBlockFunctions:{type:"array",items:{type:"string"}}},additionalProperties:!1}],messages:{noAssertions:"Test has no assertions"}},defaultOptions:[{assertFunctionNames:["expect","assert"],additionalTestBlockFunctions:[]}],create(e,[{assertFunctionNames:s=["expect"],additionalTestBlockFunctions:t=[]}]){const n=[];z(e.settings).typecheck&&s.push("expectTypeOf","assertType");const o=s.map(kn);function r(a){for(const c of a){const l=c.type===i.CallExpression?n.indexOf(c):-1;if(c.type===i.FunctionDeclaration){const p=e.sourceCode.getDeclaredVariables(c),f=ce(p,e);r(f)}if(l!==-1){n.splice(l,1);break}}}return{CallExpression(a){if(a.callee.type===i.Identifier&&a.callee.name==="bench"||a?.callee?.type===i.MemberExpression&&a.callee.property.type===i.Identifier&&a.callee.property.name==="extend"||a?.callee?.type===i.MemberExpression&&a.callee.property.type===i.Identifier&&a.callee.property.name==="skip")return;const c=R(a)??"";if(q(a,e,["test"])||t.includes(c)){if(a.callee.type===i.MemberExpression&&C(a.callee.property,"todo"))return;n.push(a)}else o.some(l=>l.test(c))&&r(e.sourceCode.getAncestors(a))},"Program:exit"(){n.forEach(a=>{e.report({node:a.callee,messageId:"noAssertions"})})}}}});function kn(e){const s=e.split(".").map(t=>t==="**"?"[_a-z\\d\\.]*":t.replace(/\*/gu,"[a-z\\d]*"));return new RegExp(`^${s.join("\\.")}(\\.|$)`,"ui")}const he="hoisted-apis-on-top",bn=["mock","hoisted","unmock"],xn=d({name:he,meta:{hasSuggestions:!0,type:"suggestion",docs:{description:"enforce hoisted APIs to be on top of the file"},messages:{hoistedApisOnTop:"Hoisted API is used in a runtime location in this file, but it is actually executed before this file is loaded.",suggestMoveHoistedApiToTop:"Move this hoisted API to the top of the file to better reflect its behavior.",suggestReplaceMockWithDoMock:"Replace 'vi.mock()' with 'vi.doMock()', which is not hoisted."},schema:[]},defaultOptions:[],create(e){let s=null;const t=[];return{ImportDeclaration(n){n.parent.type==="Program"&&(s=n.range[1])},CallExpression(n){if(!(n.parent.type==="ExpressionStatement"&&n.parent.parent.type==="Program")&&n.callee.type==="MemberExpression"){const{object:o,property:r}=n.callee;o.type==="Identifier"&&o.name==="vi"&&r.type==="Identifier"&&bn.includes(r.name)&&t.push(n)}},"Program:exit"(){for(const n of t){const o=[];o.push({messageId:"suggestMoveHoistedApiToTop",*fix(a){n.parent.type==="ExpressionStatement"?yield a.remove(n):yield a.replaceText(n,"undefined"),s!=null?yield a.insertTextAfterRange([s,s],`
`+e.sourceCode.getText(n)+";"):yield a.insertTextAfterRange([0,0],e.sourceCode.getText(n)+`;
`)}});const r=n.callee.property;r.name==="mock"&&o.push({messageId:"suggestReplaceMockWithDoMock",fix(a){return a.replaceText(r,"doMock")}}),e.report({node:n,messageId:"hoistedApisOnTop",suggest:o})}}}}}),ge="consistent-test-it",Dt=(e,s,t)=>n=>[n.replaceText(e.type===i.MemberExpression?e.object:e,In(s,t))];function In(e,s){return e===E.fit?"test.only":e.startsWith("f")||e.startsWith("x")?e.charAt(0)+s:s}function ke(e){return e===E.test?E.it:E.test}const En=d({name:ge,meta:{type:"suggestion",fixable:"code",docs:{description:"enforce using test or it but not both",recommended:!1},messages:{consistentMethod:"Prefer using {{ testFnKeyWork }} instead of {{ oppositeTestKeyword }}",consistentMethodWithinDescribe:"Prefer using {{ testKeywordWithinDescribe }} instead of {{ oppositeTestKeyword }} within describe"},schema:[{type:"object",properties:{fn:{type:"string",enum:[E.test,E.it]},withinDescribe:{type:"string",enum:[E.test,E.it]}},additionalProperties:!1}]},defaultOptions:[{fn:E.test,withinDescribe:E.it}],create(e){const s=e.options[0]??{},t=s.fn||E.test,n=s?.withinDescribe||s?.fn||E?.it,o=t===n?t:void 0;let r=0;return{ImportDeclaration(a){if(o==null||a.source.type!=="Literal"||a.source.value!=="vitest")return;const c=ke(o);for(const l of a.specifiers)l.type==="ImportSpecifier"&&l.imported.type==="Identifier"&&l.local.name===l.imported.name&&l.local.name===c&&e.report({node:l,data:{testFnKeyWork:t,oppositeTestKeyword:c},messageId:"consistentMethod",fix:p=>{const f=a.specifiers.filter(u=>u.local.name!==c);if(f.length>0){const u=f.map(m=>m.local.name).join(", "),b=a.specifiers.at(-1)?.range;return b?p.replaceTextRange([a.specifiers[0].range[0],b[1]],u):null}return p.replaceText(l.local,o)}})},CallExpression(a){if(a.callee.type===i.Identifier&&a.callee.name==="bench")return;const c=h(a,e);if(!c)return;if(c.type==="describe"){r++;return}const l=a.callee.type===i.TaggedTemplateExpression?a.callee.tag:a.callee.type===i.CallExpression?a.callee.callee:a.callee;if(c.type==="test"&&r===0&&!c.name.endsWith(t)){const p=ke(t);e.report({node:a.callee,data:{testFnKeyWork:t,oppositeTestKeyword:p},messageId:"consistentMethod",fix:Dt(l,c.name,t)})}else if(c.type==="test"&&r>0&&!c.name.endsWith(n)){const p=ke(n);e.report({messageId:"consistentMethodWithinDescribe",node:a.callee,data:{testKeywordWithinDescribe:n,oppositeTestKeyword:p},fix:Dt(l,c.name,n)})}},"CallExpression:exit"(a){q(a,e,["describe"])&&r--}}}}),be="consistent-vitest-vi",qn=e=>e===_.vi?_.vitest:_.vi,Tn=d({name:be,meta:{type:"suggestion",fixable:"code",docs:{description:"enforce using vitest or vi but not both",recommended:!1},messages:{consistentUtil:"Prefer using {{ utilKeyword }} instead of {{ oppositeUtilKeyword }}"},schema:[{type:"object",properties:{fn:{type:"string",enum:[_.vi,_.vitest]}},additionalProperties:!1}]},defaultOptions:[{fn:_.vi}],create(e){const s=(e.options[0]??{}).fn||_.vi,t=qn(s);return{ImportDeclaration(n){if(!(n.source.type!==i.Literal||n.source.value!=="vitest"))for(const o of n.specifiers)o.type===i.ImportSpecifier&&o.imported.type===i.Identifier&&o.local.name===o.imported.name&&o.imported.name===t&&e.report({node:o,messageId:"consistentUtil",data:{utilKeyword:s,oppositeUtilKeyword:t},fix:r=>{const a=n.specifiers.filter(c=>c.local.name!==t);if(a.length>0){const c=a.map(p=>p.local.name).join(", "),l=n.specifiers.at(-1)?.range;return l?r.replaceTextRange([n.specifiers[0].range[0],l[1]],c):null}return r.replaceText(o.local,s)}})},CallExpression(n){if(h(n,e)?.type!==t)return;const o=n.callee.type===i.MemberExpression?n.callee.object:n.callee;e.report({node:o,data:{utilKeyword:s,oppositeUtilKeyword:t},messageId:"consistentUtil",fix:r=>r.replaceText(o,s)})}}}}),xe="prefer-to-be",wn=e=>e.type===i.Literal&&e.value===null,An=e=>wn(P(e)),Wt=(e,s)=>L(P(e),s),vn=e=>Math.floor(e)!==Math.ceil(e),Cn=e=>{let s=P(e);return s.type===i.Literal&&typeof s.value=="number"&&vn(s.value)?!1:(s.type===i.UnaryExpression&&s.operator==="-"&&(s=s.argument),s.type===i.Literal?!("regex"in s):s.type===i.TemplateLiteral)},K=(e,s,t,n,o)=>{e.report({messageId:`useToBe${s}`,fix(r){const a=[G(r,t.matcher,`toBe${s}`)];return t.args?.length&&s!==""&&a.push(Nt(r,e,n,0)),o&&a.push(r.removeRange([o.range[0]-1,o.range[1]])),a},node:t.matcher})},Sn=d({name:xe,meta:{type:"suggestion",docs:{description:"enforce using toBe()",recommended:!1},schema:[],fixable:"code",messages:{useToBe:"Use `toBe` instead",useToBeUndefined:"Use `toBeUndefined()` instead",useToBeDefined:"Use `toBeDefined()` instead",useToBeNull:"Use `toBeNull()` instead",useToBeNaN:"Use `toBeNaN()` instead"}},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);if(t?.type!=="expect")return;const n=y(t.matcher),o=t.modifiers.find(r=>y(r)==="not");if(o&&["toBeUndefined","toBeDefined"].includes(n)){K(e,n==="toBeDefined"?"Undefined":"Defined",t,s,o);return}if(!(!F.hasOwnProperty(n)||t.args.length===0)){if(An(t)){K(e,"Null",t,s);return}if(Wt(t,"undefined")){K(e,o?"Defined":"Undefined",t,s);return}if(Wt(t,"NaN")){K(e,"NaN",t,s);return}Cn(t)&&n!==F.toBe&&K(e,"",t,s)}}}}}),Ie="no-hooks",Mn=d({name:Ie,meta:{type:"suggestion",docs:{description:"disallow setup and teardown hooks",recommended:!1},schema:[{type:"object",properties:{allow:{type:"array",contains:["beforeAll","beforeEach","afterAll","afterEach"]}},additionalProperties:!1}],messages:{unexpectedHook:"Unexpected '{{ hookName }}' hook"}},defaultOptions:[{allow:[]}],create(e,[{allow:s=[]}]){return{CallExpression(t){const n=h(t,e);n?.type==="hook"&&!s.includes(n.name)&&e.report({node:t,messageId:"unexpectedHook",data:{hookName:n.name}})}}}}),Ee="no-restricted-vi-methods",$n=d({name:Ee,meta:{type:"suggestion",docs:{description:"disallow specific `vi.` methods",recommended:!1},schema:[{type:"object",additionalProperties:{type:["string","null"]}}],messages:{restrictedViMethod:"Use of `{{ restriction }}` is disallowed",restrictedViMethodWithMessage:"{{ message }}"}},defaultOptions:[{}],create(e,[s]){return{CallExpression(t){const n=h(t,e);if(n?.type!=="vi"||n.members.length===0)return;const o=y(n.members[0]);if(o in s){const r=s[o];e.report({messageId:r?"restrictedViMethodWithMessage":"restrictedViMethod",data:{message:r,restriction:o},loc:{start:n.members[0].loc.start,end:n.members[n.members.length-1].loc.end}})}}}}}),qe="consistent-test-filename",Ht=/.*\.test\.[tj]sx?$/,J=/.*\.(test|spec)\.[tj]sx?$/,On=d({name:qe,meta:{type:"problem",docs:{recommended:!1,requiresTypeChecking:!1,description:"require .spec test file pattern"},messages:{consistentTestFilename:"Use test file name pattern {{ pattern }}"},schema:[{type:"object",additionalProperties:!1,properties:{pattern:{format:"regex",default:Ht.source},allTestPattern:{format:"regex",default:J.source}}}]},defaultOptions:[{pattern:J.source,allTestPattern:J.source}],create:e=>{const s=e.options[0]??{},{pattern:t=Ht,allTestPattern:n=J}=s,o=typeof t=="string"?new RegExp(t):t,r=typeof n=="string"?new RegExp(n):n,{filename:a}=e;return r.test(a)?{Program:c=>{o.test(a)||e.report({node:c,messageId:"consistentTestFilename",data:{pattern:o.source}})}}:{}}}),Te="max-expects",Rn=d({name:Te,meta:{docs:{requiresTypeChecking:!1,recommended:!1,description:"enforce a maximum number of expect per test"},messages:{maxExpect:"Too many assertion calls ({{ count }}) - maximum allowed is {{ max }}"},type:"suggestion",schema:[{type:"object",properties:{max:{type:"number"}},additionalProperties:!1}]},defaultOptions:[{max:5}],create(e,[{max:s}]){let t=0;const n=o=>{(o.parent?.type!==i.CallExpression||q(o.parent,e,["test"]))&&(t=0)};return{FunctionExpression:n,"FunctionExpression:exit":n,ArrowFunctionExpression:n,"ArrowFunctionExpression:exit":n,CallExpression(o){const r=h(o,e);r?.type!=="expect"||r.head.node.parent?.type===i.MemberExpression||(t+=1,t>s&&e.report({node:o,messageId:"maxExpect",data:{count:t,max:s}}))}}}}),we="no-alias-methods",Nn=d({name:we,meta:{docs:{description:"disallow alias methods",requiresTypeChecking:!1,recommended:!1},messages:{noAliasMethods:"Replace {{ alias }}() with its canonical name {{ canonical }}()"},type:"suggestion",fixable:"code",schema:[]},defaultOptions:[],create(e){const s={toBeCalled:"toHaveBeenCalled",toBeCalledTimes:"toHaveBeenCalledTimes",toBeCalledWith:"toHaveBeenCalledWith",lastCalledWith:"toHaveBeenLastCalledWith",nthCalledWith:"toHaveBeenNthCalledWith",toReturn:"toHaveReturned",toReturnTimes:"toHaveReturnedTimes",toReturnWith:"toHaveReturnedWith",lastReturnedWith:"toHaveLastReturnedWith",nthReturnedWith:"toHaveNthReturnedWith",toThrowError:"toThrow"};return{CallExpression(t){const n=h(t,e);if(n?.type!=="expect")return;const{matcher:o}=n,r=y(o);if(r in s){const a=s[r];e.report({messageId:"noAliasMethods",data:{alias:r,canonical:a},node:o,fix:c=>[G(c,o,a)]})}}}}}),Q="no-commented-out-tests";function Bn(e){return/^\s*[xf]?(test|it|describe)(\.\w+|\[['"]\w+['"]\])?\s*\(/mu.test(e.value)}const Ln=d({name:Q,meta:{docs:{description:"disallow commented out tests",requiresTypeChecking:!1,recommended:!1},messages:{noCommentedOutTests:"Remove commented out tests - you may want to use `skip` or `only` instead"},schema:[],type:"suggestion"},defaultOptions:[],create(e){const{sourceCode:s}=e;function t(n){Bn(n)&&e.report({messageId:"noCommentedOutTests",node:n})}return{Program(){s.getAllComments().forEach(t)}}}}),Ae="no-conditional-expect",Vt=e=>e.callee.type===i.MemberExpression&&C(e.callee.property,"catch"),Fn=d({name:Ae,meta:{type:"problem",docs:{description:"disallow conditional expects",requiresTypeChecking:!1,recommended:!1},messages:{noConditionalExpect:"Avoid calling `expect` inside conditional statements"},schema:[]},defaultOptions:[],create(e){let s=0,t=!1,n=!1;const o=()=>t&&s++,r=()=>t&&s--;return{FunctionDeclaration(a){const c=e.sourceCode.getDeclaredVariables(a);ce(c,e).length>0&&(t=!0)},CallExpression(a){const{type:c}=h(a,e)??{};c==="test"&&(t=!0),Vt(a)&&(n=!0),t&&c==="expect"&&s>0&&e.report({messageId:"noConditionalExpect",node:a}),n&&c==="expect"&&e.report({messageId:"noConditionalExpect",node:a})},"CallExpression:exit"(a){q(a,e,["test"])&&(t=!1),Vt(a)&&(n=!1)},CatchClause:o,"CatchClause:exit":r,IfStatement:o,"IfStatement:exit":r,SwitchStatement:o,"SwitchStatement:exit":r,ConditionalExpression:o,"ConditionalExpression:exit":r,LogicalExpression:o,"LogicalExpression:exit":r}}}),Z="no-import-node-test",Pn=d({name:Z,meta:{docs:{description:"disallow importing `node:test`",recommended:!1},type:"suggestion",messages:{noImportNodeTest:"Import from `vitest` instead of `node:test`"},fixable:"code",schema:[]},defaultOptions:[],create(e){return{ImportDeclaration(s){s.source.value==="node:test"&&e.report({messageId:"noImportNodeTest",node:s,fix:t=>t.replaceText(s.source,s.source.raw.replace("node:test","vitest"))})}}}}),ve=new Set(["suite","test","chai","describe","it","expectTypeOf","assertType","expect","assert","vitest","vi","beforeAll","afterAll","beforeEach","afterEach","onTestFailed","onTestFinished"]),Kt=e=>e.source.value==="vitest",Ce=e=>e.type===i.ImportSpecifier&&e.imported.type===i.Identifier&&ve.has(e.imported.name),Se=e=>e.type===i.Property&&e.key.type===i.Identifier&&ve.has(e.key.name),Un=e=>e.callee.type===i.Identifier&&ve.has(e.callee.name),Me=e=>{if(e?.type!==i.CallExpression||e.callee.type!==i.Identifier||e.callee.name!=="require")return!1;const s=e.arguments;return s.length===1&&s[0].type===i.Literal&&s[0].value==="vitest"},Gt=e=>e.type===i.ObjectPattern,jn=(e,s)=>{const t=s.parent,n=t.declarations;if(n.length===1)return e.remove(t);const o=n.findIndex(r=>r.range[0]===s.range[0]&&r.range[1]===s.range[1]);if(o===0){const r=n[1];return e.removeRange([s.range[0],r.range[0]])}else{const r=n[o-1];return e.removeRange([r.range[1],s.range[1]])}},Xt=(e,s,t)=>{const n=s.indexOf(t);if(n===-1)throw new Error("Target node not found in nodes array");if(n===0){const o=s[1];return e.removeRange([t.range[0],o.range[0]])}else{const o=s[n-1];return e.removeRange([o.range[1],t.range[1]])}},$e="no-importing-vitest-globals",_n=d({name:$e,meta:{type:"suggestion",docs:{description:"disallow importing Vitest globals",recommended:!1},messages:{noImportingVitestGlobals:"Do not import '{{name}}' from 'vitest'. Use globals configuration instead.",noRequiringVitestGlobals:"Do not require '{{name}}' from 'vitest'. Use globals configuration instead."},fixable:"code",schema:[]},defaultOptions:[],create(e){return{ImportDeclaration(s){if(!Kt(s))return;const t=s.specifiers;for(const n of t)Ce(n)&&e.report({node:n,messageId:"noImportingVitestGlobals",data:{name:n.imported.name},fix(o){return t.every(r=>Ce(r))?o.remove(s):Xt(o,t,n)}})},VariableDeclarator(s){if(!Me(s.init)||!Gt(s.id))return;const t=s.id.properties;for(const n of t)Se(n)&&e.report({node:n,messageId:"noRequiringVitestGlobals",data:{name:n.key.name},fix(o){return t.every(r=>Se(r))?jn(o,s):Xt(o,t,n)}})}}}}),Oe="prefer-importing-vitest-globals",Dn=d({name:Oe,meta:{type:"suggestion",docs:{description:"enforce importing Vitest globals",recommended:!1},messages:{preferImportingVitestGlobals:"Import '{{name}}' from 'vitest'"},schema:[],fixable:"code"},defaultOptions:[],create(e){const s=new Set;let t,n;return{ImportDeclaration(o){if(!Kt(o))return;const r=o.specifiers;for(const a of r)if(Ce(a)){const c=a.imported.name;s.add(c)}t=o.specifiers},VariableDeclarator(o){if(!Me(o.init)||!Gt(o.id))return;const r=o.id.properties;for(const a of r)if(Se(a)){const c=a.key.name;s.add(c)}n=r},CallExpression(o){if(!Un(o))return;const r=o.callee.name;if(s.has(r))return;const a=e.sourceCode.getScope(o).set.get(r);a&&a.defs.length>0&&a.defs.some(c=>!(c.type==="ImportBinding"||c.type==="Variable"&&c.node.init&&Me(c.node.init)))||e.report({node:o.callee,messageId:"preferImportingVitestGlobals",data:{name:r},fix(c){const l=e.sourceCode.ast;if(!t)if(n){const u=n[n.length-1];return c.insertTextAfter(u,`, ${r}`)}else return c.insertTextBefore(l.body[0],`import { ${r} } from 'vitest';
`);if(t.find(u=>u.type==="ImportNamespaceSpecifier"))return c.insertTextBefore(l.body[0],`import { ${r} } from 'vitest';
`);const p=t.find(u=>u.type==="ImportDefaultSpecifier");if(p)return c.insertTextAfter(p,`, { ${r} }`);const f=t[t.length-1];return c.insertTextAfter(f,`, ${r}`)}})}}}}),Re="no-conditional-in-test",Wn=d({name:Re,meta:{docs:{description:"disallow conditional tests",requiresTypeChecking:!1,recommended:!1},messages:{noConditionalInTest:"Remove conditional tests"},schema:[],type:"problem"},defaultOptions:[],create(e){return{IfStatement(s){s.parent?.parent?.parent?.type==="CallExpression"&&q(s.parent?.parent?.parent,e,["test","it"])&&e.report({messageId:"noConditionalInTest",node:s})}}}}),Ne="no-disabled-tests",Hn=d({name:Ne,meta:{type:"suggestion",docs:{description:"disallow disabled tests",recommended:!1},messages:{missingFunction:"Test is missing function argument",pending:"Call to pending()",pendingSuite:"Call to pending() within test suite",pendingTest:"Call to pending() within test",disabledSuite:"Disabled test suite - if you want to skip a test suite temporarily, use .todo() instead",disabledTest:"Disabled test - if you want to skip a test temporarily, use .todo() instead"},schema:[]},defaultOptions:[],create(e){let s=0,t=0;return{CallExpression(n){const o=h(n,e);if(!o)return;o.type==="describe"&&s++,o.type==="test"&&(t++,n.arguments.length<2&&o.members.every(a=>y(a)==="skip")&&e.report({messageId:"missingFunction",node:n}));const r=o.members.find(a=>y(a)==="skip");(o.name.startsWith("x")||r!==void 0)&&e.report({messageId:o.type==="describe"?"disabledSuite":"disabledTest",node:r??o.head.node})},"CallExpression:exit"(n){const o=h(n,e);o&&(o.type==="describe"&&s--,o.type==="test"&&t--)},'CallExpression[callee.name="pending"]'(n){const o=ae(e,n);jt(o,"pending")||(t>0?e.report({messageId:"pendingTest",node:n}):s>0?e.report({messageId:"pendingSuite",node:n}):e.report({messageId:"pending",node:n}))}}}}),Be="no-done-callback",Vn=(e,s,t)=>{if(s)return e.arguments[1];const n=h(e,t);return n?.type==="hook"&&e.arguments.length>=1?e.arguments[0]:n?.type==="test"&&e.arguments.length>=2?e.arguments[1]:null},Kn=d({name:Be,meta:{type:"suggestion",docs:{description:"disallow using a callback in asynchronous tests and hooks",recommended:!1},deprecated:!0,schema:[],messages:{noDoneCallback:"Return a promise instead of relying on callback parameter",suggestWrappingInPromise:"Wrap in `new Promise({{ callback }} => ...`",useAwaitInsteadOfCallback:"Use `await` instead of callback in async function"},hasSuggestions:!0},defaultOptions:[],create(e){return{CallExpression(s){const t=/\.each$|\.concurrent$/.test(R(s.callee)??"");if(t&&s.callee.type!==i.TaggedTemplateExpression||e.sourceCode.getAncestors(s).some(a=>a.type!==i.CallExpression||!q(a,e,["describe","test"])?!1:a.callee.type===i.MemberExpression&&C(a.callee.property,"concurrent")))return;const n=Vn(s,t,e),o=Number(t);if(!n||!M(n)||n.params.length!==1+o)return;const r=n.params[o];if(r.type!==i.Identifier){e.report({node:r,messageId:"noDoneCallback"});return}if(n.async){e.report({node:r,messageId:"useAwaitInsteadOfCallback"});return}e.report({node:s,messageId:"noDoneCallback",suggest:[{messageId:"suggestWrappingInPromise",data:{callback:r.name},fix(a){const{body:c,params:l}=n,{sourceCode:p}=e,f=p.getFirstToken(c),u=p.getLastToken(c),[b]=l,m=l[l.length-1],I=p.getTokenBefore(b);let k=p.getTokenAfter(m);if(k?.value===","&&(k=p.getTokenAfter(k)),!f||!u||!I||!k)throw new Error(`Unexpected null when attempting to fix ${e.filename} - please file an issue at https://github/veritem/eslint-plugin-vitest`);let x=a.replaceText(b,"()");I.value==="("&&k.value===")"&&(x=a.removeRange([I.range[1],k.range[0]]));let A=`new Promise(${r.name} => `,w=")",T=!0;return c.type===i.BlockStatement&&(A=`return ${A}{`,w+="}",T=!1),[x,T?a.insertTextBefore(f,A):a.insertTextAfter(f,A),a.insertTextAfter(u,w)]}}]})}}}}),Le="no-duplicate-hooks",Gn=d({name:Le,meta:{docs:{recommended:!1,description:"disallow duplicate hooks and teardown hooks",requiresTypeChecking:!1},messages:{noDuplicateHooks:"Duplicate {{ hook }} in describe block"},schema:[],type:"suggestion"},defaultOptions:[],create(e){const s=[{}];return{CallExpression(t){const n=h(t,e);if(n?.type==="describe"&&s.push({}),n?.type!=="hook")return;const o=s[s.length-1];o[n.name]||=0,o[n.name]+=1,o[n.name]>1&&e.report({messageId:"noDuplicateHooks",data:{hook:n.name},node:t})},"CallExpression:exit"(t){q(t,e,["describe"])&&s.pop()}}}}),Fe="no-large-snapshots",zt=(e,s,{maxSize:t=50,allowedSnapshots:n={}})=>{const o=s.loc.start.line,r=s.loc.end.line-o;if(!Object.keys(n).every(js))throw new Error("All paths for allowedSnapshots must be absolute. You can use JS config and `path.resolve`");let a=!1;if(s.type===i.ExpressionStatement&&"left"in s.expression&&s.expression.left.type===i.MemberExpression&&C(s.expression.left.property)){const c=e.filename,l=n[c];if(l){const p=y(s.expression.left.property);a=l.some(f=>f instanceof RegExp?f.test(p):p===f)}}!a&&r>t&&e.report({node:s,messageId:t===0?"noSnapShot":"tooLongSnapShot",data:{lineCount:r,lineLimit:t}})},Xn=d({name:Fe,meta:{docs:{description:"disallow large snapshots",recommended:!1},messages:{noSnapShot:"`{{ lineCount }}`s should begin with lowercase",tooLongSnapShot:"Expected vitest snapshot to be smaller than {{ lineLimit }} lines but was {{ lineCount }} lines long"},type:"suggestion",schema:[{type:"object",properties:{maxSize:{type:"number"},inlineMaxSize:{type:"number"},allowedSnapshots:{type:"object",additionalProperties:{type:"array"}}},additionalProperties:!1}]},defaultOptions:[{}],create(e,[s]){return e.filename.endsWith(".snap")?{ExpressionStatement(t){zt(e,t,s)}}:{CallExpression(t){const n=h(t,e);n?.type==="expect"&&["toMatchInlineSnapshot","toThrowErrorMatchingInlineSnapshot"].includes(y(n.matcher))&&n.args.length&&zt(e,n.args[0],{...s,maxSize:s.inlineMaxSize??s.maxSize})}}}}),Pe="no-interpolation-in-snapshots",zn=d({name:Pe,meta:{type:"problem",docs:{description:"disallow string interpolation in snapshots",recommended:!1},fixable:"code",schema:[],messages:{noInterpolationInSnapshots:"Do not use string interpolation in snapshots"}},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);t?.type==="expect"&&["toMatchInlineSnapshot","toThrowErrorMatchingInlineSnapshot"].includes(y(t.matcher))&&t.args.forEach(n=>{n.type===i.TemplateLiteral&&n.expressions.length>0&&e.report({messageId:"noInterpolationInSnapshots",node:n})})}}}}),Yt="__mocks__",Yn=e=>e.split(_s.sep).includes(Yt),Jt=e=>B(e)&&Yn(j(e)),Ue="no-mocks-import",Jn=d({name:Ue,meta:{type:"problem",docs:{description:"disallow importing from __mocks__ directory",recommended:!1},messages:{noMocksImport:`Mocks should not be manually imported from a ${Yt} directory. Instead use \`vi.mock\` and import from the original module path`},schema:[]},defaultOptions:[],create(e){return{ImportDeclaration(s){Jt(s.source)&&e.report({node:s,messageId:"noMocksImport"})},'CallExpression[callee.name="require"]'(s){const[t]=s.arguments;t&&Jt(t)&&e.report({node:t,messageId:"noMocksImport"})}}}}),je="no-restricted-matchers",Qn=(e,s)=>N.hasOwnProperty(s)||s.endsWith(".not")?e.startsWith(s):e===s,Zn=d({name:je,meta:{docs:{description:"disallow the use of certain matchers",recommended:!1},type:"suggestion",schema:[{type:"object",additionalProperties:{type:["string","null"]}}],messages:{restrictedChain:"use of {{ restriction }} is disallowed",restrictedChainWithMessage:"{{ message }}"}},defaultOptions:[{}],create(e,[s]){return{CallExpression(t){const n=h(t,e);if(n?.type!=="expect")return;const o=n.members.map(r=>y(r)).join(".");for(const[r,a]of Object.entries(s))if(Qn(o,r)){e.report({messageId:a?"restrictedChainWithMessage":"restrictedChain",data:{message:a,restriction:r},loc:{start:n.members[0].loc.start,end:n.members[n.members.length-1].loc.end}});break}}}}}),_e="no-standalone-expect",Qt=(e,s)=>{const t=e.parent;if(!t)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(t.type===i.FunctionDeclaration)return"function";if(M(t)&&t.parent){const n=t.parent;if(n.type===i.VariableDeclarator)return"function";if(n.type===i.CallExpression&&q(n,s,["describe"]))return"describe"}return null},eo=d({name:_e,meta:{docs:{description:"disallow using `expect` outside of `it` or `test` blocks",recommended:!1},type:"suggestion",messages:{noStandaloneExpect:"Expect must be called inside a test block"},schema:[{type:"object",properties:{additionalTestBlockFunctions:{type:"array",items:{type:"string"}}},additionalProperties:!1}]},defaultOptions:[{additionalTestBlockFunctions:[]}],create(e,[{additionalTestBlockFunctions:s=[]}]){const t=[],n=o=>s.includes(R(o)||"");return{CallExpression(o){const r=h(o,e);if(r?.type==="expect"){if(r.head.node.parent?.type===i.MemberExpression&&r.members.length===1&&!["assertions","hasAssertions"].includes(y(r.members[0])))return;const a=t[t.length-1];(!a||a===H.describe)&&e.report({node:o,messageId:"noStandaloneExpect"});return}(r?.type==="test"||n(o))&&t.push("test"),o.callee.type===i.TaggedTemplateExpression&&t.push("template")},"CallExpression:exit"(o){const r=t[t.length-1];(r==="test"&&(q(o,e,["test"])||n(o))&&o.callee.type!==i.MemberExpression||r==="template"&&o.callee.type===i.TaggedTemplateExpression)&&t.pop()},BlockStatement(o){const r=Qt(o,e);r&&t.push(r)},"BlockStatement:exit"(o){Qt(o,e)&&t.pop()},ArrowFunctionExpression(o){o.parent?.type!==i.CallExpression&&t.push("arrow")},"ArrowFunctionExpression:exit"(){t[t.length-1]==="arrow"&&t.pop()}}}}),De="no-test-prefixes",to=d({name:De,meta:{docs:{description:"disallow using the `f` and `x` prefixes in favour of `.only` and `.skip`",recommended:!1},type:"suggestion",messages:{usePreferredName:'Use "{{ preferredNodeName }}" instead'},fixable:"code",schema:[]},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);if(t?.type!=="describe"&&t?.type!=="test"||t.name[0]!=="f"&&t.name[0]!=="x")return;const n=[t.name.slice(1),t.name[0]==="f"?"only":"skip",...t.members.map(r=>y(r))].join("."),o=s.callee.type===i.TaggedTemplateExpression?s.callee.tag:s.callee.type===i.CallExpression?s.callee.callee:s.callee;e.report({messageId:"usePreferredName",node:s.callee,data:{preferredNodeName:n},fix:r=>[r.replaceText(o,n)]})}}}}),We="no-test-return-statement",so=e=>{const[,s]=e;return s&&M(s)&&s.body.type===i.BlockStatement?s.body.body:[]},no=d({name:We,meta:{type:"problem",docs:{description:"disallow return statements in tests",recommended:!1},schema:[],messages:{noTestReturnStatement:"Return statements are not allowed in tests"}},defaultOptions:[],create(e){return{CallExpression(s){if(!q(s,e,["test"]))return;const t=so(s.arguments).find(n=>n.type===i.ReturnStatement);t&&e.report({messageId:"noTestReturnStatement",node:t})},FunctionDeclaration(s){const t=e.sourceCode.getDeclaredVariables(s);if(ce(t,e).length===0)return;const n=s.body.body.find(o=>o.type===i.ReturnStatement);n&&e.report({messageId:"noTestReturnStatement",node:n})}}}}),He="prefer-called-with",oo=d({name:He,meta:{docs:{description:"enforce using `toBeCalledWith()` or `toHaveBeenCalledWith()`",recommended:!1},messages:{preferCalledWith:"Prefer {{ matcherName }}With(/* expected args */)"},type:"suggestion",fixable:"code",schema:[]},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);if(t?.type!=="expect"||t.modifiers.some(r=>y(r)==="not"))return;const{matcher:n}=t,o=y(n);["toBeCalled","toHaveBeenCalled"].includes(o)&&e.report({data:{matcherName:o},messageId:"preferCalledWith",node:n,fix:r=>[r.replaceText(n,`${o}With`)]})}}}}),ee="valid-title",ro=e=>["f","x"].includes(e.charAt(0))?e.substring(1):e,Zt=e=>e.type===i.TemplateLiteral?`\`${e.quasis[0].value.raw}\``:e.raw,es={type:"array",items:{type:"string"},minItems:1,maxItems:2,additionalItems:!1},te=e=>{const[s,t]=Array.isArray(e)?e:[e];return[new RegExp(s,"u"),t]};function io(e){return!!(e.flags&U.TypeFlags.StringLike)}const ts=e=>{if(typeof e=="string"||Array.isArray(e)){const s=te(e);return{describe:s,test:s,it:s}}return{describe:e.describe?te(e.describe):null,test:e.test?te(e.test):null,it:e.it?te(e.it):null}},ss=e=>B(e.right)?!0:e.left.type===i.BinaryExpression?ss(e.left):B(e.left),ao=d({name:ee,meta:{docs:{description:"enforce valid titles",recommended:!1},messages:{titleMustBeString:"Test title must be a string, a function or class name",emptyTitle:"{{ functionName }} should not have an empty title",duplicatePrefix:"should not have duplicate prefix",accidentalSpace:"should not have leading or trailing spaces",disallowedWord:'"{{ word }}" is not allowed in test title',mustNotMatch:"{{ functionName }} should not match {{ pattern }}",mustMatch:"{{ functionName }} should match {{ pattern }}",mustNotMatchCustom:"{{ message }}",mustMatchCustom:"{{ message }}"},type:"suggestion",schema:[{type:"object",properties:{ignoreTypeOfDescribeName:{type:"boolean",default:!1},allowArguments:{type:"boolean",default:!1},disallowedWords:{type:"array",items:{type:"string"}}},patternProperties:{[/^must(?:Not)?Match$/u.source]:{oneOf:[{type:"string"},es,{type:"object",propertyNames:{type:"string",enum:["describe","test","it"]},additionalProperties:{oneOf:[{type:"string"},es]}}]}},additionalProperties:!1}],fixable:"code"},defaultOptions:[{ignoreTypeOfDescribeName:!1,allowArguments:!1,disallowedWords:[]}],create(e,[{ignoreTypeOfDescribeName:s,allowArguments:t,disallowedWords:n=[],mustNotMatch:o,mustMatch:r}]){const a=new RegExp(`\\b(${n.join("|")})\\b`,"iu"),c=ts(o??{}),l=ts(r??{}),p=z(e.settings);return{CallExpression(f){const u=h(f,e);if(u?.type!=="describe"&&u?.type!=="test"&&u?.type!=="it"||u.members&&u.members[0]&&u.members[0].type===i.Identifier&&u.members[0].name==="extend")return;const b=O=>{e.report({messageId:"emptyTitle",data:{functionName:u.type==="describe"?H.describe:E.test},node:O})},[m]=f.arguments;if(p.typecheck){const O=ie.getParserServices(e).getTypeAtLocation(m);if(Lt(O))return;if(io(O)){B(m)&&!j(m)&&b(f);return}}if(!m||t&&m.type===i.Identifier)return;if(!B(m)){if(m.type===i.BinaryExpression&&ss(m))return;m.type!==i.TemplateLiteral&&!(s&&u.type==="describe")&&e.report({messageId:"titleMustBeString",loc:m.loc});return}const I=j(m);if(!I){b(f);return}if(n.length>0){const O=a.exec(I);if(O){e.report({messageId:"disallowedWord",data:{word:O[1]},node:m});return}}I.trim().length!==I.length&&e.report({messageId:"accidentalSpace",node:m,fix:O=>[O.replaceTextRange(m.range,Zt(m).replace(/^([`'"]) +?/u,"$1").replace(/ +?([`'"])$/u,"$1"))]});const k=ro(u.name),[x]=I.split(" ");x.toLowerCase()===k&&e.report({messageId:"duplicatePrefix",node:m,fix:O=>[O.replaceTextRange(m.range,Zt(m).replace(/^([`'"]).+? /u,"$1"))]});const A=k,[w,T]=c[A]??[];if(w&&w.test(I)){e.report({messageId:T?"mustNotMatchCustom":"mustNotMatch",node:m,data:{functionName:A,pattern:w,message:T}});return}const[v,W]=l[A]??[];v&&(v.test(I)||e.report({messageId:W?"mustMatchCustom":"mustMatch",node:m,data:{functionName:A,pattern:v,message:W}}))}}}}),se="valid-expect",ns=["toReject","toResolve"],co=e=>(e.type===i.ArrayExpression&&e.parent&&e.parent.type===i.CallExpression&&(e=e.parent),e.type===i.CallExpression&&e.callee.type===i.MemberExpression&&C(e.callee.object,"Promise")&&e.parent?e:null),os=({start:e,end:s})=>`${e.line}:${e.column}-${s.line}:${s.column}`,lo=e=>e.parent.type===i.Property&&e.type===i.FunctionExpression?e.parent:e;function rs(e){const s=e.parent?.parent;return s&&s.type===i.CallExpression&&s.callee.type===i.MemberExpression&&C(s.callee.property)&&["then","catch"].includes(y(s.callee.property))&&s.parent?rs(s):e}const uo=e=>e.parent?.parent&&[i.CallExpression,i.ArrayExpression].includes(e.parent.type)?co(e.parent):null,is=({parent:e})=>e?M(e)?e:is(e):null,as=(e,s)=>s&&e.type===i.ReturnStatement?!0:e.type===i.ConditionalExpression&&e.parent?as(e.parent,s):[i.ArrowFunctionExpression,i.AwaitExpression].includes(e.type),po=d({name:se,meta:{docs:{description:"enforce valid `expect()` usage",recommended:!1},messages:{tooManyArgs:"Expect takes at most {{ amount}} argument{{ s }}",notEnoughArgs:"Expect requires at least {{ amount }} argument{{ s }}",modifierUnknown:"Expect has an unknown modifier",matcherNotFound:"Expect must have a corresponding matcher call",matcherNotCalled:"Matchers must be called to assert",asyncMustBeAwaited:"Async assertions must be awaited{{ orReturned }}",promisesWithAsyncAssertionsMustBeAwaited:"Promises which return async assertions must be awaited{{ orReturned }}"},type:"suggestion",fixable:"code",schema:[{type:"object",properties:{alwaysAwait:{type:"boolean",default:!1},asyncMatchers:{type:"array",items:{type:"string"}},minArgs:{type:"number",minimum:1},maxArgs:{type:"number",minimum:1}},additionalProperties:!1}]},defaultOptions:[{alwaysAwait:!1,asyncMatchers:ns,minArgs:1,maxArgs:1}],create:(e,[{alwaysAwait:s,asyncMatchers:t=ns,minArgs:n=1,maxArgs:o=1}])=>{const r=new Set,a=[],c=f=>r.add(os(f)),l=f=>r.has(os(f)),p=f=>{let u=f,{parent:b}=f;for(;b&&b.type===i.MemberExpression;)u=b,b=b.parent;return u};return{CallExpression(f){const u=Pt(f,e),b=z(e.settings);if(typeof u=="string"){const v=f.parent?.type===i.MemberExpression?p(f.parent).property:f;if(u==="matcher-not-found"){e.report({messageId:"matcherNotFound",node:v});return}if(u==="matcher-not-called"&&e.report({messageId:C(v)&&N.hasOwnProperty(y(v))?"matcherNotFound":"matcherNotCalled",node:v}),u==="modifier-unknown"){e.report({messageId:"modifierUnknown",node:v});return}return}else if(u?.type==="expectTypeOf"&&b.typecheck||u?.type!=="expect"||u.modifiers.some(v=>v.type===i.Identifier&&v.name=="to"))return;const{parent:m}=u.head.node;if(m?.type!==i.CallExpression)return;if(m.arguments.length<n){const v=y(u.head.node).length,W={start:{column:m.loc.start.column+v,line:m.loc.start.line},end:{column:m.loc.start.column+v+1,line:m.loc.start.line}};e.report({messageId:"notEnoughArgs",data:{amount:n,s:n===1?"":"s"},node:m,loc:W})}if(m.arguments.length>o){if(m.arguments.length===2){const Ps=m.arguments[1].type===i.Literal&&typeof m.arguments[1].value=="string",Us=m.arguments[1].type===i.TemplateLiteral;if(Ps||Us)return}const{start:v}=m.arguments[o].loc,{end:W}=m.arguments[m.arguments.length-1].loc,O={start:v,end:{column:W.column+1,line:W.line}};e.report({messageId:"tooManyArgs",data:{amount:o,s:o===1?"":"s"},node:m,loc:O})}const{matcher:I}=u,k=I.parent.parent,x=u.modifiers.some(v=>y(v)!=="not")||t.includes(y(I));if(!k?.parent||!x)return;const A=k.parent.type===i.ArrayExpression,w=rs(k),T=uo(w)||w;T.parent&&!as(T.parent,!s)&&!l(T.loc)&&(a.push({messageId:T===w?"asyncMustBeAwaited":"promisesWithAsyncAssertionsMustBeAwaited",node:T}),A&&c(T.loc))},"Program:exit"(){const f=[];a.forEach(({node:u,messageId:b},m)=>{const I=s?"":" or returned";e.report({loc:u.loc,data:{orReturned:I},messageId:b,node:u,fix(k){const x=is(u);if(!x)return null;const A=f.some(T=>T.text==="async ");if(!x.async&&!A){const T=lo(x);f.push(k.insertTextBefore(T,"async "))}const w=u.parent?.type===i.ReturnStatement?u.parent:null;if(s&&w){const T=e.sourceCode.getText(w).replace("return","await");f.push(k.replaceText(w,T))}else f.push(k.insertTextBefore(u,"await "));return m===a.length-1?f:null}})})}}}}),ne=e=>e.type===i.Literal&&typeof e.value=="boolean",fo=e=>{const s=y(e.matcher);if(["toBeTruthy","toBeFalsy"].includes(s))return!0;if(e.args.length!==1)return!1;const t=P(e);return F.hasOwnProperty(s)&&ne(t)},mo=(e,s)=>e.type===i.BinaryExpression&&e.operator==="instanceof"&&C(e.right,s),cs=e=>e.arguments.length===1,Ve="prefer-to-be-object",yo=d({name:Ve,meta:{type:"suggestion",docs:{description:"enforce using toBeObject()",recommended:!1},fixable:"code",messages:{preferToBeObject:"Prefer toBeObject() to test if a value is an object"},schema:[]},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);if(t?.type!=="expectTypeOf")return;if(Ks(t,"Object")){e.report({node:t.matcher,messageId:"preferToBeObject",fix:r=>[r.replaceTextRange([t.matcher.range[0],t.matcher.range[1]+8],"toBeObject()")]});return}const{parent:n}=t.head.node;if(n?.type!==i.CallExpression)return;const[o]=n.arguments;!o||!fo(t)||!mo(o,"Object")||e.report({node:t.matcher,messageId:"preferToBeObject",fix(r){const a=[r.replaceText(t.matcher,"toBeObject"),r.removeRange([o.left.range[1],o.range[1]])];let c=y(t.matcher)==="toBeFalsy";if(t.args.length){const[l]=t.args;a.push(r.remove(l)),c=l.type===i.Literal&&le(l).value===!1}if(c){const l=t.modifiers.find(p=>y(p)==="not");a.push(l?r.removeRange([l.range[0]-1,l.range[1]]):r.insertTextBefore(t.matcher,"not."))}return a}})}}}}),Ke="prefer-to-be-truthy",ho=e=>e.type===i.Literal&&e.value===!0,go=d({name:Ke,meta:{type:"suggestion",docs:{description:"enforce using `toBeTruthy`",recommended:!1},messages:{preferToBeTruthy:"Prefer using `toBeTruthy` to test value is `true`"},fixable:"code",schema:[]},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);(t?.type==="expect"||t?.type==="expectTypeOf")&&t.args.length===1&&ho(P(t))&&F.hasOwnProperty(y(t.matcher))&&e.report({node:t.matcher,messageId:"preferToBeTruthy",fix:n=>[n.replaceText(t.matcher,"toBeTruthy"),n.remove(t.args[0])]})}}}}),Ge="prefer-to-be-falsy",ko=e=>e.type===i.Literal&&e.value===!1,bo=d({name:Ge,meta:{type:"suggestion",docs:{description:"enforce using toBeFalsy()",recommended:!1},fixable:"code",schema:[],messages:{preferToBeFalsy:"Prefer using toBeFalsy()"}},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);(t?.type==="expect"||t?.type==="expectTypeOf")&&t.args.length===1&&ko(P(t))&&F.hasOwnProperty(y(t.matcher))&&e.report({node:t.matcher,messageId:"preferToBeFalsy",fix:n=>[n.replaceText(t.matcher,"toBeFalsy"),n.remove(t.args[0])]})}}}}),Xe="prefer-to-have-length",xo=d({name:Xe,meta:{type:"suggestion",docs:{description:"enforce using toHaveLength()",recommended:!1},fixable:"code",messages:{preferToHaveLength:"Prefer toHaveLength()"},schema:[]},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);if(t?.type!=="expect")return;const{parent:n}=t.head.node;if(n?.type!==i.CallExpression)return;const[o]=n.arguments,{matcher:r}=t;!F.hasOwnProperty(y(r))||o?.type!==i.MemberExpression||!C(o.property,"length")||e.report({node:r,messageId:"preferToHaveLength",fix(a){return[a.removeRange([o.property.range[0]-1,o.range[1]]),a.replaceTextRange([r.parent.object.range[1],r.parent.range[1]],".toHaveLength")]}})}}}}),ze="prefer-equality-matcher",Io=d({name:ze,meta:{type:"suggestion",docs:{description:"enforce using the built-in quality matchers",recommended:!1},messages:{useEqualityMatcher:"Prefer using one of the equality matchers instead",suggestEqualityMatcher:"Use `{{ equalityMatcher }}`"},hasSuggestions:!0,schema:[]},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);if(t?.type!=="expect"||t.args.length===0)return;const{parent:n}=t.head.node;if(n?.type!==i.CallExpression)return;const{arguments:[o],range:[,r]}=n,{matcher:a}=t,c=P(t);if(o?.type!==i.BinaryExpression||o.operator!=="==="&&o.operator!=="!=="||!F.hasOwnProperty(y(a))||!ne(c))return;const l=c.value,[p]=t.modifiers,f=t.modifiers.some(m=>y(m)==="not"),u=(o.operator==="!=="?!l:l)===f,b=m=>I=>{const{sourceCode:k}=e;let x=p&&y(p)!=="not"?`.${y(p)}`:"";return u&&(x+=`.${N.not}`),[I.replaceText(o,k.getText(o.left)),I.replaceTextRange([r,a.parent.range[1]],`${x}.${m}`),I.replaceText(c,k.getText(o.right))]};e.report({messageId:"useEqualityMatcher",suggest:["toBe","toEqual","toStrictEqual"].map(m=>({messageId:"suggestEqualityMatcher",data:{equalityMatcher:m},fix:b(m)})),node:a})}}}}),Ye="prefer-strict-equal",Eo=d({name:Ye,meta:{type:"suggestion",docs:{description:"enforce strict equal over equal",recommended:!1},messages:{useToStrictEqual:"Use `toStrictEqual()` instead",suggestReplaceWithStrictEqual:"Replace with `toStrictEqual()`"},schema:[],hasSuggestions:!0},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);if(t?.type!=="expect")return;const{matcher:n}=t;C(n,"toEqual")&&e.report({messageId:"useToStrictEqual",node:n,suggest:[{messageId:"suggestReplaceWithStrictEqual",fix:o=>[G(o,n,F.toStrictEqual)]}]})}}}}),Je="prefer-expect-resolves",qo=d({name:Je,meta:{type:"suggestion",docs:{description:"enforce using `expect().resolves` over `expect(await ...)` syntax",recommended:!1},fixable:"code",messages:{expectResolves:"Use `expect().resolves` instead"},schema:[]},defaultOptions:[],create:e=>({CallExpression(s){const t=h(s,e);if(t?.type!=="expect")return;const{parent:n}=t.head.node;if(n?.type!==i.CallExpression)return;const[o]=n.arguments;o?.type===i.AwaitExpression&&e.report({node:o,messageId:"expectResolves",fix(r){return[r.insertTextBefore(n,"await "),r.removeRange([o.range[0],o.argument.range[0]]),r.insertTextAfter(n,".resolves")]}})}})}),Qe="prefer-each",To=d({name:Qe,meta:{type:"suggestion",docs:{description:"enforce using `each` rather than manual loops",recommended:!1},schema:[],messages:{preferEach:"Prefer using `{{ fn }}.each` rather than a manual loop"}},defaultOptions:[],create(e){const s=[];let t=!1;const n=()=>s.length===1&&s[0]==="test"?"it":"describe",o=()=>{s.length===0||t||(s.length=0)},r=a=>{s.length===0||t||(e.report({node:a,messageId:"preferEach",data:{fn:n()}}),s.length=0)};return{ForStatement:o,"ForStatement:exit":r,ForInStatement:o,"ForInStatement:exit":r,ForOfStatement:o,"ForOfStatement:exit":r,CallExpression(a){const{type:c}=h(a,e)??{};(c==="hook"||c==="describe"||c==="test")&&s.push(c),c==="test"&&(t=!0)},"CallExpression:exit"(a){const{type:c}=h(a,e)??{};c==="test"&&(t=!1)}}}}),Ze="prefer-hooks-on-top",wo=d({name:Ze,meta:{type:"suggestion",docs:{description:"enforce having hooks before any test cases",recommended:!1},messages:{noHookOnTop:"Hooks should come before test cases"},schema:[]},defaultOptions:[],create(e){const s=[!1];return{CallExpression(t){q(t,e,["test"])&&(s[s.length-1]=!0),s[s.length-1]&&q(t,e,["hook"])&&e.report({messageId:"noHookOnTop",node:t}),s.push(!1)},"CallExpression:exit"(){s.pop()}}}}),et="prefer-hooks-in-order",ls=["beforeAll","beforeEach","afterEach","afterAll"],Ao=d({name:et,meta:{type:"suggestion",docs:{description:"enforce having hooks in consistent order",recommended:!1},messages:{reorderHooks:"`{{ currentHook }}` hooks should be before any `{{ previousHook }}` hooks"},schema:[]},defaultOptions:[],create(e){let s=-1,t=!1;return{CallExpression(n){if(t)return;const o=h(n,e);if(o?.type!=="hook"){s=-1;return}t=!0;const r=o.name,a=ls.indexOf(r);if(a<s){e.report({messageId:"reorderHooks",data:{previousHook:ls[s],currentHook:r},node:n}),t=!1;return}s=a},"CallExpression:exit"(n){if(q(n,e,["hook"])){t=!1;return}t||(s=-1)}}}}),tt="prefer-mock-promise-shorthand",st=(e,s)=>`${e}${s?"Once":""}`,vo=e=>e.body.type!==i.BlockStatement?e.body:e.body.body[0]?.type===i.ReturnStatement?e.body.body[0].argument:null,Co=d({name:tt,meta:{type:"suggestion",docs:{description:"enforce mock resolved/rejected shorthands for promises",recommended:!1},messages:{useMockShorthand:"Prefer {{ replacement }}"},schema:[],fixable:"code"},defaultOptions:[],create(e){const s=(t,n,o,r=o)=>{if(r?.type!==i.CallExpression)return;const a=R(r);if(a!=="Promise.resolve"&&a!=="Promise.reject")return;const c=st(a.endsWith("reject")?"mockRejectedValue":"mockResolvedValue",n);e.report({node:t,messageId:"useMockShorthand",data:{replacement:c},fix(l){const{sourceCode:p}=e;return r.arguments.length>1?null:[l.replaceText(t,c),l.replaceText(o,r.arguments.length===1?p.getText(r.arguments[0]):"undefined")]}})};return{CallExpression(t){if(t.callee.type!==i.MemberExpression||!C(t.callee.property)||t.arguments.length===0)return;const n=y(t.callee.property),o=n.endsWith("Once");if(n===st("mockReturnValue",o))s(t.callee.property,o,t.arguments[0]);else if(n===st("mockImplementation",o)){const[r]=t.arguments;if(!M(r)||r.params.length!==0)return;s(t.callee.property,o,r,vo(r))}}}}}),So=Ot(import.meta.url),Mo=Ot(So.resolve("eslint"));Mo.resolve("espree");const $o=new Set([i.Program,i.BlockStatement,i.SwitchCase,i.SwitchStatement]),Oo=e=>$o.has(e),Ro=e=>e.value===";"&&e.type===$t.Punctuator,us=(e,s)=>{const t=e.getLastToken(s),n=e.getTokenBefore(t),o=e.getTokenAfter(t);return n&&o&&n.range[0]>=s.range[0]&&Ro(t)&&t.loc.start.line!==n.loc.end.line&&t.loc.end.line===o.loc.start.line?n:t},No=(e,s,t)=>{const n=[];let o=us(t,e);if(s.loc.start.line-e.loc.end.line>=2)do{const r=t.getTokenAfter(o,{includeComments:!0});r.loc.start.line-o.loc.end.line>=2&&n.push([o,r]),o=r}while(o.range[0]<s.range[0]);return n},ps=(e,s)=>e.loc.end.line===s.loc.start.line,Bo=e=>e.type===i.TSAsExpression||e.type===i.TSTypeAssertion,ds=e=>Bo(e)?ds(e.expression):e,nt="prefer-vi-mocked",Lo=["Mock","MockedFunction","MockedClass","MockedObject"],Fo=d({name:nt,meta:{type:"suggestion",docs:{description:"require `vi.mocked()` over `fn as Mock`",requiresTypeChecking:!0,recommended:!1},fixable:"code",messages:{useViMocked:"Prefer `vi.mocked()`"},schema:[]},defaultOptions:[],create(e){function s(t){const{typeAnnotation:n}=t;if(n.type!==i.TSTypeReference)return;const{typeName:o}=n;if(o.type!==i.Identifier||!Lo.includes(o.name))return;const r=e.sourceCode.text.slice(...ds(t.expression).range);e.report({node:t,messageId:"useViMocked",fix(a){return a.replaceText(t,`vi.mocked(${r})`)}})}return{TSAsExpression(t){t.parent.type!==i.TSAsExpression&&s(t)},TSTypeAssertion(t){s(t)}}}}),ot="prefer-snapshot-hint",Po=["toMatchSnapshot","toThrowErrorMatchingSnapshot"],Uo=Po,jo=e=>{if(e.args.length===0)return!0;if(!C(e.matcher,"toMatchSnapshot"))return e.args.length!==1;if(e.args.length===2)return!1;const[s]=e.args;return!B(s)},_o=d({name:ot,meta:{type:"suggestion",docs:{description:"enforce including a hint with external snapshots",recommended:!1},messages:{missingHint:"You should provide a hint for this snapshot"},schema:[{type:"string",enum:["always","multi"]}]},defaultOptions:["multi"],create(e,[s]){const t=[];let n=0;const o=[],r=()=>{for(const l of t)jo(l)&&e.report({messageId:"missingHint",node:l.matcher})},a=()=>{n++},c=()=>{n--,s==="always"&&(r(),t.length=0),s==="multi"&&n===0&&(t.length>1&&r(),t.length=0)};return{"Program:exit"(){a(),c()},FunctionExpression:a,"FunctionExpression:exit":c,ArrowFunctionExpression:a,"ArrowFunctionExpression:exit":c,"CallExpression:exit"(l){q(l,e,["describe","test"])&&(n=o.pop()??0)},CallExpression(l){const p=h(l,e);if(p?.type!=="expect"){(p?.type==="describe"||p?.type==="test")&&(o.push(n),n=0);return}const f=y(p.matcher);Uo.includes(f)&&t.push(p)}}}}),oe="valid-describe-callback",fs=e=>{const[s]=e,t=e[e.length-1];return{start:s.loc.start,end:t.loc.end}},ms=(e,s)=>e.members.every(t=>y(t)!=="each")&&s.params.length,ys=(e,s)=>{e.body.forEach(t=>{t.type===i.ReturnStatement&&s.report({messageId:"unexpectedReturnInDescribe",node:t})})},Do=d({name:oe,meta:{type:"problem",docs:{description:"enforce valid describe callback",recommended:!1},messages:{nameAndCallback:"Describe requires a name and callback arguments",secondArgumentMustBeFunction:"Second argument must be a function",unexpectedDescribeArgument:"Unexpected argument in describe callback",unexpectedReturnInDescribe:"Unexpected return statement in describe callback"},schema:[]},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);if(t?.type!=="describe"||t?.members[0]?.type===i.Identifier&&t.members[0].name==="todo")return;if(s.arguments.length<1)return e.report({messageId:"nameAndCallback",loc:s.loc});const[,n,o]=s.arguments;if(!n){e.report({messageId:"nameAndCallback",loc:fs(s.arguments)});return}if(!M(n)){if(o&&M(o)){ms(t,o)&&e.report({messageId:"unexpectedDescribeArgument",node:o}),o.body.type===i.CallExpression&&e.report({messageId:"unexpectedReturnInDescribe",node:o}),o.body.type===i.BlockStatement&&ys(o.body,e);return}e.report({messageId:"secondArgumentMustBeFunction",loc:fs(s.arguments)});return}ms(t,n)&&e.report({messageId:"unexpectedDescribeArgument",node:n}),n.body.type===i.CallExpression&&e.report({messageId:"unexpectedReturnInDescribe",node:n}),n.body.type===i.BlockStatement&&ys(n.body,e)}}}}),rt="require-top-level-describe",Wo=d({name:rt,meta:{docs:{description:"enforce that all tests are in a top-level describe",recommended:!1},messages:{tooManyDescribes:"There should not be more than {{ max }} describe{{ s }} at the top level",unexpectedTestCase:"All test cases must be wrapped in a describe block",unexpectedHook:"All hooks must be wrapped in a describe block"},type:"suggestion",schema:[{type:"object",properties:{maxNumberOfTopLevelDescribes:{type:"number",minimum:1}},additionalProperties:!1}]},defaultOptions:[{}],create(e){const{maxNumberOfTopLevelDescribes:s=1/0}=e.options[0]??{};let t=0,n=0;return{CallExpression(o){const r=h(o,e);if(r){if(r.type==="describe"){n++,n===1&&(t++,t>s&&e.report({node:o,messageId:"tooManyDescribes",data:{max:s,s:s===1?"":"s"}}));return}if(n===0){if(r.type==="test"){e.report({node:o,messageId:"unexpectedTestCase"});return}r.type==="hook"&&e.report({node:o,messageId:"unexpectedHook"})}}},"CallExpression:exit"(o){q(o,e,["describe"])&&n--}}}}),it="require-to-throw-message",Ho=d({name:it,meta:{type:"suggestion",docs:{description:"require toThrow() to be called with an error message",recommended:!1},schema:[],messages:{addErrorMessage:"Add an error message to {{ matcherName }}()"}},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);if(t?.type!=="expect")return;const{matcher:n}=t,o=y(n);t.args.length===0&&["toThrow","toThrowError"].includes(o)&&!t.modifiers.some(r=>y(r)==="not")&&e.report({messageId:"addErrorMessage",data:{matcherName:o},node:n})}}}}),at="require-hook",Vo=(e,s)=>h(e,s)?!0:!!R(e)?.startsWith("vi"),Ko=e=>e.type===i.Literal&&e.value===null||L(e,"undefined"),hs=(e,s,t=[])=>{switch(e.type){case i.ExpressionStatement:return hs(e.expression,s,t);case i.CallExpression:return!(Vo(e,s)||t.includes(R(e)));case i.VariableDeclaration:return e.kind==="const"?!1:e.declarations.some(({init:n})=>n!==null&&!Ko(n));default:return!1}},Go=d({name:at,meta:{docs:{description:"require setup and teardown to be within a hook",recommended:!1},messages:{useHook:"This should be done within a hook"},type:"suggestion",schema:[{type:"object",properties:{allowedFunctionCalls:{type:"array",items:{type:"string"}}},additionalProperties:!1}]},defaultOptions:[{allowedFunctionCalls:[]}],create(e){const{allowedFunctionCalls:s}=e.options[0]??{},t=n=>{for(const o of n)hs(o,e,s)&&e.report({node:o,messageId:"useHook"})};return{Program(n){t(n.body)},CallExpression(n){if(!q(n,e,["describe"])||n.arguments.length<2)return;const[,o]=n.arguments;!M(o)||o.body.type!==i.BlockStatement||t(o.body.body)}}}}),re="require-local-test-context-for-concurrent-snapshots",Xo=d({name:re,meta:{docs:{description:"require local Test Context for concurrent snapshot tests",recommended:!1},messages:{requireLocalTestContext:"Use local Test Context instead"},type:"problem",schema:[]},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);t===null||t.type!=="expect"||t.type==="expect"&&t.head.type==="testContext"||!["toMatchSnapshot","toMatchInlineSnapshot","toMatchFileSnapshot","toThrowErrorMatchingSnapshot","toThrowErrorMatchingInlineSnapshot"].includes(s.callee?.property.name)||!e.sourceCode.getAncestors(s).some(n=>n.type!==i.CallExpression||!q(n,e,["describe","test"])?!1:n.callee.type===i.MemberExpression&&C(n.callee.property,"concurrent"))||e.report({node:s,messageId:"requireLocalTestContext"})}}}}),ct="prefer-todo",zo=e=>e.members.some(s=>y(s)!=="skip")||e.name.startsWith("x")?!1:!e.name.startsWith("f");function Yo(e){return M(e)?e.body.type===i.BlockStatement&&!e.body.body.length:!1}function gs(e,s){return e.members.length?G(s,e.members[0],"todo"):s.replaceText(e.head.node,`${e.head.local}.todo`)}const Jo=d({name:ct,meta:{type:"layout",docs:{description:"enforce using `test.todo`",recommended:!1},messages:{emptyTest:"Prefer todo test case over empty test case",unimplementedTest:"Prefer todo test case over unimplemented test case"},fixable:"code",schema:[]},defaultOptions:[],create(e){return{CallExpression(s){const[t,n]=s.arguments,o=h(s,e);!t||o?.type!=="test"||!zo(o)||!B(t)||(n&&Yo(n)&&e.report({messageId:"emptyTest",node:s,fix:r=>[r.removeRange([t.range[1],n.range[1]]),gs(o,r)]}),cs(s)&&e.report({messageId:"unimplementedTest",node:s,fix:r=>gs(o,r)}))}}}}),lt="prefer-spy-on",Qo=e=>"object"in e?e.object:e.callee.type===i.MemberExpression?e.callee.object:null,ks=e=>{if(e.type!==i.CallExpression&&e.type!==i.MemberExpression)return null;const s=Qo(e);return s?s.type===i.Identifier?e.type===i.CallExpression&&R(e.callee)==="vi.fn"?e:null:ks(s):null},Zo=(e,s)=>{if(e.parent?.type===i.MemberExpression&&e.parent.property.type===i.Identifier&&e.parent.property.name==="mockImplementation")return"";const[t]=e.arguments,n=t&&s.sourceCode.getText(t);return n?`.mockImplementation(${n})`:".mockImplementation()"},er=d({name:lt,meta:{type:"suggestion",docs:{description:"enforce using `vi.spyOn`",recommended:!1},messages:{useViSpayOn:"Use `vi.spyOn` instead"},fixable:"code",schema:[]},defaultOptions:[],create(e){return{AssignmentExpression(s){const{left:t,right:n}=s;if(t.type!==i.MemberExpression)return;const o=ks(n);o&&e.report({node:s,messageId:"useViSpayOn",fix(r){const a=t.property.type===i.Identifier&&!t.computed?"'":"",c=Zo(o,e);return[r.insertTextBefore(t,"vi.spyOn("),r.replaceTextRange([t.object.range[1],t.property.range[0]],`, ${a}`),r.replaceTextRange([t.property.range[1],o.range[1]],`${a})${c}`)]}})}}}}),ut="prefer-comparison-matcher",bs=e=>B(e)||e?.type===i.TemplateLiteral,tr=e=>bs(e.left)||bs(e.right),sr=e=>{switch(e){case">":return"<=";case"<":return">=";case">=":return"<";case"<=":return">"}return null},nr=(e,s)=>{switch(s?sr(e):e){case">":return"toBeGreaterThan";case"<":return"toBeLessThan";case">=":return"toBeGreaterThanOrEqual";case"<=":return"toBeLessThanOrEqual"}return null},or=d({name:ut,meta:{type:"suggestion",docs:{description:"enforce using the built-in comparison matchers",recommended:!1},schema:[],fixable:"code",messages:{useToBeComparison:"Prefer using `{{ preferredMatcher }}` instead"}},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);if(t?.type!=="expect"||t.args.length===0)return;const{parent:n}=t.head.node;if(n?.type!==i.CallExpression)return;const{arguments:[o],range:[,r]}=n,{matcher:a}=t,c=P(t);if(o?.type!==i.BinaryExpression||tr(o)||!F.hasOwnProperty(y(a))||!ne(c))return;const[l]=t.modifiers,p=t.modifiers.some(u=>y(u)==="not"),f=nr(o.operator,c.value===p);f&&e.report({fix(u){const{sourceCode:b}=e,m=l&&y(l)!=="not"?`.${y(l)}`:"";return[u.replaceText(o,b.getText(o.left)),u.replaceTextRange([r,a.parent.range[1]],`${m}.${f}`),u.replaceText(c,b.getText(o.right))]},messageId:"useToBeComparison",data:{preferredMatcher:f},node:a})}}}}),pt="prefer-describe-function-title",rr=d({name:pt,meta:{type:"problem",docs:{description:"enforce using a function as a describe title over an equivalent string",recommended:!1},fixable:"code",schema:[],messages:{preferFunction:"Enforce using a function over an equivalent string"}},defaultOptions:[],create(e){return{CallExpression(s){if(s.arguments.length<2)return;const t=Xs(e,s),[n]=s.arguments;if(n.type===i.MemberExpression&&n.object.type===i.Identifier&&n.property.type===i.Identifier){const a=n.object.name;if(t?.set.get(a)?.defs[0]?.type!==Rt.ImportBinding||n.property.name!=="name")return;e.report({node:n,messageId:"preferFunction",fix(c){return c.replaceText(n,a)}});return}if(n.type!==i.Literal||typeof n.value!="string")return;const o=n.value;if(h(s,e)?.type!=="describe")return;const r=t?.set.get(o)?.defs[0];if(r?.type===Rt.ImportBinding){if(z(e.settings).typecheck){const a=ie.getParserServices(e).getTypeAtLocation(r.node);if(!Lt(a))return}e.report({node:n,messageId:"preferFunction",fix(a){return a.replaceText(n,o)}})}}}}}),dt="prefer-to-contain",ir=e=>e.type===i.CallExpression&&e.callee.type===i.MemberExpression&&C(e.callee.property,"includes")&&cs(e)&&e.arguments[0].type!==i.SpreadElement,ar=d({name:dt,meta:{docs:{description:"enforce using toContain()",recommended:!1},messages:{useToContain:"Use toContain() instead"},fixable:"code",type:"suggestion",schema:[]},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);if(t?.type!=="expect"||t.args.length===0)return;const{parent:n}=t.head.node;if(n?.type!==i.CallExpression)return;const{arguments:[o],range:[,r]}=n,{matcher:a}=t,c=P(t);if(!o||c.type===i.SpreadElement||!F.hasOwnProperty(y(a))||!ne(c)||!ir(o))return;const l=t.modifiers.some(p=>y(p)==="not");e.report({fix(p){const{sourceCode:f}=e,u=c.value===l;return[p.removeRange([o.callee.property.range[0]-1,o.range[1]]),p.replaceTextRange([r,a.parent.range[1]],u?`.${N.not}.toContain`:".toContain"),p.replaceText(t.args[0],f.getText(o.arguments[0]))]},messageId:"useToContain",node:a})}}}}),xs="prefer-expect-assertions",cr=e=>{let s=e;for(;s;){if(s.parent?.type===i.BlockStatement)return s.parent.body[0]===s;if(s.parent?.type===i.ArrowFunctionExpression)return!0;s=s.parent}throw new Error("Could not find parent block statement")},Is=(e,s,t)=>({messageId:"suggestRemovingExtraArguments",fix:n=>Nt(n,e,s,t)}),lr=d({name:"prefer-expect-assertions",meta:{docs:{description:"enforce using expect assertions instead of callbacks",recommended:!1},messages:{hasAssertionsTakesNoArguments:"`expect.hasAssertions` expects no arguments",assertionsRequiresOneArgument:"`expect.assertions` excepts a single argument of type number",assertionsRequiresNumberArgument:"This argument should be a number",haveExpectAssertions:"Every test should have either `expect.assertions(<number of assertions>)` or `expect.hasAssertions()` as its first expression",suggestAddingHasAssertions:"Add `expect.hasAssertions()`",suggestAddingAssertions:"Add `expect.assertions(<number of assertions>)`",suggestRemovingExtraArguments:"Remove extra arguments"},type:"suggestion",hasSuggestions:!0,schema:[{type:"object",properties:{onlyFunctionsWithAsyncKeyword:{type:"boolean"},onlyFunctionsWithExpectInLoop:{type:"boolean"},onlyFunctionsWithExpectInCallback:{type:"boolean"}},additionalProperties:!1}]},defaultOptions:[{onlyFunctionsWithAsyncKeyword:!1,onlyFunctionsWithExpectInCallback:!1,onlyFunctionsWithExpectInLoop:!1}],create(e,[s]){let t=0,n=!1,o=!1,r=!1,a=null,c=!1,l=!1;const p=k=>!!(!s.onlyFunctionsWithAsyncKeyword&&!s.onlyFunctionsWithExpectInCallback&&!s.onlyFunctionsWithExpectInLoop||s.onlyFunctionsWithAsyncKeyword&&k.async||s.onlyFunctionsWithExpectInCallback&&n||s.onlyFunctionsWithExpectInLoop&&o);function f(k,x){if(y(k.members[0])==="hasAssertions"){k.args.length&&e.report({messageId:"hasAssertionsTakesNoArguments",node:k.matcher,suggest:[Is(e,x,0)]});return}if(k.args.length!==1){let{loc:w}=k.matcher;const T=[];k.args.length&&(w=k.args[1].loc,T.push(Is(e,x,1))),e.report({messageId:"assertionsRequiresOneArgument",suggest:T,loc:w});return}const[A]=k.args;A.type===i.Literal&&typeof A.value=="number"&&Number.isInteger(A.value)||e.report({messageId:"assertionsRequiresNumberArgument",node:A})}const u=()=>c&&t++,b=()=>c&&t--,m=()=>l=!0,I=()=>l=!1;return{FunctionExpression:u,"FunctionExpression:exit":b,ArrowFunctionExpression:u,"ArrowFunctionExpression:exit":b,ForStatement:m,"ForStatement:exit":I,ForInStatement:m,"ForInStatement:exit":I,ForOfStatement:m,"ForOfStatement:exit":I,CallExpression(k){const x=h(k,e);if(x?.type==="test"){c=!0;return}x?.head.type==="testContext"&&x.members[0]&&x.members[0].type===i.Identifier&&x.members[0].name==="expect"&&(a=`${x.head.local}`),x?.type==="expect"&&c&&(t===1&&cr(k)&&x.head.node.parent?.type===i.MemberExpression&&x.members.length===1&&["assertions","hasAssertions"].includes(y(x.members[0]))&&(f(x,k),r=!0),l&&(o=!0),t>1&&(n=!0))},"CallExpression:exit"(k){if(!q(k,e,["test"])||(c=!1,k.arguments.length<2))return;const[,x]=k.arguments;if(!M(x)||!p(x))return;if(o=!1,n=!1,r){r=!1;return}const A=[];if(x.body.type===i.BlockStatement){const w=a?`${a}.`:"";A.push(["suggestAddingHasAssertions",`${w}expect.hasAssertions();`],["suggestAddingAssertions",`${w}expect.assertions();`])}e.report({messageId:"haveExpectAssertions",node:k,suggest:A.map(([w,T])=>({messageId:w,fix:v=>v.insertTextBeforeRange([x.body.range[0]+1,x.body.range[1]],T)}))})}}}});var S=(e=>(e[e.Any=0]="Any",e[e.Always=1]="Always",e))(S||{}),g=(e=>(e[e.Any=0]="Any",e[e.AfterAllToken=1]="AfterAllToken",e[e.AfterEachToken=2]="AfterEachToken",e[e.BeforeAllToken=3]="BeforeAllToken",e[e.BeforeEachToken=4]="BeforeEachToken",e[e.DescribeToken=5]="DescribeToken",e[e.ExpectToken=6]="ExpectToken",e[e.ExpectTypeOfToken=7]="ExpectTypeOfToken",e[e.FdescribeToken=8]="FdescribeToken",e[e.FitToken=9]="FitToken",e[e.ItToken=10]="ItToken",e[e.TestToken=11]="TestToken",e[e.XdescribeToken=12]="XdescribeToken",e[e.XitToken=13]="XitToken",e[e.XtestToken=14]="XtestToken",e))(g||{});const ur=(e,s,t)=>{const{sourceCode:n,ruleContext:o}=t;No(e,s,n).length>0||o.report({node:s,messageId:"missingPadding",fix(r){let a=us(n,e);const c=n.getFirstTokenBetween(a,s,{includeComments:!0,filter(p){return ps(a,p)?(a=p,!1):!0}})||s,l=ps(a,c)?`

`:`
`;return r.insertTextAfter(a,l)}})},pr={0:()=>!0,1:ur},dr=()=>{let e=null;return{get prevNode(){return e.prevNode},set prevNode(s){e.prevNode=s},enter(){e={upper:e,prevNode:null}},exit(){e=e.upper}}},$=e=>(s,t)=>{let n=s;if(n.type===i.ExpressionStatement){n.expression.type===i.AwaitExpression&&(n=n.expression.argument);const o=t.getFirstToken(n);return o?.type===$t.Identifier&&o.value===e}return!1},fr={0:()=>!0,1:$("afterAll"),2:$("afterEach"),3:$("beforeAll"),4:$("beforeEach"),5:$("describe"),6:$("expect"),7:$("expectTypeOf"),8:$("fdescribe"),9:$("fit"),10:$("it"),11:$("test"),12:$("xdescribe"),13:$("xit"),14:$("xtest")},ft=(e,s,t)=>{let n=e;const{sourceCode:o}=t;for(;n.type===i.LabeledStatement;)n=n.body;return Array.isArray(s)?s.some(r=>ft(n,r,t)):fr[s](n,o)},mr=(e,s,t)=>{const{configs:n}=t,o=r=>pr[r](e,s,t);for(let r=n.length-1;r>=0;--r){const{prevStatementType:a,nextStatementType:c,paddingType:l}=n[r];if(ft(e,a,t)&&ft(s,c,t))return o(l)}return o(0)},Es=(e,s)=>{const{scopeInfo:t}=s;Oo(e?.parent.type)&&(t.prevNode&&mr(t.prevNode,e,s),t.prevNode=e)},D=(e,s,t,n=!1)=>d({name:e,meta:{docs:{description:s},fixable:"whitespace",deprecated:n,messages:{missingPadding:"expect blank line before this statement"},schema:[],type:"suggestion"},defaultOptions:[],create(o){const r={ruleContext:o,sourceCode:o.sourceCode??o.getSourceCode(),scopeInfo:dr(),configs:t},{scopeInfo:a}=r;return{Program:a.enter,"Program:exit":a.exit,BlockStatement:a.enter,"BlockStatement:exit":a.exit,SwitchStatement:a.enter,"SwitchStatement:exit":a.exit,":statement":c=>Es(c,r),SwitchCase(c){Es(c,r),a.enter()},"SwitchCase:exit":a.exit}}}),mt="padding-around-after-all-blocks",qs=[{paddingType:S.Always,prevStatementType:g.Any,nextStatementType:g.AfterAllToken},{paddingType:S.Always,prevStatementType:g.AfterAllToken,nextStatementType:g.Any}],yr=D(mt,"Enforce padding around `afterAll` blocks",qs),yt="padding-around-after-each-blocks",Ts=[{paddingType:S.Always,prevStatementType:g.Any,nextStatementType:g.AfterEachToken},{paddingType:S.Always,prevStatementType:g.AfterEachToken,nextStatementType:g.Any}],hr=D(yt,"Enforce padding around `afterEach` blocks",Ts),ht="padding-around-before-all-blocks",ws=[{paddingType:S.Always,prevStatementType:g.Any,nextStatementType:g.BeforeAllToken},{paddingType:S.Always,prevStatementType:g.BeforeAllToken,nextStatementType:g.Any}],gr=D(ht,"Enforce padding around `beforeAll` blocks",ws),gt="padding-around-before-each-blocks",As=[{paddingType:S.Always,prevStatementType:g.Any,nextStatementType:g.BeforeEachToken},{paddingType:S.Always,prevStatementType:g.BeforeEachToken,nextStatementType:g.Any}],kr=D(gt,"Enforce padding around `beforeEach` blocks",As),kt="padding-around-describe-blocks",vs=[{paddingType:S.Always,prevStatementType:g.Any,nextStatementType:[g.DescribeToken,g.FdescribeToken,g.XdescribeToken]},{paddingType:S.Always,prevStatementType:[g.DescribeToken,g.FdescribeToken,g.XdescribeToken],nextStatementType:g.Any}],br=D(kt,"Enforce padding around `describe` blocks",vs),bt="padding-around-expect-groups",Cs=[{paddingType:S.Always,prevStatementType:g.Any,nextStatementType:g.ExpectToken},{paddingType:S.Always,prevStatementType:g.ExpectToken,nextStatementType:g.Any},{paddingType:S.Any,prevStatementType:g.ExpectToken,nextStatementType:g.ExpectToken},{paddingType:S.Always,prevStatementType:g.Any,nextStatementType:g.ExpectTypeOfToken},{paddingType:S.Always,prevStatementType:g.ExpectTypeOfToken,nextStatementType:g.Any},{paddingType:S.Any,prevStatementType:g.ExpectTypeOfToken,nextStatementType:g.ExpectTypeOfToken}],xr=D(bt,"Enforce padding around `expect` groups",Cs),xt="padding-around-test-blocks",Ss=[{paddingType:S.Always,prevStatementType:g.Any,nextStatementType:[g.TestToken,g.ItToken,g.FitToken,g.XitToken,g.XtestToken]},{paddingType:S.Always,prevStatementType:[g.TestToken,g.ItToken,g.FitToken,g.XitToken,g.XtestToken],nextStatementType:g.Any}],Ir=D(xt,"Enforce padding around `test` blocks",Ss),It="padding-around-all",Er=D(It,"Enforce padding around vitest functions",[...qs,...Ts,...ws,...As,...vs,...Cs,...Ss]),Et="valid-expect-in-promise",qr=["toRejectWith","toResolveWith"],qt=e=>{if(e.type===i.CallExpression&&e.callee.type===i.MemberExpression&&C(e.callee.property)){if(e.arguments.length===0)return!1;switch(y(e.callee.property)){case"then":return e.arguments.length<3;case"catch":case"finally":return e.arguments.length<2}}return!1},Tr=(e,s)=>{const t=h(e,s);if(t?.type!=="test")return!1;const n=t.members.some(a=>y(a)==="each");if(n&&e.callee.type!==i.TaggedTemplateExpression)return!0;const[,o]=e.arguments,r=Number(n);return o&&M(o)&&o.params.length===1+r},Ms=(e,s)=>{const{name:t}=s;if(e.argument===null)return!1;if(e.argument.type===i.CallExpression&&e.argument.arguments.length>0){const n=R(e.argument);if(["Promise.all","Promise.allSettled"].includes(n)){const[o]=e.argument.arguments;if(o.type===i.ArrayExpression&&o.elements.some(r=>r&&L(r,t)))return!0}if(["Promise.resolve","Promise.reject"].includes(n)&&e.argument.arguments.length===1)return L(e.argument.arguments[0],t)}return L(e.argument,t)},$s=(e,s)=>{for(const t of s)if(t?.type===i.AwaitExpression&&L(t.argument,e)||t?.type===i.ArrayExpression&&$s(e,t.elements))return!0;return!1},wr=(e,s)=>{let t=s;for(;t;){if(t.type===i.CallExpression){if($s(e,t.arguments))return!0;t=t.callee}if(t.type!==i.MemberExpression)break;t=t.object}return!1},Ar=e=>{let s=e,t=e;for(;t&&(t.type===i.CallExpression&&(s=t,t=t.callee),t.type===i.MemberExpression);)t=t.object;return s},Tt=(e,s,t)=>{const{name:n}=e;for(const o of s)if(!(o.range[0]<=e.range[0])){if(o.type===i.ReturnStatement)return Ms(o,e);if(o.type===i.ExpressionStatement){if(o.expression.type===i.CallExpression){if(wr(n,o.expression))return!0;const r=Ar(o.expression),a=h(o.expression,t);if(a?.type==="expect"&&r.arguments.length>0&&L(r.arguments[0],n)&&a.members.some(c=>{const l=y(c);return l===N.resolves||l===N.rejects}))return!0}if(o.expression.type===i.AwaitExpression&&Ms(o.expression,e))return!0;if(o.expression.type===i.AssignmentExpression){if(L(o.expression.left,n)&&R(o.expression.right)?.startsWith(`${n}.`)&&qt(o.expression.right))continue;break}}if(o.type===i.BlockStatement&&Tt(e,o.body,t))return!0}return!1},Os=e=>{let s=e;for(;s;){if(s.type===i.BlockStatement)return s.body;s=s.parent}throw new Error("Could not find BlockStatement - please file a github issue at https://github.com/vitest-dev/eslint-plugin-vitest")},vr=(e,s)=>{let t=e;for(;t;){if(M(t))return t=t.parent,t?.type===i.CallExpression&&q(t,s,["test"]);t=t.parent}return!1},Cr=(e,s)=>{const t=Os(e);return L(e.id)?Tt(e.id,t,s):!0},Sr=d({name:Et,meta:{docs:{description:"require promises that have expectations in their chain to be valid"},messages:{expectInFloatingPromise:"This promise should either be returned or awaited to ensure the expects in its chain are called"},type:"suggestion",schema:[]},defaultOptions:[{alwaysAwait:!1,asyncMatchers:qr,minArgs:1,maxArgs:1}],create(e){let s=!1;const t=[];return{CallExpression(n){if(Tr(n,e)){s=!0;return}if(qt(n)){t.unshift(!1);return}t.length>0&&q(n,e,["expect"])&&(t[0]=!0)},"CallExpression:exit"(n){if(s){q(n,e,["test"])&&(s=!1);return}if(!qt(n)||!t.shift())return;const{parent:o}=Ut(n);if(!(!o||!vr(o,e))){switch(o.type){case i.VariableDeclarator:{if(Cr(o,e))return;break}case i.AssignmentExpression:{if(o.left.type===i.Identifier&&Tt(o.left,Os(o),e))return;break}case i.ExpressionStatement:break;case i.ReturnStatement:case i.AwaitExpression:default:return}e.report({messageId:"expectInFloatingPromise",node:o})}}}}}),wt="prefer-strict-boolean-matchers",Mr=d({name:wt,meta:{type:"suggestion",docs:{description:"enforce using `toBe(true)` and `toBe(false)` over matchers that coerce types to boolean",recommended:!1},messages:{preferToBeTrue:"Prefer using `toBe(true)` to test value is `true`",preferToBeFalse:"Prefer using `toBe(false)` to test value is `false`"},fixable:"code",schema:[]},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);if(!(t?.type==="expect"||t?.type==="expectTypeOf"))return;const n=y(t.matcher);n==="toBeFalsy"&&e.report({node:t.matcher,messageId:"preferToBeFalse",fix:o=>[o.replaceText(t.matcher,"toBe"),o.insertTextAfterRange([t.matcher.range[0],t.matcher.range[1]+1],"false")]}),n==="toBeTruthy"&&e.report({node:t.matcher,messageId:"preferToBeTrue",fix:o=>[o.replaceText(t.matcher,"toBe"),o.insertTextAfterRange([t.matcher.range[0],t.matcher.range[1]+1],"true")]})}}}}),At="require-mock-type-parameters",$r=d({name:At,meta:{type:"suggestion",docs:{description:"enforce using type parameters with vitest mock functions",recommended:!1},messages:{noTypeParameter:"Missing type parameters"},fixable:"code",schema:[{type:"object",properties:{checkImportFunctions:{type:"boolean"}},additionalProperties:!1}]},defaultOptions:[{checkImportFunctions:!1}],create(e,[s]){return{CallExpression(t){const n=h(t,e);if(n?.type==="vi")for(const o of n?.members)!("name"in o)||o.parent.parent.typeArguments!==void 0||(o.name==="fn"&&e.report({node:o,messageId:"noTypeParameter"}),s.checkImportFunctions&&["importActual","importMock"].includes(o.name)&&e.report({node:o,messageId:"noTypeParameter"}))}}}}),vt="prefer-called-once",Or=e=>e.type===i.Literal&&e.value===1,Rr=d({name:vt,meta:{docs:{description:"enforce using `toBeCalledOnce()` or `toHaveBeenCalledOnce()`",recommended:!1},messages:{preferCalledOnce:"Prefer {{ replacedMatcherName }}()"},type:"suggestion",fixable:"code",schema:[]},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);if(t?.type!=="expect")return;const{matcher:n}=t,o=y(n);if(["toBeCalledTimes","toHaveBeenCalledTimes"].includes(o)&&t.args.length===1&&Or(P(t))){const r=o.replace("Times","Once");e.report({data:{replacedMatcherName:r},messageId:"preferCalledOnce",node:n,fix:a=>[a.replaceText(n,r),a.remove(t.args[0])]})}}}}}),Ct="prefer-called-times",Nr=d({name:Ct,meta:{docs:{description:"enforce using `toBeCalledTimes(1)` or `toHaveBeenCalledTimes(1)`",recommended:!1},messages:{preferCalledTimes:"Prefer {{ replacedMatcherName }}(1)"},type:"suggestion",fixable:"code",schema:[]},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);if(t?.type!=="expect")return;const{matcher:n}=t,o=y(n);if(["toBeCalledOnce","toHaveBeenCalledOnce"].includes(o)){const r=o.replace("Once","Times");e.report({data:{replacedMatcherName:r},messageId:"preferCalledTimes",node:n,fix:a=>[a.replaceText(n,r),a.insertTextAfterRange([t.matcher.range[0],t.matcher.range[1]+1],"1")]})}}}}}),St="prefer-expect-type-of",Br={string:"toBeString",number:"toBeNumber",boolean:"toBeBoolean",object:"toBeObject",function:"toBeFunction",symbol:"toBeSymbol",bigint:"toBeBigInt",undefined:"toBeUndefined"},Lr=d({name:St,meta:{type:"suggestion",docs:{description:"enforce using `expectTypeOf` instead of `expect(typeof ...)`",recommended:!1},schema:[],fixable:"code",messages:{preferExpectTypeOf:'Use `expectTypeOf({{ value }}).{{ matcher }}()` instead of `expect(typeof {{ value }}).toBe("{{ type }}")`'}},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);if(t?.type!=="expect"||t.head.node.parent?.type!==i.CallExpression)return;const n=t.head.node.parent,[o]=n.arguments;if(!o||o.type!==i.UnaryExpression||o.operator!=="typeof")return;const r=y(t.matcher);if(r!=="toBe"&&r!=="toEqual")return;const[a]=t.args;if(!a||a.type!==i.Literal||typeof a.value!="string")return;const c=a.value,l=Br[c];if(!l)return;const p=e.sourceCode.getText(o.argument),f=t.modifiers.map(b=>y(b)).join("."),u=f?`.${f}`:"";e.report({node:s,messageId:"preferExpectTypeOf",data:{value:p,matcher:l,type:c},fix(b){return b.replaceText(s,`expectTypeOf(${p})${u}.${l}()`)}})}}}}),Rs="warn-todo",Fr=d({name:Rs,meta:{docs:{description:"disallow `.todo` usage",recommended:!1},messages:{warnTodo:"The use of `.todo` is not recommended."},type:"suggestion",schema:[]},defaultOptions:[],create(e){return{CallExpression(s){const t=h(s,e);if(t?.type!=="describe"&&t?.type!=="test"&&t?.type!=="it")return;const n=t.members.find(o=>o.type==="Identifier"&&o.name==="todo");n&&e.report({messageId:"warnTodo",node:n})}}}}),Ns=e=>Object.keys(e).reduce((s,t)=>({...s,[`vitest/${t}`]:e[t]}),{}),Bs=e=>({plugins:["@vitest"],rules:Object.keys(e).reduce((s,t)=>({...s,[`@vitest/${t}`]:e[t]}),{})}),Ls={[ue]:"warn",[pe]:"warn",[de]:"warn",[ye]:"warn",[ge]:"warn",[be]:"warn",[Ie]:"warn",[Ee]:"warn",[qe]:"warn",[Te]:"warn",[we]:"warn",[Ae]:"warn",[Re]:"warn",[Ne]:"warn",[Be]:"warn",[Le]:"warn",[Fe]:"warn",[Pe]:"warn",[Ue]:"warn",[je]:"warn",[_e]:"warn",[De]:"warn",[We]:"warn",[He]:"warn",[Ge]:"off",[Ve]:"warn",[Ke]:"off",[Xe]:"warn",[ze]:"warn",[Ye]:"warn",[Je]:"warn",[Qe]:"warn",[Ze]:"warn",[et]:"warn",[tt]:"warn",[nt]:"warn",[ot]:"warn",[rt]:"warn",[it]:"warn",[at]:"warn",[ct]:"warn",[lt]:"warn",[ut]:"warn",[pt]:"warn",[dt]:"warn",[xs]:"warn",[xe]:"warn",[mt]:"warn",[yt]:"warn",[It]:"warn",[ht]:"warn",[gt]:"warn",[kt]:"warn",[bt]:"warn",[xt]:"warn",[Et]:"warn",[Y]:"warn",[X]:"warn",[Q]:"warn",[ee]:"warn",[se]:"warn",[oe]:"warn",[re]:"warn",[Z]:"warn",[wt]:"warn",[At]:"warn",[$e]:"off",[Oe]:"warn",[vt]:"off",[Ct]:"warn",[St]:"warn",[he]:"warn"},Fs={[Y]:"error",[X]:"error",[Q]:"error",[ee]:"error",[se]:"error",[oe]:"error",[re]:"error",[Z]:"error"},Pr={[ue]:pn,[pe]:dn,[X]:fn,[de]:mn,[ye]:yn,[Y]:gn,[he]:xn,[ge]:En,[be]:Tn,[xe]:Sn,[Ie]:Mn,[Ee]:$n,[qe]:On,[Te]:Rn,[we]:Nn,[Q]:Ln,[Ae]:Fn,[Re]:Wn,[Ne]:Hn,[Be]:Kn,[Le]:Gn,[Fe]:Xn,[Pe]:zn,[Ue]:Jn,[je]:Zn,[_e]:eo,[De]:to,[We]:no,[Z]:Pn,[He]:oo,[ee]:ao,[se]:po,[Ge]:bo,[Ve]:yo,[Ke]:go,[Xe]:xo,[ze]:Io,[Ye]:Eo,[Je]:qo,[Qe]:To,[Ze]:wo,[et]:Ao,[re]:Xo,[tt]:Co,[nt]:Fo,[ot]:_o,[oe]:Do,[rt]:Wo,[it]:Ho,[at]:Go,[ct]:Jo,[lt]:er,[ut]:or,[pt]:rr,[dt]:ar,[xs]:lr,[mt]:yr,[yt]:hr,[It]:Er,[ht]:gr,[gt]:kr,[kt]:br,[bt]:xr,[xt]:Ir,[Et]:Sr,[wt]:Mr,[At]:$r,[$e]:_n,[Oe]:Dn,[vt]:Rr,[Ct]:Nr,[St]:Lr,[Rs]:Fr},Mt={meta:{name:"vitest",version:Ds},rules:Pr,environments:{env:{globals:{suite:!0,test:!0,describe:!0,it:!0,expectTypeOf:!0,assertType:!0,expect:!0,assert:!0,chai:!0,vitest:!0,vi:!0,beforeAll:!0,afterAll:!0,beforeEach:!0,afterEach:!0,onTestFailed:!0,onTestFinished:!0}}},configs:{"legacy-recommended":Bs(Fs),"legacy-all":Bs(Ls),recommended:{name:"vitest/recommended",plugins:{get vitest(){return Mt}},rules:Ns(Fs)},all:{name:"vitest/all",plugins:{get vitest(){return Mt}},rules:Ns(Ls)},env:{name:"vitest/env",languageOptions:{globals:{suite:"writable",test:"writable",describe:"writable",it:"writable",expectTypeOf:"writable",assertType:"writable",expect:"writable",assert:"writable",chai:"writable",vitest:"writable",vi:"writable",beforeAll:"writable",afterAll:"writable",beforeEach:"writable",afterEach:"writable",onTestFailed:"writable",onTestFinished:"writable"}}}}};export{Mt as default};