nitro-nightly 3.0.1-20260120-020848-6786d069 → 3.0.1-20260120-133849-ca1a9dee

package/dist/_libs/local-pkg+quansync+unimport.mjs

@@ -1,1526 +0,0 @@
-import { r as __toESM } from "../_chunks/nitro.mjs";
-import { a as join$1, c as parse, n as dirname$1, o as normalize$1, t as basename$1, u as resolve$1 } from "./pathe.mjs";
-import { c as resolvePackageJSON, o as readPackageJSON } from "./confbox+exsolve+pkg-types.mjs";
-import { n as require_picomatch, t as glob } from "./fdir+picomatch+tinyglobby.mjs";
-import { D as findStaticImports, E as findExports, M as resolve$2, N as resolveModuleExportNames, O as findTypeExports, P as resolvePathSync, T as detectSyntax, a as defineUnimportPreset, b as vueTemplateAddon, c as importAsRE, d as separatorRE, g as toTypeDeclarationFile, h as toExports, i as dedupeImports, j as parseStaticImport, l as matchRE, m as stripFileExtension, n as VUE_TEMPLATE_NAME, o as excludeRE, p as stripCommentsAndStrings, r as addImportToCode, s as getMagicString, t as VUE_DIRECTIVES_NAME, u as normalizeImports, v as toTypeReExports, y as vueDirectivesAddon } from "./acorn+confbox+js-tokens+magic-string+mlly+pkg-types+sourcemap-codec+strip-literal+unimport.mjs";
-import { createRequire } from "node:module";
-import fs, { accessSync, constants, existsSync, promises, readFileSync } from "node:fs";
-import fsp, { readFile } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
-import os from "node:os";
-import path, { dirname, join, win32 } from "node:path";
-import process$1 from "node:process";
-import { camelCase } from "scule";
-
-//#region node_modules/.pnpm/quansync@0.2.11/node_modules/quansync/dist/index.mjs
-const GET_IS_ASYNC = Symbol.for("quansync.getIsAsync");
-var QuansyncError = class extends Error {
-	constructor(message = "Unexpected promise in sync context") {
-		super(message);
-		this.name = "QuansyncError";
-	}
-};
-function isThenable(value) {
-	return value && typeof value === "object" && typeof value.then === "function";
-}
-function isQuansyncGenerator(value) {
-	return value && typeof value === "object" && typeof value[Symbol.iterator] === "function" && "__quansync" in value;
-}
-function fromObject(options) {
-	const generator = function* (...args) {
-		if (yield GET_IS_ASYNC) return yield options.async.apply(this, args);
-		return options.sync.apply(this, args);
-	};
-	function fn(...args) {
-		const iter = generator.apply(this, args);
-		iter.then = (...thenArgs) => options.async.apply(this, args).then(...thenArgs);
-		iter.__quansync = true;
-		return iter;
-	}
-	fn.sync = options.sync;
-	fn.async = options.async;
-	return fn;
-}
-function fromPromise(promise) {
-	return fromObject({
-		async: () => Promise.resolve(promise),
-		sync: () => {
-			if (isThenable(promise)) throw new QuansyncError();
-			return promise;
-		}
-	});
-}
-function unwrapYield(value, isAsync) {
-	if (value === GET_IS_ASYNC) return isAsync;
-	if (isQuansyncGenerator(value)) return isAsync ? iterateAsync(value) : iterateSync(value);
-	if (!isAsync && isThenable(value)) throw new QuansyncError();
-	return value;
-}
-const DEFAULT_ON_YIELD = (value) => value;
-function iterateSync(generator, onYield = DEFAULT_ON_YIELD) {
-	let current = generator.next();
-	while (!current.done) try {
-		current = generator.next(unwrapYield(onYield(current.value, false)));
-	} catch (err) {
-		current = generator.throw(err);
-	}
-	return unwrapYield(current.value);
-}
-async function iterateAsync(generator, onYield = DEFAULT_ON_YIELD) {
-	let current = generator.next();
-	while (!current.done) try {
-		current = generator.next(await unwrapYield(onYield(current.value, true), true));
-	} catch (err) {
-		current = generator.throw(err);
-	}
-	return current.value;
-}
-function fromGeneratorFn(generatorFn, options) {
-	return fromObject({
-		name: generatorFn.name,
-		async(...args) {
-			return iterateAsync(generatorFn.apply(this, args), options?.onYield);
-		},
-		sync(...args) {
-			return iterateSync(generatorFn.apply(this, args), options?.onYield);
-		}
-	});
-}
-function quansync$1(input, options) {
-	if (isThenable(input)) return fromPromise(input);
-	if (typeof input === "function") return fromGeneratorFn(input, options);
-	else return fromObject(input);
-}
-const getIsAsync = quansync$1({
-	async: () => Promise.resolve(true),
-	sync: () => false
-});
-
-//#endregion
-//#region node_modules/.pnpm/quansync@0.2.11/node_modules/quansync/dist/macro.mjs
-const quansync = quansync$1;
-
-//#endregion
-//#region node_modules/.pnpm/local-pkg@1.1.2/node_modules/local-pkg/dist/index.mjs
-const toPath = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
-async function findUp$1(name, { cwd: cwd$1 = process$1.cwd(), type: type$1 = "file", stopAt } = {}) {
-	let directory = path.resolve(toPath(cwd$1) ?? "");
-	const { root } = path.parse(directory);
-	stopAt = path.resolve(directory, toPath(stopAt ?? root));
-	const isAbsoluteName = path.isAbsolute(name);
-	while (directory) {
-		const filePath = isAbsoluteName ? name : path.join(directory, name);
-		try {
-			const stats = await fsp.stat(filePath);
-			if (type$1 === "file" && stats.isFile() || type$1 === "directory" && stats.isDirectory()) return filePath;
-		} catch {}
-		if (directory === stopAt || directory === root) break;
-		directory = path.dirname(directory);
-	}
-}
-function findUpSync(name, { cwd: cwd$1 = process$1.cwd(), type: type$1 = "file", stopAt } = {}) {
-	let directory = path.resolve(toPath(cwd$1) ?? "");
-	const { root } = path.parse(directory);
-	stopAt = path.resolve(directory, toPath(stopAt) ?? root);
-	const isAbsoluteName = path.isAbsolute(name);
-	while (directory) {
-		const filePath = isAbsoluteName ? name : path.join(directory, name);
-		try {
-			const stats = fs.statSync(filePath, { throwIfNoEntry: false });
-			if (type$1 === "file" && stats?.isFile() || type$1 === "directory" && stats?.isDirectory()) return filePath;
-		} catch {}
-		if (directory === stopAt || directory === root) break;
-		directory = path.dirname(directory);
-	}
-}
-function _resolve(path$1, options = {}) {
-	if (options.platform === "auto" || !options.platform) options.platform = process$1.platform === "win32" ? "win32" : "posix";
-	if (process$1.versions.pnp) {
-		const paths = options.paths || [];
-		if (paths.length === 0) paths.push(process$1.cwd());
-		const targetRequire = createRequire(import.meta.url);
-		try {
-			return targetRequire.resolve(path$1, { paths });
-		} catch {}
-	}
-	const modulePath = resolvePathSync(path$1, { url: options.paths });
-	if (options.platform === "win32") return win32.normalize(modulePath);
-	return modulePath;
-}
-function resolveModule(name, options = {}) {
-	try {
-		return _resolve(name, options);
-	} catch {
-		return;
-	}
-}
-function getPackageJsonPath(name, options = {}) {
-	const entry = resolvePackage(name, options);
-	if (!entry) return;
-	return searchPackageJSON(entry);
-}
-const readFile$1 = quansync({
-	async: (id) => fs.promises.readFile(id, "utf8"),
-	sync: (id) => fs.readFileSync(id, "utf8")
-});
-const getPackageInfo = quansync(function* (name, options = {}) {
-	const packageJsonPath = getPackageJsonPath(name, options);
-	if (!packageJsonPath) return;
-	const packageJson = JSON.parse(yield readFile$1(packageJsonPath));
-	return {
-		name,
-		version: packageJson.version,
-		rootPath: dirname(packageJsonPath),
-		packageJsonPath,
-		packageJson
-	};
-});
-const getPackageInfoSync = getPackageInfo.sync;
-function resolvePackage(name, options = {}) {
-	try {
-		return _resolve(`${name}/package.json`, options);
-	} catch {}
-	try {
-		return _resolve(name, options);
-	} catch (e) {
-		if (e.code !== "MODULE_NOT_FOUND" && e.code !== "ERR_MODULE_NOT_FOUND") console.error(e);
-		return false;
-	}
-}
-function searchPackageJSON(dir) {
-	let packageJsonPath;
-	while (true) {
-		if (!dir) return;
-		const newDir = dirname(dir);
-		if (newDir === dir) return;
-		dir = newDir;
-		packageJsonPath = join(dir, "package.json");
-		if (fs.existsSync(packageJsonPath)) break;
-	}
-	return packageJsonPath;
-}
-const findUp = quansync({
-	sync: findUpSync,
-	async: findUp$1
-});
-const loadPackageJSON = quansync(function* (cwd$1 = process$1.cwd()) {
-	const path$1 = yield findUp("package.json", { cwd: cwd$1 });
-	if (!path$1 || !fs.existsSync(path$1)) return null;
-	return JSON.parse(yield readFile$1(path$1));
-});
-const loadPackageJSONSync = loadPackageJSON.sync;
-const isPackageListed = quansync(function* (name, cwd$1) {
-	const pkg = (yield loadPackageJSON(cwd$1)) || {};
-	return name in (pkg.dependencies || {}) || name in (pkg.devDependencies || {});
-});
-const isPackageListedSync = isPackageListed.sync;
-
-//#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("./estree-walker+unimport.mjs").then((r) => r.detectImportsAcorn(code, ctx, options));
-	return detectImportsRegex(code, ctx, options);
-}
-const FileExtensionLookup = [
-	"mts",
-	"cts",
-	"ts",
-	"tsx",
-	"mjs",
-	"cjs",
-	"js",
-	"jsx"
-];
-const FileLookupPatterns = `*.{${FileExtensionLookup.join(",")}}`;
-function resolveGlobsExclude(glob2, cwd$1) {
-	return `${glob2.startsWith("!") ? "!" : ""}${resolve$1(cwd$1, glob2.replace(/^!/, ""))}`;
-}
-function joinGlobFilePattern(glob2, filePattern) {
-	return join$1(basename$1(glob2) === "*" ? dirname$1(glob2) : glob2, filePattern);
-}
-function normalizeScanDirs(dirs, options) {
-	const topLevelTypes = options?.types ?? true;
-	const cwd$1 = options?.cwd ?? process$1.cwd();
-	const filePatterns = options?.filePatterns || [FileLookupPatterns];
-	return dirs.map((dir) => {
-		const isString = 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
-export { resolveBuiltinPresets as a, scanExports as c, normalizeScanDirs as i, scanFilesFromDir as l, createUnimport as n, resolvePreset as o, dedupeDtsExports as r, scanDirExports as s, builtinPresets as t, version as u };