vitest 0.3.4 → 0.3.5

package/dist/{globals-bb4e160a.js → globals-4885c33f.js}

@@ -1,17 +1,17 @@
 import { g as globalApis } from './constants-861ea902.js';
-import { i as index } from './index-c9e80681.js';
+import { i as index } from './index-b99f1c97.js';
 import 'url';
 import './index-373b5ce3.js';
 import 'path';
-import './vi-14b6cd9b.js';
+import './vi-b258f071.js';
 import 'util';
-import './index-61b7ead7.js';
+import './index-5e0ca99c.js';
 import 'tty';
 import 'local-pkg';
 import './jest-mock.js';
 import 'chai';
 import 'tinyspy';
-import './source-map-c0dbec82.js';
+import './source-map-1b1fae71.js';
 import './_commonjsHelpers-c9e3b764.js';
 import './defaults-ac98ff15.js';
 
@@ -22,4 +22,4 @@ function registerApiGlobally() {
 }
 
 export { registerApiGlobally };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2xvYmFscy1iYjRlMTYwYS5qcyIsInNvdXJjZXMiOlsiLi4vc3JjL2ludGVncmF0aW9ucy9nbG9iYWxzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGdsb2JhbEFwaXMgfSBmcm9tICcuLi9jb25zdGFudHMnXG5pbXBvcnQgKiBhcyBpbmRleCBmcm9tICcuLi9pbmRleCdcblxuZXhwb3J0IGZ1bmN0aW9uIHJlZ2lzdGVyQXBpR2xvYmFsbHkoKSB7XG4gIGdsb2JhbEFwaXMuZm9yRWFjaCgoYXBpKSA9PiB7XG4gICAgLy8gQHRzLWV4cGVjdC1lcnJvciBJIGtub3cgd2hhdCBJIGFtIGRvaW5nIDpQXG4gICAgZ2xvYmFsVGhpc1thcGldID0gaW5kZXhbYXBpXVxuICB9KVxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBRU8sU0FBUyxtQkFBbUIsR0FBRztBQUN0QyxFQUFFLFVBQVUsQ0FBQyxPQUFPLENBQUMsQ0FBQyxHQUFHLEtBQUs7QUFDOUIsSUFBSSxVQUFVLENBQUMsR0FBRyxDQUFDLEdBQUcsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ2pDLEdBQUcsQ0FBQyxDQUFDO0FBQ0w7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2xvYmFscy00ODg1YzMzZi5qcyIsInNvdXJjZXMiOlsiLi4vc3JjL2ludGVncmF0aW9ucy9nbG9iYWxzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGdsb2JhbEFwaXMgfSBmcm9tICcuLi9jb25zdGFudHMnXG5pbXBvcnQgKiBhcyBpbmRleCBmcm9tICcuLi9pbmRleCdcblxuZXhwb3J0IGZ1bmN0aW9uIHJlZ2lzdGVyQXBpR2xvYmFsbHkoKSB7XG4gIGdsb2JhbEFwaXMuZm9yRWFjaCgoYXBpKSA9PiB7XG4gICAgLy8gQHRzLWV4cGVjdC1lcnJvciBJIGtub3cgd2hhdCBJIGFtIGRvaW5nIDpQXG4gICAgZ2xvYmFsVGhpc1thcGldID0gaW5kZXhbYXBpXVxuICB9KVxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBRU8sU0FBUyxtQkFBbUIsR0FBRztBQUN0QyxFQUFFLFVBQVUsQ0FBQyxPQUFPLENBQUMsQ0FBQyxHQUFHLEtBQUs7QUFDOUIsSUFBSSxVQUFVLENBQUMsR0FBRyxDQUFDLEdBQUcsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ2pDLEdBQUcsQ0FBQyxDQUFDO0FBQ0w7OyJ9

package/dist/index-5e0ca99c.js

@@ -0,0 +1,224 @@
+import require$$0 from 'tty';
+import { isPackageExists } from 'local-pkg';
+
+var picocolors = {exports: {}};
+
+let tty = require$$0;
+
+let isColorSupported =
+	!("NO_COLOR" in process.env || process.argv.includes("--no-color")) &&
+	("FORCE_COLOR" in process.env ||
+		process.argv.includes("--color") ||
+		process.platform === "win32" ||
+		(tty.isatty(1) && process.env.TERM !== "dumb") ||
+		"CI" in process.env);
+
+let formatter =
+	(open, close, replace = open) =>
+	input => {
+		let string = "" + input;
+		let index = string.indexOf(close, open.length);
+		return ~index
+			? open + replaceClose(string, close, replace, index) + close
+			: open + string + close
+	};
+
+let replaceClose = (string, close, replace, index) => {
+	let start = string.substring(0, index) + replace;
+	let end = string.substring(index + close.length);
+	let nextIndex = end.indexOf(close);
+	return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end
+};
+
+let createColors = (enabled = isColorSupported) => ({
+	isColorSupported: enabled,
+	reset: enabled ? s => `\x1b[0m${s}\x1b[0m` : String,
+	bold: enabled ? formatter("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m") : String,
+	dim: enabled ? formatter("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m") : String,
+	italic: enabled ? formatter("\x1b[3m", "\x1b[23m") : String,
+	underline: enabled ? formatter("\x1b[4m", "\x1b[24m") : String,
+	inverse: enabled ? formatter("\x1b[7m", "\x1b[27m") : String,
+	hidden: enabled ? formatter("\x1b[8m", "\x1b[28m") : String,
+	strikethrough: enabled ? formatter("\x1b[9m", "\x1b[29m") : String,
+	black: enabled ? formatter("\x1b[30m", "\x1b[39m") : String,
+	red: enabled ? formatter("\x1b[31m", "\x1b[39m") : String,
+	green: enabled ? formatter("\x1b[32m", "\x1b[39m") : String,
+	yellow: enabled ? formatter("\x1b[33m", "\x1b[39m") : String,
+	blue: enabled ? formatter("\x1b[34m", "\x1b[39m") : String,
+	magenta: enabled ? formatter("\x1b[35m", "\x1b[39m") : String,
+	cyan: enabled ? formatter("\x1b[36m", "\x1b[39m") : String,
+	white: enabled ? formatter("\x1b[37m", "\x1b[39m") : String,
+	gray: enabled ? formatter("\x1b[90m", "\x1b[39m") : String,
+	bgBlack: enabled ? formatter("\x1b[40m", "\x1b[49m") : String,
+	bgRed: enabled ? formatter("\x1b[41m", "\x1b[49m") : String,
+	bgGreen: enabled ? formatter("\x1b[42m", "\x1b[49m") : String,
+	bgYellow: enabled ? formatter("\x1b[43m", "\x1b[49m") : String,
+	bgBlue: enabled ? formatter("\x1b[44m", "\x1b[49m") : String,
+	bgMagenta: enabled ? formatter("\x1b[45m", "\x1b[49m") : String,
+	bgCyan: enabled ? formatter("\x1b[46m", "\x1b[49m") : String,
+	bgWhite: enabled ? formatter("\x1b[47m", "\x1b[49m") : String,
+});
+
+picocolors.exports = createColors();
+picocolors.exports.createColors = createColors;
+
+var c = picocolors.exports;
+
+function notNullish(v) {
+  return v != null;
+}
+function slash(str) {
+  return str.replace(/\\/g, "/");
+}
+function mergeSlashes(str) {
+  return str.replace(/\/\//g, "/");
+}
+const noop = () => {
+};
+function toArray(array) {
+  array = array || [];
+  if (Array.isArray(array))
+    return array;
+  return [array];
+}
+const toString = (v) => Object.prototype.toString.call(v);
+const isPlainObject = (val) => toString(val) === "[object Object]";
+function isObject(item) {
+  return item != null && typeof item === "object" && !Array.isArray(item);
+}
+function deepMerge(target, ...sources) {
+  if (!sources.length)
+    return target;
+  const source = sources.shift();
+  if (source === void 0)
+    return target;
+  if (isMergableObject(target) && isMergableObject(source)) {
+    Object.keys(source).forEach((key) => {
+      if (isMergableObject(source[key])) {
+        if (!target[key])
+          target[key] = {};
+        deepMerge(target[key], source[key]);
+      } else {
+        target[key] = source[key];
+      }
+    });
+  }
+  return deepMerge(target, ...sources);
+}
+function isMergableObject(item) {
+  return isPlainObject(item) && !Array.isArray(item);
+}
+function assertTypes(value, name, types) {
+  const receivedType = typeof value;
+  const pass = types.includes(receivedType);
+  if (!pass)
+    throw new TypeError(`${name} value must be ${types.join(" or ")}, received "${receivedType}"`);
+}
+
+function getTests(suite) {
+  return toArray(suite).flatMap((s) => s.type === "test" ? [s] : s.tasks.flatMap((c) => c.type === "test" ? [c] : getTests(c)));
+}
+function getSuites(suite) {
+  return toArray(suite).flatMap((s) => s.type === "suite" ? [s, ...getSuites(s.tasks)] : []);
+}
+function hasTests(suite) {
+  return toArray(suite).some((s) => s.tasks.some((c) => c.type === "test" || hasTests(c)));
+}
+function hasFailed(suite) {
+  return toArray(suite).some((s) => {
+    var _a;
+    return ((_a = s.result) == null ? void 0 : _a.state) === "fail" || s.type === "suite" && hasFailed(s.tasks);
+  });
+}
+function hasFailedSnapshot(suite) {
+  return getTests(suite).some((s) => {
+    var _a, _b;
+    const message = (_b = (_a = s.result) == null ? void 0 : _a.error) == null ? void 0 : _b.message;
+    return message == null ? void 0 : message.match(/Snapshot .* mismatched/);
+  });
+}
+function getNames(task) {
+  const names = [task.name];
+  let current = task;
+  while ((current == null ? void 0 : current.suite) || (current == null ? void 0 : current.file)) {
+    current = current.suite || current.file;
+    if (current == null ? void 0 : current.name)
+      names.unshift(current.name);
+  }
+  return names;
+}
+
+const isWindows = process.platform === "win32";
+function partitionSuiteChildren(suite) {
+  let tasksGroup = [];
+  const tasksGroups = [];
+  for (const c2 of suite.tasks) {
+    if (tasksGroup.length === 0 || c2.concurrent === tasksGroup[0].concurrent) {
+      tasksGroup.push(c2);
+    } else {
+      tasksGroups.push(tasksGroup);
+      tasksGroup = [c2];
+    }
+  }
+  if (tasksGroup.length > 0)
+    tasksGroups.push(tasksGroup);
+  return tasksGroups;
+}
+function getFullName(task) {
+  return getNames(task).join(c.dim(" > "));
+}
+async function ensurePackageInstalled(dependency, promptInstall = !process.env.CI && process.stdout.isTTY) {
+  if (isPackageExists(dependency))
+    return true;
+  process.stderr.write(c.red(`${c.inverse(c.red(" MISSING DEP "))} Can not find dependency '${dependency}'
+
+`));
+  if (!promptInstall)
+    return false;
+  const prompts = await import('./index-fa899e66.js').then(function (n) { return n.i; });
+  const { install } = await prompts.prompt({
+    type: "confirm",
+    name: "install",
+    message: c.reset(`Do you want to install ${c.green(dependency)}?`)
+  });
+  if (install) {
+    await (await import('./index-ce49e384.js')).installPackage(dependency, { dev: true });
+    process.stderr.write(c.yellow(`
+Package ${dependency} installed, re-run the command to start.
+`));
+    process.exit(1);
+    return true;
+  }
+  return false;
+}
+function getCallLastIndex(code) {
+  let charIndex = -1;
+  let inString = null;
+  let startedBracers = 0;
+  let endedBracers = 0;
+  let beforeChar = null;
+  while (charIndex <= code.length) {
+    beforeChar = code[charIndex];
+    charIndex++;
+    const char = code[charIndex];
+    const isCharString = char === '"' || char === "'" || char === "`";
+    if (isCharString && beforeChar !== "\\") {
+      if (inString === char)
+        inString = null;
+      else if (!inString)
+        inString = char;
+    }
+    if (!inString) {
+      if (char === "(")
+        startedBracers++;
+      if (char === ")")
+        endedBracers++;
+    }
+    if (startedBracers && endedBracers && startedBracers === endedBracers)
+      return charIndex;
+  }
+  return null;
+}
+
+export { assertTypes as a, notNullish as b, c, hasFailedSnapshot as d, ensurePackageInstalled as e, getSuites as f, getFullName as g, hasFailed as h, isObject as i, getTests as j, deepMerge as k, getCallLastIndex as l, isWindows as m, noop as n, mergeSlashes as o, getNames as p, partitionSuiteChildren as q, hasTests as r, slash as s, toArray as t };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index-5e0ca99c.js","sources":["../../../node_modules/.pnpm/picocolors@1.0.0/node_modules/picocolors/picocolors.js","../src/utils/base.ts","../src/utils/tasks.ts","../src/utils/index.ts"],"sourcesContent":["let tty = require(\"tty\")\n\nlet isColorSupported =\n\t!(\"NO_COLOR\" in process.env || process.argv.includes(\"--no-color\")) &&\n\t(\"FORCE_COLOR\" in process.env ||\n\t\tprocess.argv.includes(\"--color\") ||\n\t\tprocess.platform === \"win32\" ||\n\t\t(tty.isatty(1) && process.env.TERM !== \"dumb\") ||\n\t\t\"CI\" in process.env)\n\nlet formatter =\n\t(open, close, replace = open) =>\n\tinput => {\n\t\tlet string = \"\" + input\n\t\tlet index = string.indexOf(close, open.length)\n\t\treturn ~index\n\t\t\t? open + replaceClose(string, close, replace, index) + close\n\t\t\t: open + string + close\n\t}\n\nlet replaceClose = (string, close, replace, index) => {\n\tlet start = string.substring(0, index) + replace\n\tlet end = string.substring(index + close.length)\n\tlet nextIndex = end.indexOf(close)\n\treturn ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end\n}\n\nlet createColors = (enabled = isColorSupported) => ({\n\tisColorSupported: enabled,\n\treset: enabled ? s => `\\x1b[0m${s}\\x1b[0m` : String,\n\tbold: enabled ? formatter(\"\\x1b[1m\", \"\\x1b[22m\", \"\\x1b[22m\\x1b[1m\") : String,\n\tdim: enabled ? formatter(\"\\x1b[2m\", \"\\x1b[22m\", \"\\x1b[22m\\x1b[2m\") : String,\n\titalic: enabled ? formatter(\"\\x1b[3m\", \"\\x1b[23m\") : String,\n\tunderline: enabled ? formatter(\"\\x1b[4m\", \"\\x1b[24m\") : String,\n\tinverse: enabled ? formatter(\"\\x1b[7m\", \"\\x1b[27m\") : String,\n\thidden: enabled ? formatter(\"\\x1b[8m\", \"\\x1b[28m\") : String,\n\tstrikethrough: enabled ? formatter(\"\\x1b[9m\", \"\\x1b[29m\") : String,\n\tblack: enabled ? formatter(\"\\x1b[30m\", \"\\x1b[39m\") : String,\n\tred: enabled ? formatter(\"\\x1b[31m\", \"\\x1b[39m\") : String,\n\tgreen: enabled ? formatter(\"\\x1b[32m\", \"\\x1b[39m\") : String,\n\tyellow: enabled ? formatter(\"\\x1b[33m\", \"\\x1b[39m\") : String,\n\tblue: enabled ? formatter(\"\\x1b[34m\", \"\\x1b[39m\") : String,\n\tmagenta: enabled ? formatter(\"\\x1b[35m\", \"\\x1b[39m\") : String,\n\tcyan: enabled ? formatter(\"\\x1b[36m\", \"\\x1b[39m\") : String,\n\twhite: enabled ? formatter(\"\\x1b[37m\", \"\\x1b[39m\") : String,\n\tgray: enabled ? formatter(\"\\x1b[90m\", \"\\x1b[39m\") : String,\n\tbgBlack: enabled ? formatter(\"\\x1b[40m\", \"\\x1b[49m\") : String,\n\tbgRed: enabled ? formatter(\"\\x1b[41m\", \"\\x1b[49m\") : String,\n\tbgGreen: enabled ? formatter(\"\\x1b[42m\", \"\\x1b[49m\") : String,\n\tbgYellow: enabled ? formatter(\"\\x1b[43m\", \"\\x1b[49m\") : String,\n\tbgBlue: enabled ? formatter(\"\\x1b[44m\", \"\\x1b[49m\") : String,\n\tbgMagenta: enabled ? formatter(\"\\x1b[45m\", \"\\x1b[49m\") : String,\n\tbgCyan: enabled ? formatter(\"\\x1b[46m\", \"\\x1b[49m\") : String,\n\tbgWhite: enabled ? formatter(\"\\x1b[47m\", \"\\x1b[49m\") : String,\n})\n\nmodule.exports = createColors()\nmodule.exports.createColors = createColors\n","import type { Arrayable, DeepMerge, Nullable } from '../types'\n\nexport function notNullish<T>(v: T | null | undefined): v is NonNullable<T> {\n  return v != null\n}\n\nexport function slash(str: string) {\n  return str.replace(/\\\\/g, '/')\n}\n\nexport function mergeSlashes(str: string) {\n  return str.replace(/\\/\\//g, '/')\n}\n\nexport const noop = () => { }\n\nexport function clone<T>(val: T): T {\n  let k: any, out: any, tmp: any\n\n  if (Array.isArray(val)) {\n    out = Array(k = val.length)\n    while (k--)\n      // eslint-disable-next-line no-cond-assign\n      out[k] = (tmp = val[k]) && typeof tmp === 'object' ? clone(tmp) : tmp\n    return out as any\n  }\n\n  if (Object.prototype.toString.call(val) === '[object Object]') {\n    out = {} // null\n    for (k in val) {\n      if (k === '__proto__') {\n        Object.defineProperty(out, k, {\n          value: clone((val as any)[k]),\n          configurable: true,\n          enumerable: true,\n          writable: true,\n        })\n      }\n      else {\n        // eslint-disable-next-line no-cond-assign\n        out[k] = (tmp = (val as any)[k]) && typeof tmp === 'object' ? clone(tmp) : tmp\n      }\n    }\n    return out\n  }\n\n  return val\n}\n/**\n * Convert `Arrayable<T>` to `Array<T>`\n *\n * @category Array\n */\n\nexport function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T> {\n  array = array || []\n  if (Array.isArray(array))\n    return array\n  return [array]\n}\n\nexport const toString = (v: any) => Object.prototype.toString.call(v)\nexport const isPlainObject = (val: any): val is object => toString(val) === '[object Object]'\n\nexport function isObject(item: unknown): boolean {\n  return item != null && typeof item === 'object' && !Array.isArray(item)\n}\n\n/**\n * Deep merge :P\n *\n * Will merge objects only if they are plain\n */\nexport function deepMerge<T extends object = object, S extends object = T>(target: T, ...sources: S[]): DeepMerge<T, S> {\n  if (!sources.length)\n    return target as any\n\n  const source = sources.shift()\n  if (source === undefined)\n    return target as any\n\n  if (isMergableObject(target) && isMergableObject(source)) {\n    (Object.keys(source) as (keyof S & keyof T)[]).forEach((key) => {\n      if (isMergableObject(source[key])) {\n        if (!target[key])\n          target[key] = {} as any\n\n        deepMerge(target[key] as any, source[key] as any)\n      }\n      else {\n        target[key] = source[key] as any\n      }\n    })\n  }\n\n  return deepMerge(target, ...sources)\n}\n\nfunction isMergableObject(item: any): item is Object {\n  return isPlainObject(item) && !Array.isArray(item)\n}\n\nexport function assertTypes(value: unknown, name: string, types: string[]): void {\n  const receivedType = typeof value\n  const pass = types.includes(receivedType)\n  if (!pass) throw new TypeError(`${name} value must be ${types.join(' or ')}, received \"${receivedType}\"`)\n}\n","import type { Arrayable, Suite, Task, Test } from '../types'\nimport { toArray } from './base'\n\nexport function getTests(suite: Arrayable<Task>): Test[] {\n  return toArray(suite).flatMap(s => s.type === 'test' ? [s] : s.tasks.flatMap(c => c.type === 'test' ? [c] : getTests(c)))\n}\n\nexport function getTasks(tasks: Arrayable<Task> = []): Task[] {\n  return toArray(tasks).flatMap(s => s.type === 'test' ? [s] : [s, ...getTasks(s.tasks)])\n}\n\nexport function getSuites(suite: Arrayable<Task>): Suite[] {\n  return toArray(suite).flatMap(s => s.type === 'suite' ? [s, ...getSuites(s.tasks)] : [])\n}\n\nexport function hasTests(suite: Arrayable<Suite>): boolean {\n  return toArray(suite).some(s => s.tasks.some(c => c.type === 'test' || hasTests(c as Suite)))\n}\n\nexport function hasFailed(suite: Arrayable<Task>): boolean {\n  return toArray(suite).some(s => s.result?.state === 'fail' || (s.type === 'suite' && hasFailed(s.tasks)))\n}\n\nexport function hasFailedSnapshot(suite: Arrayable<Task>): boolean {\n  return getTests(suite).some((s) => {\n    const message = s.result?.error?.message\n    return message?.match(/Snapshot .* mismatched/)\n  })\n}\n\nexport function getNames(task: Task) {\n  const names = [task.name]\n  let current: Task | undefined = task\n\n  while (current?.suite || current?.file) {\n    current = current.suite || current.file\n    if (current?.name)\n      names.unshift(current.name)\n  }\n\n  return names\n}\n","import c from 'picocolors'\nimport { isPackageExists } from 'local-pkg'\nimport { resolve } from 'pathe'\nimport type { Suite, Task } from '../types'\nimport { getNames } from './tasks'\n\nexport * from './tasks'\nexport * from './path'\nexport * from './base'\n\nexport const isWindows = process.platform === 'win32'\n\n/**\n * Partition in tasks groups by consecutive concurrent\n */\nexport function partitionSuiteChildren(suite: Suite) {\n  let tasksGroup: Task[] = []\n  const tasksGroups: Task[][] = []\n  for (const c of suite.tasks) {\n    if (tasksGroup.length === 0 || c.concurrent === tasksGroup[0].concurrent) {\n      tasksGroup.push(c)\n    }\n    else {\n      tasksGroups.push(tasksGroup)\n      tasksGroup = [c]\n    }\n  }\n  if (tasksGroup.length > 0)\n    tasksGroups.push(tasksGroup)\n\n  return tasksGroups\n}\n\nexport function getFullName(task: Task) {\n  return getNames(task).join(c.dim(' > '))\n}\n\nexport async function ensurePackageInstalled(\n  dependency: string,\n  promptInstall = !process.env.CI && process.stdout.isTTY,\n) {\n  if (isPackageExists(dependency))\n    return true\n\n  process.stderr.write(c.red(`${c.inverse(c.red(' MISSING DEP '))} Can not find dependency '${dependency}'\\n\\n`))\n\n  if (!promptInstall)\n    return false\n\n  const prompts = await import('prompts')\n  const { install } = await prompts.prompt({\n    type: 'confirm',\n    name: 'install',\n    message: c.reset(`Do you want to install ${c.green(dependency)}?`),\n  })\n\n  if (install) {\n    await (await import('@antfu/install-pkg')).installPackage(dependency, { dev: true })\n    // TODO: somehow it fails to load the package after installation, remove this when it's fixed\n    process.stderr.write(c.yellow(`\\nPackage ${dependency} installed, re-run the command to start.\\n`))\n    process.exit(1)\n    return true\n  }\n\n  return false\n}\n\n/**\n * If code starts with a function call, will return its last index, respecting arguments.\n * This will return 25 - last ending character of toMatch \")\"\n * Also works with callbacks\n * ```\n * toMatch({ test: '123' });\n * toBeAliased('123')\n * ```\n */\nexport function getCallLastIndex(code: string) {\n  let charIndex = -1\n  let inString: string | null = null\n  let startedBracers = 0\n  let endedBracers = 0\n  let beforeChar: string | null = null\n  while (charIndex <= code.length) {\n    beforeChar = code[charIndex]\n    charIndex++\n    const char = code[charIndex]\n\n    const isCharString = char === '\"' || char === '\\'' || char === '`'\n\n    if (isCharString && beforeChar !== '\\\\') {\n      if (inString === char)\n        inString = null\n      else if (!inString)\n        inString = char\n    }\n\n    if (!inString) {\n      if (char === '(')\n        startedBracers++\n      if (char === ')')\n        endedBracers++\n    }\n\n    if (startedBracers && endedBracers && startedBracers === endedBracers)\n      return charIndex\n  }\n  return null\n}\n\nexport { resolve as resolvePath }\n"],"names":["picocolorsModule"],"mappings":"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"}

package/dist/index-b99f1c97.js

@@ -0,0 +1,49 @@
+import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, b as getState, s as setState, c as suite, t as test, d as describe, i as it, v as vitest, e as vi } from './vi-b258f071.js';
+import chai, { assert, should } from 'chai';
+import { spies, isMockFunction, spyOn, fn } from './jest-mock.js';
+import { c as configDefaults } from './defaults-ac98ff15.js';
+
+const beforeAll = (fn, timeout) => getCurrentSuite().on("beforeAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+const afterAll = (fn, timeout) => getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+const beforeEach = (fn, timeout) => getCurrentSuite().on("beforeEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+const afterEach = (fn, timeout) => getCurrentSuite().on("afterEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+
+const expect = (value, message) => {
+  const { assertionCalls } = getState();
+  setState({ assertionCalls: assertionCalls + 1 });
+  return chai.expect(value, message);
+};
+expect.getState = getState;
+expect.setState = setState;
+Object.assign(expect, chai.expect);
+
+function defineConfig(config) {
+  return config;
+}
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  defineConfig: defineConfig,
+  suite: suite,
+  test: test,
+  describe: describe,
+  it: it,
+  configDefaults: configDefaults,
+  beforeAll: beforeAll,
+  afterAll: afterAll,
+  beforeEach: beforeEach,
+  afterEach: afterEach,
+  assert: assert,
+  should: should,
+  chai: chai,
+  expect: expect,
+  spies: spies,
+  isMockFunction: isMockFunction,
+  spyOn: spyOn,
+  fn: fn,
+  vitest: vitest,
+  vi: vi
+});
+
+export { afterAll as a, beforeAll as b, beforeEach as c, defineConfig as d, afterEach as e, expect as f, index as i };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index-b99f1c97.js","sources":["../src/runtime/hooks.ts","../src/integrations/chai/index.ts","../src/index.ts"],"sourcesContent":["import type { SuiteHooks } from '../types'\nimport { getDefaultHookTimeout, withTimeout } from './context'\nimport { getCurrentSuite } from './suite'\n\n// suite hooks\nexport const beforeAll = (fn: SuiteHooks['beforeAll'][0], timeout?: number) => getCurrentSuite().on('beforeAll', withTimeout(fn, timeout ?? getDefaultHookTimeout()))\nexport const afterAll = (fn: SuiteHooks['afterAll'][0], timeout?: number) => getCurrentSuite().on('afterAll', withTimeout(fn, timeout ?? getDefaultHookTimeout()))\nexport const beforeEach = (fn: SuiteHooks['beforeEach'][0], timeout?: number) => getCurrentSuite().on('beforeEach', withTimeout(fn, timeout ?? getDefaultHookTimeout()))\nexport const afterEach = (fn: SuiteHooks['afterEach'][0], timeout?: number) => getCurrentSuite().on('afterEach', withTimeout(fn, timeout ?? getDefaultHookTimeout()))\n","import chai from 'chai'\nimport { getState, setState } from './jest-expect'\n\nexport { assert, should } from 'chai'\n\nconst expect = ((value: any, message?: string): Vi.Assertion => {\n  const { assertionCalls } = getState()\n  setState({ assertionCalls: assertionCalls + 1 })\n  return chai.expect(value, message) as unknown as Vi.Assertion\n}) as Vi.ExpectStatic\nexpect.getState = getState\nexpect.setState = setState\n\nObject.assign(expect, chai.expect)\n\nexport { chai, expect }\n","import type { UserConfig } from 'vite'\nimport type { Plugin as PrettyFormatPlugin } from 'pretty-format'\nimport type { Any, Anything } from './integrations/chai/jest-asymmetric-matchers'\nimport type { MatcherState, MatchersObject } from './integrations/chai/types'\nimport type { Constructable, InlineConfig } from './types'\n\nexport { suite, test, describe, it } from './runtime/suite'\n\nexport * from './runtime/hooks'\nexport * from './integrations/chai'\nexport * from './integrations/jest-mock'\nexport * from './integrations/vi'\n\nexport * from './types'\nexport * from './api/types'\n\nexport { configDefaults } from './defaults'\n\ntype VitestInlineConfig = InlineConfig\n\ndeclare module 'vite' {\n  interface UserConfig {\n    /**\n     * Options for Vitest\n     */\n    test?: VitestInlineConfig\n  }\n}\n\nexport function defineConfig(config: UserConfig) {\n  return config\n}\n\ninterface AsymmetricMatchersContaining {\n  stringContaining(expected: string): any\n  objectContaining(expected: any): any\n  arrayContaining(expected: unknown[]): any\n  stringMatching(expected: string | RegExp): any\n}\n\ntype Promisify<O> = {\n  [K in keyof O]: O[K] extends (...args: infer A) => infer R\n    ? O extends R\n      ? Promisify<O[K]>\n      : (...args: A) => Promise<R>\n    : O[K]\n}\n\ndeclare global {\n  // support augmenting jest.Matchers by other libraries\n  namespace jest {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    interface Matchers<R, T = {}> {}\n  }\n\n  namespace Vi {\n    interface ExpectStatic extends Chai.ExpectStatic, AsymmetricMatchersContaining {\n      <T>(actual: T, message?: string): Vi.Assertion<T>\n\n      extend(expects: MatchersObject): void\n      assertions(expected: number): void\n      hasAssertions(): void\n      anything(): Anything\n      any(constructor: unknown): Any\n      addSnapshotSerializer(plugin: PrettyFormatPlugin): void\n      getState(): MatcherState\n      setState(state: Partial<MatcherState>): void\n      not: AsymmetricMatchersContaining\n    }\n\n    interface JestAssertion<T = any> extends jest.Matchers<void, T> {\n      // Snapshot\n      toMatchSnapshot<U extends { [P in keyof T]: any }>(snapshot: Partial<U>, message?: string): void\n      toMatchSnapshot(message?: string): void\n      matchSnapshot<U extends { [P in keyof T]: any }>(snapshot: Partial<U>, message?: string): void\n      matchSnapshot(message?: string): void\n      toMatchInlineSnapshot<U extends { [P in keyof T]: any }>(properties: Partial<U>, snapshot?: string, message?: string): void\n      toMatchInlineSnapshot(snapshot?: string, message?: string): void\n      toThrowErrorMatchingSnapshot(message?: string): void\n      toThrowErrorMatchingInlineSnapshot(snapshot?: string, message?: string): void\n\n      // Jest compact\n      toEqual<E>(expected: E): void\n      toStrictEqual<E>(expected: E): void\n      toBe<E>(expected: E): void\n      toMatch(expected: string | RegExp): void\n      toMatchObject<E extends {} | any[]>(expected: E): void\n      toContain<E>(item: E): void\n      toContainEqual<E>(item: E): void\n      toBeTruthy(): void\n      toBeFalsy(): void\n      toBeGreaterThan(num: number | bigint): void\n      toBeGreaterThanOrEqual(num: number | bigint): void\n      toBeLessThan(num: number | bigint): void\n      toBeLessThanOrEqual(num: number | bigint): void\n      toBeNaN(): void\n      toBeUndefined(): void\n      toBeNull(): void\n      toBeDefined(): void\n      toBeInstanceOf<E>(expected: E): void\n      toBeCalledTimes(times: number): void\n      toHaveLength(length: number): void\n      toHaveProperty<E>(property: string, value?: E): void\n      toBeCloseTo(number: number, numDigits?: number): void\n      toHaveBeenCalledTimes(times: number): void\n      toHaveBeenCalledOnce(): void\n      toHaveBeenCalled(): void\n      toBeCalled(): void\n      toHaveBeenCalledWith<E extends any[]>(...args: E): void\n      toBeCalledWith<E extends any[]>(...args: E): void\n      toHaveBeenNthCalledWith<E extends any[]>(n: number, ...args: E): void\n      nthCalledWith<E extends any[]>(nthCall: number, ...args: E): void\n      toHaveBeenLastCalledWith<E extends any[]>(...args: E): void\n      lastCalledWith<E extends any[]>(...args: E): void\n      toThrow(expected?: string | Constructable | RegExp | Error): void\n      toThrowError(expected?: string | Constructable | RegExp | Error): void\n      toReturn(): void\n      toHaveReturned(): void\n      toReturnTimes(times: number): void\n      toHaveReturnedTimes(times: number): void\n      toReturnWith<E>(value: E): void\n      toHaveReturnedWith<E>(value: E): void\n      toHaveLastReturnedWith<E>(value: E): void\n      lastReturnedWith<E>(value: E): void\n      toHaveNthReturnedWith<E>(nthCall: number, value: E): void\n      nthReturnedWith<E>(nthCall: number, value: E): void\n    }\n\n    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error\n    // @ts-ignore build namspace conflict\n    type VitestAssertion<A, T> = {\n      [K in keyof A]: A[K] extends Chai.Assertion\n        ? Assertion<T>\n        : A[K] extends (...args: any[]) => any\n          ? A[K] // not converting function since they may contain overload\n          : VitestAssertion<A[K], T>\n    } & ((type: string, message?: string) => Assertion)\n\n    interface Assertion<T = any> extends VitestAssertion<Chai.Assertion, T>, JestAssertion<T> {\n      resolves: Promisify<Assertion<T>>\n      rejects: Promisify<Assertion<T>>\n    }\n  }\n}\n"],"names":[],"mappings":";;;;;AAEY,MAAC,SAAS,GAAG,CAAC,EAAE,EAAE,OAAO,KAAK,eAAe,EAAE,CAAC,EAAE,CAAC,WAAW,EAAE,WAAW,CAAC,EAAE,EAAE,OAAO,IAAI,qBAAqB,EAAE,CAAC,EAAE;AACrH,MAAC,QAAQ,GAAG,CAAC,EAAE,EAAE,OAAO,KAAK,eAAe,EAAE,CAAC,EAAE,CAAC,UAAU,EAAE,WAAW,CAAC,EAAE,EAAE,OAAO,IAAI,qBAAqB,EAAE,CAAC,EAAE;AACnH,MAAC,UAAU,GAAG,CAAC,EAAE,EAAE,OAAO,KAAK,eAAe,EAAE,CAAC,EAAE,CAAC,YAAY,EAAE,WAAW,CAAC,EAAE,EAAE,OAAO,IAAI,qBAAqB,EAAE,CAAC,EAAE;AACvH,MAAC,SAAS,GAAG,CAAC,EAAE,EAAE,OAAO,KAAK,eAAe,EAAE,CAAC,EAAE,CAAC,WAAW,EAAE,WAAW,CAAC,EAAE,EAAE,OAAO,IAAI,qBAAqB,EAAE,CAAC;;ACF1H,MAAC,MAAM,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK;AACnC,EAAE,MAAM,EAAE,cAAc,EAAE,GAAG,QAAQ,EAAE,CAAC;AACxC,EAAE,QAAQ,CAAC,EAAE,cAAc,EAAE,cAAc,GAAG,CAAC,EAAE,CAAC,CAAC;AACnD,EAAE,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AACrC,EAAE;AACF,MAAM,CAAC,QAAQ,GAAG,QAAQ,CAAC;AAC3B,MAAM,CAAC,QAAQ,GAAG,QAAQ,CAAC;AAC3B,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC;;ACF3B,SAAS,YAAY,CAAC,MAAM,EAAE;AACrC,EAAE,OAAO,MAAM,CAAC;AAChB;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ViteDevServer, TransformResult, CommonServerOptions } from 'vite';
+import { ViteDevServer, TransformResult, CommonServerOptions, UserConfig as UserConfig$1 } from 'vite';
 import { MessagePort } from 'worker_threads';
 import { SpyImpl } from 'tinyspy';
 export { assert, default as chai, should } from 'chai';
@@ -370,7 +370,7 @@ declare class Vitest {
     private handleFileChanged;
     close(): Promise<void>;
     exit(force?: boolean): Promise<void>;
-    report<T extends keyof Reporter>(name: T, ...args: ArgumentsType<Reporter[T]>): Promise<void>;
+    report<T extends keyof Reporter>(name: T, ...args: ArgumentsType$1<Reporter[T]>): Promise<void>;
     globTestFiles(filters?: string[]): Promise<string[]>;
     isTargetFile(id: string): boolean;
     onServerRestarted(fn: () => void): void;
@@ -486,7 +486,7 @@ declare type BuiltinReporters = keyof typeof ReportersMap;
 declare type Awaitable<T> = T | PromiseLike<T>;
 declare type Nullable<T> = T | null | undefined;
 declare type Arrayable<T> = T | Array<T>;
-declare type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
+declare type ArgumentsType$1<T> = T extends (...args: infer U) => any ? U : never;
 declare type MergeInsertions<T> = T extends object ? {
     [K in keyof T]: MergeInsertions<T[K]>;
 } : T;
@@ -499,7 +499,7 @@ declare type MutableArray<T extends readonly any[]> = {
 interface Constructable {
     new (...args: any[]): any;
 }
-interface ModuleCache {
+interface ModuleCache$1 {
     promise?: Promise<any>;
     exports?: any;
     code?: string;
@@ -1101,6 +1101,11 @@ interface FetchResult {
     map?: RawSourceMap;
 }
 declare type FetchFunction = (id: string) => Promise<FetchResult>;
+interface ModuleCache {
+    promise?: Promise<any>;
+    exports?: any;
+    code?: string;
+}
 interface ViteNodeResolveId {
     external?: boolean | 'absolute' | 'relative';
     id: string;
@@ -1109,6 +1114,22 @@ interface ViteNodeResolveId {
     syntheticNamedExports?: boolean | string | null;
 }
 
+declare type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
+declare type ReturnType$1<T> = T extends (...args: any) => infer R ? R : never;
+declare type BirpcFn<T> = {
+    /**
+     * Call the remote function and wait for the result.
+     */
+    (...args: ArgumentsType<T>): Promise<Awaited<ReturnType$1<T>>>;
+    /**
+     * Send event without asking for response
+     */
+    asEvent(...args: ArgumentsType<T>): void;
+};
+declare type BirpcReturn<RemoteFunctions> = {
+    [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
+};
+
 interface WorkerContext {
     port: MessagePort;
     config: ResolvedConfig;
@@ -1127,6 +1148,14 @@ interface WorkerRPC {
     onTaskUpdate: (pack: TaskResultPack[]) => void;
     snapshotSaved: (snapshot: SnapshotResult) => void;
 }
+interface WorkerGlobalState {
+    ctx: WorkerContext;
+    config: ResolvedConfig;
+    rpc: BirpcReturn<WorkerRPC>;
+    current?: Test;
+    filepath?: string;
+    moduleCache: Map<string, ModuleCache>;
+}
 
 declare const suite: SuiteAPI;
 declare const test: TestAPI;
@@ -1333,6 +1362,7 @@ declare module 'vite' {
         test?: VitestInlineConfig;
     }
 }
+declare function defineConfig(config: UserConfig$1): UserConfig$1;
 interface AsymmetricMatchersContaining {
     stringContaining(expected: string): any;
     objectContaining(expected: any): any;
@@ -1384,10 +1414,10 @@ declare global {
             toContainEqual<E>(item: E): void;
             toBeTruthy(): void;
             toBeFalsy(): void;
-            toBeGreaterThan(num: number): void;
-            toBeGreaterThanOrEqual(num: number): void;
-            toBeLessThan(num: number): void;
-            toBeLessThanOrEqual(num: number): void;
+            toBeGreaterThan(num: number | bigint): void;
+            toBeGreaterThanOrEqual(num: number | bigint): void;
+            toBeLessThan(num: number | bigint): void;
+            toBeLessThanOrEqual(num: number | bigint): void;
             toBeNaN(): void;
             toBeUndefined(): void;
             toBeNull(): void;
@@ -1430,4 +1460,4 @@ declare global {
     }
 }
 
-export { ApiConfig, ArgumentsType, Arrayable, Awaitable, BuiltinEnvironment, C8Options, Constructable, CoverageReporter, DeepMerge, DoneCallback, EachFunction, EnhancedSpy, Environment, EnvironmentOptions, EnvironmentReturn, ErrorWithDiff, File, HookListener, InlineConfig, JSDOMOptions, JestMockCompatContext, MaybeMocked, MaybeMockedConstructor, MaybeMockedDeep, MergeInsertions, MockWithArgs, MockedFunction, MockedFunctionDeep, MockedObject, MockedObjectDeep, ModuleCache, ModuleGraphData, MutableArray, Nullable, ParsedStack, Position, Reporter, ResolveIdFunction, ResolvedC8Options, ResolvedConfig, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, SpyInstance, SpyInstanceFn, Suite, SuiteAPI, SuiteCollector, SuiteFactory, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestAPI, TestFunction, TransformResultWithSource, UncheckedSnapshot, UserConfig, UserConsoleLog, WebSocketEvents, WebSocketHandlers, WorkerContext, WorkerRPC, afterAll, afterEach, beforeAll, beforeEach, configDefaults, describe, expect, fn, isMockFunction, it, spies, spyOn, suite, test, vi, vitest };
+export { ApiConfig, ArgumentsType$1 as ArgumentsType, Arrayable, Awaitable, BuiltinEnvironment, C8Options, Constructable, CoverageReporter, DeepMerge, DoneCallback, EachFunction, EnhancedSpy, Environment, EnvironmentOptions, EnvironmentReturn, ErrorWithDiff, File, HookListener, InlineConfig, JSDOMOptions, JestMockCompatContext, MaybeMocked, MaybeMockedConstructor, MaybeMockedDeep, MergeInsertions, MockWithArgs, MockedFunction, MockedFunctionDeep, MockedObject, MockedObjectDeep, ModuleCache$1 as ModuleCache, ModuleGraphData, MutableArray, Nullable, ParsedStack, Position, Reporter, ResolveIdFunction, ResolvedC8Options, ResolvedConfig, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, SpyInstance, SpyInstanceFn, Suite, SuiteAPI, SuiteCollector, SuiteFactory, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestAPI, TestFunction, TransformResultWithSource, UncheckedSnapshot, UserConfig, UserConsoleLog, WebSocketEvents, WebSocketHandlers, WorkerContext, WorkerGlobalState, WorkerRPC, afterAll, afterEach, beforeAll, beforeEach, configDefaults, defineConfig, describe, expect, fn, isMockFunction, it, spies, spyOn, suite, test, vi, vitest };

package/dist/index.js

@@ -1,13 +1,13 @@
-export { d as describe, i as it, c as suite, t as test, e as vi, v as vitest } from './vi-14b6cd9b.js';
-export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, e as expect } from './index-c9e80681.js';
+export { d as describe, i as it, c as suite, t as test, e as vi, v as vitest } from './vi-b258f071.js';
+export { a as afterAll, e as afterEach, b as beforeAll, c as beforeEach, d as defineConfig, f as expect } from './index-b99f1c97.js';
 export { fn, isMockFunction, spies, spyOn } from './jest-mock.js';
 export { c as configDefaults } from './defaults-ac98ff15.js';
 export { assert, default as chai, should } from 'chai';
 import 'util';
-import './index-61b7ead7.js';
+import './index-5e0ca99c.js';
 import 'tty';
 import 'local-pkg';
-import './source-map-c0dbec82.js';
+import './source-map-1b1fae71.js';
 import './_commonjsHelpers-c9e3b764.js';
 import 'tinyspy';
 //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OzsifQ==

package/dist/node.js

@@ -1,4 +1,4 @@
-export { V as VitestPlugin, c as createVitest } from './create-03db0821.js';
+export { V as VitestPlugin, c as createVitest } from './create-c989e565.js';
 import './index-373b5ce3.js';
 import 'path';
 import 'vite';
@@ -10,7 +10,7 @@ import 'os';
 import 'util';
 import 'stream';
 import 'events';
-import './index-61b7ead7.js';
+import './index-5e0ca99c.js';
 import 'tty';
 import 'local-pkg';
 import './client-d27bd0a9.js';
@@ -19,8 +19,8 @@ import 'assert';
 import 'vm';
 import './defaults-ac98ff15.js';
 import 'perf_hooks';
-import './diff-21debc94.js';
-import './source-map-c0dbec82.js';
+import './diff-00c7fe6a.js';
+import './source-map-1b1fae71.js';
 import './index-648e7ab2.js';
 import './_commonjsHelpers-c9e3b764.js';
 import 'worker_threads';

package/dist/rpc-377d999b.js

@@ -0,0 +1,6 @@
+const rpc = () => {
+  return __vitest_worker__.rpc;
+};
+
+export { rpc as r };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnBjLTM3N2Q5OTliLmpzIiwic291cmNlcyI6WyIuLi9zcmMvcnVudGltZS9ycGMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IHJwYyA9ICgpID0+IHtcbiAgcmV0dXJuIF9fdml0ZXN0X3dvcmtlcl9fIS5ycGNcbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBWSxNQUFDLEdBQUcsR0FBRyxNQUFNO0FBQ3pCLEVBQUUsT0FBTyxpQkFBaUIsQ0FBQyxHQUFHLENBQUM7QUFDL0I7OyJ9