nitro-nightly 3.0.1-20260106-182834-5019d347 → 3.0.1-20260106-205209-b085a480

package/dist/_libs/unimport.mjs

@@ -1,1778 +1,18 @@
-import { i as __toESM, n as __exportAll } from "../_rolldown.mjs";
-import { a as isAbsolute$1, c as parse, l as relative$1, n as basename$1, o as join$1, r as dirname$1, s as normalize$1, u as resolve$1 } from "./pathe.mjs";
-import { l as resolvePackageJSON, s as readPackageJSON } from "./pkg-types.mjs";
-import { t as require_picomatch } from "./picomatch.mjs";
-import { t as glob } from "./tinyglobby.mjs";
-import { n as parse$1 } from "./acorn.mjs";
-import { c as resolve$2, i as findTypeExports, l as resolveModuleExportNames, n as findExports, r as findStaticImports, s as parseStaticImport, t as detectSyntax } from "./mlly.mjs";
-import { t as MagicString } from "./magic-string.mjs";
-import { t as stripLiteral } from "./strip-literal.mjs";
-import { t as resolveModule } from "./local-pkg.mjs";
+import { i as __toESM, n as __exportAll, r as __require, t as __commonJSMin } from "../_common.mjs";
+import { Ft as resolve$1, K as MagicString, M as getMagicString, Mt as join$1, X as parse$1, Y as Parser, it as require_picomatch, jt as isAbsolute$2, y as createUnimport } from "../_build/common.mjs";
 import { t as walk } from "./estree-walker.mjs";
-import { t as createUnplugin } from "./unplugin.mjs";
-import { t as createFilter } from "./unplugin-utils.mjs";
-import { accessSync, constants, existsSync, promises, readFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { t as remapping } from "./@jridgewell/remapping.mjs";
+import { createRequire } from "node:module";
+import fs, { promises } from "node:fs";
+import "node:fs/promises";
 import { fileURLToPath } from "node:url";
-import os from "node:os";
-import { basename } from "node:path";
+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 "scule";
+import { Buffer } from "node:buffer";
+import * as querystring from "node:querystring";
 
-//#region node_modules/.pnpm/unimport@5.6.0/node_modules/unimport/dist/shared/unimport.CWY7iHFZ.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 === "const 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, options = {}) {
-	const map = toImportModuleMap(imports, includeType, options);
-	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 = modulesMap.get(from);
-		if (!module) {
-			module = {
-				typeImports: /* @__PURE__ */ new Set(),
-				starTypeImport: void 0
-			};
-			modulesMap.set(from, module);
-		}
-		if (import_.name === "*") {
-			if (import_.as) module.starTypeImport = import_;
-		} else module.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]) => {
-		from = from.replace(/\.d\.([cm]?)ts$/i, ".$1js");
-		const { starTypeImport, typeImports } = module;
-		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, options = {}) {
-	const map = {};
-	for (const _import of imports) {
-		if (_import.type && !includeType) continue;
-		const from = options.declaration && _import.typeFrom || _import.from;
-		if (!map[from]) map[from] = /* @__PURE__ */ new Set();
-		map[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(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(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.6.0/node_modules/unimport/dist/shared/unimport.u_OYhQoS.mjs
-var import_picomatch = /* @__PURE__ */ __toESM(require_picomatch(), 1);
-const version = "5.6.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) {
-	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);
-		});
-		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 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,
-		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
-	};
-}
-async function detectImports(code, ctx, options) {
-	if (options?.parser === "acorn") return import("./unimport.mjs").then((n) => n.s).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 = typeof dir === "string";
-		const glob2 = resolveGlobsExclude(isString ? dir : dir.glob, cwd$1);
-		const types = isString ? topLevelTypes : dir.types ?? topLevelTypes;
-		if (glob2.match(/\.\w+$/)) return {
-			glob: glob2,
-			types
-		};
-		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$1(i));
-	const fileFilter = options?.fileFilter || (() => true);
-	const indexOfDirs = (file) => dirGlobs.findIndex((glob2) => import_picomatch.default.isMatch(file, glob2));
-	return files.reduce((acc, file) => {
-		const index = indexOfDirs(file);
-		if (acc[index]) acc[index].push(normalize$1(file));
-		else acc[index] = [normalize$1(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.default.isMatch(file, dir.glob));
-	return dedupeDtsExports((await Promise.all(files.map((file) => scanExports(file, isIncludeTypes(file))))).flat());
-}
-function dedupeDtsExports(exports) {
-	return exports.filter((i) => {
-		if (!i.type) return true;
-		if (i.declarationType === "enum" || i.declarationType === "const enum" || i.declarationType === "class") return true;
-		return !exports.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 [];
-	}
-	seen.add(filepath);
-	const imports = [];
-	const code = await readFile(filepath, "utf-8");
-	const exports = findExports(code);
-	if (exports.find((i) => i.type === "default")) {
-		let name = parse(filepath).name;
-		if (name === "index") name = parse(filepath.split("/").slice(0, -1).join("/")).name;
-		const as = /[-_.]/.test(name) ? camelCase(name) : name;
-		imports.push({
-			name: "default",
-			as,
-			from: filepath
-		});
-	}
-	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 === "const 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;
-			}
-			if (existsSync(subfilepath)) subfilepathResolved = true;
-			else try {
-				subfilepath = await resolve$2(exp.specifier);
-				subfilepath = normalize$1(fileURLToPath(subfilepath));
-				if (existsSync(subfilepath)) subfilepathResolved = true;
-			} catch {}
-			if (!subfilepathResolved) {
-				console.warn(`[unimport] failed to resolve "${subfilepath}", skip scanning`);
-				continue;
-			}
-			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, { type: true });
-			await toImport(findTypeExports(code), { type: true });
-		}
-	} else {
-		await toImport(exports);
-		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();
-	}
-	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)
-	};
-}
-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(", ")}` : ""}`);
-	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
-	};
-}
-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/unimport@5.6.0/node_modules/unimport/dist/index.mjs
-var dist_exports = /* @__PURE__ */ __exportAll({ createUnimport: () => createUnimport });
-
-//#endregion
 //#region node_modules/.pnpm/unimport@5.6.0/node_modules/unimport/dist/chunks/detect-acorn.mjs
 var detect_acorn_exports = /* @__PURE__ */ __exportAll({
 	createVirtualImportsAcronWalker: () => createVirtualImportsAcronWalker,
@@ -1962,6 +202,1541 @@ function createVirtualImportsAcronWalker(importMap, virtualImports = []) {
 	};
 }
 
+//#endregion
+//#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;
+	return [array];
+}
+const BACKSLASH_REGEX = /\\/g;
+function normalize$1(path$1) {
+	return path$1.replace(BACKSLASH_REGEX, "/");
+}
+const ABSOLUTE_PATH_REGEX = /^(?:\/|(?:[A-Z]:)?[/\\|])/i;
+function isAbsolute$1(path$1) {
+	return ABSOLUTE_PATH_REGEX.test(path$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) => {
+		const normalizedId = normalize$1(id);
+		const result = pattern.test(normalizedId);
+		pattern.lastIndex = 0;
+		return result;
+	};
+	const matcher = (0, import_picomatch.default)(getMatcherString$1(pattern, process.cwd()), { dot: true });
+	return (id) => {
+		return matcher(normalize$1(id));
+	};
+}
+function patternToCodeFilter(pattern) {
+	if (pattern instanceof RegExp) return (code) => {
+		const result = pattern.test(code);
+		pattern.lastIndex = 0;
+		return result;
+	};
+	return (code) => code.includes(pattern);
+}
+function createFilter$1(exclude, include) {
+	if (!exclude && !include) return;
+	return (input) => {
+		if (exclude?.some((filter) => filter(input))) return false;
+		if (include?.some((filter) => filter(input))) return true;
+		return !(include && include.length > 0);
+	};
+}
+function normalizeFilter(filter) {
+	if (typeof filter === "string" || filter instanceof RegExp) return { include: [filter] };
+	if (Array.isArray(filter)) return { include: filter };
+	return {
+		exclude: filter.exclude ? toArray$2(filter.exclude) : void 0,
+		include: filter.include ? toArray$2(filter.include) : void 0
+	};
+}
+function createIdFilter(filter) {
+	if (!filter) return;
+	const { exclude, include } = normalizeFilter(filter);
+	const excludeFilter = exclude?.map(patternToIdFilter);
+	const includeFilter = include?.map(patternToIdFilter);
+	return createFilter$1(excludeFilter, includeFilter);
+}
+function createCodeFilter(filter) {
+	if (!filter) return;
+	const { exclude, include } = normalizeFilter(filter);
+	const excludeFilter = exclude?.map(patternToCodeFilter);
+	const includeFilter = include?.map(patternToCodeFilter);
+	return createFilter$1(excludeFilter, includeFilter);
+}
+function createFilterForId(filter) {
+	const filterFunction = createIdFilter(filter);
+	return filterFunction ? (id) => !!filterFunction(id) : void 0;
+}
+function createFilterForTransform(idFilter, codeFilter) {
+	if (!idFilter && !codeFilter) return;
+	const idFilterFunction = createIdFilter(idFilter);
+	const codeFilterFunction = createCodeFilter(codeFilter);
+	return (id, code) => {
+		let fallback = true;
+		if (idFilterFunction) fallback &&= idFilterFunction(id);
+		if (!fallback) return false;
+		if (codeFilterFunction) fallback &&= codeFilterFunction(code);
+		return fallback;
+	};
+}
+function normalizeObjectHook(name, hook) {
+	let handler;
+	let filter;
+	if (typeof hook === "function") handler = hook;
+	else {
+		handler = hook.handler;
+		const hookFilter = hook.filter;
+		if (name === "resolveId" || name === "load") filter = createFilterForId(hookFilter?.id);
+		else filter = createFilterForTransform(hookFilter?.id, hookFilter?.code);
+	}
+	return {
+		handler,
+		filter: filter || (() => true)
+	};
+}
+function parse(code, opts = {}) {
+	return Parser.parse(code, {
+		sourceType: "module",
+		ecmaVersion: "latest",
+		locations: true,
+		...opts
+	});
+}
+
+//#endregion
+//#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 || ""));
+	if (plugin.transformInclude && !plugin.transformInclude(id)) return [];
+	const { filter } = normalizeObjectHook("load", plugin.transform);
+	if (!filter(id)) return [];
+	return [{
+		loader: transformLoader,
+		options: { plugin },
+		ident: plugin.name
+	}];
+}
+/**
+* Normalizes a given path when it's absolute. Normalizing means returning a new path by converting
+* the input path to the native os format. This is useful in cases where we want to normalize
+* the `id` argument of a hook. Any absolute ids should be in the default format
+* of the operating system. Any relative imports or node_module imports should remain
+* untouched.
+*
+* @param path - Path to normalize.
+* @returns a new normalized path.
+*/
+function normalizeAbsolutePath(path$1) {
+	if (isAbsolute(path$1)) return normalize(path$1);
+	else return path$1;
+}
+
+//#endregion
+//#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,
+				inputSourceMap
+			};
+		},
+		addWatchFile(file) {
+			const cwd$1 = process.cwd();
+			compilation.fileDependencies.add(resolve(cwd$1, file));
+		},
+		getWatchFiles() {
+			return Array.from(compilation.fileDependencies);
+		},
+		parse,
+		emitFile(emittedFile) {
+			const outFileName = emittedFile.fileName || emittedFile.name;
+			if (emittedFile.source && outFileName) {
+				const { sources } = compilation.compiler.webpack;
+				compilation.emitAsset(outFileName, new sources.RawSource(typeof emittedFile.source === "string" ? emittedFile.source : Buffer.from(emittedFile.source)));
+			}
+		}
+	};
+}
+function normalizeMessage$1(error) {
+	const err = new Error(typeof error === "string" ? error : error.message);
+	if (typeof error === "object") {
+		err.stack = error.stack;
+		err.cause = error.meta;
+	}
+	return err;
+}
+
+//#endregion
+//#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));
+}
+function decodeVirtualModuleId(encoded, _plugin) {
+	return decodeURIComponent(basename(encoded));
+}
+function isVirtualModuleId(encoded, plugin) {
+	return dirname(encoded) === plugin.__virtualModulePrefix;
+}
+var FakeVirtualModulesPlugin = class FakeVirtualModulesPlugin$1 {
+	name = "FakeVirtualModulesPlugin";
+	static counters = /* @__PURE__ */ new Map();
+	static initCleanup = false;
+	constructor(plugin) {
+		this.plugin = plugin;
+		if (!FakeVirtualModulesPlugin$1.initCleanup) {
+			FakeVirtualModulesPlugin$1.initCleanup = true;
+			process.once("exit", () => {
+				FakeVirtualModulesPlugin$1.counters.forEach((_, dir) => {
+					fs.rmSync(dir, {
+						recursive: true,
+						force: true
+					});
+				});
+			});
+		}
+	}
+	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);
+		compiler.hooks.shutdown.tap(this.name, () => {
+			const counter$1 = (FakeVirtualModulesPlugin$1.counters.get(dir) ?? 1) - 1;
+			if (counter$1 === 0) {
+				FakeVirtualModulesPlugin$1.counters.delete(dir);
+				fs.rmSync(dir, {
+					recursive: true,
+					force: true
+				});
+			} else FakeVirtualModulesPlugin$1.counters.set(dir, counter$1);
+		});
+	}
+	async writeModule(file) {
+		return fs.promises.writeFile(file, "");
+	}
+};
+
+//#endregion
+//#region node_modules/.pnpm/unplugin@2.3.11/node_modules/unplugin/dist/context-OCFO8EW1.js
+function contextOptionsFromCompilation(compilation) {
+	return {
+		addWatchFile(file) {
+			(compilation.fileDependencies ?? compilation.compilationDependencies).add(file);
+		},
+		getWatchFiles() {
+			return Array.from(compilation.fileDependencies ?? compilation.compilationDependencies);
+		}
+	};
+}
+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(options, compiler, compilation, loaderContext, inputSourceMap) {
+	return {
+		parse,
+		addWatchFile(id) {
+			options.addWatchFile(resolve(process$1.cwd(), id));
+		},
+		emitFile(emittedFile) {
+			const outFileName = emittedFile.fileName || emittedFile.name;
+			if (emittedFile.source && outFileName) {
+				if (!compilation) throw new Error("unplugin/webpack: emitFile outside supported hooks  (buildStart, buildEnd, load, transform, watchChange)");
+				compilation.emitAsset(outFileName, getSource(emittedFile.source));
+			}
+		},
+		getWatchFiles() {
+			return options.getWatchFiles();
+		},
+		getNativeBuildContext() {
+			return {
+				framework: "webpack",
+				compiler,
+				compilation,
+				loaderContext,
+				inputSourceMap
+			};
+		}
+	};
+}
+function normalizeMessage(error) {
+	const err = new Error(typeof error === "string" ? error : error.message);
+	if (typeof error === "object") {
+		err.stack = error.stack;
+		err.cause = error.meta;
+	}
+	return err;
+}
+
+//#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__ */ __commonJSMin(((exports) => {
+	var __importDefault = exports && exports.__importDefault || function(mod) {
+		return mod && mod.__esModule ? mod : { "default": mod };
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.VirtualStats = void 0;
+	const constants_1 = __importDefault(__require("constants"));
+	var VirtualStats = class {
+		constructor(config) {
+			for (const key in config) {
+				if (!Object.prototype.hasOwnProperty.call(config, key)) continue;
+				this[key] = config[key];
+			}
+		}
+		_checkModeProperty(property) {
+			return (this.mode & constants_1.default.S_IFMT) === property;
+		}
+		isDirectory() {
+			return this._checkModeProperty(constants_1.default.S_IFDIR);
+		}
+		isFile() {
+			return this._checkModeProperty(constants_1.default.S_IFREG);
+		}
+		isBlockDevice() {
+			return this._checkModeProperty(constants_1.default.S_IFBLK);
+		}
+		isCharacterDevice() {
+			return this._checkModeProperty(constants_1.default.S_IFCHR);
+		}
+		isSymbolicLink() {
+			return this._checkModeProperty(constants_1.default.S_IFLNK);
+		}
+		isFIFO() {
+			return this._checkModeProperty(constants_1.default.S_IFIFO);
+		}
+		isSocket() {
+			return this._checkModeProperty(constants_1.default.S_IFSOCK);
+		}
+	};
+	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__ */ __commonJSMin(((exports, module) => {
+	const path_1 = (exports && exports.__importDefault || function(mod) {
+		return mod && mod.__esModule ? mod : { "default": mod };
+	})(__require("path"));
+	const virtual_stats_1 = require_virtual_stats();
+	let inode = 45e6;
+	const ALL = "all";
+	const STATIC = "static";
+	const DYNAMIC = "dynamic";
+	function checkActivation(instance) {
+		if (!instance._compiler) throw new Error("You must use this plugin only after creating webpack instance!");
+	}
+	function getModulePath(filePath, compiler) {
+		return path_1.default.isAbsolute(filePath) ? filePath : path_1.default.join(compiler.context, filePath);
+	}
+	function createWebpackData(result) {
+		return (backendOrStorage) => {
+			if (backendOrStorage._data) {
+				const curLevelIdx = backendOrStorage._currentLevel;
+				return {
+					result,
+					level: backendOrStorage._levels[curLevelIdx]
+				};
+			}
+			return [null, result];
+		};
+	}
+	function getData(storage, key) {
+		if (storage._data instanceof Map) return storage._data.get(key);
+		else if (storage._data) return storage.data[key];
+		else if (storage.data instanceof Map) return storage.data.get(key);
+		else return storage.data[key];
+	}
+	function setData(backendOrStorage, key, valueFactory) {
+		const value = valueFactory(backendOrStorage);
+		if (backendOrStorage._data instanceof Map) backendOrStorage._data.set(key, value);
+		else if (backendOrStorage._data) backendOrStorage.data[key] = value;
+		else if (backendOrStorage.data instanceof Map) backendOrStorage.data.set(key, value);
+		else backendOrStorage.data[key] = value;
+	}
+	function getStatStorage(fileSystem) {
+		if (fileSystem._statStorage) return fileSystem._statStorage;
+		else if (fileSystem._statBackend) return fileSystem._statBackend;
+		else throw new Error("Couldn't find a stat storage");
+	}
+	function getFileStorage(fileSystem) {
+		if (fileSystem._readFileStorage) return fileSystem._readFileStorage;
+		else if (fileSystem._readFileBackend) return fileSystem._readFileBackend;
+		else throw new Error("Couldn't find a readFileStorage");
+	}
+	function getReadDirBackend(fileSystem) {
+		if (fileSystem._readdirBackend) return fileSystem._readdirBackend;
+		else if (fileSystem._readdirStorage) return fileSystem._readdirStorage;
+		else throw new Error("Couldn't find a readDirStorage from Webpack Internals");
+	}
+	function getRealpathBackend(fileSystem) {
+		if (fileSystem._realpathBackend) return fileSystem._realpathBackend;
+	}
+	var VirtualModulesPlugin = class {
+		constructor(modules) {
+			this._compiler = null;
+			this._watcher = null;
+			this._staticModules = modules || null;
+		}
+		getModuleList(filter = ALL) {
+			var _a, _b;
+			let modules = {};
+			const shouldGetStaticModules = filter === ALL || filter === STATIC;
+			const shouldGetDynamicModules = filter === ALL || filter === DYNAMIC;
+			if (shouldGetStaticModules) modules = Object.assign(Object.assign({}, modules), this._staticModules);
+			if (shouldGetDynamicModules) {
+				const finalInputFileSystem = (_a = this._compiler) === null || _a === void 0 ? void 0 : _a.inputFileSystem;
+				const virtualFiles = (_b = finalInputFileSystem === null || finalInputFileSystem === void 0 ? void 0 : finalInputFileSystem._virtualFiles) !== null && _b !== void 0 ? _b : {};
+				const dynamicModules = {};
+				Object.keys(virtualFiles).forEach((key) => {
+					dynamicModules[key] = virtualFiles[key].contents;
+				});
+				modules = Object.assign(Object.assign({}, modules), dynamicModules);
+			}
+			return modules;
+		}
+		writeModule(filePath, contents) {
+			if (!this._compiler) throw new Error(`Plugin has not been initialized`);
+			checkActivation(this);
+			const len = contents ? contents.length : 0;
+			const time = Date.now();
+			const date = new Date(time);
+			const stats = new virtual_stats_1.VirtualStats({
+				dev: 8675309,
+				nlink: 0,
+				uid: 1e3,
+				gid: 1e3,
+				rdev: 0,
+				blksize: 4096,
+				ino: inode++,
+				mode: 33188,
+				size: len,
+				blocks: Math.floor(len / 4096),
+				atime: date,
+				mtime: date,
+				ctime: date,
+				birthtime: date
+			});
+			const modulePath = getModulePath(filePath, this._compiler);
+			if (process.env.WVM_DEBUG) console.log(this._compiler.name, "Write virtual module:", modulePath, contents);
+			let finalWatchFileSystem = this._watcher && this._watcher.watchFileSystem;
+			while (finalWatchFileSystem && finalWatchFileSystem.wfs) finalWatchFileSystem = finalWatchFileSystem.wfs;
+			let finalInputFileSystem = this._compiler.inputFileSystem;
+			while (finalInputFileSystem && finalInputFileSystem._inputFileSystem) finalInputFileSystem = finalInputFileSystem._inputFileSystem;
+			finalInputFileSystem._writeVirtualFile(modulePath, stats, contents);
+			if (finalWatchFileSystem && finalWatchFileSystem.watcher && (finalWatchFileSystem.watcher.fileWatchers.size || finalWatchFileSystem.watcher.fileWatchers.length)) {
+				const fileWatchers = finalWatchFileSystem.watcher.fileWatchers instanceof Map ? Array.from(finalWatchFileSystem.watcher.fileWatchers.values()) : finalWatchFileSystem.watcher.fileWatchers;
+				for (let fileWatcher of fileWatchers) {
+					if ("watcher" in fileWatcher) fileWatcher = fileWatcher.watcher;
+					if (fileWatcher.path === modulePath) {
+						if (process.env.DEBUG) console.log(this._compiler.name, "Emit file change:", modulePath, time);
+						delete fileWatcher.directoryWatcher._cachedTimeInfoEntries;
+						fileWatcher.emit("change", time, null);
+					}
+				}
+			}
+		}
+		apply(compiler) {
+			this._compiler = compiler;
+			const afterEnvironmentHook = () => {
+				let finalInputFileSystem = compiler.inputFileSystem;
+				while (finalInputFileSystem && finalInputFileSystem._inputFileSystem) finalInputFileSystem = finalInputFileSystem._inputFileSystem;
+				if (!finalInputFileSystem._writeVirtualFile) {
+					const originalPurge = finalInputFileSystem.purge;
+					finalInputFileSystem.purge = () => {
+						originalPurge.apply(finalInputFileSystem, []);
+						if (finalInputFileSystem._virtualFiles) Object.keys(finalInputFileSystem._virtualFiles).forEach((file) => {
+							const data = finalInputFileSystem._virtualFiles[file];
+							finalInputFileSystem._writeVirtualFile(file, data.stats, data.contents);
+						});
+					};
+					finalInputFileSystem._writeVirtualFile = (file, stats, contents) => {
+						const statStorage = getStatStorage(finalInputFileSystem);
+						const fileStorage = getFileStorage(finalInputFileSystem);
+						const readDirStorage = getReadDirBackend(finalInputFileSystem);
+						const realPathStorage = getRealpathBackend(finalInputFileSystem);
+						finalInputFileSystem._virtualFiles = finalInputFileSystem._virtualFiles || {};
+						finalInputFileSystem._virtualFiles[file] = {
+							stats,
+							contents
+						};
+						setData(statStorage, file, createWebpackData(stats));
+						setData(fileStorage, file, createWebpackData(contents));
+						const segments = file.split(/[\\/]/);
+						let count = segments.length - 1;
+						const minCount = segments[0] ? 1 : 0;
+						while (count > minCount) {
+							const dir = segments.slice(0, count).join(path_1.default.sep) || path_1.default.sep;
+							try {
+								finalInputFileSystem.readdirSync(dir);
+							} catch (e) {
+								const time = Date.now();
+								const dirStats = new virtual_stats_1.VirtualStats({
+									dev: 8675309,
+									nlink: 0,
+									uid: 1e3,
+									gid: 1e3,
+									rdev: 0,
+									blksize: 4096,
+									ino: inode++,
+									mode: 16877,
+									size: stats.size,
+									blocks: Math.floor(stats.size / 4096),
+									atime: time,
+									mtime: time,
+									ctime: time,
+									birthtime: time
+								});
+								setData(readDirStorage, dir, createWebpackData([]));
+								if (realPathStorage) setData(realPathStorage, dir, createWebpackData(dir));
+								setData(statStorage, dir, createWebpackData(dirStats));
+							}
+							let dirData = getData(getReadDirBackend(finalInputFileSystem), dir);
+							dirData = dirData[1] || dirData.result;
+							const filename = segments[count];
+							if (dirData.indexOf(filename) < 0) {
+								const files = dirData.concat([filename]).sort();
+								setData(getReadDirBackend(finalInputFileSystem), dir, createWebpackData(files));
+							} else break;
+							count--;
+						}
+					};
+				}
+			};
+			const afterResolversHook = () => {
+				if (this._staticModules) {
+					for (const [filePath, contents] of Object.entries(this._staticModules)) this.writeModule(filePath, contents);
+					this._staticModules = null;
+				}
+			};
+			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 === 4 ? mtime : {
+						safeTime: mtime,
+						timestamp: mtime
+					});
+				});
+				callback();
+			};
+			if (compiler.hooks) {
+				compiler.hooks.afterEnvironment.tap("VirtualModulesPlugin", afterEnvironmentHook);
+				compiler.hooks.afterResolvers.tap("VirtualModulesPlugin", afterResolversHook);
+				compiler.hooks.watchRun.tapAsync("VirtualModulesPlugin", watchRunHook);
+			} else {
+				compiler.plugin("after-environment", afterEnvironmentHook);
+				compiler.plugin("after-resolvers", afterResolversHook);
+				compiler.plugin("watch-run", watchRunHook);
+			}
+		}
+	};
+	module.exports = VirtualModulesPlugin;
+}));
+
+//#endregion
+//#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",
+	".mjs": "js",
+	".cjs": "js",
+	".jsx": "jsx",
+	".ts": "ts",
+	".cts": "ts",
+	".mts": "ts",
+	".tsx": "tsx",
+	".css": "css",
+	".less": "css",
+	".stylus": "css",
+	".scss": "css",
+	".sass": "css",
+	".json": "json",
+	".txt": "text"
+};
+function guessLoader(code, id) {
+	return ExtToLoader[path.extname(id).toLowerCase()] || "js";
+}
+function unwrapLoader(loader, code, id) {
+	if (typeof loader === "function") return loader(code, id);
+	return loader;
+}
+function fixSourceMap(map) {
+	if (!Object.prototype.hasOwnProperty.call(map, "toString")) Object.defineProperty(map, "toString", {
+		enumerable: false,
+		value: function toString() {
+			return JSON.stringify(this);
+		}
+	});
+	if (!Object.prototype.hasOwnProperty.call(map, "toUrl")) Object.defineProperty(map, "toUrl", {
+		enumerable: false,
+		value: function toUrl() {
+			return `data:application/json;charset=utf-8;base64,${Buffer.from(this.toString()).toString("base64")}`;
+		}
+	});
+	return map;
+}
+const nullSourceMap = {
+	names: [],
+	sources: [],
+	mappings: "",
+	version: 3
+};
+function combineSourcemaps(filename, sourcemapList) {
+	sourcemapList = sourcemapList.filter((m) => m.sources);
+	if (sourcemapList.length === 0 || sourcemapList.every((m) => m.sources.length === 0)) return { ...nullSourceMap };
+	let map;
+	let mapIndex = 1;
+	if (sourcemapList.slice(0, -1).find((m) => m.sources.length !== 1) === void 0) map = remapping(sourcemapList, () => null, true);
+	else map = remapping(sourcemapList[0], (sourcefile) => {
+		if (sourcefile === filename && sourcemapList[mapIndex]) return sourcemapList[mapIndex++];
+		else return { ...nullSourceMap };
+	}, true);
+	if (!map.file) delete map.file;
+	return map;
+}
+function createBuildContext$2(build) {
+	const watchFiles = [];
+	const { initialOptions } = build;
+	return {
+		parse,
+		addWatchFile() {
+			throw new Error("unplugin/esbuild: addWatchFile outside supported hooks (resolveId, load, transform)");
+		},
+		emitFile(emittedFile) {
+			const outFileName = emittedFile.fileName || emittedFile.name;
+			if (initialOptions.outdir && emittedFile.source && outFileName) {
+				const outPath = path.resolve(initialOptions.outdir, outFileName);
+				const outDir = path.dirname(outPath);
+				if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+				fs.writeFileSync(outPath, emittedFile.source);
+			}
+		},
+		getWatchFiles() {
+			return watchFiles;
+		},
+		getNativeBuildContext() {
+			return {
+				framework: "esbuild",
+				build
+			};
+		}
+	};
+}
+function createPluginContext(context) {
+	const errors = [];
+	const warnings = [];
+	const pluginContext = {
+		error(message) {
+			errors.push(normalizeMessage$2(message));
+		},
+		warn(message) {
+			warnings.push(normalizeMessage$2(message));
+		}
+	};
+	return {
+		errors,
+		warnings,
+		mixedContext: {
+			...context,
+			...pluginContext,
+			addWatchFile(id) {
+				context.getWatchFiles().push(id);
+			}
+		}
+	};
+}
+function normalizeMessage$2(message) {
+	if (typeof message === "string") message = { message };
+	return {
+		id: message.id,
+		pluginName: message.plugin,
+		text: message.message,
+		location: message.loc ? {
+			file: message.loc.file,
+			line: message.loc.line,
+			column: message.loc.column
+		} : null,
+		detail: message.meta,
+		notes: []
+	};
+}
+function processCodeWithSourceMap(map, code) {
+	if (map) {
+		if (!map.sourcesContent || map.sourcesContent.length === 0) map.sourcesContent = [code];
+		map = fixSourceMap(map);
+		code += `\n//# sourceMappingURL=${map.toUrl()}`;
+	}
+	return code;
+}
+function getEsbuildPlugin(factory) {
+	return (userOptions) => {
+		const meta = { framework: "esbuild" };
+		const plugins = toArray$2(factory(userOptions, meta));
+		const setupPlugins = async (build) => {
+			const setup = buildSetup();
+			const loaders = [];
+			for (const plugin of plugins) {
+				const loader = {};
+				await setup(plugin)({
+					...build,
+					onLoad(_options, callback) {
+						loader.options = _options;
+						loader.onLoadCb = callback;
+					},
+					onTransform(_options, callback) {
+						loader.options ||= _options;
+						loader.onTransformCb = callback;
+					}
+				}, build);
+				if (loader.onLoadCb || loader.onTransformCb) loaders.push(loader);
+			}
+			if (loaders.length) build.onLoad(loaders.length === 1 ? loaders[0].options : { filter: /.*/ }, async (args) => {
+				function checkFilter(options) {
+					return loaders.length === 1 || !options?.filter || options.filter.test(args.path);
+				}
+				let result;
+				for (const { options, onLoadCb } of loaders) {
+					if (!checkFilter(options)) continue;
+					if (onLoadCb) result = await onLoadCb(args);
+					if (result?.contents) break;
+				}
+				let fsContentsCache;
+				for (const { options, onTransformCb } of loaders) {
+					if (!checkFilter(options)) continue;
+					if (onTransformCb) {
+						const _result = await onTransformCb({
+							...result,
+							...args,
+							async getContents() {
+								if (result?.contents) return result.contents;
+								if (fsContentsCache) return fsContentsCache;
+								return fsContentsCache = await fs.promises.readFile(args.path, "utf8");
+							}
+						});
+						if (_result?.contents) result = _result;
+					}
+				}
+				if (result?.contents) return result;
+			});
+		};
+		return {
+			name: (plugins.length === 1 ? plugins[0].name : meta.esbuildHostName) ?? `unplugin-host:${plugins.map((p) => p.name).join(":")}`,
+			setup: setupPlugins
+		};
+	};
+}
+function buildSetup() {
+	return (plugin) => {
+		return (build, rawBuild) => {
+			const context = createBuildContext$2(rawBuild);
+			const { onStart, onEnd, onResolve, onLoad, onTransform, initialOptions } = build;
+			const onResolveFilter = plugin.esbuild?.onResolveFilter ?? /.*/;
+			const onLoadFilter = plugin.esbuild?.onLoadFilter ?? /.*/;
+			const loader = plugin.esbuild?.loader ?? guessLoader;
+			plugin.esbuild?.config?.call(context, initialOptions);
+			if (plugin.buildStart) onStart(() => plugin.buildStart.call(context));
+			if (plugin.buildEnd || plugin.writeBundle) onEnd(async () => {
+				if (plugin.buildEnd) await plugin.buildEnd.call(context);
+				if (plugin.writeBundle) await plugin.writeBundle();
+			});
+			if (plugin.resolveId) onResolve({ filter: onResolveFilter }, async (args) => {
+				const id = args.path;
+				if (initialOptions.external?.includes(id)) return;
+				const { handler, filter } = normalizeObjectHook("resolveId", plugin.resolveId);
+				if (!filter(id)) return;
+				const { errors, warnings, mixedContext } = createPluginContext(context);
+				const isEntry = args.kind === "entry-point";
+				const result = await handler.call(mixedContext, id, isEntry ? void 0 : args.importer, { isEntry });
+				if (typeof result === "string") return {
+					path: result,
+					namespace: plugin.name,
+					errors,
+					warnings,
+					watchFiles: mixedContext.getWatchFiles()
+				};
+				else if (typeof result === "object" && result !== null) return {
+					path: result.id,
+					external: result.external,
+					namespace: plugin.name,
+					errors,
+					warnings,
+					watchFiles: mixedContext.getWatchFiles()
+				};
+			});
+			if (plugin.load) onLoad({ filter: onLoadFilter }, async (args) => {
+				const { handler, filter } = normalizeObjectHook("load", plugin.load);
+				const id = args.path + (args.suffix || "");
+				if (plugin.loadInclude && !plugin.loadInclude(id)) return;
+				if (!filter(id)) return;
+				const { errors, warnings, mixedContext } = createPluginContext(context);
+				let code;
+				let map;
+				const result = await handler.call(mixedContext, id);
+				if (typeof result === "string") code = result;
+				else if (typeof result === "object" && result !== null) {
+					code = result.code;
+					map = result.map;
+				}
+				if (code === void 0) return null;
+				if (map) code = processCodeWithSourceMap(map, code);
+				const resolveDir = path.dirname(args.path);
+				return {
+					contents: code,
+					errors,
+					warnings,
+					watchFiles: mixedContext.getWatchFiles(),
+					loader: unwrapLoader(loader, code, args.path),
+					resolveDir
+				};
+			});
+			if (plugin.transform) onTransform({ filter: onLoadFilter }, async (args) => {
+				const { handler, filter } = normalizeObjectHook("transform", plugin.transform);
+				const id = args.path + (args.suffix || "");
+				if (plugin.transformInclude && !plugin.transformInclude(id)) return;
+				let code = await args.getContents();
+				if (!filter(id, code)) return;
+				const { mixedContext, errors, warnings } = createPluginContext(context);
+				const resolveDir = path.dirname(args.path);
+				let map;
+				const result = await handler.call(mixedContext, code, id);
+				if (typeof result === "string") code = result;
+				else if (typeof result === "object" && result !== null) {
+					code = result.code;
+					if (map && result.map) map = combineSourcemaps(args.path, [result.map === "string" ? JSON.parse(result.map) : result.map, map]);
+					else if (typeof result.map === "string") map = JSON.parse(result.map);
+					else map = result.map;
+				}
+				if (code) {
+					if (map) code = processCodeWithSourceMap(map, code);
+					return {
+						contents: code,
+						errors,
+						warnings,
+						watchFiles: mixedContext.getWatchFiles(),
+						loader: unwrapLoader(loader, code, args.path),
+						resolveDir
+					};
+				}
+			});
+			if (plugin.esbuild?.setup) return plugin.esbuild.setup(rawBuild);
+		};
+	};
+}
+function createFarmContext(context, currentResolveId) {
+	return {
+		parse,
+		addWatchFile(id) {
+			context.addWatchFile(id, currentResolveId || id);
+		},
+		emitFile(emittedFile) {
+			const outFileName = emittedFile.fileName || emittedFile.name;
+			if (emittedFile.source && outFileName) context.emitFile({
+				resolvedPath: outFileName,
+				name: outFileName,
+				content: [...Buffer.from(emittedFile.source)],
+				resourceType: extname(outFileName)
+			});
+		},
+		getWatchFiles() {
+			return context.getWatchFiles();
+		},
+		getNativeBuildContext() {
+			return {
+				framework: "farm",
+				context
+			};
+		}
+	};
+}
+function unpluginContext(context) {
+	return {
+		error: (error) => context.error(typeof error === "string" ? new Error(error) : error),
+		warn: (error) => context.warn(typeof error === "string" ? new Error(error) : error)
+	};
+}
+function convertEnforceToPriority(value) {
+	const defaultPriority = 100;
+	const enforceToPriority = {
+		pre: 102,
+		post: 98
+	};
+	return enforceToPriority[value] !== void 0 ? enforceToPriority[value] : defaultPriority;
+}
+function convertWatchEventChange(value) {
+	return {
+		Added: "create",
+		Updated: "update",
+		Removed: "delete"
+	}[value];
+}
+function isString(variable) {
+	return typeof variable === "string";
+}
+function isObject(variable) {
+	return typeof variable === "object" && variable !== null;
+}
+function customParseQueryString(url) {
+	if (!url) return [];
+	const queryString = url.split("?")[1];
+	const parsedParams = querystring.parse(queryString);
+	const paramsArray = [];
+	for (const key in parsedParams) paramsArray.push([key, parsedParams[key]]);
+	return paramsArray;
+}
+function encodeStr(str) {
+	const len = str.length;
+	if (len === 0) return str;
+	const firstNullIndex = str.indexOf("\0");
+	if (firstNullIndex === -1) return str;
+	const result = Array.from({ length: len + countNulls(str, firstNullIndex) });
+	let pos = 0;
+	for (let i = 0; i < firstNullIndex; i++) result[pos++] = str[i];
+	for (let i = firstNullIndex; i < len; i++) {
+		const char = str[i];
+		if (char === "\0") {
+			result[pos++] = "\\";
+			result[pos++] = "0";
+		} else result[pos++] = char;
+	}
+	return path.posix.normalize(result.join(""));
+}
+function decodeStr(str) {
+	const len = str.length;
+	if (len === 0) return str;
+	const firstIndex = str.indexOf("\\0");
+	if (firstIndex === -1) return str;
+	const result = Array.from({ length: len - countBackslashZeros(str, firstIndex) });
+	let pos = 0;
+	for (let i$1 = 0; i$1 < firstIndex; i$1++) result[pos++] = str[i$1];
+	let i = firstIndex;
+	while (i < len) if (str[i] === "\\" && str[i + 1] === "0") {
+		result[pos++] = "\0";
+		i += 2;
+	} else result[pos++] = str[i++];
+	return path.posix.normalize(result.join(""));
+}
+function getContentValue(content) {
+	if (content === null || content === void 0) throw new Error("Content cannot be null or undefined");
+	return encodeStr(typeof content === "string" ? content : content.code || "");
+}
+function countNulls(str, startIndex) {
+	let count = 0;
+	const len = str.length;
+	for (let i = startIndex; i < len; i++) if (str[i] === "\0") count++;
+	return count;
+}
+function countBackslashZeros(str, startIndex) {
+	let count = 0;
+	const len = str.length;
+	for (let i = startIndex; i < len - 1; i++) if (str[i] === "\\" && str[i + 1] === "0") {
+		count++;
+		i++;
+	}
+	return count;
+}
+function removeQuery(pathe) {
+	const queryIndex = pathe.indexOf("?");
+	if (queryIndex !== -1) return path.posix.normalize(pathe.slice(0, queryIndex));
+	return path.posix.normalize(pathe);
+}
+function isStartsWithSlash(str) {
+	return str?.startsWith("/");
+}
+function appendQuery(id, query) {
+	if (!query.length) return id;
+	return `${id}?${stringifyQuery(query)}`;
+}
+function stringifyQuery(query) {
+	if (!query.length) return "";
+	let queryStr = "";
+	for (const [key, value] of query) queryStr += `${key}${value ? `=${value}` : ""}&`;
+	return `${queryStr.slice(0, -1)}`;
+}
+const CSS_LANGS_RES = [
+	[/\.(less)(?:$|\?)/, "less"],
+	[/\.(scss|sass)(?:$|\?)/, "sass"],
+	[/\.(styl|stylus)(?:$|\?)/, "stylus"],
+	[/\.(css)(?:$|\?)/, "css"]
+];
+const JS_LANGS_RES = [
+	[/\.(js|mjs|cjs)(?:$|\?)/, "js"],
+	[/\.(jsx)(?:$|\?)/, "jsx"],
+	[/\.(ts|cts|mts)(?:$|\?)/, "ts"],
+	[/\.(tsx)(?:$|\?)/, "tsx"]
+];
+function getCssModuleType(id) {
+	for (const [reg, lang] of CSS_LANGS_RES) if (reg.test(id)) return lang;
+	return null;
+}
+function getJsModuleType(id) {
+	for (const [reg, lang] of JS_LANGS_RES) if (reg.test(id)) return lang;
+	return null;
+}
+function formatLoadModuleType(id) {
+	const cssModuleType = getCssModuleType(id);
+	if (cssModuleType) return cssModuleType;
+	const jsModuleType = getJsModuleType(id);
+	if (jsModuleType) return jsModuleType;
+	return "js";
+}
+function formatTransformModuleType(id) {
+	return formatLoadModuleType(id);
+}
+function getFarmPlugin(factory) {
+	return ((userOptions) => {
+		const plugins = toArray$2(factory(userOptions, { framework: "farm" })).map((rawPlugin) => {
+			const plugin = toFarmPlugin(rawPlugin, userOptions);
+			if (rawPlugin.farm) Object.assign(plugin, rawPlugin.farm);
+			return plugin;
+		});
+		return plugins.length === 1 ? plugins[0] : plugins;
+	});
+}
+function toFarmPlugin(plugin, options) {
+	const farmPlugin = {
+		name: plugin.name,
+		priority: convertEnforceToPriority(plugin.enforce)
+	};
+	if (plugin.farm) Object.keys(plugin.farm).forEach((key) => {
+		const value = plugin.farm[key];
+		if (value) Reflect.set(farmPlugin, key, value);
+	});
+	if (plugin.buildStart) {
+		const _buildStart = plugin.buildStart;
+		farmPlugin.buildStart = { async executor(_, context) {
+			await _buildStart.call(createFarmContext(context));
+		} };
+	}
+	if (plugin.resolveId) {
+		const _resolveId = plugin.resolveId;
+		let filters = [];
+		if (options) filters = options?.filters ?? [];
+		farmPlugin.resolve = {
+			filters: {
+				sources: filters.length ? filters : [".*"],
+				importers: [".*"]
+			},
+			async executor(params, context) {
+				const resolvedIdPath = path.resolve(params.importer ?? "");
+				const id = decodeStr(params.source);
+				const { handler, filter } = normalizeObjectHook("resolveId", _resolveId);
+				if (!filter(id)) return null;
+				let isEntry = false;
+				if (isObject(params.kind) && "entry" in params.kind) isEntry = params.kind.entry === "index";
+				const farmContext = createFarmContext(context, resolvedIdPath);
+				const resolveIdResult = await handler.call(Object.assign(unpluginContext(context), farmContext), id, resolvedIdPath ?? null, { isEntry });
+				if (isString(resolveIdResult)) return {
+					resolvedPath: removeQuery(encodeStr(resolveIdResult)),
+					query: customParseQueryString(resolveIdResult),
+					sideEffects: true,
+					external: false,
+					meta: {}
+				};
+				if (isObject(resolveIdResult)) return {
+					resolvedPath: removeQuery(encodeStr(resolveIdResult?.id)),
+					query: customParseQueryString(resolveIdResult?.id),
+					sideEffects: false,
+					external: Boolean(resolveIdResult?.external),
+					meta: {}
+				};
+				if (!isStartsWithSlash(params.source)) return null;
+			}
+		};
+	}
+	if (plugin.load) {
+		const _load = plugin.load;
+		farmPlugin.load = {
+			filters: { resolvedPaths: [".*"] },
+			async executor(params, context) {
+				const id = appendQuery(decodeStr(params.resolvedPath), params.query);
+				const loader = formatTransformModuleType(id);
+				if (plugin.loadInclude && !plugin.loadInclude?.(id)) return null;
+				const { handler, filter } = normalizeObjectHook("load", _load);
+				if (!filter(id)) return null;
+				const farmContext = createFarmContext(context, id);
+				return {
+					content: getContentValue(await handler.call(Object.assign(unpluginContext(context), farmContext), id)),
+					moduleType: loader
+				};
+			}
+		};
+	}
+	if (plugin.transform) {
+		const _transform = plugin.transform;
+		farmPlugin.transform = {
+			filters: {
+				resolvedPaths: [".*"],
+				moduleTypes: [".*"]
+			},
+			async executor(params, context) {
+				const id = appendQuery(decodeStr(params.resolvedPath), params.query);
+				const loader = formatTransformModuleType(id);
+				if (plugin.transformInclude && !plugin.transformInclude(id)) return null;
+				const { handler, filter } = normalizeObjectHook("transform", _transform);
+				if (!filter(id, params.content)) return null;
+				const farmContext = createFarmContext(context, id);
+				const resource = await handler.call(Object.assign(unpluginContext(context), farmContext), params.content, id);
+				if (resource && typeof resource !== "string") return {
+					content: getContentValue(resource),
+					moduleType: loader,
+					sourceMap: typeof resource.map === "object" && resource.map !== null ? JSON.stringify(resource.map) : void 0
+				};
+			}
+		};
+	}
+	if (plugin.watchChange) {
+		const _watchChange = plugin.watchChange;
+		farmPlugin.updateModules = { async executor(param, context) {
+			const updatePathContent = param.paths[0];
+			const ModifiedPath = updatePathContent[0];
+			const eventChange = convertWatchEventChange(updatePathContent[1]);
+			await _watchChange.call(createFarmContext(context), ModifiedPath, { event: eventChange });
+		} };
+	}
+	if (plugin.buildEnd) {
+		const _buildEnd = plugin.buildEnd;
+		farmPlugin.buildEnd = { async executor(_, context) {
+			await _buildEnd.call(createFarmContext(context));
+		} };
+	}
+	if (plugin.writeBundle) {
+		const _writeBundle = plugin.writeBundle;
+		farmPlugin.finish = { async executor() {
+			await _writeBundle();
+		} };
+	}
+	return farmPlugin;
+}
+function getRollupPlugin(factory) {
+	return ((userOptions) => {
+		const plugins = toArray$2(factory(userOptions, { framework: "rollup" })).map((plugin) => toRollupPlugin(plugin, "rollup"));
+		return plugins.length === 1 ? plugins[0] : plugins;
+	});
+}
+function toRollupPlugin(plugin, key) {
+	const nativeFilter = key === "rolldown";
+	if (plugin.resolveId && !nativeFilter && typeof plugin.resolveId === "object" && plugin.resolveId.filter) {
+		const resolveIdHook = plugin.resolveId;
+		const { handler, filter } = normalizeObjectHook("load", resolveIdHook);
+		replaceHookHandler("resolveId", resolveIdHook, function(...args) {
+			const [id] = args;
+			if (!supportNativeFilter(this, key) && !filter(id)) return;
+			return handler.apply(this, args);
+		});
+	}
+	if (plugin.load && (plugin.loadInclude || !nativeFilter && typeof plugin.load === "object" && plugin.load.filter)) {
+		const loadHook = plugin.load;
+		const { handler, filter } = normalizeObjectHook("load", loadHook);
+		replaceHookHandler("load", loadHook, function(...args) {
+			const [id] = args;
+			if (plugin.loadInclude && !plugin.loadInclude(id)) return;
+			if (!supportNativeFilter(this, key) && !filter(id)) return;
+			return handler.apply(this, args);
+		});
+	}
+	if (plugin.transform && (plugin.transformInclude || !nativeFilter && typeof plugin.transform === "object" && plugin.transform.filter)) {
+		const transformHook = plugin.transform;
+		const { handler, filter } = normalizeObjectHook("transform", transformHook);
+		replaceHookHandler("transform", transformHook, function(...args) {
+			const [code, id] = args;
+			if (plugin.transformInclude && !plugin.transformInclude(id)) return;
+			if (!supportNativeFilter(this, key) && !filter(id, code)) return;
+			return handler.apply(this, args);
+		});
+	}
+	if (plugin[key]) Object.assign(plugin, plugin[key]);
+	return plugin;
+	function replaceHookHandler(name, hook, handler) {
+		if (typeof hook === "function") plugin[name] = handler;
+		else hook.handler = handler;
+	}
+}
+function supportNativeFilter(context, framework) {
+	if (framework === "unloader") return false;
+	if (framework === "vite") return !!context?.meta?.viteVersion;
+	if (framework === "rolldown") return true;
+	const rollupVersion = context?.meta?.rollupVersion;
+	if (!rollupVersion) return false;
+	const [major, minor] = rollupVersion.split(".");
+	return Number(major) > 4 || Number(major) === 4 && Number(minor) >= 40;
+}
+function getRolldownPlugin(factory) {
+	return ((userOptions) => {
+		const plugins = toArray$2(factory(userOptions, { framework: "rolldown" })).map((rawPlugin) => {
+			return toRollupPlugin(rawPlugin, "rolldown");
+		});
+		return plugins.length === 1 ? plugins[0] : plugins;
+	});
+}
+const getFilename = () => fileURLToPath(import.meta.url);
+const getDirname = () => path.dirname(getFilename());
+const __dirname = /* @__PURE__ */ getDirname();
+const TRANSFORM_LOADER$1 = resolve(__dirname, "rspack/loaders/transform");
+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", compiler.rspack.experiments.VirtualModulesPlugin ? "" : process.pid.toString());
+			const meta = {
+				framework: "rspack",
+				rspack: { compiler }
+			};
+			const rawPlugins = toArray$2(factory(userOptions, meta));
+			for (const rawPlugin of rawPlugins) {
+				const plugin = Object.assign(rawPlugin, {
+					__unpluginMeta: meta,
+					__virtualModulePrefix: VIRTUAL_MODULE_PREFIX
+				});
+				const externalModules = /* @__PURE__ */ new Set();
+				if (plugin.resolveId) {
+					const createPlugin = (plugin$1) => {
+						if (compiler.rspack.experiments.VirtualModulesPlugin) return new compiler.rspack.experiments.VirtualModulesPlugin();
+						return new FakeVirtualModulesPlugin(plugin$1);
+					};
+					const vfs = createPlugin(plugin);
+					vfs.apply(compiler);
+					const vfsModules = /* @__PURE__ */ new Map();
+					plugin.__vfsModules = vfsModules;
+					plugin.__vfs = vfs;
+					compiler.hooks.compilation.tap(plugin.name, (compilation, { normalModuleFactory }) => {
+						normalModuleFactory.hooks.resolve.tapPromise(plugin.name, async (resolveData) => {
+							const id = normalizeAbsolutePath(resolveData.request);
+							const requestContext = resolveData.contextInfo;
+							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$1(compiler, compilation);
+							let error;
+							const pluginContext = {
+								error(msg) {
+									if (error == null) error = normalizeMessage$1(msg);
+									else console.error(`unplugin/rspack: multiple errors returned from resolveId hook: ${msg}`);
+								},
+								warn(msg) {
+									console.warn(`unplugin/rspack: warning from resolveId hook: ${msg}`);
+								}
+							};
+							const { handler, filter } = normalizeObjectHook("resolveId", plugin.resolveId);
+							if (!filter(id)) return;
+							const resolveIdResult = await handler.call({
+								...context,
+								...pluginContext
+							}, id, importer, { isEntry });
+							if (error != null) throw error;
+							if (resolveIdResult == null) return;
+							let resolved = typeof resolveIdResult === "string" ? resolveIdResult : resolveIdResult.id;
+							if (typeof resolveIdResult === "string" ? false : resolveIdResult.external === true) externalModules.add(resolved);
+							let isVirtual = true;
+							try {
+								(compiler.inputFileSystem?.statSync ?? fs.statSync)(resolved);
+								isVirtual = false;
+							} catch {
+								isVirtual = !isVirtualModuleId(resolved, plugin);
+							}
+							if (isVirtual) {
+								const encodedVirtualPath = encodeVirtualModuleId(resolved, plugin);
+								if (!vfsModules.has(resolved)) {
+									const fsPromise = Promise.resolve(vfs.writeModule(encodedVirtualPath, ""));
+									vfsModules.set(resolved, fsPromise);
+									await fsPromise;
+								} else await vfsModules.get(resolved);
+								resolved = encodedVirtualPath;
+							}
+							resolveData.request = resolved;
+						});
+					});
+				}
+				if (plugin.load) compiler.options.module.rules.unshift({
+					enforce: plugin.enforce,
+					include(id) {
+						if (isVirtualModuleId(id, plugin)) id = decodeVirtualModuleId(id, plugin);
+						if (plugin.loadInclude && !plugin.loadInclude(id)) return false;
+						const { filter } = normalizeObjectHook("load", plugin.load);
+						if (!filter(id)) return false;
+						return !externalModules.has(id);
+					},
+					use: [{
+						loader: LOAD_LOADER$1,
+						options: { plugin }
+					}],
+					type: "javascript/auto"
+				});
+				if (plugin.transform) compiler.options.module.rules.unshift({
+					enforce: plugin.enforce,
+					use(data) {
+						return transformUse(data, plugin, TRANSFORM_LOADER$1);
+					}
+				});
+				if (plugin.rspack) plugin.rspack(compiler);
+				if (plugin.watchChange || plugin.buildStart) compiler.hooks.make.tapPromise(plugin.name, async (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" }))));
+						if (compiler.removedFiles) compiler.removedFiles.forEach((file) => promises$1.push(Promise.resolve(plugin.watchChange.call(context, file, { event: "delete" }))));
+						await Promise.all(promises$1);
+					}
+					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(compiler, compilation));
+				});
+				if (plugin.writeBundle) compiler.hooks.afterEmit.tapPromise(plugin.name, async () => {
+					await plugin.writeBundle();
+				});
+			}
+		} };
+	};
+}
+function getUnloaderPlugin(factory) {
+	return ((userOptions) => {
+		const plugins = toArray$2(factory(userOptions, { framework: "unloader" })).map((rawPlugin) => {
+			return toRollupPlugin(rawPlugin, "unloader");
+		});
+		return plugins.length === 1 ? plugins[0] : plugins;
+	});
+}
+function getVitePlugin(factory) {
+	return ((userOptions) => {
+		const plugins = toArray$2(factory(userOptions, { framework: "vite" })).map((rawPlugin) => {
+			return toRollupPlugin(rawPlugin, "vite");
+		});
+		return plugins.length === 1 ? plugins[0] : plugins;
+	});
+}
+const TRANSFORM_LOADER = resolve(__dirname, "webpack/loaders/transform");
+const LOAD_LOADER = resolve(__dirname, "webpack/loaders/load");
+function getWebpackPlugin(factory) {
+	return (userOptions) => {
+		return { apply(compiler) {
+			const VIRTUAL_MODULE_PREFIX = resolve(compiler.options.context ?? process$1.cwd(), "_virtual_");
+			const meta = {
+				framework: "webpack",
+				webpack: { compiler }
+			};
+			const rawPlugins = toArray$2(factory(userOptions, meta));
+			for (const rawPlugin of rawPlugins) {
+				const plugin = Object.assign(rawPlugin, {
+					__unpluginMeta: meta,
+					__virtualModulePrefix: VIRTUAL_MODULE_PREFIX
+				});
+				const externalModules = /* @__PURE__ */ new Set();
+				if (plugin.resolveId) {
+					let vfs = compiler.options.plugins.find((i) => i instanceof import_lib.default);
+					if (!vfs) {
+						vfs = new import_lib.default();
+						compiler.options.plugins.push(vfs);
+					}
+					const vfsModules = /* @__PURE__ */ new Set();
+					plugin.__vfsModules = vfsModules;
+					plugin.__vfs = vfs;
+					const resolverPlugin = { apply(resolver) {
+						const target = resolver.ensureHook("resolve");
+						resolver.getHook("resolve").tapAsync(plugin.name, async (request, resolveContext, callback) => {
+							if (!request.request) return callback();
+							if (normalizeAbsolutePath(request.request).startsWith(plugin.__virtualModulePrefix)) return callback();
+							const id = normalizeAbsolutePath(request.request);
+							const requestContext = request.context;
+							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 fileDependencies = /* @__PURE__ */ new Set();
+							const context = createBuildContext({
+								addWatchFile(file) {
+									fileDependencies.add(file);
+									resolveContext.fileDependencies?.add(file);
+								},
+								getWatchFiles() {
+									return Array.from(fileDependencies);
+								}
+							}, compiler);
+							let error;
+							const pluginContext = {
+								error(msg) {
+									if (error == null) error = normalizeMessage(msg);
+									else console.error(`unplugin/webpack: multiple errors returned from resolveId hook: ${msg}`);
+								},
+								warn(msg) {
+									console.warn(`unplugin/webpack: warning from resolveId hook: ${msg}`);
+								}
+							};
+							const { handler, filter } = normalizeObjectHook("resolveId", plugin.resolveId);
+							if (!filter(id)) return callback();
+							const resolveIdResult = await handler.call({
+								...context,
+								...pluginContext
+							}, id, importer, { isEntry });
+							if (error != null) return callback(error);
+							if (resolveIdResult == null) return callback();
+							let resolved = typeof resolveIdResult === "string" ? resolveIdResult : resolveIdResult.id;
+							if (typeof resolveIdResult === "string" ? false : resolveIdResult.external === true) externalModules.add(resolved);
+							if (!fs.existsSync(resolved)) {
+								resolved = normalizeAbsolutePath(plugin.__virtualModulePrefix + encodeURIComponent(resolved));
+								if (!vfsModules.has(resolved)) {
+									plugin.__vfs.writeModule(resolved, "");
+									vfsModules.add(resolved);
+								}
+							}
+							const newRequest = {
+								...request,
+								request: resolved
+							};
+							resolver.doResolve(target, newRequest, null, resolveContext, callback);
+						});
+					} };
+					compiler.options.resolve.plugins = compiler.options.resolve.plugins || [];
+					compiler.options.resolve.plugins.push(resolverPlugin);
+				}
+				if (plugin.load) compiler.options.module.rules.unshift({
+					include(id) {
+						return shouldLoad(id, plugin, externalModules);
+					},
+					enforce: plugin.enforce,
+					use: [{
+						loader: LOAD_LOADER,
+						options: { plugin }
+					}],
+					type: "javascript/auto"
+				});
+				if (plugin.transform) compiler.options.module.rules.unshift({
+					enforce: plugin.enforce,
+					use(data) {
+						return transformUse(data, plugin, TRANSFORM_LOADER);
+					}
+				});
+				if (plugin.webpack) plugin.webpack(compiler);
+				if (plugin.watchChange || plugin.buildStart) compiler.hooks.make.tapPromise(plugin.name, async (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" }))));
+						if (compiler.removedFiles) compiler.removedFiles.forEach((file) => promises$1.push(Promise.resolve(plugin.watchChange.call(context, file, { event: "delete" }))));
+						await Promise.all(promises$1);
+					}
+					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(contextOptionsFromCompilation(compilation), compiler, compilation));
+				});
+				if (plugin.writeBundle) compiler.hooks.afterEmit.tapPromise(plugin.name, async () => {
+					await plugin.writeBundle();
+				});
+			}
+		} };
+	};
+}
+function shouldLoad(id, plugin, externalModules) {
+	if (id.startsWith(plugin.__virtualModulePrefix)) id = decodeURIComponent(id.slice(plugin.__virtualModulePrefix.length));
+	if (plugin.loadInclude && !plugin.loadInclude(id)) return false;
+	const { filter } = normalizeObjectHook("load", plugin.load);
+	if (!filter(id)) return false;
+	return !externalModules.has(id);
+}
+function createUnplugin(factory) {
+	return {
+		get esbuild() {
+			return getEsbuildPlugin(factory);
+		},
+		get rollup() {
+			return getRollupPlugin(factory);
+		},
+		get vite() {
+			return getVitePlugin(factory);
+		},
+		get rolldown() {
+			return getRolldownPlugin(factory);
+		},
+		get webpack() {
+			return getWebpackPlugin(factory);
+		},
+		get rspack() {
+			return getRspackPlugin(factory);
+		},
+		get farm() {
+			return getFarmPlugin(factory);
+		},
+		get unloader() {
+			return getUnloaderPlugin(factory);
+		},
+		get raw() {
+			return factory;
+		}
+	};
+}
+
+//#endregion
+//#region node_modules/.pnpm/unplugin-utils@0.3.1/node_modules/unplugin-utils/dist/index.js
+/**
+* Converts path separators to forward slash.
+*/
+function normalizePath(filename) {
+	return filename.replaceAll("\\", "/");
+}
+const isArray = Array.isArray;
+function toArray$1(thing) {
+	if (isArray(thing)) return thing;
+	if (thing == null) return [];
+	return [thing];
+}
+const escapeMark = "[_#EsCaPe#_]";
+function getMatcherString(id, resolutionBase) {
+	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, "\\");
+}
+/**
+* Constructs a filter function which can be used to determine whether or not
+* certain modules should be operated upon.
+* @param include If `include` is omitted or has zero length, filter will return `true` by default.
+* @param exclude ID must not match any of the `exclude` patterns.
+* @param options Additional options.
+* @param options.resolve Optionally resolves the patterns against a directory other than `process.cwd()`.
+* If a `string` is specified, then the value will be used as the base directory.
+* Relative paths will be resolved against `process.cwd()` first.
+* If `false`, then the patterns will not be resolved against any directory.
+* This can be useful if you want to create a filter for virtual module names.
+*/
+function createFilter(include, exclude, options) {
+	const resolutionBase = options && options.resolve;
+	const getMatcher = (id) => id instanceof RegExp ? id : { test: (what) => {
+		return (0, import_picomatch.default)(getMatcherString(id, resolutionBase), { dot: true })(what);
+	} };
+	const includeMatchers = toArray$1(include).map(getMatcher);
+	const excludeMatchers = toArray$1(exclude).map(getMatcher);
+	if (!includeMatchers.length && !excludeMatchers.length) return (id) => typeof id === "string" && !id.includes("\0");
+	return function result(id) {
+		if (typeof id !== "string") return false;
+		if (id.includes("\0")) return false;
+		const pathId = normalizePath(id);
+		for (const matcher of excludeMatchers) {
+			if (matcher instanceof RegExp) matcher.lastIndex = 0;
+			if (matcher.test(pathId)) return false;
+		}
+		for (const matcher of includeMatchers) {
+			if (matcher instanceof RegExp) matcher.lastIndex = 0;
+			if (matcher.test(pathId)) return true;
+		}
+		return !includeMatchers.length;
+	};
+}
+
 //#endregion
 //#region node_modules/.pnpm/unimport@5.6.0/node_modules/unimport/dist/unplugin.mjs
 var unplugin_exports = /* @__PURE__ */ __exportAll({
@@ -2007,4 +1782,4 @@ const unplugin = createUnplugin((options = {}) => {
 });
 
 //#endregion
-export { stripCommentsAndStrings as A, excludeRE as C, normalizeImports as D, matchRE as E, toTypeReExports as F, vueTemplateAddon as I, toExports as M, toTypeDeclarationFile as N, separatorRE as O, toTypeDeclarationItems as P, defineUnimportPreset as S, importAsRE as T, scanExports as _, createVirtualImportsAcronWalker as a, addImportToCode as b, traveseScopes as c, createUnimport as d, dedupeDtsExports as f, scanDirExports as g, resolvePreset as h, unplugin_exports as i, stripFileExtension as j, stringifyImports as k, dist_exports as l, resolveBuiltinPresets as m, defaultIncludes as n, detectImportsAcorn as o, normalizeScanDirs as p, unplugin as r, detect_acorn_exports as s, defaultExcludes as t, builtinPresets as u, scanFilesFromDir as v, getMagicString as w, dedupeImports as x, version as y };
+export { createVirtualImportsAcronWalker as a, traveseScopes as c, unplugin_exports as i, defaultIncludes as n, detectImportsAcorn as o, unplugin as r, detect_acorn_exports as s, defaultExcludes as t };