@vitest/mocker - npm Package Compare versions

Comparing version 5.0.0-beta.3 to 5.0.0-beta.4

dist/hoistMocks.d-CjaclmYf.d.ts

+import { Rollup } from 'vite';
+import MagicString from 'magic-string';
+
+declare function createManualModuleSource(moduleUrl: string, exports: string[], globalAccessor?: string): string;
+
+// This definition file follows a somewhat unusual format. ESTree allows
+// runtime type checks based on the `type` parameter. In order to explain this
+// to typescript we want to use discriminated union types:
+// https://github.com/Microsoft/TypeScript/pull/9163
+//
+// For ESTree this is a bit tricky because the high level interfaces like
+// Node or Function are pulling double duty. We want to pass common fields down
+// to the interfaces that extend them (like Identifier or
+// ArrowFunctionExpression), but you can't extend a type union or enforce
+// common fields on them. So we've split the high level interfaces into two
+// types, a base type which passes down inherited fields, and a type union of
+// all types which extend the base type. Only the type union is exported, and
+// the union is how other types refer to the collection of inheriting types.
+//
+// This makes the definitions file here somewhat more difficult to maintain,
+// but it has the notable advantage of making ESTree much easier to use as
+// an end user.
+
+interface BaseNodeWithoutComments {
+    // Every leaf interface that extends BaseNode must specify a type property.
+    // The type property should be a string literal. For example, Identifier
+    // has: `type: "Identifier"`
+    type: string;
+    loc?: SourceLocation | null | undefined;
+    range?: [number, number] | undefined;
+}
+
+interface BaseNode extends BaseNodeWithoutComments {
+    leadingComments?: Comment[] | undefined;
+    trailingComments?: Comment[] | undefined;
+}
+
+interface NodeMap {
+    AssignmentProperty: AssignmentProperty;
+    CatchClause: CatchClause;
+    Class: Class;
+    ClassBody: ClassBody;
+    Expression: Expression;
+    Function: Function;
+    Identifier: Identifier;
+    Literal: Literal;
+    MethodDefinition: MethodDefinition;
+    ModuleDeclaration: ModuleDeclaration;
+    ModuleSpecifier: ModuleSpecifier;
+    Pattern: Pattern;
+    PrivateIdentifier: PrivateIdentifier;
+    Program: Program;
+    Property: Property;
+    PropertyDefinition: PropertyDefinition;
+    SpreadElement: SpreadElement;
+    Statement: Statement;
+    Super: Super;
+    SwitchCase: SwitchCase;
+    TemplateElement: TemplateElement;
+    VariableDeclarator: VariableDeclarator;
+}
+
+type Node$1 = NodeMap[keyof NodeMap];
+
+interface Comment extends BaseNodeWithoutComments {
+    type: "Line" | "Block";
+    value: string;
+}
+
+interface SourceLocation {
+    source?: string | null | undefined;
+    start: Position;
+    end: Position;
+}
+
+interface Position {
+    /** >= 1 */
+    line: number;
+    /** >= 0 */
+    column: number;
+}
+
+interface Program extends BaseNode {
+    type: "Program";
+    sourceType: "script" | "module";
+    body: Array<Directive | Statement | ModuleDeclaration>;
+    comments?: Comment[] | undefined;
+}
+
+interface Directive extends BaseNode {
+    type: "ExpressionStatement";
+    expression: Literal;
+    directive: string;
+}
+
+interface BaseFunction extends BaseNode {
+    params: Pattern[];
+    generator?: boolean | undefined;
+    async?: boolean | undefined;
+    // The body is either BlockStatement or Expression because arrow functions
+    // can have a body that's either. FunctionDeclarations and
+    // FunctionExpressions have only BlockStatement bodies.
+    body: BlockStatement | Expression;
+}
+
+type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
+
+type Statement =
+    | ExpressionStatement
+    | BlockStatement
+    | StaticBlock
+    | EmptyStatement
+    | DebuggerStatement
+    | WithStatement
+    | ReturnStatement
+    | LabeledStatement
+    | BreakStatement
+    | ContinueStatement
+    | IfStatement
+    | SwitchStatement
+    | ThrowStatement
+    | TryStatement
+    | WhileStatement
+    | DoWhileStatement
+    | ForStatement
+    | ForInStatement
+    | ForOfStatement
+    | Declaration;
+
+interface BaseStatement extends BaseNode {}
+
+interface EmptyStatement extends BaseStatement {
+    type: "EmptyStatement";
+}
+
+interface BlockStatement extends BaseStatement {
+    type: "BlockStatement";
+    body: Statement[];
+    innerComments?: Comment[] | undefined;
+}
+
+interface StaticBlock extends Omit<BlockStatement, "type"> {
+    type: "StaticBlock";
+}
+
+interface ExpressionStatement extends BaseStatement {
+    type: "ExpressionStatement";
+    expression: Expression;
+}
+
+interface IfStatement extends BaseStatement {
+    type: "IfStatement";
+    test: Expression;
+    consequent: Statement;
+    alternate?: Statement | null | undefined;
+}
+
+interface LabeledStatement extends BaseStatement {
+    type: "LabeledStatement";
+    label: Identifier;
+    body: Statement;
+}
+
+interface BreakStatement extends BaseStatement {
+    type: "BreakStatement";
+    label?: Identifier | null | undefined;
+}
+
+interface ContinueStatement extends BaseStatement {
+    type: "ContinueStatement";
+    label?: Identifier | null | undefined;
+}
+
+interface WithStatement extends BaseStatement {
+    type: "WithStatement";
+    object: Expression;
+    body: Statement;
+}
+
+interface SwitchStatement extends BaseStatement {
+    type: "SwitchStatement";
+    discriminant: Expression;
+    cases: SwitchCase[];
+}
+
+interface ReturnStatement extends BaseStatement {
+    type: "ReturnStatement";
+    argument?: Expression | null | undefined;
+}
+
+interface ThrowStatement extends BaseStatement {
+    type: "ThrowStatement";
+    argument: Expression;
+}
+
+interface TryStatement extends BaseStatement {
+    type: "TryStatement";
+    block: BlockStatement;
+    handler?: CatchClause | null | undefined;
+    finalizer?: BlockStatement | null | undefined;
+}
+
+interface WhileStatement extends BaseStatement {
+    type: "WhileStatement";
+    test: Expression;
+    body: Statement;
+}
+
+interface DoWhileStatement extends BaseStatement {
+    type: "DoWhileStatement";
+    body: Statement;
+    test: Expression;
+}
+
+interface ForStatement extends BaseStatement {
+    type: "ForStatement";
+    init?: VariableDeclaration | Expression | null | undefined;
+    test?: Expression | null | undefined;
+    update?: Expression | null | undefined;
+    body: Statement;
+}
+
+interface BaseForXStatement extends BaseStatement {
+    left: VariableDeclaration | Pattern;
+    right: Expression;
+    body: Statement;
+}
+
+interface ForInStatement extends BaseForXStatement {
+    type: "ForInStatement";
+}
+
+interface DebuggerStatement extends BaseStatement {
+    type: "DebuggerStatement";
+}
+
+type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+
+interface BaseDeclaration extends BaseStatement {}
+
+interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
+    type: "FunctionDeclaration";
+    /** It is null when a function declaration is a part of the `export default function` statement */
+    id: Identifier | null;
+    body: BlockStatement;
+}
+
+interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
+    id: Identifier;
+}
+
+interface VariableDeclaration extends BaseDeclaration {
+    type: "VariableDeclaration";
+    declarations: VariableDeclarator[];
+    kind: "var" | "let" | "const" | "using" | "await using";
+}
+
+interface VariableDeclarator extends BaseNode {
+    type: "VariableDeclarator";
+    id: Pattern;
+    init?: Expression | null | undefined;
+}
+
+interface ExpressionMap {
+    ArrayExpression: ArrayExpression;
+    ArrowFunctionExpression: ArrowFunctionExpression;
+    AssignmentExpression: AssignmentExpression;
+    AwaitExpression: AwaitExpression;
+    BinaryExpression: BinaryExpression;
+    CallExpression: CallExpression;
+    ChainExpression: ChainExpression;
+    ClassExpression: ClassExpression;
+    ConditionalExpression: ConditionalExpression;
+    FunctionExpression: FunctionExpression;
+    Identifier: Identifier;
+    ImportExpression: ImportExpression;
+    Literal: Literal;
+    LogicalExpression: LogicalExpression;
+    MemberExpression: MemberExpression;
+    MetaProperty: MetaProperty;
+    NewExpression: NewExpression;
+    ObjectExpression: ObjectExpression;
+    SequenceExpression: SequenceExpression;
+    TaggedTemplateExpression: TaggedTemplateExpression;
+    TemplateLiteral: TemplateLiteral;
+    ThisExpression: ThisExpression;
+    UnaryExpression: UnaryExpression;
+    UpdateExpression: UpdateExpression;
+    YieldExpression: YieldExpression;
+}
+
+type Expression = ExpressionMap[keyof ExpressionMap];
+
+interface BaseExpression extends BaseNode {}
+
+type ChainElement = SimpleCallExpression | MemberExpression;
+
+interface ChainExpression extends BaseExpression {
+    type: "ChainExpression";
+    expression: ChainElement;
+}
+
+interface ThisExpression extends BaseExpression {
+    type: "ThisExpression";
+}
+
+interface ArrayExpression extends BaseExpression {
+    type: "ArrayExpression";
+    elements: Array<Expression | SpreadElement | null>;
+}
+
+interface ObjectExpression extends BaseExpression {
+    type: "ObjectExpression";
+    properties: Array<Property | SpreadElement>;
+}
+
+interface PrivateIdentifier extends BaseNode {
+    type: "PrivateIdentifier";
+    name: string;
+}
+
+interface Property extends BaseNode {
+    type: "Property";
+    key: Expression | PrivateIdentifier;
+    value: Expression | Pattern; // Could be an AssignmentProperty
+    kind: "init" | "get" | "set";
+    method: boolean;
+    shorthand: boolean;
+    computed: boolean;
+}
+
+interface PropertyDefinition extends BaseNode {
+    type: "PropertyDefinition";
+    key: Expression | PrivateIdentifier;
+    value?: Expression | null | undefined;
+    computed: boolean;
+    static: boolean;
+}
+
+interface FunctionExpression extends BaseFunction, BaseExpression {
+    id?: Identifier | null | undefined;
+    type: "FunctionExpression";
+    body: BlockStatement;
+}
+
+interface SequenceExpression extends BaseExpression {
+    type: "SequenceExpression";
+    expressions: Expression[];
+}
+
+interface UnaryExpression extends BaseExpression {
+    type: "UnaryExpression";
+    operator: UnaryOperator;
+    prefix: true;
+    argument: Expression;
+}
+
+interface BinaryExpression extends BaseExpression {
+    type: "BinaryExpression";
+    operator: BinaryOperator;
+    left: Expression | PrivateIdentifier;
+    right: Expression;
+}
+
+interface AssignmentExpression extends BaseExpression {
+    type: "AssignmentExpression";
+    operator: AssignmentOperator;
+    left: Pattern | MemberExpression;
+    right: Expression;
+}
+
+interface UpdateExpression extends BaseExpression {
+    type: "UpdateExpression";
+    operator: UpdateOperator;
+    argument: Expression;
+    prefix: boolean;
+}
+
+interface LogicalExpression extends BaseExpression {
+    type: "LogicalExpression";
+    operator: LogicalOperator;
+    left: Expression;
+    right: Expression;
+}
+
+interface ConditionalExpression extends BaseExpression {
+    type: "ConditionalExpression";
+    test: Expression;
+    alternate: Expression;
+    consequent: Expression;
+}
+
+interface BaseCallExpression extends BaseExpression {
+    callee: Expression | Super;
+    arguments: Array<Expression | SpreadElement>;
+}
+type CallExpression = SimpleCallExpression | NewExpression;
+
+interface SimpleCallExpression extends BaseCallExpression {
+    type: "CallExpression";
+    optional: boolean;
+}
+
+interface NewExpression extends BaseCallExpression {
+    type: "NewExpression";
+}
+
+interface MemberExpression extends BaseExpression, BasePattern {
+    type: "MemberExpression";
+    object: Expression | Super;
+    property: Expression | PrivateIdentifier;
+    computed: boolean;
+    optional: boolean;
+}
+
+type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
+
+interface BasePattern extends BaseNode {}
+
+interface SwitchCase extends BaseNode {
+    type: "SwitchCase";
+    test?: Expression | null | undefined;
+    consequent: Statement[];
+}
+
+interface CatchClause extends BaseNode {
+    type: "CatchClause";
+    param: Pattern | null;
+    body: BlockStatement;
+}
+
+interface Identifier extends BaseNode, BaseExpression, BasePattern {
+    type: "Identifier";
+    name: string;
+}
+
+type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
+
+interface SimpleLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value: string | boolean | number | null;
+    raw?: string | undefined;
+}
+
+interface RegExpLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value?: RegExp | null | undefined;
+    regex: {
+        pattern: string;
+        flags: string;
+    };
+    raw?: string | undefined;
+}
+
+interface BigIntLiteral extends BaseNode, BaseExpression {
+    type: "Literal";
+    value?: bigint | null | undefined;
+    bigint: string;
+    raw?: string | undefined;
+}
+
+type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+
+type BinaryOperator =
+    | "=="
+    | "!="
+    | "==="
+    | "!=="
+    | "<"
+    | "<="
+    | ">"
+    | ">="
+    | "<<"
+    | ">>"
+    | ">>>"
+    | "+"
+    | "-"
+    | "*"
+    | "/"
+    | "%"
+    | "**"
+    | "|"
+    | "^"
+    | "&"
+    | "in"
+    | "instanceof";
+
+type LogicalOperator = "||" | "&&" | "??";
+
+type AssignmentOperator =
+    | "="
+    | "+="
+    | "-="
+    | "*="
+    | "/="
+    | "%="
+    | "**="
+    | "<<="
+    | ">>="
+    | ">>>="
+    | "|="
+    | "^="
+    | "&="
+    | "||="
+    | "&&="
+    | "??=";
+
+type UpdateOperator = "++" | "--";
+
+interface ForOfStatement extends BaseForXStatement {
+    type: "ForOfStatement";
+    await: boolean;
+}
+
+interface Super extends BaseNode {
+    type: "Super";
+}
+
+interface SpreadElement extends BaseNode {
+    type: "SpreadElement";
+    argument: Expression;
+}
+
+interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
+    type: "ArrowFunctionExpression";
+    expression: boolean;
+    body: BlockStatement | Expression;
+}
+
+interface YieldExpression extends BaseExpression {
+    type: "YieldExpression";
+    argument?: Expression | null | undefined;
+    delegate: boolean;
+}
+
+interface TemplateLiteral extends BaseExpression {
+    type: "TemplateLiteral";
+    quasis: TemplateElement[];
+    expressions: Expression[];
+}
+
+interface TaggedTemplateExpression extends BaseExpression {
+    type: "TaggedTemplateExpression";
+    tag: Expression;
+    quasi: TemplateLiteral;
+}
+
+interface TemplateElement extends BaseNode {
+    type: "TemplateElement";
+    tail: boolean;
+    value: {
+        /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */
+        cooked?: string | null | undefined;
+        raw: string;
+    };
+}
+
+interface AssignmentProperty extends Property {
+    value: Pattern;
+    kind: "init";
+    method: boolean; // false
+}
+
+interface ObjectPattern extends BasePattern {
+    type: "ObjectPattern";
+    properties: Array<AssignmentProperty | RestElement>;
+}
+
+interface ArrayPattern extends BasePattern {
+    type: "ArrayPattern";
+    elements: Array<Pattern | null>;
+}
+
+interface RestElement extends BasePattern {
+    type: "RestElement";
+    argument: Pattern;
+}
+
+interface AssignmentPattern extends BasePattern {
+    type: "AssignmentPattern";
+    left: Pattern;
+    right: Expression;
+}
+
+type Class = ClassDeclaration | ClassExpression;
+interface BaseClass extends BaseNode {
+    superClass?: Expression | null | undefined;
+    body: ClassBody;
+}
+
+interface ClassBody extends BaseNode {
+    type: "ClassBody";
+    body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
+}
+
+interface MethodDefinition extends BaseNode {
+    type: "MethodDefinition";
+    key: Expression | PrivateIdentifier;
+    value: FunctionExpression;
+    kind: "constructor" | "method" | "get" | "set";
+    computed: boolean;
+    static: boolean;
+}
+
+interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
+    type: "ClassDeclaration";
+    /** It is null when a class declaration is a part of the `export default class` statement */
+    id: Identifier | null;
+}
+
+interface ClassDeclaration extends MaybeNamedClassDeclaration {
+    id: Identifier;
+}
+
+interface ClassExpression extends BaseClass, BaseExpression {
+    type: "ClassExpression";
+    id?: Identifier | null | undefined;
+}
+
+interface MetaProperty extends BaseExpression {
+    type: "MetaProperty";
+    meta: Identifier;
+    property: Identifier;
+}
+
+type ModuleDeclaration =
+    | ImportDeclaration
+    | ExportNamedDeclaration
+    | ExportDefaultDeclaration
+    | ExportAllDeclaration;
+interface BaseModuleDeclaration extends BaseNode {}
+
+type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
+interface BaseModuleSpecifier extends BaseNode {
+    local: Identifier;
+}
+
+interface ImportDeclaration extends BaseModuleDeclaration {
+    type: "ImportDeclaration";
+    specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
+    attributes: ImportAttribute[];
+    source: Literal;
+}
+
+interface ImportSpecifier extends BaseModuleSpecifier {
+    type: "ImportSpecifier";
+    imported: Identifier | Literal;
+}
+
+interface ImportAttribute extends BaseNode {
+    type: "ImportAttribute";
+    key: Identifier | Literal;
+    value: Literal;
+}
+
+interface ImportExpression extends BaseExpression {
+    type: "ImportExpression";
+    source: Expression;
+    options?: Expression | null | undefined;
+}
+
+interface ImportDefaultSpecifier extends BaseModuleSpecifier {
+    type: "ImportDefaultSpecifier";
+}
+
+interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
+    type: "ImportNamespaceSpecifier";
+}
+
+interface ExportNamedDeclaration extends BaseModuleDeclaration {
+    type: "ExportNamedDeclaration";
+    declaration?: Declaration | null | undefined;
+    specifiers: ExportSpecifier[];
+    attributes: ImportAttribute[];
+    source?: Literal | null | undefined;
+}
+
+interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
+    type: "ExportSpecifier";
+    local: Identifier | Literal;
+    exported: Identifier | Literal;
+}
+
+interface ExportDefaultDeclaration extends BaseModuleDeclaration {
+    type: "ExportDefaultDeclaration";
+    declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
+}
+
+interface ExportAllDeclaration extends BaseModuleDeclaration {
+    type: "ExportAllDeclaration";
+    exported: Identifier | Literal | null;
+    attributes: ImportAttribute[];
+    source: Literal;
+}
+
+interface AwaitExpression extends BaseExpression {
+    type: "AwaitExpression";
+    argument: Expression;
+}
+
+type Positioned<T> = T & {
+	start: number;
+	end: number;
+};
+type Node = Positioned<Node$1>;
+
+interface HoistMocksOptions {
+	/**
+	* List of modules that should always be imported before compiler hints.
+	* @default 'vitest'
+	*/
+	hoistedModule?: string;
+	/**
+	* @default ["vi", "vitest"]
+	*/
+	utilsObjectNames?: string[];
+	/**
+	* @default ["mock", "unmock"]
+	*/
+	hoistableMockMethodNames?: string[];
+	/**
+	* @default ["mock", "unmock", "doMock", "doUnmock"]
+	*/
+	dynamicImportMockMethodNames?: string[];
+	/**
+	* @default ["hoisted"]
+	*/
+	hoistedMethodNames?: string[];
+	globalThisAccessor?: string;
+	regexpHoistable?: RegExp;
+	codeFrameGenerator?: CodeFrameGenerator;
+	magicString?: () => MagicString;
+	/**
+	* Root of the project
+	* @default process.cwd()
+	*/
+	root?: string;
+	getMap?: () => Rollup.SourceMap;
+}
+declare function hoistMocks(code: string, id: string, parse: (code: string) => any, options?: HoistMocksOptions): MagicString | undefined;
+interface CodeFrameGenerator {
+	(node: Positioned<Node>, id: string, code: string): string;
+}
+
+export { createManualModuleSource as c, hoistMocks as h };
+export type { HoistMocksOptions as H };

dist/chunk-hoistMocks.js

@@ -0,3 +1,5 @@
+import { TraceMap, originalPositionFor } from '@jridgewell/trace-mapping';
 import MagicString from 'magic-string';
 import { e as esmWalker } from './chunk-automock.js';
+import { a as relative } from './chunk-pathe.M-eThtNZ.js';
 
@@ -457,2 +459,3 @@ // AST walker module for ESTree compatible trees
 	let hasImportMetaVitest = false;
+	let hasMockApiCall = false;
 	esmWalker(ast, {
@@ -506,2 +509,3 @@ onImportMeta(node) {
 				if (hoistableMockMethodNames.includes(methodName)) {
+					hasMockApiCall = true;
 					const method = `${node.callee.object.name}.${methodName}`;
@@ -529,2 +533,3 @@ assertNotDefaultExport(node, `Cannot export the result of "${method}". Remove export declaration because "${method}" doesn\'t return anything.`);
 				} else if (dynamicImportMockMethodNames.includes(methodName)) {
+					hasMockApiCall = true;
 					const moduleInfo = node.arguments[0];
@@ -543,2 +548,3 @@ let source = null;
 				if (hoistedMethodNames.includes(methodName)) {
+					hasMockApiCall = true;
 					assertNotDefaultExport(node, "Cannot export hoisted variable. You can control hoisting behavior by placing the import from this file first.");
@@ -560,2 +566,5 @@ const declarationNode = getVariableDeclaration(node);
 	});
+	if (!hasMockApiCall) {
+		return;
+	}
 	function getNodeName(node) {
@@ -618,4 +627,20 @@ const callee = node.callee || {};
 		}
-		for (const invalidNode of hoistedNodes) {
-			console.warn(`Warning: A ${getNodeName(getNodeCall(invalidNode))} call in "${id}" is not at the top level of the module. ` + `Although it appears nested, it will be hoisted and executed before any tests run. ` + `Move it to the top level to reflect its actual execution order. This will become an error in a future version.\n` + `See: https://vitest.dev/guide/mocking/modules#how-it-works`);
+		if (hoistedNodes.size) {
+			const locations = createIndexLocationsMap(code);
+			const map = options.getMap && new TraceMap(options.getMap());
+			const plural = hoistedNodes.size > 1;
+			const message = [
+				`${hoistedNodes.size} call${plural ? "s" : ""} in "${relative(options.root || process.cwd(), id)}" ${plural ? "were" : "was"} defined outside of the module's top level scope:`,
+				"",
+				...[...hoistedNodes].map((invalidNode) => {
+					const currentLocation = locations.get(invalidNode.start);
+					const originalLocation = map && currentLocation && originalPositionFor(map, currentLocation);
+					const location = originalLocation?.column != null && originalLocation?.line != null ? ` at ${relative(options.root || process.cwd(), id)}:${originalLocation.line}:${originalLocation.column + 1}` : "";
+					return `- ${getNodeName(getNodeCall(invalidNode))}${location}`;
+				}),
+				"",
+				`Although ${plural ? "they appear nested, they" : "it appears nested, it"} will be hoisted and executed before anything in this file. Move ${plural ? "them" : "it"} to the top level to reflect ${plural ? "their" : "its"} actual execution order.`,
+				"See: https://vitest.dev/guide/mocking/modules#how-it-works"
+			].join("\n");
+			throw new Error(message);
 		}
@@ -664,3 +689,22 @@ }
 }
+function createIndexLocationsMap(source) {
+	const map = new Map();
+	let offset = 0;
+	let line = 1;
+	let column = 1;
+	for (const char of source) {
+		map.set(offset++, {
+			line,
+			column
+		});
+		if (char === "\n" || char === "\r\n") {
+			line++;
+			column = 0;
+		} else {
+			column++;
+		}
+	}
+	return map;
+}
 
 export { hoistMocks as h };

dist/chunk-pathe.M-eThtNZ.js

@@ -12,2 +12,3 @@ const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
 const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
@@ -155,2 +156,18 @@ const normalize = function(path) {
 };
+const relative = function(from, to) {
+  const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+  const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+  if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) {
+    return _to.join("/");
+  }
+  const _fromCopy = [..._from];
+  for (const segment of _fromCopy) {
+    if (_to[0] !== segment) {
+      break;
+    }
+    _from.shift();
+    _to.shift();
+  }
+  return [..._from.map(() => ".."), ..._to].join("/");
+};
 const dirname = function(p) {
@@ -176,2 +193,2 @@ const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
 
-export { basename as b, dirname as d, extname as e, isAbsolute as i, join as j, resolve as r };
+export { relative as a, basename as b, dirname as d, extname as e, isAbsolute as i, join as j, resolve as r };

dist/node.d.ts

@@ -1,3 +0,3 @@
-import { H as HoistMocksOptions } from './hoistMocks.d-w2ILr1dG.js';
-export { c as createManualModuleSource } from './hoistMocks.d-w2ILr1dG.js';
+import { H as HoistMocksOptions } from './hoistMocks.d-CjaclmYf.js';
+export { c as createManualModuleSource } from './hoistMocks.d-CjaclmYf.js';
 import { AutomockOptions } from './automock.js';
@@ -4,0 +4,0 @@ export { automockModule } from './automock.js';

dist/node.js

@@ -17,2 +17,3 @@ import { a as cleanUrl, c as createManualModuleSource } from './chunk-utils.js';
 import './chunk-helpers.js';
+import '@jridgewell/trace-mapping';
 
@@ -105,5 +106,9 @@ function automockPlugin(options = {}) {
 	const regexpHoistable = new RegExp(`\\b(?:${utilsObjectNames.join("|")})\\s*\.\\s*(?:${Array.from(methods).join("|")})\\s*\\(`);
+	let root;
 	return {
 		name: "vitest:mocks",
 		enforce: "post",
+		configResolved(config) {
+			root = config.root;
+		},
 		transform(code, id) {
@@ -119,2 +124,4 @@ if (!filter(id)) {
 				dynamicImportMockMethodNames,
+				root,
+				getMap: () => this.getCombinedSourcemap(),
 				...options
@@ -121,0 +128,0 @@ });

dist/transforms.d.ts

@@ -1,3 +0,4 @@
-export { c as createManualModuleSource, h as hoistMocks } from './hoistMocks.d-w2ILr1dG.js';
+export { c as createManualModuleSource, h as hoistMocks } from './hoistMocks.d-CjaclmYf.js';
 export { automockModule } from './automock.js';
+import 'vite';
 import 'magic-string';
@@ -4,0 +5,0 @@

dist/transforms.js

@@ -11,1 +11,3 @@ export { c as createManualModuleSource } from './chunk-utils.js';
 import './chunk-helpers.js';
+import '@jridgewell/trace-mapping';
+import './chunk-pathe.M-eThtNZ.js';

package.json

 {
   "name": "@vitest/mocker",
   "type": "module",
-  "version": "5.0.0-beta.3",
+  "version": "5.0.0-beta.4",
   "description": "Vitest module mocker implementation",
@@ -86,5 +86,6 @@ "license": "MIT",
   "dependencies": {
+    "@jridgewell/trace-mapping": "0.3.31",
     "estree-walker": "^3.0.3",
     "magic-string": "^0.30.21",
-    "@vitest/spy": "5.0.0-beta.3"
+    "@vitest/spy": "5.0.0-beta.4"
   },
@@ -99,4 +100,4 @@ "devDependencies": {
     "vite": "^6.3.5",
-    "@vitest/spy": "5.0.0-beta.3",
-    "@vitest/utils": "5.0.0-beta.3"
+    "@vitest/spy": "5.0.0-beta.4",
+    "@vitest/utils": "5.0.0-beta.4"
   },
@@ -103,0 +104,0 @@ "scripts": {

dist/hoistMocks.d-w2ILr1dG.d.ts

-import MagicString from 'magic-string';
-
-declare function createManualModuleSource(moduleUrl: string, exports: string[], globalAccessor?: string): string;
-
-// This definition file follows a somewhat unusual format. ESTree allows
-// runtime type checks based on the `type` parameter. In order to explain this
-// to typescript we want to use discriminated union types:
-// https://github.com/Microsoft/TypeScript/pull/9163
-//
-// For ESTree this is a bit tricky because the high level interfaces like
-// Node or Function are pulling double duty. We want to pass common fields down
-// to the interfaces that extend them (like Identifier or
-// ArrowFunctionExpression), but you can't extend a type union or enforce
-// common fields on them. So we've split the high level interfaces into two
-// types, a base type which passes down inherited fields, and a type union of
-// all types which extend the base type. Only the type union is exported, and
-// the union is how other types refer to the collection of inheriting types.
-//
-// This makes the definitions file here somewhat more difficult to maintain,
-// but it has the notable advantage of making ESTree much easier to use as
-// an end user.
-
-interface BaseNodeWithoutComments {
-    // Every leaf interface that extends BaseNode must specify a type property.
-    // The type property should be a string literal. For example, Identifier
-    // has: `type: "Identifier"`
-    type: string;
-    loc?: SourceLocation | null | undefined;
-    range?: [number, number] | undefined;
-}
-
-interface BaseNode extends BaseNodeWithoutComments {
-    leadingComments?: Comment[] | undefined;
-    trailingComments?: Comment[] | undefined;
-}
-
-interface NodeMap {
-    AssignmentProperty: AssignmentProperty;
-    CatchClause: CatchClause;
-    Class: Class;
-    ClassBody: ClassBody;
-    Expression: Expression;
-    Function: Function;
-    Identifier: Identifier;
-    Literal: Literal;
-    MethodDefinition: MethodDefinition;
-    ModuleDeclaration: ModuleDeclaration;
-    ModuleSpecifier: ModuleSpecifier;
-    Pattern: Pattern;
-    PrivateIdentifier: PrivateIdentifier;
-    Program: Program;
-    Property: Property;
-    PropertyDefinition: PropertyDefinition;
-    SpreadElement: SpreadElement;
-    Statement: Statement;
-    Super: Super;
-    SwitchCase: SwitchCase;
-    TemplateElement: TemplateElement;
-    VariableDeclarator: VariableDeclarator;
-}
-
-type Node$1 = NodeMap[keyof NodeMap];
-
-interface Comment extends BaseNodeWithoutComments {
-    type: "Line" | "Block";
-    value: string;
-}
-
-interface SourceLocation {
-    source?: string | null | undefined;
-    start: Position;
-    end: Position;
-}
-
-interface Position {
-    /** >= 1 */
-    line: number;
-    /** >= 0 */
-    column: number;
-}
-
-interface Program extends BaseNode {
-    type: "Program";
-    sourceType: "script" | "module";
-    body: Array<Directive | Statement | ModuleDeclaration>;
-    comments?: Comment[] | undefined;
-}
-
-interface Directive extends BaseNode {
-    type: "ExpressionStatement";
-    expression: Literal;
-    directive: string;
-}
-
-interface BaseFunction extends BaseNode {
-    params: Pattern[];
-    generator?: boolean | undefined;
-    async?: boolean | undefined;
-    // The body is either BlockStatement or Expression because arrow functions
-    // can have a body that's either. FunctionDeclarations and
-    // FunctionExpressions have only BlockStatement bodies.
-    body: BlockStatement | Expression;
-}
-
-type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
-
-type Statement =
-    | ExpressionStatement
-    | BlockStatement
-    | StaticBlock
-    | EmptyStatement
-    | DebuggerStatement
-    | WithStatement
-    | ReturnStatement
-    | LabeledStatement
-    | BreakStatement
-    | ContinueStatement
-    | IfStatement
-    | SwitchStatement
-    | ThrowStatement
-    | TryStatement
-    | WhileStatement
-    | DoWhileStatement
-    | ForStatement
-    | ForInStatement
-    | ForOfStatement
-    | Declaration;
-
-interface BaseStatement extends BaseNode {}
-
-interface EmptyStatement extends BaseStatement {
-    type: "EmptyStatement";
-}
-
-interface BlockStatement extends BaseStatement {
-    type: "BlockStatement";
-    body: Statement[];
-    innerComments?: Comment[] | undefined;
-}
-
-interface StaticBlock extends Omit<BlockStatement, "type"> {
-    type: "StaticBlock";
-}
-
-interface ExpressionStatement extends BaseStatement {
-    type: "ExpressionStatement";
-    expression: Expression;
-}
-
-interface IfStatement extends BaseStatement {
-    type: "IfStatement";
-    test: Expression;
-    consequent: Statement;
-    alternate?: Statement | null | undefined;
-}
-
-interface LabeledStatement extends BaseStatement {
-    type: "LabeledStatement";
-    label: Identifier;
-    body: Statement;
-}
-
-interface BreakStatement extends BaseStatement {
-    type: "BreakStatement";
-    label?: Identifier | null | undefined;
-}
-
-interface ContinueStatement extends BaseStatement {
-    type: "ContinueStatement";
-    label?: Identifier | null | undefined;
-}
-
-interface WithStatement extends BaseStatement {
-    type: "WithStatement";
-    object: Expression;
-    body: Statement;
-}
-
-interface SwitchStatement extends BaseStatement {
-    type: "SwitchStatement";
-    discriminant: Expression;
-    cases: SwitchCase[];
-}
-
-interface ReturnStatement extends BaseStatement {
-    type: "ReturnStatement";
-    argument?: Expression | null | undefined;
-}
-
-interface ThrowStatement extends BaseStatement {
-    type: "ThrowStatement";
-    argument: Expression;
-}
-
-interface TryStatement extends BaseStatement {
-    type: "TryStatement";
-    block: BlockStatement;
-    handler?: CatchClause | null | undefined;
-    finalizer?: BlockStatement | null | undefined;
-}
-
-interface WhileStatement extends BaseStatement {
-    type: "WhileStatement";
-    test: Expression;
-    body: Statement;
-}
-
-interface DoWhileStatement extends BaseStatement {
-    type: "DoWhileStatement";
-    body: Statement;
-    test: Expression;
-}
-
-interface ForStatement extends BaseStatement {
-    type: "ForStatement";
-    init?: VariableDeclaration | Expression | null | undefined;
-    test?: Expression | null | undefined;
-    update?: Expression | null | undefined;
-    body: Statement;
-}
-
-interface BaseForXStatement extends BaseStatement {
-    left: VariableDeclaration | Pattern;
-    right: Expression;
-    body: Statement;
-}
-
-interface ForInStatement extends BaseForXStatement {
-    type: "ForInStatement";
-}
-
-interface DebuggerStatement extends BaseStatement {
-    type: "DebuggerStatement";
-}
-
-type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
-
-interface BaseDeclaration extends BaseStatement {}
-
-interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
-    type: "FunctionDeclaration";
-    /** It is null when a function declaration is a part of the `export default function` statement */
-    id: Identifier | null;
-    body: BlockStatement;
-}
-
-interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
-    id: Identifier;
-}
-
-interface VariableDeclaration extends BaseDeclaration {
-    type: "VariableDeclaration";
-    declarations: VariableDeclarator[];
-    kind: "var" | "let" | "const" | "using" | "await using";
-}
-
-interface VariableDeclarator extends BaseNode {
-    type: "VariableDeclarator";
-    id: Pattern;
-    init?: Expression | null | undefined;
-}
-
-interface ExpressionMap {
-    ArrayExpression: ArrayExpression;
-    ArrowFunctionExpression: ArrowFunctionExpression;
-    AssignmentExpression: AssignmentExpression;
-    AwaitExpression: AwaitExpression;
-    BinaryExpression: BinaryExpression;
-    CallExpression: CallExpression;
-    ChainExpression: ChainExpression;
-    ClassExpression: ClassExpression;
-    ConditionalExpression: ConditionalExpression;
-    FunctionExpression: FunctionExpression;
-    Identifier: Identifier;
-    ImportExpression: ImportExpression;
-    Literal: Literal;
-    LogicalExpression: LogicalExpression;
-    MemberExpression: MemberExpression;
-    MetaProperty: MetaProperty;
-    NewExpression: NewExpression;
-    ObjectExpression: ObjectExpression;
-    SequenceExpression: SequenceExpression;
-    TaggedTemplateExpression: TaggedTemplateExpression;
-    TemplateLiteral: TemplateLiteral;
-    ThisExpression: ThisExpression;
-    UnaryExpression: UnaryExpression;
-    UpdateExpression: UpdateExpression;
-    YieldExpression: YieldExpression;
-}
-
-type Expression = ExpressionMap[keyof ExpressionMap];
-
-interface BaseExpression extends BaseNode {}
-
-type ChainElement = SimpleCallExpression | MemberExpression;
-
-interface ChainExpression extends BaseExpression {
-    type: "ChainExpression";
-    expression: ChainElement;
-}
-
-interface ThisExpression extends BaseExpression {
-    type: "ThisExpression";
-}
-
-interface ArrayExpression extends BaseExpression {
-    type: "ArrayExpression";
-    elements: Array<Expression | SpreadElement | null>;
-}
-
-interface ObjectExpression extends BaseExpression {
-    type: "ObjectExpression";
-    properties: Array<Property | SpreadElement>;
-}
-
-interface PrivateIdentifier extends BaseNode {
-    type: "PrivateIdentifier";
-    name: string;
-}
-
-interface Property extends BaseNode {
-    type: "Property";
-    key: Expression | PrivateIdentifier;
-    value: Expression | Pattern; // Could be an AssignmentProperty
-    kind: "init" | "get" | "set";
-    method: boolean;
-    shorthand: boolean;
-    computed: boolean;
-}
-
-interface PropertyDefinition extends BaseNode {
-    type: "PropertyDefinition";
-    key: Expression | PrivateIdentifier;
-    value?: Expression | null | undefined;
-    computed: boolean;
-    static: boolean;
-}
-
-interface FunctionExpression extends BaseFunction, BaseExpression {
-    id?: Identifier | null | undefined;
-    type: "FunctionExpression";
-    body: BlockStatement;
-}
-
-interface SequenceExpression extends BaseExpression {
-    type: "SequenceExpression";
-    expressions: Expression[];
-}
-
-interface UnaryExpression extends BaseExpression {
-    type: "UnaryExpression";
-    operator: UnaryOperator;
-    prefix: true;
-    argument: Expression;
-}
-
-interface BinaryExpression extends BaseExpression {
-    type: "BinaryExpression";
-    operator: BinaryOperator;
-    left: Expression | PrivateIdentifier;
-    right: Expression;
-}
-
-interface AssignmentExpression extends BaseExpression {
-    type: "AssignmentExpression";
-    operator: AssignmentOperator;
-    left: Pattern | MemberExpression;
-    right: Expression;
-}
-
-interface UpdateExpression extends BaseExpression {
-    type: "UpdateExpression";
-    operator: UpdateOperator;
-    argument: Expression;
-    prefix: boolean;
-}
-
-interface LogicalExpression extends BaseExpression {
-    type: "LogicalExpression";
-    operator: LogicalOperator;
-    left: Expression;
-    right: Expression;
-}
-
-interface ConditionalExpression extends BaseExpression {
-    type: "ConditionalExpression";
-    test: Expression;
-    alternate: Expression;
-    consequent: Expression;
-}
-
-interface BaseCallExpression extends BaseExpression {
-    callee: Expression | Super;
-    arguments: Array<Expression | SpreadElement>;
-}
-type CallExpression = SimpleCallExpression | NewExpression;
-
-interface SimpleCallExpression extends BaseCallExpression {
-    type: "CallExpression";
-    optional: boolean;
-}
-
-interface NewExpression extends BaseCallExpression {
-    type: "NewExpression";
-}
-
-interface MemberExpression extends BaseExpression, BasePattern {
-    type: "MemberExpression";
-    object: Expression | Super;
-    property: Expression | PrivateIdentifier;
-    computed: boolean;
-    optional: boolean;
-}
-
-type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
-
-interface BasePattern extends BaseNode {}
-
-interface SwitchCase extends BaseNode {
-    type: "SwitchCase";
-    test?: Expression | null | undefined;
-    consequent: Statement[];
-}
-
-interface CatchClause extends BaseNode {
-    type: "CatchClause";
-    param: Pattern | null;
-    body: BlockStatement;
-}
-
-interface Identifier extends BaseNode, BaseExpression, BasePattern {
-    type: "Identifier";
-    name: string;
-}
-
-type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
-
-interface SimpleLiteral extends BaseNode, BaseExpression {
-    type: "Literal";
-    value: string | boolean | number | null;
-    raw?: string | undefined;
-}
-
-interface RegExpLiteral extends BaseNode, BaseExpression {
-    type: "Literal";
-    value?: RegExp | null | undefined;
-    regex: {
-        pattern: string;
-        flags: string;
-    };
-    raw?: string | undefined;
-}
-
-interface BigIntLiteral extends BaseNode, BaseExpression {
-    type: "Literal";
-    value?: bigint | null | undefined;
-    bigint: string;
-    raw?: string | undefined;
-}
-
-type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
-
-type BinaryOperator =
-    | "=="
-    | "!="
-    | "==="
-    | "!=="
-    | "<"
-    | "<="
-    | ">"
-    | ">="
-    | "<<"
-    | ">>"
-    | ">>>"
-    | "+"
-    | "-"
-    | "*"
-    | "/"
-    | "%"
-    | "**"
-    | "|"
-    | "^"
-    | "&"
-    | "in"
-    | "instanceof";
-
-type LogicalOperator = "||" | "&&" | "??";
-
-type AssignmentOperator =
-    | "="
-    | "+="
-    | "-="
-    | "*="
-    | "/="
-    | "%="
-    | "**="
-    | "<<="
-    | ">>="
-    | ">>>="
-    | "|="
-    | "^="
-    | "&="
-    | "||="
-    | "&&="
-    | "??=";
-
-type UpdateOperator = "++" | "--";
-
-interface ForOfStatement extends BaseForXStatement {
-    type: "ForOfStatement";
-    await: boolean;
-}
-
-interface Super extends BaseNode {
-    type: "Super";
-}
-
-interface SpreadElement extends BaseNode {
-    type: "SpreadElement";
-    argument: Expression;
-}
-
-interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
-    type: "ArrowFunctionExpression";
-    expression: boolean;
-    body: BlockStatement | Expression;
-}
-
-interface YieldExpression extends BaseExpression {
-    type: "YieldExpression";
-    argument?: Expression | null | undefined;
-    delegate: boolean;
-}
-
-interface TemplateLiteral extends BaseExpression {
-    type: "TemplateLiteral";
-    quasis: TemplateElement[];
-    expressions: Expression[];
-}
-
-interface TaggedTemplateExpression extends BaseExpression {
-    type: "TaggedTemplateExpression";
-    tag: Expression;
-    quasi: TemplateLiteral;
-}
-
-interface TemplateElement extends BaseNode {
-    type: "TemplateElement";
-    tail: boolean;
-    value: {
-        /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */
-        cooked?: string | null | undefined;
-        raw: string;
-    };
-}
-
-interface AssignmentProperty extends Property {
-    value: Pattern;
-    kind: "init";
-    method: boolean; // false
-}
-
-interface ObjectPattern extends BasePattern {
-    type: "ObjectPattern";
-    properties: Array<AssignmentProperty | RestElement>;
-}
-
-interface ArrayPattern extends BasePattern {
-    type: "ArrayPattern";
-    elements: Array<Pattern | null>;
-}
-
-interface RestElement extends BasePattern {
-    type: "RestElement";
-    argument: Pattern;
-}
-
-interface AssignmentPattern extends BasePattern {
-    type: "AssignmentPattern";
-    left: Pattern;
-    right: Expression;
-}
-
-type Class = ClassDeclaration | ClassExpression;
-interface BaseClass extends BaseNode {
-    superClass?: Expression | null | undefined;
-    body: ClassBody;
-}
-
-interface ClassBody extends BaseNode {
-    type: "ClassBody";
-    body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
-}
-
-interface MethodDefinition extends BaseNode {
-    type: "MethodDefinition";
-    key: Expression | PrivateIdentifier;
-    value: FunctionExpression;
-    kind: "constructor" | "method" | "get" | "set";
-    computed: boolean;
-    static: boolean;
-}
-
-interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
-    type: "ClassDeclaration";
-    /** It is null when a class declaration is a part of the `export default class` statement */
-    id: Identifier | null;
-}
-
-interface ClassDeclaration extends MaybeNamedClassDeclaration {
-    id: Identifier;
-}
-
-interface ClassExpression extends BaseClass, BaseExpression {
-    type: "ClassExpression";
-    id?: Identifier | null | undefined;
-}
-
-interface MetaProperty extends BaseExpression {
-    type: "MetaProperty";
-    meta: Identifier;
-    property: Identifier;
-}
-
-type ModuleDeclaration =
-    | ImportDeclaration
-    | ExportNamedDeclaration
-    | ExportDefaultDeclaration
-    | ExportAllDeclaration;
-interface BaseModuleDeclaration extends BaseNode {}
-
-type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
-interface BaseModuleSpecifier extends BaseNode {
-    local: Identifier;
-}
-
-interface ImportDeclaration extends BaseModuleDeclaration {
-    type: "ImportDeclaration";
-    specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
-    attributes: ImportAttribute[];
-    source: Literal;
-}
-
-interface ImportSpecifier extends BaseModuleSpecifier {
-    type: "ImportSpecifier";
-    imported: Identifier | Literal;
-}
-
-interface ImportAttribute extends BaseNode {
-    type: "ImportAttribute";
-    key: Identifier | Literal;
-    value: Literal;
-}
-
-interface ImportExpression extends BaseExpression {
-    type: "ImportExpression";
-    source: Expression;
-    options?: Expression | null | undefined;
-}
-
-interface ImportDefaultSpecifier extends BaseModuleSpecifier {
-    type: "ImportDefaultSpecifier";
-}
-
-interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
-    type: "ImportNamespaceSpecifier";
-}
-
-interface ExportNamedDeclaration extends BaseModuleDeclaration {
-    type: "ExportNamedDeclaration";
-    declaration?: Declaration | null | undefined;
-    specifiers: ExportSpecifier[];
-    attributes: ImportAttribute[];
-    source?: Literal | null | undefined;
-}
-
-interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
-    type: "ExportSpecifier";
-    local: Identifier | Literal;
-    exported: Identifier | Literal;
-}
-
-interface ExportDefaultDeclaration extends BaseModuleDeclaration {
-    type: "ExportDefaultDeclaration";
-    declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
-}
-
-interface ExportAllDeclaration extends BaseModuleDeclaration {
-    type: "ExportAllDeclaration";
-    exported: Identifier | Literal | null;
-    attributes: ImportAttribute[];
-    source: Literal;
-}
-
-interface AwaitExpression extends BaseExpression {
-    type: "AwaitExpression";
-    argument: Expression;
-}
-
-type Positioned<T> = T & {
-	start: number;
-	end: number;
-};
-type Node = Positioned<Node$1>;
-
-interface HoistMocksOptions {
-	/**
-	* List of modules that should always be imported before compiler hints.
-	* @default 'vitest'
-	*/
-	hoistedModule?: string;
-	/**
-	* @default ["vi", "vitest"]
-	*/
-	utilsObjectNames?: string[];
-	/**
-	* @default ["mock", "unmock"]
-	*/
-	hoistableMockMethodNames?: string[];
-	/**
-	* @default ["mock", "unmock", "doMock", "doUnmock"]
-	*/
-	dynamicImportMockMethodNames?: string[];
-	/**
-	* @default ["hoisted"]
-	*/
-	hoistedMethodNames?: string[];
-	globalThisAccessor?: string;
-	regexpHoistable?: RegExp;
-	codeFrameGenerator?: CodeFrameGenerator;
-	magicString?: () => MagicString;
-}
-declare function hoistMocks(code: string, id: string, parse: (code: string) => any, options?: HoistMocksOptions): MagicString | undefined;
-interface CodeFrameGenerator {
-	(node: Positioned<Node>, id: string, code: string): string;
-}
-
-export { createManualModuleSource as c, hoistMocks as h };
-export type { HoistMocksOptions as H };

No alert changes

Improved metrics

Total package byte prevSize

189769

1.28%

Lines of code

4212

1.86%

Worsened metrics

Dependency count

6

20%

Dependency changes

• + Added

  @jridgewell/trace-mapping@0.3.31

• + Added

  @jridgewell/resolve-uri@3.1.2
  (transitive)

• + Added

  @jridgewell/trace-mapping@0.3.31
  (transitive)

• + Added

  @vitest/spy@5.0.0-beta.4
  (transitive)

• - Removed

  @vitest/spy@5.0.0-beta.3
  (transitive)

• Updated

  @vitest/spy@5.0.0-beta.4