vitest 3.1.0-beta.2 → 3.1.1

package/LICENSE.md

@@ -681,6 +681,35 @@ Repository: terkelg/prompts
 
 ---------------------------------------
 
+## quansync
+License: MIT
+By: Anthony Fu, 三咲智子 Kevin Deng
+Repository: git+https://github.com/quansync-dev/quansync.git
+
+> MIT License
+>
+> Copyright (c) 2025-PRESENT Anthony Fu <https://github.com/antfu> and Kevin Deng <https://github.com/sxzz>
+>
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+---------------------------------------
+
 ## resolve-pkg-maps
 License: MIT
 By: Hiroki Osame

package/dist/chunks/{base.CylSMlTD.js → base.bV8rwssx.js}

@@ -1,5 +1,5 @@
 import { ModuleCacheMap } from 'vite-node/client';
-import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.DZKwfrTs.js';
+import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.CwmnH2oH.js';
 import { p as provideWorkerState } from './utils.CtocqOoE.js';
 
 let _viteNode;

package/dist/chunks/{cac.JtTXbKz0.js → cac.DK21mt6F.js}

@@ -618,7 +618,7 @@ class CAC extends EventEmitter {
 
 const cac = (name = "") => new CAC(name);
 
-var version = "3.1.0-beta.2";
+var version = "3.1.1";
 
 const apiConfig = (port) => ({
 	port: {
@@ -1203,6 +1203,10 @@ const cliOptionsConfig = {
 		alias: "no-color"
 	},
 	clearScreen: { description: "Clear terminal screen when re-running tests during watch mode (default: `true`)" },
+	configLoader: {
+		description: "Use `bundle` to bundle the config with esbuild or `runner` (experimental) to process it on the fly. This is only available in vite version 6.1.0 and above. (default: `bundle`)",
+		argument: "<loader>"
+	},
 	standalone: { description: "Start Vitest without running tests. File filters will be ignored, tests will be running only on change (default: `false`)" },
 	mergeReports: {
 		description: "Path to a blob reports directory. If this options is used, Vitest won't run any tests, it will only report previously recorded tests",
@@ -1460,13 +1464,13 @@ async function start(mode, cliFilters, options) {
 		process.title = "node (vitest)";
 	} catch {}
 	try {
-		const { startVitest } = await import('./cli-api.BTtPTYMs.js').then(function (n) { return n.f; });
+		const { startVitest } = await import('./cli-api.bwYuoT4p.js').then(function (n) { return n.f; });
 		const ctx = await startVitest(mode, cliFilters.map(normalize), normalizeCliOptions(cliFilters, options));
 		if (!ctx.shouldKeepServer()) {
 			await ctx.exit();
 		}
 	} catch (e) {
-		const { divider } = await import('./utils.OLmtDstN.js').then(function (n) { return n.u; });
+		const { divider } = await import('./utils.Lot3J_8U.js').then(function (n) { return n.u; });
 		console.error(`\n${c.red(divider(c.bold(c.inverse(" Startup Error "))))}`);
 		console.error(e);
 		console.error("\n\n");
@@ -1481,7 +1485,7 @@ async function init(project) {
 		console.error(new Error("Only the \"browser\" project is supported. Use \"vitest init browser\" to create a new project."));
 		process.exit(1);
 	}
-	const { create } = await import('./creator.BEXek7yQ.js');
+	const { create } = await import('./creator.CuL7xDWI.js');
 	await create();
 }
 async function collect(mode, cliFilters, options) {
@@ -1489,7 +1493,7 @@ async function collect(mode, cliFilters, options) {
 		process.title = "node (vitest)";
 	} catch {}
 	try {
-		const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.BTtPTYMs.js').then(function (n) { return n.f; });
+		const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.bwYuoT4p.js').then(function (n) { return n.f; });
 		const ctx = await prepareVitest(mode, {
 			...normalizeCliOptions(cliFilters, options),
 			watch: false,
@@ -1511,7 +1515,7 @@ async function collect(mode, cliFilters, options) {
 		}
 		await ctx.close();
 	} catch (e) {
-		const { divider } = await import('./utils.OLmtDstN.js').then(function (n) { return n.u; });
+		const { divider } = await import('./utils.Lot3J_8U.js').then(function (n) { return n.u; });
 		console.error(`\n${c.red(divider(c.bold(c.inverse(" Collect Error "))))}`);
 		console.error(e);
 		console.error("\n\n");

package/dist/chunks/{cli-api.BTtPTYMs.js → cli-api.bwYuoT4p.js}

@@ -11,9 +11,9 @@ import { generateFileHash, createFileTask, limitConcurrency, hasFailed, getTasks
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { ViteNodeRunner } from 'vite-node/client';
 import { ViteNodeServer } from 'vite-node/server';
-import { v as version$1 } from './cac.JtTXbKz0.js';
+import { v as version$1 } from './cac.DK21mt6F.js';
 import { c as createBirpc } from './index.68735LiX.js';
-import { p as parse, s as stringify, g as printError, h as generateCodeFrame, b as BenchmarkReportsMap, R as ReportersMap, i as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.ZIOEXBQB.js';
+import { p as parse, s as stringify, g as printError, h as generateCodeFrame, b as BenchmarkReportsMap, R as ReportersMap, i as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.CwHmn5H5.js';
 import require$$0$3 from 'events';
 import require$$1$1 from 'https';
 import require$$2 from 'http';
@@ -28,11 +28,11 @@ import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
 import { parseErrorStacktrace } from '@vitest/utils/source-map';
 import crypto from 'node:crypto';
 import { distDir, rootDir } from '../path.js';
-import { R as RandomSequencer, i as isPackageExists, h as hash, V as VitestCache, g as getFilePoolName, d as isBrowserEnabled, m as mm, r as resolveConfig, e as groupBy, f as getCoverageProvider, j as createPool, w as wildcardPatternToRegExp, a as resolveApiServerConfig, s as stdout } from './coverage.C2ohxaN0.js';
-import { c as convertTasksToEvents } from './typechecker.C2IpOhid.js';
+import { R as RandomSequencer, i as isPackageExists, h as hash, V as VitestCache, g as getFilePoolName, d as isBrowserEnabled, m as mm, r as resolveConfig, e as groupBy, f as getCoverageProvider, j as createPool, w as wildcardPatternToRegExp, a as resolveApiServerConfig, s as stdout } from './coverage.SfnlalVs.js';
+import { c as convertTasksToEvents } from './typechecker.CG0zmr19.js';
 import { Console } from 'node:console';
 import c from 'tinyrainbow';
-import { a as formatProjectName, w as withLabel, d as divider } from './utils.OLmtDstN.js';
+import { c as formatProjectName, w as withLabel, d as divider } from './utils.Lot3J_8U.js';
 import { createRequire } from 'node:module';
 import url from 'node:url';
 import { i as isTTY, a as isWindows } from './env.Dq0hM4Xv.js';
@@ -9755,7 +9755,7 @@ function NormalizeURLPlugin() {
 				return;
 			}
 			const cleanString = stripLiteral(code);
-			const assetImportMetaUrlRE = /\bnew\s+URL\s*\(\s*(?:'[^']+'|"[^"]+"|`[^`]+`)\s*,\s*import\.meta\.url\s*(?:,\s*)?\)/g;
+			const assetImportMetaUrlRE = /\bnew\s+URL\s*\(\s*(?:'[^']+'|"[^"]+"|`[^`]+`)\s*,\s*(?:'' \+ )?import\.meta\.url\s*(?:,\s*)?\)/g;
 			let updatedCode = code;
 			let match;
 			while (match = assetImportMetaUrlRE.exec(cleanString)) {
@@ -10464,6 +10464,7 @@ class TestProject {
 		return testFiles;
 	}
 	_parentBrowser;
+	/** @internal */
 	_parent;
 	/** @internal */
 	_initParentBrowser = deduped(async () => {
@@ -10473,7 +10474,7 @@ class TestProject {
 		await this.vitest.packageInstaller.ensureInstalled("@vitest/browser", this.config.root, this.vitest.version);
 		const { createBrowserServer, distRoot } = await import('@vitest/browser');
 		const browser = await createBrowserServer(this, this.vite.config.configFile, [...MocksPlugins({ filter(id) {
-			if (id.includes(distRoot)) {
+			if (id.includes(distRoot) || id.includes(browser.vite.config.cacheDir)) {
 				return false;
 			}
 			return true;
@@ -10621,6 +10622,7 @@ async function initializeProject(workspacePath, ctx, options) {
 	const config = {
 		...restOptions,
 		configFile,
+		configLoader: ctx.vite.config.inlineConfig.configLoader,
 		mode: options.test?.mode || options.mode || ctx.config.mode,
 		plugins: [...options.plugins || [], WorkspaceVitestPlugin(project, {
 			...options,
@@ -10885,6 +10887,12 @@ class ReportedTaskImplementation {
 		return !result || result.state !== "fail";
 	}
 	/**
+	* Custom metadata that was attached to the test during its execution.
+	*/
+	meta() {
+		return this.task.meta;
+	}
+	/**
 	* Creates a new reported task instance and stores it in the project's state for future use.
 	* @internal
 	*/
@@ -10982,12 +10990,6 @@ class TestCase extends ReportedTaskImplementation {
 		};
 	}
 	/**
-	* Custom metadata that was attached to the test during its execution.
-	*/
-	meta() {
-		return this.task.meta;
-	}
-	/**
 	* Useful information about the test like duration, memory usage, etc.
 	* Diagnostic is only available after the test has finished.
 	*/
@@ -11201,12 +11203,14 @@ class TestModule extends SuiteImplementation {
 		const prepareDuration = this.task.prepareDuration || 0;
 		const environmentSetupDuration = this.task.environmentLoad || 0;
 		const duration = this.task.result?.duration || 0;
+		const heap = this.task.result?.heap;
 		return {
 			environmentSetupDuration,
 			prepareDuration,
 			collectDuration,
 			setupDuration,
-			duration
+			duration,
+			heap
 		};
 	}
 }
@@ -11478,14 +11482,6 @@ class TestRun {
 			assert$1(entity.type === "suite" || entity.type === "module", "Entity type must be suite or module");
 			if (entity.state() === "skipped") {
 				await this.reportChildren(entity.children);
-			} else {
-				for (const test of entity.children.tests("skipped")) {
-					if (test.task.result?.pending) {
-						continue;
-					}
-					await this.vitest.report("onTestCaseReady", test);
-					await this.vitest.report("onTestCaseResult", test);
-				}
 			}
 			if (entity.type === "module") {
 				await this.vitest.report("onTestModuleEnd", entity);
@@ -12336,20 +12332,7 @@ class Vitest {
 		await this.report("onSpecsCollected", specifications.map((spec) => spec.toJSON()));
 		await this._testRun.start(specifications).catch(noop);
 		for (const file of files) {
-			const project = this.getProjectByName(file.projectName || "");
-			await this._testRun.enqueued(project, file).catch(noop);
-			await this._testRun.collected(project, [file]).catch(noop);
-			const logs = [];
-			const { packs, events } = convertTasksToEvents(file, (task) => {
-				if (task.logs) {
-					logs.push(...task.logs);
-				}
-			});
-			logs.sort((log1, log2) => log1.time - log2.time);
-			for (const log of logs) {
-				await this._testRun.log(log).catch(noop);
-			}
-			await this._testRun.updated(packs, events).catch(noop);
+			await this._reportFileTask(file);
 		}
 		if (hasFailed(files)) {
 			process.exitCode = 1;
@@ -12363,6 +12346,23 @@ class Vitest {
 			unhandledErrors: this.state.getUnhandledErrors()
 		};
 	}
+	/** @internal */
+	async _reportFileTask(file) {
+		const project = this.getProjectByName(file.projectName || "");
+		await this._testRun.enqueued(project, file).catch(noop);
+		await this._testRun.collected(project, [file]).catch(noop);
+		const logs = [];
+		const { packs, events } = convertTasksToEvents(file, (task) => {
+			if (task.logs) {
+				logs.push(...task.logs);
+			}
+		});
+		logs.sort((log1, log2) => log1.time - log2.time);
+		for (const log of logs) {
+			await this._testRun.log(log).catch(noop);
+		}
+		await this._testRun.updated(packs, events).catch(noop);
+	}
 	async collect(filters) {
 		const files = await this.specifications.getRelevantTestSpecifications(filters);
 		if (!files.length) {
@@ -12621,7 +12621,8 @@ class Vitest {
 		if (!task) {
 			throw new Error(`Task ${id} was not found`);
 		}
-		await this.changeNamePattern(task.name, [task.file.filepath], "tasks" in task ? "rerun suite" : "rerun test");
+		const taskNamePattern = task.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		await this.changeNamePattern(taskNamePattern, [task.file.filepath], "tasks" in task ? "rerun suite" : "rerun test");
 	}
 	/** @internal */
 	async changeProjectName(pattern) {
@@ -13122,6 +13123,7 @@ async function createVitest(mode, options, viteOverrides = {}, vitestOptions = {
 	options.config = configPath;
 	const config = {
 		configFile: configPath,
+		configLoader: options.configLoader,
 		mode: options.mode || mode,
 		plugins: await VitestPlugin(options, ctx)
 	};

package/dist/chunks/{coverage.C2ohxaN0.js → coverage.SfnlalVs.js}

@@ -2,15 +2,15 @@ import fs, { statSync, realpathSync, promises as promises$1, mkdirSync, existsSy
 import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
 import require$$0 from 'util';
 import require$$0$1 from 'path';
-import { relative, resolve, dirname, isAbsolute, join, normalize } from 'pathe';
+import { relative, resolve, dirname, isAbsolute, join as join$1, normalize } from 'pathe';
 import c from 'tinyrainbow';
 import { c as configDefaults, e as benchmarkConfigDefaults, a as coverageConfigDefaults } from './defaults.DmfNPoe5.js';
 import crypto from 'node:crypto';
 import { slash, createDefer, shuffle, toArray } from '@vitest/utils';
-import { writeFile, rename, stat, unlink } from 'node:fs/promises';
 import { builtinModules, createRequire } from 'node:module';
-import p, { win32, resolve as resolve$1 } from 'node:path';
+import p, { win32, dirname as dirname$1, join, resolve as resolve$1 } from 'node:path';
 import process$1 from 'node:process';
+import fsPromises, { writeFile, rename, stat, unlink } from 'node:fs/promises';
 import { fileURLToPath as fileURLToPath$1, pathToFileURL as pathToFileURL$1, URL as URL$1 } from 'node:url';
 import assert from 'node:assert';
 import v8 from 'node:v8';
@@ -24,7 +24,7 @@ import { version } from 'vite';
 import EventEmitter from 'node:events';
 import { c as createBirpc } from './index.68735LiX.js';
 import Tinypool$1, { Tinypool } from 'tinypool';
-import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.C2IpOhid.js';
+import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.CG0zmr19.js';
 import { MessageChannel } from 'node:worker_threads';
 import { hasFailed } from '@vitest/runner/utils';
 import { rootDir } from '../path.js';
@@ -2257,6 +2257,156 @@ function resolvePathSync(id, options) {
   return fileURLToPath(resolveSync(id, options));
 }
 
+const GET_IS_ASYNC = Symbol.for("quansync.getIsAsync");
+class QuansyncError extends Error {
+  constructor(message = "Unexpected promise in sync context") {
+    super(message);
+    this.name = "QuansyncError";
+  }
+}
+function isThenable(value) {
+  return value && typeof value === "object" && typeof value.then === "function";
+}
+function isQuansyncGenerator(value) {
+  return value && typeof value === "object" && typeof value[Symbol.iterator] === "function" && "__quansync" in value;
+}
+function fromObject(options) {
+  const generator = function* (...args) {
+    const isAsync = yield GET_IS_ASYNC;
+    if (isAsync)
+      return yield options.async.apply(this, args);
+    return options.sync.apply(this, args);
+  };
+  function fn(...args) {
+    const iter = generator.apply(this, args);
+    iter.then = (...thenArgs) => options.async.apply(this, args).then(...thenArgs);
+    iter.__quansync = true;
+    return iter;
+  }
+  fn.sync = options.sync;
+  fn.async = options.async;
+  return fn;
+}
+function fromPromise(promise) {
+  return fromObject({
+    async: () => Promise.resolve(promise),
+    sync: () => {
+      if (isThenable(promise))
+        throw new QuansyncError();
+      return promise;
+    }
+  });
+}
+function unwrapYield(value, isAsync) {
+  if (value === GET_IS_ASYNC)
+    return isAsync;
+  if (isQuansyncGenerator(value))
+    return isAsync ? iterateAsync(value) : iterateSync(value);
+  if (!isAsync && isThenable(value))
+    throw new QuansyncError();
+  return value;
+}
+function iterateSync(generator) {
+  let current = generator.next();
+  while (!current.done) {
+    try {
+      current = generator.next(unwrapYield(current.value));
+    } catch (err) {
+      current = generator.throw(err);
+    }
+  }
+  return unwrapYield(current.value);
+}
+async function iterateAsync(generator) {
+  let current = generator.next();
+  while (!current.done) {
+    try {
+      current = generator.next(await unwrapYield(current.value, true));
+    } catch (err) {
+      current = generator.throw(err);
+    }
+  }
+  return current.value;
+}
+function fromGeneratorFn(generatorFn) {
+  return fromObject({
+    name: generatorFn.name,
+    async(...args) {
+      return iterateAsync(generatorFn.apply(this, args));
+    },
+    sync(...args) {
+      return iterateSync(generatorFn.apply(this, args));
+    }
+  });
+}
+function quansync$1(options) {
+  if (isThenable(options))
+    return fromPromise(options);
+  if (typeof options === "function")
+    return fromGeneratorFn(options);
+  else
+    return fromObject(options);
+}
+
+const quansync = quansync$1;
+
+const toPath = urlOrPath => urlOrPath instanceof URL ? fileURLToPath$1(urlOrPath) : urlOrPath;
+
+async function findUp$1(name, {
+	cwd = process$1.cwd(),
+	type = 'file',
+	stopAt,
+} = {}) {
+	let directory = p.resolve(toPath(cwd) ?? '');
+	const {root} = p.parse(directory);
+	stopAt = p.resolve(directory, toPath(stopAt ?? root));
+	const isAbsoluteName = p.isAbsolute(name);
+
+	while (directory) {
+		const filePath = isAbsoluteName ? name : p.join(directory, name);
+		try {
+			const stats = await fsPromises.stat(filePath); // eslint-disable-line no-await-in-loop
+			if ((type === 'file' && stats.isFile()) || (type === 'directory' && stats.isDirectory())) {
+				return filePath;
+			}
+		} catch {}
+
+		if (directory === stopAt || directory === root) {
+			break;
+		}
+
+		directory = p.dirname(directory);
+	}
+}
+
+function findUpSync(name, {
+	cwd = process$1.cwd(),
+	type = 'file',
+	stopAt,
+} = {}) {
+	let directory = p.resolve(toPath(cwd) ?? '');
+	const {root} = p.parse(directory);
+	stopAt = p.resolve(directory, toPath(stopAt) ?? root);
+	const isAbsoluteName = p.isAbsolute(name);
+
+	while (directory) {
+		const filePath = isAbsoluteName ? name : p.join(directory, name);
+
+		try {
+			const stats = fs.statSync(filePath, {throwIfNoEntry: false});
+			if ((type === 'file' && stats?.isFile()) || (type === 'directory' && stats?.isDirectory())) {
+				return filePath;
+			}
+		} catch {}
+
+		if (directory === stopAt || directory === root) {
+			break;
+		}
+
+		directory = p.dirname(directory);
+	}
+}
+
 function _resolve(path, options = {}) {
   if (options.platform === "auto" || !options.platform)
     options.platform = process$1.platform === "win32" ? "win32" : "posix";
@@ -2281,12 +2431,36 @@ function resolveModule(name, options = {}) {
   try {
     return _resolve(name, options);
   } catch {
-    return undefined;
+    return void 0;
   }
 }
 function isPackageExists(name, options = {}) {
   return !!resolvePackage(name, options);
 }
+function getPackageJsonPath(name, options = {}) {
+  const entry = resolvePackage(name, options);
+  if (!entry)
+    return;
+  return searchPackageJSON(entry);
+}
+const readFile = quansync({
+  async: (id) => fs.promises.readFile(id, "utf8"),
+  sync: (id) => fs.readFileSync(id, "utf8")
+});
+const getPackageInfo = quansync(function* (name, options = {}) {
+  const packageJsonPath = getPackageJsonPath(name, options);
+  if (!packageJsonPath)
+    return;
+  const packageJson = JSON.parse(yield readFile(packageJsonPath));
+  return {
+    name,
+    version: packageJson.version,
+    rootPath: dirname$1(packageJsonPath),
+    packageJsonPath,
+    packageJson
+  };
+});
+getPackageInfo.sync;
 function resolvePackage(name, options = {}) {
   try {
     return _resolve(`${name}/package.json`, options);
@@ -2300,6 +2474,37 @@ function resolvePackage(name, options = {}) {
     return false;
   }
 }
+function searchPackageJSON(dir) {
+  let packageJsonPath;
+  while (true) {
+    if (!dir)
+      return;
+    const newDir = dirname$1(dir);
+    if (newDir === dir)
+      return;
+    dir = newDir;
+    packageJsonPath = join(dir, "package.json");
+    if (fs.existsSync(packageJsonPath))
+      break;
+  }
+  return packageJsonPath;
+}
+const findUp = quansync({
+  sync: findUpSync,
+  async: findUp$1
+});
+const loadPackageJSON = quansync(function* (cwd = process$1.cwd()) {
+  const path = yield findUp("package.json", { cwd });
+  if (!path || !fs.existsSync(path))
+    return null;
+  return JSON.parse(yield readFile(path));
+});
+loadPackageJSON.sync;
+const isPackageListed = quansync(function* (name, cwd) {
+  const pkg = (yield loadPackageJSON(cwd)) || {};
+  return name in (pkg.dependencies || {}) || name in (pkg.devDependencies || {});
+});
+isPackageListed.sync;
 
 function getWorkersCountByPercentage(percent) {
 	const maxWorkersCount = nodeos__default.availableParallelism?.() ?? nodeos__default.cpus().length;
@@ -6520,9 +6725,9 @@ function createMethodsRPC(project, options = {}) {
 			if (code == null) {
 				throw new Error(`Failed to fetch module ${id}`);
 			}
-			const dir = join(project.tmpDir, transformMode);
+			const dir = join$1(project.tmpDir, transformMode);
 			const name = hash("sha1", id, "hex");
-			const tmp = join(dir, name);
+			const tmp = join$1(dir, name);
 			if (!created.has(dir)) {
 				mkdirSync(dir, { recursive: true });
 				created.add(dir);
@@ -6617,7 +6822,7 @@ function handleRollupError(e) {
 */
 async function atomicWriteFile(realFilePath, data) {
 	const dir = dirname(realFilePath);
-	const tmpFilePath = join(dir, `.tmp-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+	const tmpFilePath = join$1(dir, `.tmp-${Date.now()}-${Math.random().toString(36).slice(2)}`);
 	try {
 		await writeFile(tmpFilePath, data, "utf-8");
 		await rename(tmpFilePath, realFilePath);

package/dist/chunks/{creator.BEXek7yQ.js → creator.CuL7xDWI.js}

@@ -141,6 +141,61 @@ test('renders name', async () => {
 })
 `
 };
+const litExample = {
+	name: "HelloWorld.js",
+	js: `
+import { html, LitElement } from 'lit'
+
+export class HelloWorld extends LitElement {
+  static properties = {
+    name: { type: String },
+  }
+
+  constructor() {
+    super()
+    this.name = 'World'
+  }
+
+  render() {
+    return html\`<h1>Hello \${this.name}!</h1>\`
+  }
+}
+
+customElements.define('hello-world', HelloWorld)
+`,
+	ts: `
+import { html, LitElement } from 'lit'
+import { customElement, property } from 'lit/decorators.js'
+
+@customElement('hello-world')
+export class HelloWorld extends LitElement {
+  @property({ type: String })
+  name = 'World'
+
+  render() {
+    return html\`<h1>Hello \${this.name}!</h1>\`
+  }
+}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    'hello-world': HelloWorld
+  }
+}
+`,
+	test: `
+import { expect, test } from 'vitest'
+import { render } from 'vitest-browser-lit'
+import { html } from 'lit'
+import './HelloWorld.js'
+
+test('renders name', async () => {
+  const screen = render(html\`<hello-world name="Vitest"></hello-world>\`)
+  const element = screen.getByText('Hello Vitest!')
+  await expect.element(element).toBeInTheDocument()
+})
+`
+};
 const vanillaExample = {
 	name: "HelloWorld.js",
 	js: `
@@ -192,6 +247,7 @@ function getExampleTest(framework) {
 		};
 		case "vue": return vueExample;
 		case "svelte": return svelteExample;
+		case "lit": return litExample;
 		case "marko": return markoExample;
 		default: return vanillaExample;
 	}
@@ -291,6 +347,11 @@ function getFramework() {
 			value: "react",
 			description: "\"The library for web and native user interfaces\""
 		},
+		{
+			title: "lit",
+			value: "lit",
+			description: "\"A simple library for building fast, lightweight web components.\""
+		},
 		{
 			title: "preact",
 			value: "preact",
@@ -314,6 +375,7 @@ function getFrameworkTestPackage(framework) {
 		case "vue": return "vitest-browser-vue";
 		case "svelte": return "vitest-browser-svelte";
 		case "react": return "vitest-browser-react";
+		case "lit": return "vitest-browser-lit";
 		case "preact": return "@testing-library/preact";
 		case "solid": return "@solidjs/testing-library";
 		case "marko": return "@marko/testing-library";
@@ -389,6 +451,9 @@ function getPossibleFramework(dependencies) {
 	if (dependencies.svelte || dependencies["@sveltejs/kit"]) {
 		return "svelte";
 	}
+	if (dependencies.lit || dependencies["lit-html"]) {
+		return "lit";
+	}
 	if (dependencies.preact) {
 		return "preact";
 	}