nitro-nightly 3.0.1-alpha.1 → 3.0.1-alpha.2

package/dist/_libs/{unimport.mjs → unimport+unplugin.mjs}

@@ -1,1775 +1,210 @@
-import { i as __toESM, n as __require, t as __commonJS } from "../_chunks/Bqks5huO.mjs";
-import { C as isAbsolute$1, D as parse$2, O as relative$1, T as normalize$2, b as basename$1, f as readPackageJSON, k as resolve$1, m as resolvePackageJSON, w as join$1, x as dirname$1 } from "./c12.mjs";
-import { t as MagicString } from "./magic-string.mjs";
-import { n as parse, t as Parser } from "./acorn.mjs";
-import { a as findStaticImports, d as resolveModuleExportNames, i as findExports, l as parseStaticImport, n as detectSyntax, o as findTypeExports, t as resolveModule, u as resolve$2 } from "./local-pkg.mjs";
-import { t as stripLiteral } from "./strip-literal.mjs";
-import { t as require_picomatch } from "./picomatch.mjs";
-import { t as glob } from "./tinyglobby.mjs";
+import { i as __toESM, n as __exportAll, r as __require, t as __commonJSMin } from "../_common.mjs";
+import { E as parse$1, P as require_picomatch, S as MagicString, T as Parser, at as join$1, b as getMagicString, ct as resolve$1, it as isAbsolute$2, y as createUnimport } from "../_build/common.mjs";
 import { t as walk } from "./estree-walker.mjs";
 import { t as remapping } from "./remapping.mjs";
 import { createRequire } from "node:module";
+import fs, { promises } from "node:fs";
+import "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import "node:os";
 import path, { basename, dirname, extname, isAbsolute, normalize, resolve } from "node:path";
 import process$1 from "node:process";
-import { camelCase, kebabCase } from "scule";
-import fs, { accessSync, constants, existsSync, promises, readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { readFile } from "node:fs/promises";
-import os from "node:os";
+import "scule";
 import { Buffer } from "node:buffer";
 import * as querystring from "node:querystring";
 
-//#region node_modules/.pnpm/unimport@5.5.0/node_modules/unimport/dist/shared/unimport.rkT0nXLK.mjs
-const excludeRE = [
-	/\b(import|export)\b([\w$*{},\s]+?)\bfrom\s*["']/g,
-	/\bfunction\s*([\w$]+)\s*\(/g,
-	/\bclass\s*([\w$]+)\s*\{/g,
-	/\b(?:const|let|var)\s+?(\[.*?\]|\{.*?\}|.+?)\s*?[=;\n]/gs
-];
-const importAsRE = /^.*\sas\s+/;
-const separatorRE = /[,[\]{}\n]|\b(?:import|export)\b/g;
-const matchRE = /(^|\.\.\.|(?:\bcase|\?)\s+|[^\w$/)]|\bextends\s+)([\w$]+)\s*(?=[.()[\]}:;?+\-*&|`<>,\n]|\b(?:instanceof|in)\b|$|(?<=extends\s+\w+)\s+\{)/g;
-const regexRE = /\/\S*?(?<!\\)(?<!\[[^\]]*)\/[gimsuy]*/g;
-function stripCommentsAndStrings(code, options) {
-	return stripLiteral(code, options).replace(regexRE, "new RegExp(\"\")");
-}
-function defineUnimportPreset(preset) {
-	return preset;
-}
-const identifierRE = /^[A-Z_$][\w$]*$/i;
-const safePropertyName = /^[a-z$_][\w$]*$/i;
-function stringifyWith(withValues) {
-	let withDefs = "";
-	for (let entries = Object.entries(withValues), l = entries.length, i = 0; i < l; i++) {
-		const [prop, value] = entries[i];
-		withDefs += safePropertyName.test(prop) ? prop : JSON.stringify(prop);
-		withDefs += `: ${JSON.stringify(String(value))}`;
-		if (i + 1 !== l) withDefs += ", ";
-	}
-	return `{ ${withDefs} }`;
-}
-function stringifyImports(imports, isCJS = false) {
-	const map = toImportModuleMap(imports);
-	return Object.entries(map).flatMap(([name, importSet]) => {
-		const entries = [];
-		const imports2 = Array.from(importSet).filter((i) => {
-			if (!i.name || i.as === "") {
-				let importStr;
-				if (isCJS) importStr = `require('${name}');`;
-				else {
-					importStr = `import '${name}'`;
-					if (i.with) importStr += ` with ${stringifyWith(i.with)}`;
-					importStr += ";";
-				}
-				entries.push(importStr);
-				return false;
-			} else if (i.name === "default" || i.name === "=") {
-				let importStr;
-				if (isCJS) importStr = i.name === "=" ? `const ${i.as} = require('${name}');` : `const { default: ${i.as} } = require('${name}');`;
-				else {
-					importStr = `import ${i.as} from '${name}'`;
-					if (i.with) importStr += ` with ${stringifyWith(i.with)}`;
-					importStr += ";";
-				}
-				entries.push(importStr);
-				return false;
-			} else if (i.name === "*") {
-				let importStr;
-				if (isCJS) importStr = `const ${i.as} = require('${name}');`;
-				else {
-					importStr = `import * as ${i.as} from '${name}'`;
-					if (i.with) importStr += ` with ${stringifyWith(i.with)}`;
-					importStr += ";";
-				}
-				entries.push(importStr);
-				return false;
-			} else if (!isCJS && i.with) {
-				entries.push(`import { ${stringifyImportAlias(i)} } from '${name}' with ${stringifyWith(i.with)};`);
-				return false;
-			}
-			return true;
-		});
-		if (imports2.length) {
-			const importsAs = imports2.map((i) => stringifyImportAlias(i, isCJS));
-			entries.push(isCJS ? `const { ${importsAs.join(", ")} } = require('${name}');` : `import { ${importsAs.join(", ")} } from '${name}';`);
-		}
-		return entries;
-	}).join("\n");
-}
-function dedupeImports(imports, warn) {
-	const map = /* @__PURE__ */ new Map();
-	const indexToRemove = /* @__PURE__ */ new Set();
-	imports.filter((i) => !i.disabled).forEach((i, idx) => {
-		if (i.declarationType === "enum" || i.declarationType === "class") return;
-		const name = i.as ?? i.name;
-		if (!map.has(name)) {
-			map.set(name, idx);
-			return;
-		}
-		const other = imports[map.get(name)];
-		if (other.from === i.from) {
-			indexToRemove.add(idx);
-			return;
-		}
-		const diff = (other.priority || 1) - (i.priority || 1);
-		if (diff === 0) warn(`Duplicated imports "${name}", the one from "${other.from}" has been ignored and "${i.from}" is used`);
-		if (diff <= 0) {
-			indexToRemove.add(map.get(name));
-			map.set(name, idx);
-		} else indexToRemove.add(idx);
-	});
-	return imports.filter((_, idx) => !indexToRemove.has(idx));
-}
-function toExports(imports, fileDir, includeType = false) {
-	const map = toImportModuleMap(imports, includeType);
-	return Object.entries(map).flatMap(([name, imports2]) => {
-		if (isFilePath(name)) name = name.replace(/\.[a-z]+$/i, "");
-		if (fileDir && isAbsolute$1(name)) {
-			name = relative$1(fileDir, name);
-			if (!name.match(/^[./]/)) name = `./${name}`;
-		}
-		const entries = [];
-		const filtered = Array.from(imports2).filter((i) => {
-			if (i.name === "*") {
-				entries.push(`export * as ${i.as} from '${name}';`);
-				return false;
-			}
-			return true;
-		});
-		if (filtered.length) entries.push(`export { ${filtered.map((i) => stringifyImportAlias(i, false)).join(", ")} } from '${name}';`);
-		return entries;
-	}).join("\n");
-}
-function stripFileExtension(path$1) {
-	return path$1.replace(/\.[a-z]+$/i, "");
-}
-function toTypeDeclarationItems(imports, options) {
-	return imports.map((i) => {
-		const from = options?.resolvePath?.(i) || stripFileExtension(i.typeFrom || i.from);
-		let typeDef = "";
-		if (i.with) typeDef += `import('${from}', { with: ${stringifyWith(i.with)} })`;
-		else typeDef += `import('${from}')`;
-		if (i.name !== "*" && i.name !== "=") typeDef += identifierRE.test(i.name) ? `.${i.name}` : `['${i.name}']`;
-		return `const ${i.as}: typeof ${typeDef}`;
-	}).sort();
-}
-function toTypeDeclarationFile(imports, options) {
-	const items = toTypeDeclarationItems(imports, options);
-	const { exportHelper = true } = options || {};
-	let declaration = "";
-	if (exportHelper) declaration += "export {}\n";
-	declaration += `declare global {
-${items.map((i) => `  ${i}`).join("\n")}
-}`;
-	return declaration;
-}
-function makeTypeModulesMap(imports, resolvePath$1) {
-	const modulesMap = /* @__PURE__ */ new Map();
-	const resolveImportFrom = typeof resolvePath$1 === "function" ? (i) => {
-		return resolvePath$1(i) || stripFileExtension(i.typeFrom || i.from);
-	} : (i) => stripFileExtension(i.typeFrom || i.from);
-	for (const import_ of imports) {
-		const from = resolveImportFrom(import_);
-		let module$1 = modulesMap.get(from);
-		if (!module$1) {
-			module$1 = {
-				typeImports: /* @__PURE__ */ new Set(),
-				starTypeImport: void 0
-			};
-			modulesMap.set(from, module$1);
-		}
-		if (import_.name === "*") {
-			if (import_.as) module$1.starTypeImport = import_;
-		} else module$1.typeImports.add(import_);
-	}
-	return modulesMap;
-}
-function toTypeReExports(imports, options) {
-	const importsMap = makeTypeModulesMap(imports, options?.resolvePath);
-	return `// for type re-export
-declare global {
-${Array.from(importsMap).flatMap(([from, module$1]) => {
-		from = from.replace(/\.d\.([cm]?)ts$/i, ".$1js");
-		const { starTypeImport, typeImports } = module$1;
-		const strings = [];
-		if (typeImports.size) {
-			const typeImportNames = Array.from(typeImports).map(({ name, as }) => {
-				if (as && as !== name) return `${name} as ${as}`;
-				return name;
-			});
-			strings.push("// @ts-ignore", `export type { ${typeImportNames.join(", ")} } from '${from}'`);
-		}
-		if (starTypeImport) strings.push("// @ts-ignore", `export type * as ${starTypeImport.as} from '${from}'`);
-		if (strings.length) strings.push(`import('${from}')`);
-		return strings;
-	}).map((i) => `  ${i}`).join("\n")}
-}`;
-}
-function stringifyImportAlias(item, isCJS = false) {
-	return item.as === void 0 || item.name === item.as ? item.name : isCJS ? `${item.name}: ${item.as}` : `${item.name} as ${item.as}`;
-}
-function toImportModuleMap(imports, includeType = false) {
-	const map = {};
-	for (const _import of imports) {
-		if (_import.type && !includeType) continue;
-		if (!map[_import.from]) map[_import.from] = /* @__PURE__ */ new Set();
-		map[_import.from].add(_import);
-	}
-	return map;
-}
-function getMagicString(code) {
-	if (typeof code === "string") return new MagicString(code);
-	return code;
-}
-function addImportToCode(code, imports, isCJS = false, mergeExisting = false, injectAtLast = false, firstOccurrence = Number.POSITIVE_INFINITY, onResolved, onStringified) {
-	let newImports = [];
-	const s = getMagicString(code);
-	let _staticImports;
-	const strippedCode = stripCommentsAndStrings(s.original);
-	function findStaticImportsLazy() {
-		if (!_staticImports) _staticImports = findStaticImports(s.original).filter((i) => Boolean(strippedCode.slice(i.start, i.end).trim())).map((i) => parseStaticImport(i));
-		return _staticImports;
-	}
-	function hasShebang() {
-		return /^#!.+/.test(s.original);
-	}
-	if (mergeExisting && !isCJS) {
-		const existingImports = findStaticImportsLazy();
-		const map = /* @__PURE__ */ new Map();
-		imports.forEach((i) => {
-			const target = existingImports.find((e) => e.specifier === i.from && e.imports.startsWith("{"));
-			if (!target) return newImports.push(i);
-			if (!map.has(target)) map.set(target, []);
-			map.get(target).push(i);
-		});
-		for (const [target, items] of map.entries()) {
-			const strings = items.map((i) => `${stringifyImportAlias(i)}, `);
-			const importLength = target.code.match(/^\s*import\s*\{/)?.[0]?.length;
-			if (importLength) s.appendLeft(target.start + importLength, ` ${strings.join("").trim()}`);
-		}
-	} else newImports = imports;
-	newImports = onResolved?.(newImports) ?? newImports;
-	let newEntries = stringifyImports(newImports, isCJS);
-	newEntries = onStringified?.(newEntries, newImports) ?? newEntries;
-	if (newEntries) {
-		const insertionIndex = injectAtLast ? findStaticImportsLazy().reverse().find((i) => i.end <= firstOccurrence)?.end ?? 0 : 0;
-		if (insertionIndex > 0) s.appendRight(insertionIndex, `
-${newEntries}
-`);
-		else if (hasShebang()) s.appendLeft(s.original.indexOf("\n") + 1, `
-${newEntries}
-`);
-		else s.prepend(`${newEntries}
-`);
-	}
-	return {
-		s,
-		get code() {
-			return s.toString();
-		}
-	};
-}
-function normalizeImports(imports) {
-	for (const _import of imports) _import.as = _import.as ?? _import.name;
-	return imports;
-}
-function isFilePath(path$1) {
-	return path$1.startsWith(".") || isAbsolute$1(path$1) || path$1.includes("://");
-}
-const contextRE$1 = /\b_ctx\.([$\w]+)\b/g;
-const UNREF_KEY = "__unimport_unref_";
-const VUE_TEMPLATE_NAME = "unimport:vue-template";
-function vueTemplateAddon() {
-	const self = {
-		name: VUE_TEMPLATE_NAME,
-		async transform(s, id) {
-			if (!s.original.includes("_ctx.") || s.original.includes(UNREF_KEY)) return s;
-			const matches = Array.from(s.original.matchAll(contextRE$1));
-			const imports = await this.getImports();
-			let targets = [];
-			for (const match of matches) {
-				const name = match[1];
-				const item = imports.find((i) => i.as === name);
-				if (!item) continue;
-				const start = match.index;
-				const end = start + match[0].length;
-				const tempName = `__unimport_${name}`;
-				s.overwrite(start, end, `(${JSON.stringify(name)} in _ctx ? _ctx.${name} : ${UNREF_KEY}(${tempName}))`);
-				if (!targets.find((i) => i.as === tempName)) targets.push({
-					...item,
-					as: tempName
-				});
-			}
-			if (targets.length) {
-				targets.push({
-					name: "unref",
-					from: "vue",
-					as: UNREF_KEY
-				});
-				for (const addon of this.addons) {
-					if (addon === self) continue;
-					targets = await addon.injectImportsResolved?.call(this, targets, s, id) ?? targets;
-				}
-				let injection = stringifyImports(targets);
-				for (const addon of this.addons) {
-					if (addon === self) continue;
-					injection = await addon.injectImportsStringified?.call(this, injection, targets, s, id) ?? injection;
-				}
-				s.prepend(injection);
-			}
-			return s;
-		},
-		async declaration(dts, options) {
-			return `${dts}
-// for vue template auto import
-import { UnwrapRef } from 'vue'
-declare module 'vue' {
-  interface ComponentCustomProperties {
-${(await this.getImports()).map((i) => {
-				if (i.type || i.dtsDisabled) return "";
-				const from = options?.resolvePath?.(i) || i.from;
-				return `readonly ${i.as}: UnwrapRef<typeof import('${from}')${i.name !== "*" ? `['${i.name}']` : ""}>`;
-			}).filter(Boolean).sort().map((i) => `    ${i}`).join("\n")}
-  }
-}`;
-		}
-	};
-	return self;
-}
-const contextRE = /resolveDirective as _resolveDirective/;
-const contextText = `${contextRE.source}, `;
-const directiveRE = /(?:var|const) (\w+) = _resolveDirective\("([\w.-]+)"\);?\s*/g;
-const VUE_DIRECTIVES_NAME = "unimport:vue-directives";
-function vueDirectivesAddon(options = {}) {
-	function isDirective(importEntry) {
-		let isDirective2 = importEntry.meta?.vueDirective === true;
-		if (isDirective2) return true;
-		isDirective2 = options.isDirective?.(normalizePath$1(process$1.cwd(), importEntry.from), importEntry) ?? false;
-		if (isDirective2) {
-			importEntry.meta ??= {};
-			importEntry.meta.vueDirective = true;
-		}
-		return isDirective2;
-	}
-	const self = {
-		name: VUE_DIRECTIVES_NAME,
-		async transform(s, id) {
-			if (!s.original.match(contextRE)) return s;
-			const matches = Array.from(s.original.matchAll(directiveRE)).sort((a, b) => b.index - a.index);
-			if (!matches.length) return s;
-			let targets = [];
-			for await (const [begin, end, importEntry] of findDirectives(isDirective, matches, this.getImports())) {
-				s.overwrite(begin, end, "");
-				targets.push(importEntry);
-			}
-			if (!targets.length) return s;
-			if (!s.toString().match(directiveRE)) s.replace(contextText, "");
-			for (const addon of this.addons) {
-				if (addon === self) continue;
-				targets = await addon.injectImportsResolved?.call(this, targets, s, id) ?? targets;
-			}
-			let injection = stringifyImports(targets);
-			for (const addon of this.addons) {
-				if (addon === self) continue;
-				injection = await addon.injectImportsStringified?.call(this, injection, targets, s, id) ?? injection;
-			}
-			s.prepend(injection);
-			return s;
-		},
-		async declaration(dts, options2) {
-			const directivesMap = await this.getImports().then((imports) => {
-				return imports.filter(isDirective).reduce((acc, i) => {
-					if (i.type || i.dtsDisabled) return acc;
-					let name;
-					if (i.name === "default" && (i.as === "default" || !i.as)) {
-						const file = basename(i.from);
-						const idx = file.indexOf(".");
-						name = idx > -1 ? file.slice(0, idx) : file;
-					} else name = i.as ?? i.name;
-					name = name[0] === "v" ? camelCase(name) : camelCase(`v-${name}`);
-					if (!acc.has(name)) acc.set(name, i);
-					return acc;
-				}, /* @__PURE__ */ new Map());
-			});
-			if (!directivesMap.size) return dts;
-			return `${dts}
-// for vue directives auto import
-declare module 'vue' {
-  interface GlobalDirectives {
-${Array.from(directivesMap.entries()).map(([name, i]) => `    ${name}: typeof import('${options2?.resolvePath?.(i) || i.from}')['${i.name}']`).sort().join("\n")}
-  }
-}`;
-		}
-	};
-	return self;
-}
-function resolvePath(cwd$1, path$1) {
-	return path$1[0] === "." ? resolve$1(cwd$1, path$1) : path$1;
-}
-function normalizePath$1(cwd$1, path$1) {
-	return resolvePath(cwd$1, path$1).replace(/\\/g, "/");
-}
-async function* findDirectives(isDirective, regexArray, importsPromise) {
-	const imports = (await importsPromise).filter(isDirective);
-	if (!imports.length) return;
-	const symbols = regexArray.reduce((acc, regex) => {
-		const [all, symbol, resolveDirectiveName] = regex;
-		if (acc.has(symbol)) return acc;
-		acc.set(symbol, [
-			regex.index,
-			regex.index + all.length,
-			kebabCase(resolveDirectiveName)
-		]);
-		return acc;
-	}, /* @__PURE__ */ new Map());
-	for (const [symbol, data] of symbols.entries()) yield* findDirective(imports, symbol, data);
-}
-function* findDirective(imports, symbol, [begin, end, importName]) {
-	let resolvedName;
-	for (const i of imports) {
-		if (i.name === "default" && (i.as === "default" || !i.as)) {
-			const file = basename(i.from);
-			const idx = file.indexOf(".");
-			resolvedName = kebabCase(idx > -1 ? file.slice(0, idx) : file);
-		} else resolvedName = kebabCase(i.as ?? i.name);
-		if (resolvedName === importName) {
-			yield [
-				begin,
-				end,
-				{
-					...i,
-					name: i.name,
-					as: symbol
-				}
-			];
-			return;
-		}
-		if (resolvedName[0] === "v") resolvedName = resolvedName.slice(resolvedName[1] === "-" ? 2 : 1);
-		if (resolvedName === importName) {
-			yield [
-				begin,
-				end,
-				{
-					...i,
-					name: i.name,
-					as: symbol
-				}
-			];
-			return;
-		}
-	}
-}
-
-//#endregion
-//#region node_modules/.pnpm/unimport@5.5.0/node_modules/unimport/dist/shared/unimport.C1hu2RXM.mjs
-var import_picomatch$2 = /* @__PURE__ */ __toESM(require_picomatch(), 1);
-const version = "5.5.0";
-function configureAddons(opts) {
-	const addons = [];
-	if (Array.isArray(opts.addons)) addons.push(...opts.addons);
-	else {
-		const addonsMap = /* @__PURE__ */ new Map();
-		if (opts.addons?.addons?.length) {
-			let i = 0;
-			for (const addon of opts.addons.addons) addonsMap.set(addon.name || `external:custom-${i++}`, addon);
-		}
-		if (opts.addons?.vueTemplate) {
-			if (!addonsMap.has(VUE_TEMPLATE_NAME)) addonsMap.set(VUE_TEMPLATE_NAME, vueTemplateAddon());
-		}
-		if (opts.addons?.vueDirectives) {
-			if (!addonsMap.has(VUE_DIRECTIVES_NAME)) addonsMap.set(VUE_DIRECTIVES_NAME, vueDirectivesAddon(typeof opts.addons.vueDirectives === "object" ? opts.addons.vueDirectives : void 0));
-		}
-		addons.push(...addonsMap.values());
-	}
-	return addons;
-}
-async function detectImportsRegex(code, ctx, options) {
+//#region node_modules/.pnpm/unimport@5.6.0/node_modules/unimport/dist/chunks/detect-acorn.mjs
+var detect_acorn_exports = /* @__PURE__ */ __exportAll({
+	createVirtualImportsAcronWalker: () => createVirtualImportsAcronWalker,
+	detectImportsAcorn: () => detectImportsAcorn,
+	traveseScopes: () => traveseScopes
+});
+async function detectImportsAcorn(code, ctx, options) {
 	const s = getMagicString(code);
-	const original = s.original;
-	const strippedCode = stripCommentsAndStrings(original, options?.transformVirtualImports !== false && ctx.options.virtualImports?.length ? {
-		filter: (i) => !ctx.options.virtualImports.includes(i),
-		fillChar: "-"
-	} : void 0);
-	const syntax = detectSyntax(strippedCode);
-	const isCJSContext = syntax.hasCJS && !syntax.hasESM;
-	let matchedImports = [];
-	const occurrenceMap = /* @__PURE__ */ new Map();
 	const map = await ctx.getImportMap();
-	if (options?.autoImport !== false) {
-		Array.from(strippedCode.matchAll(matchRE)).forEach((i) => {
-			if (i[1] === ".") return null;
-			const end = strippedCode[i.index + i[0].length];
-			const before = strippedCode[i.index - 1];
-			if (end === ":" && !["?", "case"].includes(i[1].trim()) && before !== ":") return null;
-			const name = i[2];
-			const occurrence = i.index + i[1].length;
-			if (occurrenceMap.get(name) || Number.POSITIVE_INFINITY > occurrence) occurrenceMap.set(name, occurrence);
+	let matchedImports = [];
+	const enableAutoImport = options?.autoImport !== false;
+	const enableTransformVirtualImports = options?.transformVirtualImports !== false && ctx.options.virtualImports?.length;
+	if (enableAutoImport || enableTransformVirtualImports) {
+		const ast = parse$1(s.original, {
+			sourceType: "module",
+			ecmaVersion: "latest",
+			locations: true
 		});
-		for (const regex of excludeRE) for (const match of strippedCode.matchAll(regex)) {
-			const segments = [...match[1]?.split(separatorRE) || [], ...match[2]?.split(separatorRE) || []];
-			for (const segment of segments) {
-				const identifier = segment.replace(importAsRE, "").trim();
-				occurrenceMap.delete(identifier);
-			}
+		const virtualImports = createVirtualImportsAcronWalker(map, ctx.options.virtualImports);
+		const scopes = traveseScopes(ast, enableTransformVirtualImports ? virtualImports.walk : {});
+		if (enableAutoImport) {
+			const identifiers = scopes.unmatched;
+			matchedImports.push(...Array.from(identifiers).map((name) => {
+				const item = map.get(name);
+				if (item && !item.disabled) return item;
+				return null;
+			}).filter(Boolean));
+			for (const addon of ctx.addons) matchedImports = await addon.matchImports?.call(ctx, identifiers, matchedImports) || matchedImports;
 		}
-		const identifiers = new Set(occurrenceMap.keys());
-		matchedImports = Array.from(identifiers).map((name) => {
-			const item = map.get(name);
-			if (item && !item.disabled) return item;
-			occurrenceMap.delete(name);
-			return null;
-		}).filter(Boolean);
-		for (const addon of ctx.addons) matchedImports = await addon.matchImports?.call(ctx, identifiers, matchedImports) || matchedImports;
-	}
-	if (options?.transformVirtualImports !== false && ctx.options.virtualImports?.length) {
-		const virtualImports = parseVirtualImportsRegex(strippedCode, map, ctx.options.virtualImports);
 		virtualImports.ranges.forEach(([start, end]) => {
 			s.remove(start, end);
 		});
 		matchedImports.push(...virtualImports.imports);
 	}
-	const firstOccurrence = Math.min(...Array.from(occurrenceMap.entries()).map((i) => i[1]));
 	return {
 		s,
-		strippedCode,
-		isCJSContext,
+		strippedCode: code.toString(),
 		matchedImports,
-		firstOccurrence
-	};
-}
-function parseVirtualImportsRegex(strippedCode, importMap, virtualImports) {
-	const imports = [];
-	const ranges = [];
-	if (virtualImports?.length) findStaticImports(strippedCode).filter((i) => virtualImports.includes(i.specifier)).map((i) => parseStaticImport(i)).forEach((i) => {
-		ranges.push([i.start, i.end]);
-		Object.entries(i.namedImports || {}).forEach(([name, as]) => {
-			const original = importMap.get(name);
-			if (!original) throw new Error(`[unimport] failed to find "${name}" imported from "${i.specifier}"`);
-			imports.push({
-				from: original.from,
-				name: original.name,
-				as
-			});
-		});
-	});
-	return {
-		imports,
-		ranges
+		isCJSContext: false,
+		firstOccurrence: 0
 	};
 }
-async function detectImports(code, ctx, options) {
-	if (options?.parser === "acorn") return import("../cli/_chunks/detect-acorn.mjs").then((r) => r.detectImportsAcorn(code, ctx, options));
-	return detectImportsRegex(code, ctx, options);
-}
-const FileExtensionLookup = [
-	"mts",
-	"cts",
-	"ts",
-	"tsx",
-	"mjs",
-	"cjs",
-	"js",
-	"jsx"
-];
-const FileLookupPatterns = `*.{${FileExtensionLookup.join(",")}}`;
-function resolveGlobsExclude(glob2, cwd$1) {
-	return `${glob2.startsWith("!") ? "!" : ""}${resolve$1(cwd$1, glob2.replace(/^!/, ""))}`;
-}
-function joinGlobFilePattern(glob2, filePattern) {
-	return join$1(basename$1(glob2) === "*" ? dirname$1(glob2) : glob2, filePattern);
-}
-function normalizeScanDirs(dirs, options) {
-	const topLevelTypes = options?.types ?? true;
-	const cwd$1 = options?.cwd ?? process$1.cwd();
-	const filePatterns = options?.filePatterns || [FileLookupPatterns];
-	return dirs.map((dir) => {
-		const isString$1 = typeof dir === "string";
-		const glob2 = resolveGlobsExclude(isString$1 ? dir : dir.glob, cwd$1);
-		const types = isString$1 ? topLevelTypes : dir.types ?? topLevelTypes;
-		if (glob2.match(/\.\w+$/)) return {
-			glob: glob2,
-			types
+function traveseScopes(ast, additionalWalk) {
+	const scopes = [];
+	let scopeCurrent = void 0;
+	const scopesStack = [];
+	function pushScope(node) {
+		scopeCurrent = {
+			node,
+			parent: scopeCurrent,
+			declarations: /* @__PURE__ */ new Set(),
+			references: /* @__PURE__ */ new Set()
 		};
-		const withFilePatterns = filePatterns.map((filePattern) => ({
-			glob: joinGlobFilePattern(glob2, filePattern),
-			types
-		}));
-		return [{
-			glob: glob2,
-			types
-		}, ...withFilePatterns];
-	}).flat();
-}
-async function scanFilesFromDir(dir, options) {
-	const dirGlobs = (Array.isArray(dir) ? dir : [dir]).map((i) => i.glob);
-	const files = (await glob(dirGlobs, {
-		absolute: true,
-		cwd: options?.cwd || process$1.cwd(),
-		onlyFiles: true,
-		followSymbolicLinks: true,
-		expandDirectories: false
-	})).map((i) => normalize$2(i));
-	const fileFilter = options?.fileFilter || (() => true);
-	const indexOfDirs = (file) => dirGlobs.findIndex((glob2) => import_picomatch$2.default.isMatch(file, glob2));
-	return files.reduce((acc, file) => {
-		const index = indexOfDirs(file);
-		if (acc[index]) acc[index].push(normalize$2(file));
-		else acc[index] = [normalize$2(file)];
-		return acc;
-	}, []).map((files2) => files2.sort()).flat().filter(fileFilter);
-}
-async function scanDirExports(dirs, options) {
-	const normalizedDirs = normalizeScanDirs(dirs, options);
-	const files = await scanFilesFromDir(normalizedDirs, options);
-	const includeTypesDirs = normalizedDirs.filter((dir) => !dir.glob.startsWith("!") && dir.types);
-	const isIncludeTypes = (file) => includeTypesDirs.some((dir) => import_picomatch$2.default.isMatch(file, dir.glob));
-	return dedupeDtsExports((await Promise.all(files.map((file) => scanExports(file, isIncludeTypes(file))))).flat());
-}
-function dedupeDtsExports(exports$1) {
-	return exports$1.filter((i) => {
-		if (!i.type) return true;
-		if (i.declarationType === "enum" || i.declarationType === "class") return true;
-		return !exports$1.find((e) => e.as === i.as && e.name === i.name && !e.type);
-	});
-}
-async function scanExports(filepath, includeTypes, seen = /* @__PURE__ */ new Set()) {
-	if (seen.has(filepath)) {
-		console.warn(`[unimport] "${filepath}" is already scanned, skipping`);
-		return [];
+		scopes.push(scopeCurrent);
+		scopesStack.push(scopeCurrent);
 	}
-	seen.add(filepath);
-	const imports = [];
-	const code = await readFile(filepath, "utf-8");
-	const exports$1 = findExports(code);
-	if (exports$1.find((i) => i.type === "default")) {
-		let name = parse$2(filepath).name;
-		if (name === "index") name = parse$2(filepath.split("/").slice(0, -1).join("/")).name;
-		const as = /[-_.]/.test(name) ? camelCase(name) : name;
-		imports.push({
-			name: "default",
-			as,
-			from: filepath
-		});
+	function popScope(node) {
+		if (scopesStack.pop()?.node !== node) throw new Error("Scope mismatch");
+		scopeCurrent = scopesStack[scopesStack.length - 1];
 	}
-	async function toImport(exports2, additional) {
-		for (const exp of exports2) if (exp.type === "named") for (const name of exp.names) imports.push({
-			name,
-			as: name,
-			from: filepath,
-			...additional
-		});
-		else if (exp.type === "declaration") {
-			if (exp.name) {
-				imports.push({
-					name: exp.name,
-					as: exp.name,
-					from: filepath,
-					...additional
-				});
-				if (exp.declarationType === "enum" || exp.declarationType === "class") imports.push({
-					name: exp.name,
-					as: exp.name,
-					from: filepath,
-					type: true,
-					declarationType: exp.declarationType,
-					...additional
-				});
-			}
-		} else if (exp.type === "star" && exp.specifier) if (exp.name) imports.push({
-			name: exp.name,
-			as: exp.name,
-			from: filepath,
-			...additional
-		});
-		else {
-			const subfile = exp.specifier;
-			let subfilepath = resolve$1(dirname$1(filepath), subfile);
-			let subfilepathResolved = false;
-			for (const ext of FileExtensionLookup) if (existsSync(`${subfilepath}.${ext}`)) {
-				subfilepath = `${subfilepath}.${ext}`;
-				break;
-			} else if (existsSync(`${subfilepath}/index.${ext}`)) {
-				subfilepath = `${subfilepath}/index.${ext}`;
-				break;
+	pushScope(void 0);
+	walk(ast, {
+		enter(node, parent, prop, index) {
+			additionalWalk?.enter?.call(this, node, parent, prop, index);
+			switch (node.type) {
+				case "ImportSpecifier":
+				case "ImportDefaultSpecifier":
+				case "ImportNamespaceSpecifier":
+					scopeCurrent.declarations.add(node.local.name);
+					return;
+				case "FunctionDeclaration":
+				case "ClassDeclaration":
+					if (node.id) scopeCurrent.declarations.add(node.id.name);
+					return;
+				case "VariableDeclarator":
+					if (node.id.type === "Identifier") scopeCurrent.declarations.add(node.id.name);
+					else walk(node.id, { enter(node2) {
+						if (node2.type === "ObjectPattern") node2.properties.forEach((i) => {
+							if (i.type === "Property" && i.value.type === "Identifier") scopeCurrent.declarations.add(i.value.name);
+							else if (i.type === "RestElement" && i.argument.type === "Identifier") scopeCurrent.declarations.add(i.argument.name);
+						});
+						else if (node2.type === "ArrayPattern") node2.elements.forEach((i) => {
+							if (i?.type === "Identifier") scopeCurrent.declarations.add(i.name);
+							if (i?.type === "RestElement" && i.argument.type === "Identifier") scopeCurrent.declarations.add(i.argument.name);
+						});
+					} });
+					return;
+				case "BlockStatement":
+					switch (parent?.type) {
+						case "FunctionDeclaration":
+						case "ArrowFunctionExpression":
+						case "FunctionExpression": {
+							const parameterIdentifiers = parent.params.filter((p) => p.type === "Identifier");
+							for (const id of parameterIdentifiers) scopeCurrent.declarations.add(id.name);
+							break;
+						}
+					}
+					pushScope(node);
+					return;
+				case "Identifier":
+					switch (parent?.type) {
+						case "CallExpression":
+							if (parent.callee === node || parent.arguments.includes(node)) scopeCurrent.references.add(node.name);
+							return;
+						case "MemberExpression":
+							if (parent.object === node) scopeCurrent.references.add(node.name);
+							return;
+						case "VariableDeclarator":
+							if (parent.init === node) scopeCurrent.references.add(node.name);
+							return;
+						case "SpreadElement":
+							if (parent.argument === node) scopeCurrent.references.add(node.name);
+							return;
+						case "ClassDeclaration":
+							if (parent.superClass === node) scopeCurrent.references.add(node.name);
+							return;
+						case "Property":
+							if (parent.value === node) scopeCurrent.references.add(node.name);
+							return;
+						case "TemplateLiteral":
+							if (parent.expressions.includes(node)) scopeCurrent.references.add(node.name);
+							return;
+						case "AssignmentExpression":
+							if (parent.right === node) scopeCurrent.references.add(node.name);
+							return;
+						case "IfStatement":
+						case "WhileStatement":
+						case "DoWhileStatement":
+							if (parent.test === node) scopeCurrent.references.add(node.name);
+							return;
+						case "SwitchStatement":
+							if (parent.discriminant === node) scopeCurrent.references.add(node.name);
+							return;
+					}
+					if (parent?.type.includes("Expression")) scopeCurrent.references.add(node.name);
 			}
-			if (existsSync(subfilepath)) subfilepathResolved = true;
-			else try {
-				subfilepath = await resolve$2(exp.specifier);
-				subfilepath = normalize$2(fileURLToPath(subfilepath));
-				if (existsSync(subfilepath)) subfilepathResolved = true;
-			} catch {}
-			if (!subfilepathResolved) {
-				console.warn(`[unimport] failed to resolve "${subfilepath}", skip scanning`);
-				continue;
+		},
+		leave(node, parent, prop, index) {
+			additionalWalk?.leave?.call(this, node, parent, prop, index);
+			switch (node.type) {
+				case "BlockStatement": popScope(node);
 			}
-			const nested = await scanExports(subfilepath, includeTypes, seen);
-			imports.push(...additional ? nested.map((i) => ({
-				...i,
-				...additional
-			})) : nested);
 		}
-	}
-	if (filepath.match(/\.d\.[mc]?ts$/)) {
-		if (includeTypes) {
-			await toImport(exports$1, { type: true });
-			await toImport(findTypeExports(code), { type: true });
-		}
-	} else {
-		await toImport(exports$1);
-		if (includeTypes) await toImport(findTypeExports(code), { type: true });
-	}
-	return imports;
-}
-const CACHE_PATH = /* @__PURE__ */ join$1(os.tmpdir(), "unimport");
-let CACHE_WRITEABLE;
-async function resolvePackagePreset(preset) {
-	return (await extractExports(preset.package, preset.url, preset.cache)).filter((name) => {
-		for (const item of preset.ignore || []) {
-			if (typeof item === "string" && item === name) return false;
-			if (item instanceof RegExp && item.test(name)) return false;
-			if (typeof item === "function" && item(name) === false) return false;
-		}
-		return true;
-	}).map((name) => ({
-		from: preset.package,
-		name
-	}));
-}
-async function extractExports(name, url, cache = true) {
-	const version$1 = (await readPackageJSON(await resolvePackageJSON(name, { url }))).version;
-	const cachePath = join$1(CACHE_PATH, `${name}@${version$1}`, "exports.json");
-	if (cache && CACHE_WRITEABLE === void 0) try {
-		CACHE_WRITEABLE = isWritable(CACHE_PATH);
-	} catch {
-		CACHE_WRITEABLE = false;
-	}
-	const useCache = cache && version$1 && CACHE_WRITEABLE;
-	if (useCache && existsSync(cachePath)) return JSON.parse(await promises.readFile(cachePath, "utf-8"));
-	const scanned = await resolveModuleExportNames(name, { url });
-	if (useCache) {
-		await promises.mkdir(dirname$1(cachePath), { recursive: true });
-		await promises.writeFile(cachePath, JSON.stringify(scanned), "utf-8");
-	}
-	return scanned;
-}
-function isWritable(filename) {
-	try {
-		accessSync(filename, constants.W_OK);
-		return true;
-	} catch {
-		return false;
-	}
-}
-const dateFns = defineUnimportPreset({
-	from: "date-fns",
-	imports: [
-		"add",
-		"addBusinessDays",
-		"addDays",
-		"addHours",
-		"addISOWeekYears",
-		"addMilliseconds",
-		"addMinutes",
-		"addMonths",
-		"addQuarters",
-		"addSeconds",
-		"addWeeks",
-		"addYears",
-		"areIntervalsOverlapping",
-		"clamp",
-		"closestIndexTo",
-		"closestTo",
-		"compareAsc",
-		"compareDesc",
-		"constants",
-		"daysToWeeks",
-		"differenceInBusinessDays",
-		"differenceInCalendarDays",
-		"differenceInCalendarISOWeekYears",
-		"differenceInCalendarISOWeeks",
-		"differenceInCalendarMonths",
-		"differenceInCalendarQuarters",
-		"differenceInCalendarWeeks",
-		"differenceInCalendarYears",
-		"differenceInDays",
-		"differenceInHours",
-		"differenceInISOWeekYears",
-		"differenceInMilliseconds",
-		"differenceInMinutes",
-		"differenceInMonths",
-		"differenceInQuarters",
-		"differenceInSeconds",
-		"differenceInWeeks",
-		"differenceInYears",
-		"eachDayOfInterval",
-		"eachHourOfInterval",
-		"eachMinuteOfInterval",
-		"eachMonthOfInterval",
-		"eachQuarterOfInterval",
-		"eachWeekOfInterval",
-		"eachWeekendOfInterval",
-		"eachWeekendOfMonth",
-		"eachWeekendOfYear",
-		"eachYearOfInterval",
-		"endOfDay",
-		"endOfDecade",
-		"endOfHour",
-		"endOfISOWeek",
-		"endOfISOWeekYear",
-		"endOfMinute",
-		"endOfMonth",
-		"endOfQuarter",
-		"endOfSecond",
-		"endOfToday",
-		"endOfTomorrow",
-		"endOfWeek",
-		"endOfYear",
-		"endOfYesterday",
-		"format",
-		"formatDistance",
-		"formatDistanceStrict",
-		"formatDistanceToNow",
-		"formatDistanceToNowStrict",
-		"formatDuration",
-		"formatISO",
-		"formatISO9075",
-		"formatISODuration",
-		"formatRFC3339",
-		"formatRFC7231",
-		"formatRelative",
-		"fromUnixTime",
-		"getDate",
-		"getDay",
-		"getDayOfYear",
-		"getDaysInMonth",
-		"getDaysInYear",
-		"getDecade",
-		"getDefaultOptions",
-		"getHours",
-		"getISODay",
-		"getISOWeek",
-		"getISOWeekYear",
-		"getISOWeeksInYear",
-		"getMilliseconds",
-		"getMinutes",
-		"getMonth",
-		"getOverlappingDaysInIntervals",
-		"getQuarter",
-		"getSeconds",
-		"getTime",
-		"getUnixTime",
-		"getWeek",
-		"getWeekOfMonth",
-		"getWeekYear",
-		"getWeeksInMonth",
-		"getYear",
-		"hoursToMilliseconds",
-		"hoursToMinutes",
-		"hoursToSeconds",
-		"intervalToDuration",
-		"intlFormat",
-		"intlFormatDistance",
-		"isAfter",
-		"isBefore",
-		"isDate",
-		"isEqual",
-		"isExists",
-		"isFirstDayOfMonth",
-		"isFriday",
-		"isFuture",
-		"isLastDayOfMonth",
-		"isLeapYear",
-		"isMatch",
-		"isMonday",
-		"isPast",
-		"isSameDay",
-		"isSameHour",
-		"isSameISOWeek",
-		"isSameISOWeekYear",
-		"isSameMinute",
-		"isSameMonth",
-		"isSameQuarter",
-		"isSameSecond",
-		"isSameWeek",
-		"isSameYear",
-		"isSaturday",
-		"isSunday",
-		"isThisHour",
-		"isThisISOWeek",
-		"isThisMinute",
-		"isThisMonth",
-		"isThisQuarter",
-		"isThisSecond",
-		"isThisWeek",
-		"isThisYear",
-		"isThursday",
-		"isToday",
-		"isTomorrow",
-		"isTuesday",
-		"isValid",
-		"isWednesday",
-		"isWeekend",
-		"isWithinInterval",
-		"isYesterday",
-		"lastDayOfDecade",
-		"lastDayOfISOWeek",
-		"lastDayOfISOWeekYear",
-		"lastDayOfMonth",
-		"lastDayOfQuarter",
-		"lastDayOfWeek",
-		"lastDayOfYear",
-		"lightFormat",
-		"max",
-		"milliseconds",
-		"millisecondsToHours",
-		"millisecondsToMinutes",
-		"millisecondsToSeconds",
-		"min",
-		"minutesToHours",
-		"minutesToMilliseconds",
-		"minutesToSeconds",
-		"monthsToQuarters",
-		"monthsToYears",
-		"nextDay",
-		"nextFriday",
-		"nextMonday",
-		"nextSaturday",
-		"nextSunday",
-		"nextThursday",
-		"nextTuesday",
-		"nextWednesday",
-		"parse",
-		"parseISO",
-		"parseJSON",
-		"previousDay",
-		"previousFriday",
-		"previousMonday",
-		"previousSaturday",
-		"previousSunday",
-		"previousThursday",
-		"previousTuesday",
-		"previousWednesday",
-		"quartersToMonths",
-		"quartersToYears",
-		"roundToNearestMinutes",
-		"secondsToHours",
-		"secondsToMilliseconds",
-		"secondsToMinutes",
-		"set",
-		"setDate",
-		"setDay",
-		"setDayOfYear",
-		"setDefaultOptions",
-		"setHours",
-		"setISODay",
-		"setISOWeek",
-		"setISOWeekYear",
-		"setMilliseconds",
-		"setMinutes",
-		"setMonth",
-		"setQuarter",
-		"setSeconds",
-		"setWeek",
-		"setWeekYear",
-		"setYear",
-		"startOfDay",
-		"startOfDecade",
-		"startOfHour",
-		"startOfISOWeek",
-		"startOfISOWeekYear",
-		"startOfMinute",
-		"startOfMonth",
-		"startOfQuarter",
-		"startOfSecond",
-		"startOfToday",
-		"startOfTomorrow",
-		"startOfWeek",
-		"startOfWeekYear",
-		"startOfYear",
-		"startOfYesterday",
-		"sub",
-		"subBusinessDays",
-		"subDays",
-		"subHours",
-		"subISOWeekYears",
-		"subMilliseconds",
-		"subMinutes",
-		"subMonths",
-		"subQuarters",
-		"subSeconds",
-		"subWeeks",
-		"subYears",
-		"toDate",
-		"weeksToDays",
-		"yearsToMonths",
-		"yearsToQuarters"
-	]
-});
-const pinia = defineUnimportPreset({
-	from: "pinia",
-	imports: [
-		"acceptHMRUpdate",
-		"createPinia",
-		"defineStore",
-		"getActivePinia",
-		"mapActions",
-		"mapGetters",
-		"mapState",
-		"mapStores",
-		"mapWritableState",
-		"setActivePinia",
-		"setMapStoreSuffix",
-		"storeToRefs"
-	]
-});
-const preact = defineUnimportPreset({
-	from: "preact",
-	imports: [
-		"useState",
-		"useCallback",
-		"useMemo",
-		"useEffect",
-		"useRef",
-		"useContext",
-		"useReducer"
-	]
-});
-const quasar = defineUnimportPreset({
-	from: "quasar",
-	imports: [
-		"useQuasar",
-		"useDialogPluginComponent",
-		"useFormChild",
-		"useMeta"
-	]
-});
-const react = defineUnimportPreset({
-	from: "react",
-	imports: [
-		"useState",
-		"useCallback",
-		"useMemo",
-		"useEffect",
-		"useRef",
-		"useContext",
-		"useReducer"
-	]
-});
-const ReactRouterHooks = [
-	"useOutletContext",
-	"useHref",
-	"useInRouterContext",
-	"useLocation",
-	"useNavigationType",
-	"useNavigate",
-	"useOutlet",
-	"useParams",
-	"useResolvedPath",
-	"useRoutes"
-];
-const reactRouter = defineUnimportPreset({
-	from: "react-router",
-	imports: [...ReactRouterHooks]
-});
-const reactRouterDom = defineUnimportPreset({
-	from: "react-router-dom",
-	imports: [
-		...ReactRouterHooks,
-		"useLinkClickHandler",
-		"useSearchParams",
-		"Link",
-		"NavLink",
-		"Navigate",
-		"Outlet",
-		"Route",
-		"Routes"
-	]
-});
-const rxjs = defineUnimportPreset({
-	from: "rxjs",
-	imports: [
-		"of",
-		"from",
-		"map",
-		"tap",
-		"filter",
-		"forkJoin",
-		"throwError",
-		"catchError",
-		"Observable",
-		"mergeMap",
-		"switchMap",
-		"merge",
-		"zip",
-		"take",
-		"takeUntil",
-		"first",
-		"lastValueFrom",
-		"skip",
-		"skipUntil",
-		"distinct",
-		"distinctUntilChanged",
-		"throttle",
-		"throttleTime",
-		"retry",
-		"retryWhen",
-		"timeout",
-		"delay",
-		"debounce",
-		"debounceTime",
-		"find",
-		"every"
-	]
-});
-const solid = defineUnimportPreset({
-	from: "solid-js",
-	imports: [
-		defineUnimportPreset({
-			from: "solid-js",
-			imports: [
-				"createSignal",
-				"createEffect",
-				"createMemo",
-				"createResource",
-				"onMount",
-				"onCleanup",
-				"onError",
-				"untrack",
-				"batch",
-				"on",
-				"createRoot",
-				"mergeProps",
-				"splitProps",
-				"useTransition",
-				"observable",
-				"mapArray",
-				"indexArray",
-				"createContext",
-				"useContext",
-				"children",
-				"lazy",
-				"createDeferred",
-				"createRenderEffect",
-				"createSelector",
-				"For",
-				"Show",
-				"Switch",
-				"Match",
-				"Index",
-				"ErrorBoundary",
-				"Suspense",
-				"SuspenseList"
-			]
-		}),
-		defineUnimportPreset({
-			from: "solid-js/store",
-			imports: [
-				"createStore",
-				"produce",
-				"reconcile",
-				"createMutable"
-			]
-		}),
-		defineUnimportPreset({
-			from: "solid-js/web",
-			imports: [
-				"Dynamic",
-				"hydrate",
-				"render",
-				"renderToString",
-				"renderToStringAsync",
-				"renderToStream",
-				"isServer",
-				"Portal"
-			]
-		})
-	]
-});
-const solidAppRouter = defineUnimportPreset({
-	from: "solid-app-router",
-	imports: [
-		"Link",
-		"NavLink",
-		"Navigate",
-		"Outlet",
-		"Route",
-		"Router",
-		"Routes",
-		"_mergeSearchString",
-		"createIntegration",
-		"hashIntegration",
-		"normalizeIntegration",
-		"pathIntegration",
-		"staticIntegration",
-		"useHref",
-		"useIsRouting",
-		"useLocation",
-		"useMatch",
-		"useNavigate",
-		"useParams",
-		"useResolvedPath",
-		"useRouteData",
-		"useRoutes",
-		"useSearchParams"
-	]
-});
-const svelteAnimate = defineUnimportPreset({
-	from: "svelte/animate",
-	imports: ["flip"]
-});
-const svelteEasing = defineUnimportPreset({
-	from: "svelte/easing",
-	imports: [
-		"back",
-		"bounce",
-		"circ",
-		"cubic",
-		"elastic",
-		"expo",
-		"quad",
-		"quart",
-		"quint",
-		"sine"
-	].reduce((acc, e) => {
-		acc.push(`${e}In`, `${e}Out`, `${e}InOut`);
-		return acc;
-	}, ["linear"])
-});
-const svelteStore = defineUnimportPreset({
-	from: "svelte/store",
-	imports: [
-		"writable",
-		"readable",
-		"derived",
-		"get"
-	]
-});
-const svelteMotion = defineUnimportPreset({
-	from: "svelte/motion",
-	imports: ["tweened", "spring"]
-});
-const svelteTransition = defineUnimportPreset({
-	from: "svelte/transition",
-	imports: [
-		"fade",
-		"blur",
-		"fly",
-		"slide",
-		"scale",
-		"draw",
-		"crossfade"
-	]
-});
-const svelte = defineUnimportPreset({
-	from: "svelte",
-	imports: [
-		"onMount",
-		"beforeUpdate",
-		"afterUpdate",
-		"onDestroy",
-		"tick",
-		"setContext",
-		"getContext",
-		"hasContext",
-		"getAllContexts",
-		"createEventDispatcher"
-	]
-});
-const uniApp = defineUnimportPreset({
-	from: "@dcloudio/uni-app",
-	imports: [
-		"onAddToFavorites",
-		"onBackPress",
-		"onError",
-		"onHide",
-		"onLaunch",
-		"onLoad",
-		"onNavigationBarButtonTap",
-		"onNavigationBarSearchInputChanged",
-		"onNavigationBarSearchInputClicked",
-		"onNavigationBarSearchInputConfirmed",
-		"onNavigationBarSearchInputFocusChanged",
-		"onPageNotFound",
-		"onPageScroll",
-		"onPullDownRefresh",
-		"onReachBottom",
-		"onReady",
-		"onResize",
-		"onShareAppMessage",
-		"onShareTimeline",
-		"onShow",
-		"onTabItemTap",
-		"onThemeChange",
-		"onUnhandledRejection",
-		"onUnload"
-	]
-});
-const veeValidate = defineUnimportPreset({
-	from: "vee-validate",
-	imports: [
-		"validate",
-		"defineRule",
-		"configure",
-		"useField",
-		"useForm",
-		"useFieldArray",
-		"useResetForm",
-		"useIsFieldDirty",
-		"useIsFieldTouched",
-		"useIsFieldValid",
-		"useIsSubmitting",
-		"useValidateField",
-		"useIsFormDirty",
-		"useIsFormTouched",
-		"useIsFormValid",
-		"useValidateForm",
-		"useSubmitCount",
-		"useFieldValue",
-		"useFormValues",
-		"useFormErrors",
-		"useFieldError",
-		"useSubmitForm",
-		"FormContextKey",
-		"FieldContextKey"
-	]
-});
-const vitepress = defineUnimportPreset({
-	from: "vitepress",
-	imports: [
-		"useData",
-		"useRoute",
-		"useRouter",
-		"withBase"
-	]
-});
-const vitest = defineUnimportPreset({
-	from: "vitest",
-	imports: [
-		"suite",
-		"test",
-		"describe",
-		"it",
-		"chai",
-		"expect",
-		"assert",
-		"vitest",
-		"vi",
-		"beforeAll",
-		"afterAll",
-		"beforeEach",
-		"afterEach"
-	]
-});
-const CommonCompositionAPI = [
-	"onActivated",
-	"onBeforeMount",
-	"onBeforeUnmount",
-	"onBeforeUpdate",
-	"onErrorCaptured",
-	"onDeactivated",
-	"onMounted",
-	"onServerPrefetch",
-	"onUnmounted",
-	"onUpdated",
-	"useAttrs",
-	"useSlots",
-	"computed",
-	"customRef",
-	"isReadonly",
-	"isRef",
-	"isShallow",
-	"isProxy",
-	"isReactive",
-	"markRaw",
-	"reactive",
-	"readonly",
-	"ref",
-	"shallowReactive",
-	"shallowReadonly",
-	"shallowRef",
-	"triggerRef",
-	"toRaw",
-	"toRef",
-	"toRefs",
-	"toValue",
-	"unref",
-	"watch",
-	"watchEffect",
-	"watchPostEffect",
-	"watchSyncEffect",
-	"defineComponent",
-	"defineAsyncComponent",
-	"getCurrentInstance",
-	"h",
-	"inject",
-	"nextTick",
-	"provide",
-	"useCssModule",
-	"createApp",
-	"effectScope",
-	"EffectScope",
-	"getCurrentScope",
-	"onScopeDispose",
-	...[
-		"Component",
-		"Slot",
-		"Slots",
-		"ComponentPublicInstance",
-		"ComputedRef",
-		"DirectiveBinding",
-		"ExtractDefaultPropTypes",
-		"ExtractPropTypes",
-		"ExtractPublicPropTypes",
-		"InjectionKey",
-		"PropType",
-		"Ref",
-		"ShallowRef",
-		"MaybeRef",
-		"MaybeRefOrGetter",
-		"VNode",
-		"WritableComputedRef"
-	].map((name) => ({
-		name,
-		type: true
-	}))
-];
-const vue = defineUnimportPreset({
-	from: "vue",
-	imports: [
-		...CommonCompositionAPI,
-		"onRenderTracked",
-		"onRenderTriggered",
-		"resolveComponent",
-		"useCssVars",
-		"useModel",
-		"getCurrentWatcher",
-		"onWatcherCleanup",
-		"useId",
-		"useTemplateRef"
-	]
-});
-const vueCompositionApi = defineUnimportPreset({
-	from: "@vue/composition-api",
-	imports: CommonCompositionAPI
-});
-const vueDemi = defineUnimportPreset({
-	from: "vue-demi",
-	imports: CommonCompositionAPI
-});
-const vueI18n = defineUnimportPreset({
-	from: "vue-i18n",
-	imports: ["useI18n"]
-});
-const vueMacros = defineUnimportPreset({
-	from: "vue/macros",
-	imports: [
-		"$",
-		"$$",
-		"$ref",
-		"$shallowRef",
-		"$toRef",
-		"$customRef",
-		"$computed"
-	]
-});
-const vueRouter = defineUnimportPreset({
-	from: "vue-router",
-	imports: [
-		"useRouter",
-		"useRoute",
-		"useLink",
-		"onBeforeRouteLeave",
-		"onBeforeRouteUpdate"
-	]
-});
-const vueRouterComposables = defineUnimportPreset({
-	from: "vue-router/composables",
-	imports: [
-		"useRouter",
-		"useRoute",
-		"useLink",
-		"onBeforeRouteLeave",
-		"onBeforeRouteUpdate"
-	]
-});
-let _cache;
-const vueuseCore = () => {
-	const excluded = ["toRefs", "utils"];
-	if (!_cache) try {
-		const corePath = resolveModule("@vueuse/core") || process$1.cwd();
-		const path$1 = resolveModule("@vueuse/core/indexes.json") || resolveModule("@vueuse/metadata/index.json") || resolveModule("@vueuse/metadata/index.json", { paths: [corePath] });
-		_cache = defineUnimportPreset({
-			from: "@vueuse/core",
-			imports: JSON.parse(readFileSync(path$1, "utf-8")).functions.filter((i) => ["core", "shared"].includes(i.package)).map((i) => i.name).filter((i) => i && i.length >= 4 && !excluded.includes(i))
-		});
-	} catch (error) {
-		console.error(error);
-		throw new Error("[auto-import] failed to load @vueuse/core, have you installed it?");
-	}
-	return _cache;
-};
-const vueuseHead = defineUnimportPreset({
-	from: "@vueuse/head",
-	imports: ["useHead"]
-});
-const vuex = defineUnimportPreset({
-	from: "vuex",
-	imports: [
-		"createStore",
-		"createLogger",
-		"mapState",
-		"mapGetters",
-		"mapActions",
-		"mapMutations",
-		"createNamespacedHelpers",
-		"useStore"
-	]
-});
-const builtinPresets = {
-	"@vue/composition-api": vueCompositionApi,
-	"@vueuse/core": vueuseCore,
-	"@vueuse/head": vueuseHead,
-	"pinia": pinia,
-	"preact": preact,
-	"quasar": quasar,
-	"react": react,
-	"react-router": reactRouter,
-	"react-router-dom": reactRouterDom,
-	"svelte": svelte,
-	"svelte/animate": svelteAnimate,
-	"svelte/easing": svelteEasing,
-	"svelte/motion": svelteMotion,
-	"svelte/store": svelteStore,
-	"svelte/transition": svelteTransition,
-	"vee-validate": veeValidate,
-	"vitepress": vitepress,
-	"vue-demi": vueDemi,
-	"vue-i18n": vueI18n,
-	"vue-router": vueRouter,
-	"vue-router-composables": vueRouterComposables,
-	"vue": vue,
-	"vue/macros": vueMacros,
-	"vuex": vuex,
-	"vitest": vitest,
-	"uni-app": uniApp,
-	"solid-js": solid,
-	"solid-app-router": solidAppRouter,
-	"rxjs": rxjs,
-	"date-fns": dateFns
-};
-const commonProps = [
-	"from",
-	"priority",
-	"disabled",
-	"dtsDisabled",
-	"declarationType",
-	"meta",
-	"type",
-	"typeFrom"
-];
-async function resolvePreset(preset) {
-	const imports = [];
-	if ("package" in preset) return await resolvePackagePreset(preset);
-	const common = {};
-	commonProps.forEach((i) => {
-		if (i in preset) common[i] = preset[i];
-	});
-	for (const _import of preset.imports) if (typeof _import === "string") imports.push({
-		...common,
-		name: _import,
-		as: _import
-	});
-	else if (Array.isArray(_import)) imports.push({
-		...common,
-		name: _import[0],
-		as: _import[1] || _import[0],
-		from: _import[2] || preset.from
 	});
-	else if (_import.imports) imports.push(...await resolvePreset(_import));
-	else imports.push({
-		...common,
-		..._import
-	});
-	return imports;
-}
-async function resolveBuiltinPresets(presets) {
-	return (await Promise.all(presets.map(async (p) => {
-		let preset = typeof p === "string" ? builtinPresets[p] : p;
-		if (typeof preset === "function") preset = preset();
-		return await resolvePreset(preset);
-	}))).flat();
-}
-function createUnimport(opts) {
-	const ctx = createInternalContext(opts);
-	async function generateTypeDeclarations(options) {
-		const opts2 = {
-			resolvePath: (i) => stripFileExtension(i.typeFrom || i.from),
-			...options
-		};
-		const { typeReExports = true } = opts2;
-		const imports = await ctx.getImports();
-		let dts = toTypeDeclarationFile(imports.filter((i) => !i.type && !i.dtsDisabled), opts2);
-		const typeOnly = imports.filter((i) => i.type);
-		if (typeReExports && typeOnly.length) dts += `
-${toTypeReExports(typeOnly, opts2)}`;
-		for (const addon of ctx.addons) dts = await addon.declaration?.call(ctx, dts, opts2) ?? dts;
-		return dts;
-	}
-	async function scanImportsFromFile(filepath, includeTypes = true) {
-		const additions = await scanExports(filepath, includeTypes);
-		await ctx.modifyDynamicImports((imports) => imports.filter((i) => i.from !== filepath).concat(additions));
-		return additions;
-	}
-	async function scanImportsFromDir(dirs = ctx.options.dirs || [], options = ctx.options.dirsScanOptions) {
-		const imports = await scanDirExports(dirs, options);
-		const files = new Set(imports.map((f) => f.from));
-		await ctx.modifyDynamicImports((i) => i.filter((i2) => !files.has(i2.from)).concat(imports));
-		return imports;
-	}
-	async function injectImportsWithContext(code, id, options) {
-		const result = await injectImports(code, id, ctx, {
-			...opts,
-			...options
-		});
-		const metadata = ctx.getMetadata();
-		if (metadata) result.imports.forEach((i) => {
-			metadata.injectionUsage[i.name] = metadata.injectionUsage[i.name] || {
-				import: i,
-				count: 0,
-				moduleIds: []
-			};
-			metadata.injectionUsage[i.name].count++;
-			if (id && !metadata.injectionUsage[i.name].moduleIds.includes(id)) metadata.injectionUsage[i.name].moduleIds.push(id);
-		});
-		return result;
-	}
-	async function init() {
-		if (ctx.options.dirs?.length) await scanImportsFromDir();
+	const unmatched = /* @__PURE__ */ new Set();
+	for (const scope of scopes) for (const name of scope.references) {
+		let defined = false;
+		let parent = scope;
+		while (parent) {
+			if (parent.declarations.has(name)) {
+				defined = true;
+				break;
+			}
+			parent = parent?.parent;
+		}
+		if (!defined) unmatched.add(name);
 	}
 	return {
-		version,
-		init,
-		clearDynamicImports: () => ctx.clearDynamicImports(),
-		modifyDynamicImports: (fn) => ctx.modifyDynamicImports(fn),
-		scanImportsFromDir,
-		scanImportsFromFile,
-		getImports: () => ctx.getImports(),
-		getImportMap: () => ctx.getImportMap(),
-		detectImports: (code) => detectImports(code, ctx),
-		injectImports: injectImportsWithContext,
-		generateTypeDeclarations: (options) => generateTypeDeclarations(options),
-		getMetadata: () => ctx.getMetadata(),
-		getInternalContext: () => ctx,
-		toExports: async (filepath, includeTypes = false) => toExports(await ctx.getImports(), filepath, includeTypes)
+		unmatched,
+		scopes
 	};
 }
-function createInternalContext(opts) {
-	let _combinedImports;
-	const _map = /* @__PURE__ */ new Map();
-	const addons = configureAddons(opts);
-	opts.addons = addons;
-	opts.commentsDisable = opts.commentsDisable ?? ["@unimport-disable", "@imports-disable"];
-	opts.commentsDebug = opts.commentsDebug ?? ["@unimport-debug", "@imports-debug"];
-	let metadata;
-	if (opts.collectMeta) metadata = { injectionUsage: {} };
-	let resolvePromise;
-	const ctx = {
-		version,
-		options: opts,
-		addons,
-		staticImports: [...opts.imports || []].filter(Boolean),
-		dynamicImports: [],
-		modifyDynamicImports,
-		clearDynamicImports,
-		async getImports() {
-			await resolvePromise;
-			return updateImports();
-		},
-		async replaceImports(imports) {
-			ctx.staticImports = [...imports || []].filter(Boolean);
-			ctx.invalidate();
-			await resolvePromise;
-			return updateImports();
-		},
-		async getImportMap() {
-			await ctx.getImports();
-			return _map;
-		},
-		getMetadata() {
-			return metadata;
-		},
-		invalidate() {
-			_combinedImports = void 0;
-		},
-		resolveId: (id, parentId) => opts.resolveId?.(id, parentId)
-	};
-	resolvePromise = resolveBuiltinPresets(opts.presets || []).then((r) => {
-		ctx.staticImports.unshift(...r);
-		_combinedImports = void 0;
-		updateImports();
-	});
-	function updateImports() {
-		if (!_combinedImports) {
-			let imports = normalizeImports(dedupeImports([...ctx.staticImports, ...ctx.dynamicImports], opts.warn || console.warn));
-			for (const addon of ctx.addons) if (addon.extendImports) imports = addon.extendImports.call(ctx, imports) ?? imports;
-			imports = imports.filter((i) => !i.disabled);
-			_map.clear();
-			for (const _import of imports) if (!_import.type) _map.set(_import.as ?? _import.name, _import);
-			_combinedImports = imports;
-		}
-		return _combinedImports;
-	}
-	async function modifyDynamicImports(fn) {
-		const result = await fn(ctx.dynamicImports);
-		if (Array.isArray(result)) ctx.dynamicImports = result;
-		ctx.invalidate();
-	}
-	function clearDynamicImports() {
-		ctx.dynamicImports.length = 0;
-		ctx.invalidate();
-	}
-	return ctx;
-}
-async function injectImports(code, id, ctx, options) {
-	const s = getMagicString(code);
-	if (ctx.options.commentsDisable?.some((c) => s.original.includes(c))) return {
-		s,
-		get code() {
-			return s.toString();
-		},
-		imports: []
-	};
-	for (const addon of ctx.addons) await addon.transform?.call(ctx, s, id);
-	const { isCJSContext, matchedImports, firstOccurrence } = await detectImports(s, ctx, options);
-	const imports = await resolveImports(ctx, matchedImports, id);
-	if (ctx.options.commentsDebug?.some((c) => s.original.includes(c))) (ctx.options.debugLog || console.log)(`[unimport] ${imports.length} imports detected in "${id}"${imports.length ? `: ${imports.map((i) => i.name).join(", ")}` : ""}`);
+function createVirtualImportsAcronWalker(importMap, virtualImports = []) {
+	const imports = [];
+	const ranges = [];
 	return {
-		...addImportToCode(s, imports, isCJSContext, options?.mergeExisting, options?.injectAtEnd, firstOccurrence, (imports2) => {
-			for (const addon of ctx.addons) imports2 = addon.injectImportsResolved?.call(ctx, imports2, s, id) ?? imports2;
-			return imports2;
-		}, (str, imports2) => {
-			for (const addon of ctx.addons) str = addon.injectImportsStringified?.call(ctx, str, imports2, s, id) ?? str;
-			return str;
-		}),
-		imports
+		imports,
+		ranges,
+		walk: { enter(node) {
+			if (node.type === "ImportDeclaration") {
+				if (virtualImports.includes(node.source.value)) {
+					ranges.push([node.start, node.end]);
+					node.specifiers.forEach((i) => {
+						if (i.type === "ImportSpecifier" && i.imported.type === "Identifier") {
+							const original = importMap.get(i.imported.name);
+							if (!original) throw new Error(`[unimport] failed to find "${i.imported.name}" imported from "${node.source.value}"`);
+							imports.push({
+								from: original.from,
+								name: original.name,
+								as: i.local.name
+							});
+						}
+					});
+				}
+			}
+		} }
 	};
 }
-async function resolveImports(ctx, imports, id) {
-	const resolveCache = /* @__PURE__ */ new Map();
-	return (await Promise.all(imports.map(async (i) => {
-		if (!resolveCache.has(i.from)) resolveCache.set(i.from, await ctx.resolveId(i.from, id) || i.from);
-		const from = resolveCache.get(i.from);
-		if (i.from === id || !from || from === "." || from === id) return;
-		return {
-			...i,
-			from
-		};
-	}))).filter(Boolean);
-}
 
 //#endregion
-//#region node_modules/.pnpm/unplugin@2.3.10/node_modules/unplugin/dist/context-D49cMElb.js
-var import_picomatch$1 = /* @__PURE__ */ __toESM(require_picomatch(), 1);
+//#region node_modules/.pnpm/unplugin@2.3.11/node_modules/unplugin/dist/context-Csj9j3eN.js
+var import_picomatch = /* @__PURE__ */ __toESM(require_picomatch(), 1);
 function toArray$2(array) {
 	array = array || [];
 	if (Array.isArray(array)) return array;
@@ -1780,12 +215,12 @@ function normalize$1(path$1) {
 	return path$1.replace(BACKSLASH_REGEX, "/");
 }
 const ABSOLUTE_PATH_REGEX = /^(?:\/|(?:[A-Z]:)?[/\\|])/i;
-function isAbsolute$1$1(path$1) {
+function isAbsolute$1(path$1) {
 	return ABSOLUTE_PATH_REGEX.test(path$1);
 }
-function getMatcherString$1(glob$1, cwd$1) {
-	if (glob$1.startsWith("**") || isAbsolute$1$1(glob$1)) return normalize$1(glob$1);
-	return normalize$1(resolve(cwd$1, glob$1));
+function getMatcherString$1(glob, cwd$1) {
+	if (glob.startsWith("**") || isAbsolute$1(glob)) return normalize$1(glob);
+	return normalize$1(resolve(cwd$1, glob));
 }
 function patternToIdFilter(pattern) {
 	if (pattern instanceof RegExp) return (id) => {
@@ -1794,7 +229,7 @@ function patternToIdFilter(pattern) {
 		pattern.lastIndex = 0;
 		return result;
 	};
-	const matcher = (0, import_picomatch$1.default)(getMatcherString$1(pattern, process.cwd()), { dot: true });
+	const matcher = (0, import_picomatch.default)(getMatcherString$1(pattern, process.cwd()), { dot: true });
 	return (id) => {
 		return matcher(normalize$1(id));
 	};
@@ -1868,7 +303,7 @@ function normalizeObjectHook(name, hook) {
 		filter: filter || (() => true)
 	};
 }
-function parse$1(code, opts = {}) {
+function parse(code, opts = {}) {
 	return Parser.parse(code, {
 		sourceType: "module",
 		ecmaVersion: "latest",
@@ -1878,7 +313,7 @@ function parse$1(code, opts = {}) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/unplugin@2.3.10/node_modules/unplugin/dist/webpack-like-CSbnjTNU.js
+//#region node_modules/.pnpm/unplugin@2.3.11/node_modules/unplugin/dist/webpack-like-DFGTNSuV.js
 function transformUse(data, plugin, transformLoader) {
 	if (data.resource == null) return [];
 	const id = normalizeAbsolutePath(data.resource + (data.resourceQuery || ""));
@@ -1907,15 +342,16 @@ function normalizeAbsolutePath(path$1) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/unplugin@2.3.10/node_modules/unplugin/dist/context-D_KPTgTH.js
-function createBuildContext(compiler, compilation, loaderContext) {
+//#region node_modules/.pnpm/unplugin@2.3.11/node_modules/unplugin/dist/context-DkYlx1xL.js
+function createBuildContext$1(compiler, compilation, loaderContext, inputSourceMap) {
 	return {
 		getNativeBuildContext() {
 			return {
 				framework: "rspack",
 				compiler,
 				compilation,
-				loaderContext
+				loaderContext,
+				inputSourceMap
 			};
 		},
 		addWatchFile(file) {
@@ -1925,7 +361,7 @@ function createBuildContext(compiler, compilation, loaderContext) {
 		getWatchFiles() {
 			return Array.from(compilation.fileDependencies);
 		},
-		parse: parse$1,
+		parse,
 		emitFile(emittedFile) {
 			const outFileName = emittedFile.fileName || emittedFile.name;
 			if (emittedFile.source && outFileName) {
@@ -1935,7 +371,7 @@ function createBuildContext(compiler, compilation, loaderContext) {
 		}
 	};
 }
-function normalizeMessage(error) {
+function normalizeMessage$1(error) {
 	const err = new Error(typeof error === "string" ? error : error.message);
 	if (typeof error === "object") {
 		err.stack = error.stack;
@@ -1945,7 +381,7 @@ function normalizeMessage(error) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/unplugin@2.3.10/node_modules/unplugin/dist/utils-C8vphsat.js
+//#region node_modules/.pnpm/unplugin@2.3.11/node_modules/unplugin/dist/utils-BosfZ0pB.js
 function encodeVirtualModuleId(id, plugin) {
 	return resolve(plugin.__virtualModulePrefix, encodeURIComponent(id));
 }
@@ -1955,16 +391,16 @@ function decodeVirtualModuleId(encoded, _plugin) {
 function isVirtualModuleId(encoded, plugin) {
 	return dirname(encoded) === plugin.__virtualModulePrefix;
 }
-var FakeVirtualModulesPlugin = class FakeVirtualModulesPlugin$1 {
+var FakeVirtualModulesPlugin = class FakeVirtualModulesPlugin {
 	name = "FakeVirtualModulesPlugin";
 	static counters = /* @__PURE__ */ new Map();
 	static initCleanup = false;
 	constructor(plugin) {
 		this.plugin = plugin;
-		if (!FakeVirtualModulesPlugin$1.initCleanup) {
-			FakeVirtualModulesPlugin$1.initCleanup = true;
+		if (!FakeVirtualModulesPlugin.initCleanup) {
+			FakeVirtualModulesPlugin.initCleanup = true;
 			process.once("exit", () => {
-				FakeVirtualModulesPlugin$1.counters.forEach((_, dir) => {
+				FakeVirtualModulesPlugin.counters.forEach((_, dir) => {
 					fs.rmSync(dir, {
 						recursive: true,
 						force: true
@@ -1976,17 +412,17 @@ var FakeVirtualModulesPlugin = class FakeVirtualModulesPlugin$1 {
 	apply(compiler) {
 		const dir = this.plugin.__virtualModulePrefix;
 		if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-		const counter = FakeVirtualModulesPlugin$1.counters.get(dir) ?? 0;
-		FakeVirtualModulesPlugin$1.counters.set(dir, counter + 1);
+		const counter = FakeVirtualModulesPlugin.counters.get(dir) ?? 0;
+		FakeVirtualModulesPlugin.counters.set(dir, counter + 1);
 		compiler.hooks.shutdown.tap(this.name, () => {
-			const counter$1 = (FakeVirtualModulesPlugin$1.counters.get(dir) ?? 1) - 1;
+			const counter$1 = (FakeVirtualModulesPlugin.counters.get(dir) ?? 1) - 1;
 			if (counter$1 === 0) {
-				FakeVirtualModulesPlugin$1.counters.delete(dir);
+				FakeVirtualModulesPlugin.counters.delete(dir);
 				fs.rmSync(dir, {
 					recursive: true,
 					force: true
 				});
-			} else FakeVirtualModulesPlugin$1.counters.set(dir, counter$1);
+			} else FakeVirtualModulesPlugin.counters.set(dir, counter$1);
 		});
 	}
 	async writeModule(file) {
@@ -1995,7 +431,7 @@ var FakeVirtualModulesPlugin = class FakeVirtualModulesPlugin$1 {
 };
 
 //#endregion
-//#region node_modules/.pnpm/unplugin@2.3.10/node_modules/unplugin/dist/context-BZKy5Nsn.js
+//#region node_modules/.pnpm/unplugin@2.3.11/node_modules/unplugin/dist/context-OCFO8EW1.js
 function contextOptionsFromCompilation(compilation) {
 	return {
 		addWatchFile(file) {
@@ -2010,9 +446,9 @@ const require$1 = createRequire(import.meta.url);
 function getSource(fileSource) {
 	return new (require$1("webpack")).sources.RawSource(typeof fileSource === "string" ? fileSource : Buffer.from(fileSource.buffer));
 }
-function createBuildContext$1(options, compiler, compilation, loaderContext) {
+function createBuildContext(options, compiler, compilation, loaderContext, inputSourceMap) {
 	return {
-		parse: parse$1,
+		parse,
 		addWatchFile(id) {
 			options.addWatchFile(resolve(process$1.cwd(), id));
 		},
@@ -2031,12 +467,13 @@ function createBuildContext$1(options, compiler, compilation, loaderContext) {
 				framework: "webpack",
 				compiler,
 				compilation,
-				loaderContext
+				loaderContext,
+				inputSourceMap
 			};
 		}
 	};
 }
-function normalizeMessage$1(error) {
+function normalizeMessage(error) {
 	const err = new Error(typeof error === "string" ? error : error.message);
 	if (typeof error === "object") {
 		err.stack = error.stack;
@@ -2047,7 +484,7 @@ function normalizeMessage$1(error) {
 
 //#endregion
 //#region node_modules/.pnpm/webpack-virtual-modules@0.6.2/node_modules/webpack-virtual-modules/lib/virtual-stats.js
-var require_virtual_stats = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/webpack-virtual-modules@0.6.2/node_modules/webpack-virtual-modules/lib/virtual-stats.js": ((exports) => {
+var require_virtual_stats = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var __importDefault = exports && exports.__importDefault || function(mod) {
 		return mod && mod.__esModule ? mod : { "default": mod };
 	};
@@ -2087,11 +524,11 @@ var require_virtual_stats = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/web
 		}
 	};
 	exports.VirtualStats = VirtualStats;
-}) });
+}));
 
 //#endregion
 //#region node_modules/.pnpm/webpack-virtual-modules@0.6.2/node_modules/webpack-virtual-modules/lib/index.js
-var require_lib = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/webpack-virtual-modules@0.6.2/node_modules/webpack-virtual-modules/lib/index.js": ((exports, module) => {
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const path_1 = (exports && exports.__importDefault || function(mod) {
 		return mod && mod.__esModule ? mod : { "default": mod };
 	})(__require("path"));
@@ -2149,7 +586,7 @@ var require_lib = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/webpack-virtu
 	function getRealpathBackend(fileSystem) {
 		if (fileSystem._realpathBackend) return fileSystem._realpathBackend;
 	}
-	var VirtualModulesPlugin$1 = class {
+	var VirtualModulesPlugin = class {
 		constructor(modules) {
 			this._compiler = null;
 			this._watcher = null;
@@ -2286,14 +723,14 @@ var require_lib = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/webpack-virtu
 					this._staticModules = null;
 				}
 			};
-			const version$1 = typeof compiler.webpack === "undefined" ? 4 : 5;
+			const version = typeof compiler.webpack === "undefined" ? 4 : 5;
 			const watchRunHook = (watcher, callback) => {
 				this._watcher = watcher.compiler || watcher;
 				const virtualFiles = compiler.inputFileSystem._virtualFiles;
 				const fts = compiler.fileTimestamps;
 				if (virtualFiles && fts && typeof fts.set === "function") Object.keys(virtualFiles).forEach((file) => {
 					const mtime = +virtualFiles[file].stats.mtime;
-					fts.set(file, version$1 === 4 ? mtime : {
+					fts.set(file, version === 4 ? mtime : {
 						safeTime: mtime,
 						timestamp: mtime
 					});
@@ -2311,11 +748,11 @@ var require_lib = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/webpack-virtu
 			}
 		}
 	};
-	module.exports = VirtualModulesPlugin$1;
-}) });
+	module.exports = VirtualModulesPlugin;
+}));
 
 //#endregion
-//#region node_modules/.pnpm/unplugin@2.3.10/node_modules/unplugin/dist/index.js
+//#region node_modules/.pnpm/unplugin@2.3.11/node_modules/unplugin/dist/index.js
 var import_lib = /* @__PURE__ */ __toESM(require_lib(), 1);
 const ExtToLoader = {
 	".js": "js",
@@ -2379,7 +816,7 @@ function createBuildContext$2(build) {
 	const watchFiles = [];
 	const { initialOptions } = build;
 	return {
-		parse: parse$1,
+		parse,
 		addWatchFile() {
 			throw new Error("unplugin/esbuild: addWatchFile outside supported hooks (resolveId, load, transform)");
 		},
@@ -2605,7 +1042,7 @@ function buildSetup() {
 }
 function createFarmContext(context, currentResolveId) {
 	return {
-		parse: parse$1,
+		parse,
 		addWatchFile(id) {
 			context.addWatchFile(id, currentResolveId || id);
 		},
@@ -2957,7 +1394,7 @@ const LOAD_LOADER$1 = resolve(__dirname, "rspack/loaders/load");
 function getRspackPlugin(factory) {
 	return (userOptions) => {
 		return { apply(compiler) {
-			const VIRTUAL_MODULE_PREFIX = resolve(compiler.options.context ?? process.cwd(), "node_modules/.virtual", process.pid.toString());
+			const VIRTUAL_MODULE_PREFIX = resolve(compiler.options.context ?? process.cwd(), "node_modules/.virtual", compiler.rspack.experiments.VirtualModulesPlugin ? "" : process.pid.toString());
 			const meta = {
 				framework: "rspack",
 				rspack: { compiler }
@@ -2986,11 +1423,11 @@ function getRspackPlugin(factory) {
 							let importer = requestContext.issuer !== "" ? requestContext.issuer : void 0;
 							const isEntry = requestContext.issuer === "";
 							if (importer?.startsWith(plugin.__virtualModulePrefix)) importer = decodeURIComponent(importer.slice(plugin.__virtualModulePrefix.length));
-							const context = createBuildContext(compiler, compilation);
+							const context = createBuildContext$1(compiler, compilation);
 							let error;
 							const pluginContext = {
 								error(msg) {
-									if (error == null) error = normalizeMessage(msg);
+									if (error == null) error = normalizeMessage$1(msg);
 									else console.error(`unplugin/rspack: multiple errors returned from resolveId hook: ${msg}`);
 								},
 								warn(msg) {
@@ -3050,7 +1487,7 @@ function getRspackPlugin(factory) {
 				});
 				if (plugin.rspack) plugin.rspack(compiler);
 				if (plugin.watchChange || plugin.buildStart) compiler.hooks.make.tapPromise(plugin.name, async (compilation) => {
-					const context = createBuildContext(compiler, compilation);
+					const context = createBuildContext$1(compiler, compilation);
 					if (plugin.watchChange && (compiler.modifiedFiles || compiler.removedFiles)) {
 						const promises$1 = [];
 						if (compiler.modifiedFiles) compiler.modifiedFiles.forEach((file) => promises$1.push(Promise.resolve(plugin.watchChange.call(context, file, { event: "update" }))));
@@ -3060,7 +1497,7 @@ function getRspackPlugin(factory) {
 					if (plugin.buildStart) return await plugin.buildStart.call(context);
 				});
 				if (plugin.buildEnd) compiler.hooks.emit.tapPromise(plugin.name, async (compilation) => {
-					await plugin.buildEnd.call(createBuildContext(compiler, compilation));
+					await plugin.buildEnd.call(createBuildContext$1(compiler, compilation));
 				});
 				if (plugin.writeBundle) compiler.hooks.afterEmit.tapPromise(plugin.name, async () => {
 					await plugin.writeBundle();
@@ -3122,7 +1559,7 @@ function getWebpackPlugin(factory) {
 							const isEntry = requestContext.issuer === "";
 							if (importer?.startsWith(plugin.__virtualModulePrefix)) importer = decodeURIComponent(importer.slice(plugin.__virtualModulePrefix.length));
 							const fileDependencies = /* @__PURE__ */ new Set();
-							const context = createBuildContext$1({
+							const context = createBuildContext({
 								addWatchFile(file) {
 									fileDependencies.add(file);
 									resolveContext.fileDependencies?.add(file);
@@ -3134,7 +1571,7 @@ function getWebpackPlugin(factory) {
 							let error;
 							const pluginContext = {
 								error(msg) {
-									if (error == null) error = normalizeMessage$1(msg);
+									if (error == null) error = normalizeMessage(msg);
 									else console.error(`unplugin/webpack: multiple errors returned from resolveId hook: ${msg}`);
 								},
 								warn(msg) {
@@ -3187,7 +1624,7 @@ function getWebpackPlugin(factory) {
 				});
 				if (plugin.webpack) plugin.webpack(compiler);
 				if (plugin.watchChange || plugin.buildStart) compiler.hooks.make.tapPromise(plugin.name, async (compilation) => {
-					const context = createBuildContext$1(contextOptionsFromCompilation(compilation), compiler, compilation);
+					const context = createBuildContext(contextOptionsFromCompilation(compilation), compiler, compilation);
 					if (plugin.watchChange && (compiler.modifiedFiles || compiler.removedFiles)) {
 						const promises$1 = [];
 						if (compiler.modifiedFiles) compiler.modifiedFiles.forEach((file) => promises$1.push(Promise.resolve(plugin.watchChange.call(context, file, { event: "update" }))));
@@ -3197,7 +1634,7 @@ function getWebpackPlugin(factory) {
 					if (plugin.buildStart) return await plugin.buildStart.call(context);
 				});
 				if (plugin.buildEnd) compiler.hooks.emit.tapPromise(plugin.name, async (compilation) => {
-					await plugin.buildEnd.call(createBuildContext$1(contextOptionsFromCompilation(compilation), compiler, compilation));
+					await plugin.buildEnd.call(createBuildContext(contextOptionsFromCompilation(compilation), compiler, compilation));
 				});
 				if (plugin.writeBundle) compiler.hooks.afterEmit.tapPromise(plugin.name, async () => {
 					await plugin.writeBundle();
@@ -3247,7 +1684,6 @@ function createUnplugin(factory) {
 
 //#endregion
 //#region node_modules/.pnpm/unplugin-utils@0.3.1/node_modules/unplugin-utils/dist/index.js
-var import_picomatch = /* @__PURE__ */ __toESM(require_picomatch(), 1);
 /**
 * Converts path separators to forward slash.
 */
@@ -3262,7 +1698,7 @@ function toArray$1(thing) {
 }
 const escapeMark = "[_#EsCaPe#_]";
 function getMatcherString(id, resolutionBase) {
-	if (resolutionBase === false || isAbsolute$1(id) || id.startsWith("**")) return normalizePath(id);
+	if (resolutionBase === false || isAbsolute$2(id) || id.startsWith("**")) return normalizePath(id);
 	return join$1(normalizePath(resolve$1(resolutionBase || "")).replaceAll(/[-^$*+?.()|[\]{}]/g, `${escapeMark}$&`), normalizePath(id)).replaceAll(escapeMark, "\\");
 }
 /**
@@ -3302,7 +1738,12 @@ function createFilter(include, exclude, options) {
 }
 
 //#endregion
-//#region node_modules/.pnpm/unimport@5.5.0/node_modules/unimport/dist/unplugin.mjs
+//#region node_modules/.pnpm/unimport@5.6.0/node_modules/unimport/dist/unplugin.mjs
+var unplugin_exports = /* @__PURE__ */ __exportAll({
+	default: () => unplugin,
+	defaultExcludes: () => defaultExcludes,
+	defaultIncludes: () => defaultIncludes
+});
 const defaultIncludes = [
 	/\.[jt]sx?$/,
 	/\.vue$/,
@@ -3341,180 +1782,4 @@ const unplugin = createUnplugin((options = {}) => {
 });
 
 //#endregion
-//#region node_modules/.pnpm/unimport@5.5.0/node_modules/unimport/dist/chunks/detect-acorn.mjs
-async function detectImportsAcorn(code, ctx, options) {
-	const s = getMagicString(code);
-	const map = await ctx.getImportMap();
-	let matchedImports = [];
-	const enableAutoImport = options?.autoImport !== false;
-	const enableTransformVirtualImports = options?.transformVirtualImports !== false && ctx.options.virtualImports?.length;
-	if (enableAutoImport || enableTransformVirtualImports) {
-		const ast = parse(s.original, {
-			sourceType: "module",
-			ecmaVersion: "latest",
-			locations: true
-		});
-		const virtualImports = createVirtualImportsAcronWalker(map, ctx.options.virtualImports);
-		const scopes = traveseScopes(ast, enableTransformVirtualImports ? virtualImports.walk : {});
-		if (enableAutoImport) {
-			const identifiers = scopes.unmatched;
-			matchedImports.push(...Array.from(identifiers).map((name) => {
-				const item = map.get(name);
-				if (item && !item.disabled) return item;
-				return null;
-			}).filter(Boolean));
-			for (const addon of ctx.addons) matchedImports = await addon.matchImports?.call(ctx, identifiers, matchedImports) || matchedImports;
-		}
-		virtualImports.ranges.forEach(([start, end]) => {
-			s.remove(start, end);
-		});
-		matchedImports.push(...virtualImports.imports);
-	}
-	return {
-		s,
-		strippedCode: code.toString(),
-		matchedImports,
-		isCJSContext: false,
-		firstOccurrence: 0
-	};
-}
-function traveseScopes(ast, additionalWalk) {
-	const scopes = [];
-	let scopeCurrent = void 0;
-	const scopesStack = [];
-	function pushScope(node) {
-		scopeCurrent = {
-			node,
-			parent: scopeCurrent,
-			declarations: /* @__PURE__ */ new Set(),
-			references: /* @__PURE__ */ new Set()
-		};
-		scopes.push(scopeCurrent);
-		scopesStack.push(scopeCurrent);
-	}
-	function popScope(node) {
-		if (scopesStack.pop()?.node !== node) throw new Error("Scope mismatch");
-		scopeCurrent = scopesStack[scopesStack.length - 1];
-	}
-	pushScope(void 0);
-	walk(ast, {
-		enter(node, parent, prop, index) {
-			additionalWalk?.enter?.call(this, node, parent, prop, index);
-			switch (node.type) {
-				case "ImportSpecifier":
-				case "ImportDefaultSpecifier":
-				case "ImportNamespaceSpecifier":
-					scopeCurrent.declarations.add(node.local.name);
-					return;
-				case "FunctionDeclaration":
-				case "ClassDeclaration":
-					if (node.id) scopeCurrent.declarations.add(node.id.name);
-					return;
-				case "VariableDeclarator":
-					if (node.id.type === "Identifier") scopeCurrent.declarations.add(node.id.name);
-					else walk(node.id, { enter(node2) {
-						if (node2.type === "ObjectPattern") node2.properties.forEach((i) => {
-							if (i.type === "Property" && i.value.type === "Identifier") scopeCurrent.declarations.add(i.value.name);
-							else if (i.type === "RestElement" && i.argument.type === "Identifier") scopeCurrent.declarations.add(i.argument.name);
-						});
-						else if (node2.type === "ArrayPattern") node2.elements.forEach((i) => {
-							if (i?.type === "Identifier") scopeCurrent.declarations.add(i.name);
-							if (i?.type === "RestElement" && i.argument.type === "Identifier") scopeCurrent.declarations.add(i.argument.name);
-						});
-					} });
-					return;
-				case "BlockStatement":
-					pushScope(node);
-					return;
-				case "Identifier":
-					switch (parent?.type) {
-						case "CallExpression":
-							if (parent.callee === node || parent.arguments.includes(node)) scopeCurrent.references.add(node.name);
-							return;
-						case "MemberExpression":
-							if (parent.object === node) scopeCurrent.references.add(node.name);
-							return;
-						case "VariableDeclarator":
-							if (parent.init === node) scopeCurrent.references.add(node.name);
-							return;
-						case "SpreadElement":
-							if (parent.argument === node) scopeCurrent.references.add(node.name);
-							return;
-						case "ClassDeclaration":
-							if (parent.superClass === node) scopeCurrent.references.add(node.name);
-							return;
-						case "Property":
-							if (parent.value === node) scopeCurrent.references.add(node.name);
-							return;
-						case "TemplateLiteral":
-							if (parent.expressions.includes(node)) scopeCurrent.references.add(node.name);
-							return;
-						case "AssignmentExpression":
-							if (parent.right === node) scopeCurrent.references.add(node.name);
-							return;
-						case "IfStatement":
-						case "WhileStatement":
-						case "DoWhileStatement":
-							if (parent.test === node) scopeCurrent.references.add(node.name);
-							return;
-						case "SwitchStatement":
-							if (parent.discriminant === node) scopeCurrent.references.add(node.name);
-							return;
-					}
-					if (parent?.type.includes("Expression")) scopeCurrent.references.add(node.name);
-			}
-		},
-		leave(node, parent, prop, index) {
-			additionalWalk?.leave?.call(this, node, parent, prop, index);
-			switch (node.type) {
-				case "BlockStatement": popScope(node);
-			}
-		}
-	});
-	const unmatched = /* @__PURE__ */ new Set();
-	for (const scope of scopes) for (const name of scope.references) {
-		let defined = false;
-		let parent = scope;
-		while (parent) {
-			if (parent.declarations.has(name)) {
-				defined = true;
-				break;
-			}
-			parent = parent?.parent;
-		}
-		if (!defined) unmatched.add(name);
-	}
-	return {
-		unmatched,
-		scopes
-	};
-}
-function createVirtualImportsAcronWalker(importMap, virtualImports = []) {
-	const imports = [];
-	const ranges = [];
-	return {
-		imports,
-		ranges,
-		walk: { enter(node) {
-			if (node.type === "ImportDeclaration") {
-				if (virtualImports.includes(node.source.value)) {
-					ranges.push([node.start, node.end]);
-					node.specifiers.forEach((i) => {
-						if (i.type === "ImportSpecifier" && i.imported.type === "Identifier") {
-							const original = importMap.get(i.imported.name);
-							if (!original) throw new Error(`[unimport] failed to find "${i.imported.name}" imported from "${node.source.value}"`);
-							imports.push({
-								from: original.from,
-								name: original.name,
-								as: i.local.name
-							});
-						}
-					});
-				}
-			}
-		} }
-	};
-}
-
-//#endregion
-export { createUnimport as a, unplugin as i, detectImportsAcorn as n, toExports as o, traveseScopes as r, createVirtualImportsAcronWalker as t };
+export { detect_acorn_exports as n, unplugin_exports as t };