vitest 0.24.5 → 0.25.1

package/dist/{chunk-runtime-hooks.d748b085.js → chunk-runtime-test-state.4ed42543.js}

@@ -1,17 +1,37 @@
-import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, s as suite, t as test, d as describe, i as it, b as bench, c as createExpect, e as globalExpect } from './chunk-runtime-chain.37ec5d73.js';
-import { g as getWorkerState, R as RealDate, r as resetDate, m as mockDate, a as resetModules } from './chunk-mock-date.030959d3.js';
-import { p as parseStacktrace } from './chunk-utils-source-map.663e2952.js';
+import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, s as suite, t as test, d as describe, i as it, b as bench, c as createExpect, e as globalExpect } from './chunk-runtime-chain.e387e274.js';
+import { g as getWorkerState, R as RealDate, r as resetDate, m as mockDate, a as resetModules } from './chunk-typecheck-constants.4891f22f.js';
+import { p as parseStacktrace } from './chunk-utils-source-map.c6dfbbc1.js';
 import { c as commonjsGlobal } from './vendor-_commonjsHelpers.addc3445.js';
 import util from 'util';
 import { spyOn, fn, isMockFunction, spies } from './spy.js';
-import { s as safeSetTimeout } from './chunk-utils-timers.8fca243e.js';
+import { s as safeSetTimeout } from './chunk-utils-timers.06f993db.js';
 import * as chai from 'chai';
 import { assert, should } from 'chai';
 
+let _test;
+function setCurrentTest(test) {
+  _test = test;
+}
+function getCurrentTest() {
+  return _test;
+}
+
 const beforeAll = (fn, timeout) => getCurrentSuite().on("beforeAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
 const afterAll = (fn, timeout) => getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
 const beforeEach = (fn, timeout) => getCurrentSuite().on("beforeEach", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
 const afterEach = (fn, timeout) => getCurrentSuite().on("afterEach", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
+const onTestFailed = createTestHook("onTestFailed", (test, handler) => {
+  test.onFailed || (test.onFailed = []);
+  test.onFailed.push(handler);
+});
+function createTestHook(name, handler) {
+  return (fn) => {
+    const current = getCurrentTest();
+    if (!current)
+      throw new Error(`Hook ${name}() can only be called inside a test`);
+    handler(current, fn);
+  };
+}
 
 function withCallback(fn) {
   return new Promise(
@@ -2663,6 +2683,7 @@ class VitestUtils {
   constructor() {
     this.spyOn = spyOn;
     this.fn = fn;
+    this._config = null;
     this._mocker = typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : null;
     this._mockedDate = null;
     if (!this._mocker) {
@@ -2793,6 +2814,18 @@ class VitestUtils {
     await Promise.allSettled(promises);
     await new Promise((resolve) => safeSetTimeout(resolve, 1)).then(() => Promise.resolve());
   }
+  setConfig(config) {
+    const state = getWorkerState();
+    if (!this._config)
+      this._config = { ...state.config };
+    Object.assign(state.config, config);
+  }
+  resetConfig() {
+    if (this._config) {
+      const state = getWorkerState();
+      state.config = { ...this._config };
+    }
+  }
 }
 const vitest = new VitestUtils();
 const vi = vitest;
@@ -2804,6 +2837,83 @@ function isWatchMode() {
   return getRunningMode() === "watch";
 }
 
+var dist = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.expectTypeOf = void 0;
+	const fn = () => true;
+	/**
+	 * Similar to Jest's `expect`, but with type-awareness.
+	 * Gives you access to a number of type-matchers that let you make assertions about the
+	 * form of a reference or generic type parameter.
+	 *
+	 * @example
+	 * import {foo, bar} from '../foo'
+	 * import {expectTypeOf} from 'expect-type'
+	 *
+	 * test('foo types', () => {
+	 *   // make sure `foo` has type {a: number}
+	 *   expectTypeOf(foo).toMatchTypeOf({a: 1})
+	 *   expectTypeOf(foo).toHaveProperty('a').toBeNumber()
+	 *
+	 *   // make sure `bar` is a function taking a string:
+	 *   expectTypeOf(bar).parameter(0).toBeString()
+	 *   expectTypeOf(bar).returns.not.toBeAny()
+	 * })
+	 *
+	 * @description
+	 * See the [full docs](https://npmjs.com/package/expect-type#documentation) for lots more examples.
+	 */
+	const expectTypeOf = (_actual) => {
+	    const nonFunctionProperties = [
+	        'parameters',
+	        'returns',
+	        'resolves',
+	        'not',
+	        'items',
+	        'constructorParameters',
+	        'instance',
+	        'guards',
+	        'asserts',
+	    ];
+	    const obj = {
+	        /* eslint-disable mmkal/@typescript-eslint/no-unsafe-assignment */
+	        toBeAny: fn,
+	        toBeUnknown: fn,
+	        toBeNever: fn,
+	        toBeFunction: fn,
+	        toBeObject: fn,
+	        toBeArray: fn,
+	        toBeString: fn,
+	        toBeNumber: fn,
+	        toBeBoolean: fn,
+	        toBeVoid: fn,
+	        toBeSymbol: fn,
+	        toBeNull: fn,
+	        toBeUndefined: fn,
+	        toBeNullable: fn,
+	        toMatchTypeOf: fn,
+	        toEqualTypeOf: fn,
+	        toBeCallableWith: fn,
+	        toBeConstructibleWith: fn,
+	        /* eslint-enable mmkal/@typescript-eslint/no-unsafe-assignment */
+	        extract: exports.expectTypeOf,
+	        exclude: exports.expectTypeOf,
+	        toHaveProperty: exports.expectTypeOf,
+	        parameter: exports.expectTypeOf,
+	    };
+	    const getterProperties = nonFunctionProperties;
+	    getterProperties.forEach((prop) => Object.defineProperty(obj, prop, { get: () => (0, exports.expectTypeOf)({}) }));
+	    return obj;
+	};
+	exports.expectTypeOf = expectTypeOf;
+} (dist));
+
+const noop = () => {
+};
+const assertType = noop;
+
 var index = /*#__PURE__*/Object.freeze({
   __proto__: null,
   suite: suite,
@@ -2817,6 +2927,7 @@ var index = /*#__PURE__*/Object.freeze({
   afterAll: afterAll,
   beforeEach: beforeEach,
   afterEach: afterEach,
+  onTestFailed: onTestFailed,
   withCallback: withCallback,
   assert: assert,
   should: should,
@@ -2826,7 +2937,9 @@ var index = /*#__PURE__*/Object.freeze({
   vitest: vitest,
   vi: vi,
   getRunningMode: getRunningMode,
-  isWatchMode: isWatchMode
+  isWatchMode: isWatchMode,
+  expectTypeOf: dist.expectTypeOf,
+  assertType: assertType
 });
 
-export { afterAll as a, beforeAll as b, beforeEach as c, afterEach as d, runOnce as e, isFirstRun as f, vitest as g, getRunningMode as h, index as i, isWatchMode as j, resetRunOnceCounter as r, vi as v, withCallback as w };
+export { afterAll as a, beforeAll as b, beforeEach as c, afterEach as d, dist as e, assertType as f, runOnce as g, isFirstRun as h, index as i, vitest as j, getRunningMode as k, isWatchMode as l, onTestFailed as o, resetRunOnceCounter as r, setCurrentTest as s, vi as v, withCallback as w };

package/dist/{chunk-mock-date.030959d3.js → chunk-typecheck-constants.4891f22f.js}

@@ -1,7 +1,9 @@
 import { relative } from 'path';
-import { i as isNode, a as isBrowser, r as relative$1, p as picocolors, E as EXIT_CODE_RESTART } from './chunk-utils-env.b1281522.js';
+import { i as isNode, a as isBrowser, r as relative$1, p as picocolors, E as EXIT_CODE_RESTART } from './chunk-utils-env.03f840f2.js';
 import { isPackageExists } from 'local-pkg';
 
+const TYPECHECK_SUITE = Symbol("vitest:typecheck-suite");
+
 const RealDate = Date;
 let now = null;
 class MockDate extends RealDate {
@@ -179,11 +181,21 @@ function shuffle(array, seed = RealDate.now()) {
 }
 
 function isAtomTest(s) {
-  return s.type === "test" || s.type === "benchmark";
+  return s.type === "test" || s.type === "benchmark" || s.type === "typecheck";
 }
 function getTests(suite) {
   return toArray(suite).flatMap((s) => isAtomTest(s) ? [s] : s.tasks.flatMap((c) => isAtomTest(c) ? [c] : getTests(c)));
 }
+function isTypecheckTest(suite) {
+  return TYPECHECK_SUITE in suite;
+}
+function getTypecheckTests(suite) {
+  return toArray(suite).flatMap((s) => {
+    if (s.type !== "suite")
+      return [];
+    return TYPECHECK_SUITE in s ? [s, ...getTypecheckTests(s.tasks)] : getTypecheckTests(s.tasks);
+  });
+}
 function getSuites(suite) {
   return toArray(suite).flatMap((s) => s.type === "suite" ? [s, ...getSuites(s.tasks)] : []);
 }
@@ -254,6 +266,13 @@ function resetModules(modules, resetMocks = false) {
 function getFullName(task) {
   return getNames(task).join(picocolors.exports.dim(" > "));
 }
+function removeUndefinedValues(obj) {
+  for (const key in Object.keys(obj)) {
+    if (obj[key] === void 0)
+      delete obj[key];
+  }
+  return obj;
+}
 async function ensurePackageInstalled(dependency, root) {
   if (isPackageExists(dependency, { paths: [root] }))
     return true;
@@ -270,7 +289,7 @@ async function ensurePackageInstalled(dependency, root) {
     message: picocolors.exports.reset(`Do you want to install ${picocolors.exports.green(dependency)}?`)
   });
   if (install) {
-    await (await import('./chunk-install-pkg.22707ee4.js')).installPackage(dependency, { dev: true });
+    await (await import('./chunk-install-pkg.579a5a27.js')).installPackage(dependency, { dev: true });
     process.stderr.write(picocolors.exports.yellow(`
 Package ${dependency} installed, re-run the command to start.
 `));
@@ -326,4 +345,4 @@ function createDefer() {
   return p;
 }
 
-export { AggregateErrorPonyfill as A, deepMerge as B, ensurePackageInstalled as C, stdout as D, mergeSlashes as E, getAllMockableProperties as F, RealDate as R, resetModules as a, getCallLastIndex as b, getNames as c, assertTypes as d, getFullName as e, isRunningInTest as f, getWorkerState as g, isRunningInBenchmark as h, isObject as i, notNullish as j, relativePath as k, shuffle as l, mockDate as m, noop as n, hasTests as o, partitionSuiteChildren as p, hasFailed as q, resetDate as r, slash as s, toArray as t, createDefer as u, deepClone as v, getType as w, getTests as x, hasFailedSnapshot as y, getSuites as z };
+export { AggregateErrorPonyfill as A, getTypecheckTests as B, getSuites as C, isTypecheckTest as D, deepMerge as E, removeUndefinedValues as F, stdout as G, mergeSlashes as H, getAllMockableProperties as I, RealDate as R, TYPECHECK_SUITE as T, resetModules as a, getCallLastIndex as b, getNames as c, assertTypes as d, getFullName as e, isRunningInTest as f, getWorkerState as g, isRunningInBenchmark as h, isObject as i, notNullish as j, relativePath as k, shuffle as l, mockDate as m, noop as n, hasTests as o, partitionSuiteChildren as p, hasFailed as q, resetDate as r, slash as s, toArray as t, createDefer as u, deepClone as v, getType as w, ensurePackageInstalled as x, getTests as y, hasFailedSnapshot as z };

package/dist/{chunk-utils-env.b1281522.js → chunk-utils-env.03f840f2.js}

@@ -277,6 +277,8 @@ const globalApis = [
   "chai",
   "expect",
   "assert",
+  "expectTypeOf",
+  "assertType",
   "vitest",
   "vi",
   "beforeAll",

package/dist/chunk-utils-source-map.c6dfbbc1.js

@@ -0,0 +1,90 @@
+import { s as slash, j as notNullish } from './chunk-typecheck-constants.4891f22f.js';
+
+const lineSplitRE = /\r?\n/;
+const stackIgnorePatterns = [
+  "node:internal",
+  "/vitest/dist/",
+  "/vitest/src/",
+  "/node_modules/chai/",
+  "/node_modules/tinypool/",
+  "/node_modules/tinyspy/"
+];
+function extractLocation(urlLike) {
+  if (!urlLike.includes(":"))
+    return [urlLike];
+  const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
+  const parts = regExp.exec(urlLike.replace(/[()]/g, ""));
+  if (!parts)
+    return [urlLike];
+  return [parts[1], parts[2] || void 0, parts[3] || void 0];
+}
+function parseStacktrace(e, full = false) {
+  if (!e)
+    return [];
+  if (e.stacks)
+    return e.stacks;
+  const stackStr = e.stack || e.stackStr || "";
+  const stackFrames = stackStr.split("\n").map((raw) => {
+    let line = raw.trim();
+    if (line.includes("(eval "))
+      line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
+    let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
+    const location = sanitizedLine.match(/ (\(.+\)$)/);
+    sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
+    const [url, lineNumber, columnNumber] = extractLocation(location ? location[1] : sanitizedLine);
+    let method = location && sanitizedLine || "";
+    let file = url && ["eval", "<anonymous>"].includes(url) ? void 0 : url;
+    if (!file || !lineNumber || !columnNumber)
+      return null;
+    if (method.startsWith("async "))
+      method = method.slice(6);
+    if (file.startsWith("file://"))
+      file = file.slice(7);
+    if (!full && stackIgnorePatterns.some((p) => file && file.includes(p)))
+      return null;
+    return {
+      method,
+      file: slash(file),
+      line: parseInt(lineNumber),
+      column: parseInt(columnNumber)
+    };
+  }).filter(notNullish);
+  e.stacks = stackFrames;
+  return stackFrames;
+}
+function posToNumber(source, pos) {
+  if (typeof pos === "number")
+    return pos;
+  const lines = source.split(lineSplitRE);
+  const { line, column } = pos;
+  let start = 0;
+  if (line > lines.length)
+    return source.length;
+  for (let i = 0; i < line - 1; i++)
+    start += lines[i].length + 1;
+  return start + column;
+}
+function numberToPos(source, offset) {
+  if (typeof offset !== "number")
+    return offset;
+  if (offset > source.length) {
+    throw new Error(
+      `offset is longer than source length! offset ${offset} > length ${source.length}`
+    );
+  }
+  const lines = source.split(lineSplitRE);
+  let counted = 0;
+  let line = 0;
+  let column = 0;
+  for (; line < lines.length; line++) {
+    const lineLength = lines[line].length + 1;
+    if (counted + lineLength >= offset) {
+      column = offset - counted + 1;
+      break;
+    }
+    counted += lineLength;
+  }
+  return { line: line + 1, column };
+}
+
+export { posToNumber as a, lineSplitRE as l, numberToPos as n, parseStacktrace as p };

package/dist/{chunk-utils-timers.8fca243e.js → chunk-utils-timers.06f993db.js}

@@ -1,4 +1,4 @@
-import { p as picocolors } from './chunk-utils-env.b1281522.js';
+import { p as picocolors } from './chunk-utils-env.03f840f2.js';
 
 const {
   setTimeout: safeSetTimeout,
@@ -3043,74 +3043,78 @@ const wrapAnsi256 = (offset = 0) => code => `\u001B[${38 + offset};5;${code}m`;
 
 const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
 
+const styles = {
+	modifier: {
+		reset: [0, 0],
+		// 21 isn't widely supported and 22 does the same thing
+		bold: [1, 22],
+		dim: [2, 22],
+		italic: [3, 23],
+		underline: [4, 24],
+		overline: [53, 55],
+		inverse: [7, 27],
+		hidden: [8, 28],
+		strikethrough: [9, 29],
+	},
+	color: {
+		black: [30, 39],
+		red: [31, 39],
+		green: [32, 39],
+		yellow: [33, 39],
+		blue: [34, 39],
+		magenta: [35, 39],
+		cyan: [36, 39],
+		white: [37, 39],
+
+		// Bright color
+		blackBright: [90, 39],
+		gray: [90, 39], // Alias of `blackBright`
+		grey: [90, 39], // Alias of `blackBright`
+		redBright: [91, 39],
+		greenBright: [92, 39],
+		yellowBright: [93, 39],
+		blueBright: [94, 39],
+		magentaBright: [95, 39],
+		cyanBright: [96, 39],
+		whiteBright: [97, 39],
+	},
+	bgColor: {
+		bgBlack: [40, 49],
+		bgRed: [41, 49],
+		bgGreen: [42, 49],
+		bgYellow: [43, 49],
+		bgBlue: [44, 49],
+		bgMagenta: [45, 49],
+		bgCyan: [46, 49],
+		bgWhite: [47, 49],
+
+		// Bright color
+		bgBlackBright: [100, 49],
+		bgGray: [100, 49], // Alias of `bgBlackBright`
+		bgGrey: [100, 49], // Alias of `bgBlackBright`
+		bgRedBright: [101, 49],
+		bgGreenBright: [102, 49],
+		bgYellowBright: [103, 49],
+		bgBlueBright: [104, 49],
+		bgMagentaBright: [105, 49],
+		bgCyanBright: [106, 49],
+		bgWhiteBright: [107, 49],
+	},
+};
+
+Object.keys(styles.modifier);
+const foregroundColorNames = Object.keys(styles.color);
+const backgroundColorNames = Object.keys(styles.bgColor);
+[...foregroundColorNames, ...backgroundColorNames];
+
 function assembleStyles() {
 	const codes = new Map();
-	const styles = {
-		modifier: {
-			reset: [0, 0],
-			// 21 isn't widely supported and 22 does the same thing
-			bold: [1, 22],
-			dim: [2, 22],
-			italic: [3, 23],
-			underline: [4, 24],
-			overline: [53, 55],
-			inverse: [7, 27],
-			hidden: [8, 28],
-			strikethrough: [9, 29]
-		},
-		color: {
-			black: [30, 39],
-			red: [31, 39],
-			green: [32, 39],
-			yellow: [33, 39],
-			blue: [34, 39],
-			magenta: [35, 39],
-			cyan: [36, 39],
-			white: [37, 39],
-
-			// Bright color
-			blackBright: [90, 39],
-			redBright: [91, 39],
-			greenBright: [92, 39],
-			yellowBright: [93, 39],
-			blueBright: [94, 39],
-			magentaBright: [95, 39],
-			cyanBright: [96, 39],
-			whiteBright: [97, 39]
-		},
-		bgColor: {
-			bgBlack: [40, 49],
-			bgRed: [41, 49],
-			bgGreen: [42, 49],
-			bgYellow: [43, 49],
-			bgBlue: [44, 49],
-			bgMagenta: [45, 49],
-			bgCyan: [46, 49],
-			bgWhite: [47, 49],
-
-			// Bright color
-			bgBlackBright: [100, 49],
-			bgRedBright: [101, 49],
-			bgGreenBright: [102, 49],
-			bgYellowBright: [103, 49],
-			bgBlueBright: [104, 49],
-			bgMagentaBright: [105, 49],
-			bgCyanBright: [106, 49],
-			bgWhiteBright: [107, 49]
-		}
-	};
-
-	// Alias bright black as gray (and grey)
-	styles.color.gray = styles.color.blackBright;
-	styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
-	styles.color.grey = styles.color.blackBright;
-	styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
 
 	for (const [groupName, group] of Object.entries(styles)) {
 		for (const [styleName, style] of Object.entries(group)) {
 			styles[styleName] = {
 				open: `\u001B[${style[0]}m`,
-				close: `\u001B[${style[1]}m`
+				close: `\u001B[${style[1]}m`,
 			};
 
 			group[styleName] = styles[styleName];
@@ -3120,13 +3124,13 @@ function assembleStyles() {
 
 		Object.defineProperty(styles, groupName, {
 			value: group,
-			enumerable: false
+			enumerable: false,
 		});
 	}
 
 	Object.defineProperty(styles, 'codes', {
 		value: codes,
-		enumerable: false
+		enumerable: false,
 	});
 
 	styles.color.close = '\u001B[39m';
@@ -3157,39 +3161,41 @@ function assembleStyles() {
 					return Math.round(((red - 8) / 247) * 24) + 232;
 				}
 
-				return 16 +
-					(36 * Math.round(red / 255 * 5)) +
-					(6 * Math.round(green / 255 * 5)) +
-					Math.round(blue / 255 * 5);
+				return 16
+					+ (36 * Math.round(red / 255 * 5))
+					+ (6 * Math.round(green / 255 * 5))
+					+ Math.round(blue / 255 * 5);
 			},
-			enumerable: false
+			enumerable: false,
 		},
 		hexToRgb: {
 			value: hex => {
-				const matches = /(?<colorString>[a-f\d]{6}|[a-f\d]{3})/i.exec(hex.toString(16));
+				const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
 				if (!matches) {
 					return [0, 0, 0];
 				}
 
-				let {colorString} = matches.groups;
+				let [colorString] = matches;
 
 				if (colorString.length === 3) {
-					colorString = colorString.split('').map(character => character + character).join('');
+					colorString = [...colorString].map(character => character + character).join('');
 				}
 
 				const integer = Number.parseInt(colorString, 16);
 
 				return [
+					/* eslint-disable no-bitwise */
 					(integer >> 16) & 0xFF,
 					(integer >> 8) & 0xFF,
-					integer & 0xFF
+					integer & 0xFF,
+					/* eslint-enable no-bitwise */
 				];
 			},
-			enumerable: false
+			enumerable: false,
 		},
 		hexToAnsi256: {
 			value: hex => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
-			enumerable: false
+			enumerable: false,
 		},
 		ansi256ToAnsi: {
 			value: code => {
@@ -3225,6 +3231,7 @@ function assembleStyles() {
 					return 30;
 				}
 
+				// eslint-disable-next-line no-bitwise
 				let result = 30 + ((Math.round(blue) << 2) | (Math.round(green) << 1) | Math.round(red));
 
 				if (value === 2) {
@@ -3233,16 +3240,16 @@ function assembleStyles() {
 
 				return result;
 			},
-			enumerable: false
+			enumerable: false,
 		},
 		rgbToAnsi: {
 			value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
-			enumerable: false
+			enumerable: false,
 		},
 		hexToAnsi: {
 			value: hex => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
-			enumerable: false
-		}
+			enumerable: false,
+		},
 	});
 
 	return styles;

package/dist/{chunk-vite-node-client.3868b3ba.js → chunk-vite-node-client.b2ab6dcf.js}

@@ -1,8 +1,8 @@
 import { createRequire } from 'module';
 import { pathToFileURL, fileURLToPath } from 'url';
 import vm from 'vm';
-import { b as resolve, d as dirname, g as isAbsolute, l as extname } from './chunk-utils-env.b1281522.js';
-import { s as slash, n as normalizeRequestId, b as toFilePath, i as isNodeBuiltin, c as isPrimitive, d as normalizeModuleId, m as mergeSlashes } from './chunk-vite-node-utils.2144000e.js';
+import { b as resolve, d as dirname, g as isAbsolute, l as extname } from './chunk-utils-env.03f840f2.js';
+import { s as slash, n as normalizeRequestId, b as toFilePath, i as isNodeBuiltin, c as isPrimitive, d as normalizeModuleId, m as mergeSlashes } from './chunk-vite-node-utils.8f0b4a12.js';
 import createDebug from 'debug';
 
 const debugExecute = createDebug("vite-node:client:execute");
@@ -95,6 +95,20 @@ class ModuleCacheMap extends Map {
     }
     return invalidated;
   }
+  getSourceMap(id) {
+    var _a, _b;
+    const fsPath = this.normalizePath(id);
+    const cache = this.get(fsPath);
+    if (cache.map)
+      return cache.map;
+    const mapString = (_b = (_a = cache == null ? void 0 : cache.code) == null ? void 0 : _a.match(/\/\/# sourceMappingURL=data:application\/json;charset=utf-8;base64,(.+)/)) == null ? void 0 : _b[1];
+    if (mapString) {
+      const map = JSON.parse(Buffer.from(mapString, "base64").toString("utf-8"));
+      cache.map = map;
+      return map;
+    }
+    return null;
+  }
 }
 class ViteNodeRunner {
   constructor(options) {
@@ -109,6 +123,9 @@ class ViteNodeRunner {
   async executeId(id) {
     return await this.cachedRequest(id, []);
   }
+  getSourceMap(id) {
+    return this.moduleCache.getSourceMap(id);
+  }
   async cachedRequest(rawId, callstack) {
     const id = normalizeRequestId(rawId, this.options.base);
     const fsPath = toFilePath(id, this.root);
@@ -240,10 +257,13 @@ ${getStack()}`), 2e3);
     debugExecute(__filename);
     if (transformed[0] === "#")
       transformed = transformed.replace(/^\#\!.*/, (s) => " ".repeat(s.length));
-    const fn = vm.runInThisContext(`'use strict';async (${Object.keys(context).join(",")})=>{{${transformed}
-}}`, {
+    const codeDefinition = `'use strict';async (${Object.keys(context).join(",")})=>{{`;
+    const code = `${codeDefinition}${transformed}
+}}`;
+    const fn = vm.runInThisContext(code, {
       filename: fsPath,
-      lineOffset: 0
+      lineOffset: 0,
+      columnOffset: -codeDefinition.length
     });
     await fn(...Object.values(context));
     return exports;