nitro-nightly 4.0.0-20251030-091344-d4418b98 → 4.0.0-20251030-121649-98b56dfe

package/dist/_chunks/_deps/unimport.mjs

@@ -1,2267 +0,0 @@
-import { readFileSync, existsSync, promises, accessSync, constants } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import process$1 from 'node:process';
-import { fileURLToPath } from 'node:url';
-import { camelCase, kebabCase } from 'scule';
-import os from 'node:os';
-import { basename } from 'node:path';
-import { M as MagicString } from './magic-string.mjs';
-import { c as createUnplugin } from './unplugin.mjs';
-import { c as createFilter } from './unplugin-utils.mjs';
-import { f as findStaticImports, p as parseStaticImport, d as detectSyntax, b as findExports, c as findTypeExports, e as resolve$1, g as resolveModuleExportNames } from './mlly.mjs';
-import { p as pm } from './picomatch.mjs';
-import { g as glob } from './tinyglobby.mjs';
-import { b as resolvePackageJSON, r as readPackageJSON } from './pkg-types.mjs';
-import { r as resolveModule } from './local-pkg.mjs';
-import { i as isAbsolute, a as relative, r as resolve, p as parse, d as dirname, n as normalize, j as join, b as basename$1 } from './pathe.mjs';
-import { p as parse$1 } from './acorn.mjs';
-import { a as walk } from './estree-walker.mjs';
-import { s as stripLiteral } from './strip-literal.mjs';
-
-const excludeRE = [
-  // imported/exported from other module
-  /\b(import|export)\b([\w$*{},\s]+?)\bfrom\s*["']/g,
-  // defined as function
-  /\bfunction\s*([\w$]+)\s*\(/g,
-  // defined as class
-  /\bclass\s*([\w$]+)\s*\{/g,
-  // defined as local variable
-  // eslint-disable-next-line regexp/no-super-linear-backtracking
-  /\b(?:const|let|var)\s+?(\[.*?\]|\{.*?\}|.+?)\s*?[=;\n]/gs
-];
-const importAsRE = /^.*\sas\s+/;
-const separatorRE = /[,[\]{}\n]|\b(?:import|export)\b/g;
-const matchRE = /(^|\.\.\.|(?:\bcase|\?)\s+|[^\w$/)]|\bextends\s+)([\w$]+)\s*(?=[.()[\]}:;?+\-*&|`<>,\n]|\b(?:instanceof|in)\b|$|(?<=extends\s+\w+)\s+\{)/g;
-const regexRE = /\/\S*?(?<!\\)(?<!\[[^\]]*)\/[gimsuy]*/g;
-function stripCommentsAndStrings(code, options) {
-  return stripLiteral(code, options).replace(regexRE, 'new RegExp("")');
-}
-
-function defineUnimportPreset(preset) {
-  return preset;
-}
-const identifierRE = /^[A-Z_$][\w$]*$/i;
-const safePropertyName = /^[a-z$_][\w$]*$/i;
-function stringifyWith(withValues) {
-  let withDefs = "";
-  for (let entries = Object.entries(withValues), l = entries.length, i = 0; i < l; i++) {
-    const [prop, value] = entries[i];
-    withDefs += safePropertyName.test(prop) ? prop : JSON.stringify(prop);
-    withDefs += `: ${JSON.stringify(String(value))}`;
-    if (i + 1 !== l)
-      withDefs += ", ";
-  }
-  return `{ ${withDefs} }`;
-}
-function stringifyImports(imports, isCJS = false) {
-  const map = toImportModuleMap(imports);
-  return Object.entries(map).flatMap(([name, importSet]) => {
-    const entries = [];
-    const imports2 = Array.from(importSet).filter((i) => {
-      if (!i.name || i.as === "") {
-        let importStr;
-        if (isCJS) {
-          importStr = `require('${name}');`;
-        } else {
-          importStr = `import '${name}'`;
-          if (i.with)
-            importStr += ` with ${stringifyWith(i.with)}`;
-          importStr += ";";
-        }
-        entries.push(importStr);
-        return false;
-      } else if (i.name === "default" || i.name === "=") {
-        let importStr;
-        if (isCJS) {
-          importStr = i.name === "=" ? `const ${i.as} = require('${name}');` : `const { default: ${i.as} } = require('${name}');`;
-        } else {
-          importStr = `import ${i.as} from '${name}'`;
-          if (i.with)
-            importStr += ` with ${stringifyWith(i.with)}`;
-          importStr += ";";
-        }
-        entries.push(importStr);
-        return false;
-      } else if (i.name === "*") {
-        let importStr;
-        if (isCJS) {
-          importStr = `const ${i.as} = require('${name}');`;
-        } else {
-          importStr = `import * as ${i.as} from '${name}'`;
-          if (i.with)
-            importStr += ` with ${stringifyWith(i.with)}`;
-          importStr += ";";
-        }
-        entries.push(importStr);
-        return false;
-      } else if (!isCJS && i.with) {
-        entries.push(`import { ${stringifyImportAlias(i)} } from '${name}' with ${stringifyWith(i.with)};`);
-        return false;
-      }
-      return true;
-    });
-    if (imports2.length) {
-      const importsAs = imports2.map((i) => stringifyImportAlias(i, isCJS));
-      entries.push(
-        isCJS ? `const { ${importsAs.join(", ")} } = require('${name}');` : `import { ${importsAs.join(", ")} } from '${name}';`
-      );
-    }
-    return entries;
-  }).join("\n");
-}
-function dedupeImports(imports, warn) {
-  const map = /* @__PURE__ */ new Map();
-  const indexToRemove = /* @__PURE__ */ new Set();
-  imports.filter((i) => !i.disabled).forEach((i, idx) => {
-    if (i.declarationType === "enum" || i.declarationType === "class")
-      return;
-    const name = i.as ?? i.name;
-    if (!map.has(name)) {
-      map.set(name, idx);
-      return;
-    }
-    const other = imports[map.get(name)];
-    if (other.from === i.from) {
-      indexToRemove.add(idx);
-      return;
-    }
-    const diff = (other.priority || 1) - (i.priority || 1);
-    if (diff === 0)
-      warn(`Duplicated imports "${name}", the one from "${other.from}" has been ignored and "${i.from}" is used`);
-    if (diff <= 0) {
-      indexToRemove.add(map.get(name));
-      map.set(name, idx);
-    } else {
-      indexToRemove.add(idx);
-    }
-  });
-  return imports.filter((_, idx) => !indexToRemove.has(idx));
-}
-function toExports(imports, fileDir, includeType = false) {
-  const map = toImportModuleMap(imports, includeType);
-  return Object.entries(map).flatMap(([name, imports2]) => {
-    if (isFilePath(name))
-      name = name.replace(/\.[a-z]+$/i, "");
-    if (fileDir && isAbsolute(name)) {
-      name = relative(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) {
-  return path.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) {
-  const modulesMap = /* @__PURE__ */ new Map();
-  const resolveImportFrom = typeof resolvePath === "function" ? (i) => {
-    return resolvePath(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);
-  const code = 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(
-        // This is a workaround for a TypeScript issue where type-only re-exports are not properly initialized.
-        `import('${from}')`
-      );
-    }
-    return strings;
-  });
-  return `// for type re-export
-declare global {
-${code.map((i) => `  ${i}`).join("\n")}
-}`;
-}
-function stringifyImportAlias(item, isCJS = false) {
-  return item.as === void 0 || item.name === item.as ? item.name : isCJS ? `${item.name}: ${item.as}` : `${item.name} as ${item.as}`;
-}
-function toImportModuleMap(imports, includeType = false) {
-  const map = {};
-  for (const _import of imports) {
-    if (_import.type && !includeType)
-      continue;
-    if (!map[_import.from])
-      map[_import.from] = /* @__PURE__ */ new Set();
-    map[_import.from].add(_import);
-  }
-  return map;
-}
-function getMagicString(code) {
-  if (typeof code === "string")
-    return new MagicString(code);
-  return code;
-}
-function addImportToCode(code, imports, isCJS = false, mergeExisting = false, injectAtLast = false, firstOccurrence = Number.POSITIVE_INFINITY, onResolved, onStringified) {
-  let newImports = [];
-  const s = getMagicString(code);
-  let _staticImports;
-  const strippedCode = stripCommentsAndStrings(s.original);
-  function findStaticImportsLazy() {
-    if (!_staticImports) {
-      _staticImports = findStaticImports(s.original).filter((i) => Boolean(strippedCode.slice(i.start, i.end).trim())).map((i) => parseStaticImport(i));
-    }
-    return _staticImports;
-  }
-  function hasShebang() {
-    const shebangRegex = /^#!.+/;
-    return shebangRegex.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) {
-  return path.startsWith(".") || isAbsolute(path) || path.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) {
-      const imports = await this.getImports();
-      const items = imports.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();
-      const extendItems = items.map((i) => `    ${i}`).join("\n");
-      return `${dts}
-// for vue template auto import
-import { UnwrapRef } from 'vue'
-declare module 'vue' {
-  interface ComponentCustomProperties {
-${extendItems}
-  }
-}`;
-    }
-  };
-  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;
-      const directives = Array.from(directivesMap.entries()).map(([name, i]) => `    ${name}: typeof import('${options2?.resolvePath?.(i) || i.from}')['${i.name}']`).sort().join("\n");
-      return `${dts}
-// for vue directives auto import
-declare module 'vue' {
-  interface GlobalDirectives {
-${directives}
-  }
-}`;
-    }
-  };
-  return self;
-}
-function resolvePath(cwd, path) {
-  return path[0] === "." ? resolve(cwd, path) : path;
-}
-function normalizePath(cwd, path) {
-  return resolvePath(cwd, path).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;
-    }
-  }
-}
-
-const version = "5.5.0";
-
-function configureAddons(opts) {
-  const addons = [];
-  if (Array.isArray(opts.addons)) {
-    addons.push(...opts.addons);
-  } else {
-    const addonsMap = /* @__PURE__ */ new Map();
-    if (opts.addons?.addons?.length) {
-      let i = 0;
-      for (const addon of opts.addons.addons) {
-        addonsMap.set(addon.name || `external:custom-${i++}`, addon);
-      }
-    }
-    if (opts.addons?.vueTemplate) {
-      if (!addonsMap.has(VUE_TEMPLATE_NAME)) {
-        addonsMap.set(VUE_TEMPLATE_NAME, vueTemplateAddon());
-      }
-    }
-    if (opts.addons?.vueDirectives) {
-      if (!addonsMap.has(VUE_DIRECTIVES_NAME)) {
-        addonsMap.set(VUE_DIRECTIVES_NAME, vueDirectivesAddon(
-          typeof opts.addons.vueDirectives === "object" ? opts.addons.vueDirectives : void 0
-        ));
-      }
-    }
-    addons.push(...addonsMap.values());
-  }
-  return addons;
-}
-
-async function detectImportsRegex(code, ctx, options) {
-  const s = getMagicString(code);
-  const original = s.original;
-  const strippedCode = stripCommentsAndStrings(
-    original,
-    // Do not strip comments if they are virtual import names
-    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 Promise.resolve().then(function () { return detectAcorn; }).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) {
-  return `${glob2.startsWith("!") ? "!" : ""}${resolve(cwd, glob2.replace(/^!/, ""))}`;
-}
-function joinGlobFilePattern(glob2, filePattern) {
-  return join(basename$1(glob2) === "*" ? dirname(glob2) : glob2, filePattern);
-}
-function normalizeScanDirs(dirs, options) {
-  const topLevelTypes = options?.types ?? true;
-  const cwd = 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);
-    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(i));
-  const fileFilter = options?.fileFilter || (() => true);
-  const indexOfDirs = (file) => dirGlobs.findIndex((glob2) => pm.isMatch(file, glob2));
-  const fileSortByDirs = files.reduce((acc, file) => {
-    const index = indexOfDirs(file);
-    if (acc[index])
-      acc[index].push(normalize(file));
-    else
-      acc[index] = [normalize(file)];
-    return acc;
-  }, []).map((files2) => files2.sort()).flat();
-  return fileSortByDirs.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) => pm.isMatch(file, dir.glob));
-  const imports = (await Promise.all(files.map((file) => scanExports(file, isIncludeTypes(file))))).flat();
-  const deduped = dedupeDtsExports(imports);
-  return deduped;
-}
-function dedupeDtsExports(exports) {
-  return exports.filter((i) => {
-    if (!i.type)
-      return true;
-    if (i.declarationType === "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);
-  const defaultExport = exports.find((i) => i.type === "default");
-  if (defaultExport) {
-    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 === "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(dirname(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$1(exp.specifier);
-              subfilepath = normalize(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);
-        }
-      }
-    }
-  }
-  const isDts = filepath.match(/\.d\.[mc]?ts$/);
-  if (isDts) {
-    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(os.tmpdir(), "unimport");
-let CACHE_WRITEABLE;
-async function resolvePackagePreset(preset) {
-  const scanned = await extractExports(preset.package, preset.url, preset.cache);
-  const filtered = scanned.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;
-  });
-  return filtered.map((name) => ({
-    from: preset.package,
-    name
-  }));
-}
-async function extractExports(name, url, cache = true) {
-  const packageJsonPath = await resolvePackageJSON(name, { url });
-  const packageJson = await readPackageJSON(packageJsonPath);
-  const version = packageJson.version;
-  const cachePath = join(CACHE_PATH, `${name}@${version}`, "exports.json");
-  if (cache && CACHE_WRITEABLE === void 0) {
-    try {
-      CACHE_WRITEABLE = isWritable(CACHE_PATH);
-    } catch {
-      CACHE_WRITEABLE = false;
-    }
-  }
-  const useCache = cache && version && 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(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: [
-    // https://pinia.esm.dev/api/modules/pinia.html#functions
-    "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: [
-    // https://quasar.dev/vue-composables
-    "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,
-    // react-router-dom only hooks
-    "useLinkClickHandler",
-    "useSearchParams",
-    // react-router-dom Component
-    // call once in general
-    // 'BrowserRouter',
-    // 'HashRouter',
-    // 'MemoryRouter',
-    "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 solidCore = 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"
-  ]
-});
-const solidStore = defineUnimportPreset({
-  from: "solid-js/store",
-  imports: [
-    "createStore",
-    "produce",
-    "reconcile",
-    "createMutable"
-  ]
-});
-const solidWeb = defineUnimportPreset({
-  from: "solid-js/web",
-  imports: [
-    "Dynamic",
-    "hydrate",
-    "render",
-    "renderToString",
-    "renderToStringAsync",
-    "renderToStream",
-    "isServer",
-    "Portal"
-  ]
-});
-const solid = defineUnimportPreset({
-  from: "solid-js",
-  imports: [
-    solidCore,
-    solidStore,
-    solidWeb
-  ]
-});
-
-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: [
-    // lifecycle
-    "onMount",
-    "beforeUpdate",
-    "afterUpdate",
-    "onDestroy",
-    // tick
-    "tick",
-    // context
-    "setContext",
-    "getContext",
-    "hasContext",
-    "getAllContexts",
-    // event dispatcher
-    "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: [
-    // https://vee-validate.logaretm.com/v4/guide/composition-api/api-review
-    // https://github.com/logaretm/vee-validate/blob/main/packages/vee-validate/src/index.ts
-    "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: [
-    // helper methods
-    "useData",
-    "useRoute",
-    "useRouter",
-    "withBase"
-  ]
-});
-
-const vitest = defineUnimportPreset({
-  from: "vitest",
-  imports: [
-    // suite
-    "suite",
-    "test",
-    "describe",
-    "it",
-    // chai
-    "chai",
-    "expect",
-    "assert",
-    // utils
-    "vitest",
-    "vi",
-    // hooks
-    "beforeAll",
-    "afterAll",
-    "beforeEach",
-    "afterEach"
-  ]
-});
-
-const CommonCompositionAPI = [
-  // lifecycle
-  "onActivated",
-  "onBeforeMount",
-  "onBeforeUnmount",
-  "onBeforeUpdate",
-  "onErrorCaptured",
-  "onDeactivated",
-  "onMounted",
-  "onServerPrefetch",
-  "onUnmounted",
-  "onUpdated",
-  // setup helpers
-  "useAttrs",
-  "useSlots",
-  // reactivity,
-  "computed",
-  "customRef",
-  "isReadonly",
-  "isRef",
-  "isShallow",
-  "isProxy",
-  "isReactive",
-  "markRaw",
-  "reactive",
-  "readonly",
-  "ref",
-  "shallowReactive",
-  "shallowReadonly",
-  "shallowRef",
-  "triggerRef",
-  "toRaw",
-  "toRef",
-  "toRefs",
-  "toValue",
-  "unref",
-  "watch",
-  "watchEffect",
-  "watchPostEffect",
-  "watchSyncEffect",
-  // component
-  "defineComponent",
-  "defineAsyncComponent",
-  "getCurrentInstance",
-  "h",
-  "inject",
-  "nextTick",
-  "provide",
-  "useCssModule",
-  "createApp",
-  // effect scope
-  "effectScope",
-  "EffectScope",
-  "getCurrentScope",
-  "onScopeDispose",
-  // types
-  ...[
-    "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,
-    // vue3 only
-    "onRenderTracked",
-    "onRenderTriggered",
-    "resolveComponent",
-    "useCssVars",
-    // vue3.4+
-    "useModel",
-    // vue3.5+
-    "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: [
-    // https://vuejs.org/guide/extras/reactivity-transform.html#refs-vs-reactive-variables
-    "$",
-    "$$",
-    "$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 = resolveModule("@vueuse/core/indexes.json") || resolveModule("@vueuse/metadata/index.json") || resolveModule("@vueuse/metadata/index.json", { paths: [corePath] });
-      const indexesJson = JSON.parse(readFileSync(path, "utf-8"));
-      _cache = defineUnimportPreset({
-        from: "@vueuse/core",
-        imports: indexesJson.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: [
-    // https://next.vuex.vuejs.org/api/#createstore
-    "createStore",
-    // https://github.com/vuejs/vuex/blob/4.0/types/logger.d.ts#L20
-    "createLogger",
-    // https://next.vuex.vuejs.org/api/#component-binding-helpers
-    "mapState",
-    "mapGetters",
-    "mapActions",
-    "mapMutations",
-    "createNamespacedHelpers",
-    // https://next.vuex.vuejs.org/api/#composable-functions
-    "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) {
-  const resolved = 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);
-  }));
-  return resolved.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,
-    // Deprecated
-    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))) {
-    const log = ctx.options.debugLog || console.log;
-    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();
-  const _imports = 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
-    };
-  }));
-  return _imports.filter(Boolean);
-}
-
-const defaultIncludes = [/\.[jt]sx?$/, /\.vue$/, /\.vue\?vue/, /\.svelte$/];
-const defaultExcludes = [/[\\/]node_modules[\\/]/, /[\\/]\.git[\\/]/];
-function toArray(x) {
-  return x == null ? [] : Array.isArray(x) ? x : [x];
-}
-const unplugin = createUnplugin((options = {}) => {
-  const ctx = createUnimport(options);
-  const filter = createFilter(
-    toArray(options.include || []).length ? options.include : defaultIncludes,
-    options.exclude || defaultExcludes
-  );
-  const dts = options.dts === true ? "unimport.d.ts" : options.dts;
-  const {
-    autoImport = true
-  } = options;
-  return {
-    name: "unimport",
-    enforce: "post",
-    transformInclude(id) {
-      return filter(id);
-    },
-    async transform(code, id) {
-      const s = new MagicString(code);
-      await ctx.injectImports(s, id, {
-        autoImport
-      });
-      if (!s.hasChanged())
-        return;
-      return {
-        code: s.toString(),
-        map: s.generateMap()
-      };
-    },
-    async buildStart() {
-      await ctx.init();
-      if (dts)
-        return promises.writeFile(dts, await ctx.generateTypeDeclarations(), "utf-8");
-    }
-  };
-});
-
-async function detectImportsAcorn(code, ctx, options) {
-  const s = getMagicString(code);
-  const map = await ctx.getImportMap();
-  let matchedImports = [];
-  const enableAutoImport = options?.autoImport !== false;
-  const enableTransformVirtualImports = options?.transformVirtualImports !== false && ctx.options.virtualImports?.length;
-  if (enableAutoImport || enableTransformVirtualImports) {
-    const ast = parse$1(s.original, {
-      sourceType: "module",
-      ecmaVersion: "latest",
-      locations: true
-    });
-    const virtualImports = createVirtualImportsAcronWalker(map, ctx.options.virtualImports);
-    const scopes = traveseScopes(
-      ast,
-      enableTransformVirtualImports ? virtualImports.walk : {}
-    );
-    if (enableAutoImport) {
-      const identifiers = scopes.unmatched;
-      matchedImports.push(
-        ...Array.from(identifiers).map((name) => {
-          const item = map.get(name);
-          if (item && !item.disabled)
-            return item;
-          return null;
-        }).filter(Boolean)
-      );
-      for (const addon of ctx.addons)
-        matchedImports = await addon.matchImports?.call(ctx, identifiers, matchedImports) || matchedImports;
-    }
-    virtualImports.ranges.forEach(([start, end]) => {
-      s.remove(start, end);
-    });
-    matchedImports.push(...virtualImports.imports);
-  }
-  return {
-    s,
-    strippedCode: code.toString(),
-    matchedImports,
-    isCJSContext: false,
-    firstOccurrence: 0
-    // TODO:
-  };
-}
-function traveseScopes(ast, additionalWalk) {
-  const scopes = [];
-  let scopeCurrent = void 0;
-  const scopesStack = [];
-  function pushScope(node) {
-    scopeCurrent = {
-      node,
-      parent: scopeCurrent,
-      declarations: /* @__PURE__ */ new Set(),
-      references: /* @__PURE__ */ new Set()
-    };
-    scopes.push(scopeCurrent);
-    scopesStack.push(scopeCurrent);
-  }
-  function popScope(node) {
-    const scope = scopesStack.pop();
-    if (scope?.node !== node)
-      throw new Error("Scope mismatch");
-    scopeCurrent = scopesStack[scopesStack.length - 1];
-  }
-  pushScope(void 0);
-  walk(ast, {
-    enter(node, parent, prop, index) {
-      additionalWalk?.enter?.call(this, node, parent, prop, index);
-      switch (node.type) {
-        // ====== Declaration ======
-        case "ImportSpecifier":
-        case "ImportDefaultSpecifier":
-        case "ImportNamespaceSpecifier":
-          scopeCurrent.declarations.add(node.local.name);
-          return;
-        case "FunctionDeclaration":
-        case "ClassDeclaration":
-          if (node.id)
-            scopeCurrent.declarations.add(node.id.name);
-          return;
-        case "VariableDeclarator":
-          if (node.id.type === "Identifier") {
-            scopeCurrent.declarations.add(node.id.name);
-          } else {
-            walk(node.id, {
-              enter(node2) {
-                if (node2.type === "ObjectPattern") {
-                  node2.properties.forEach((i) => {
-                    if (i.type === "Property" && i.value.type === "Identifier")
-                      scopeCurrent.declarations.add(i.value.name);
-                    else if (i.type === "RestElement" && i.argument.type === "Identifier")
-                      scopeCurrent.declarations.add(i.argument.name);
-                  });
-                } else if (node2.type === "ArrayPattern") {
-                  node2.elements.forEach((i) => {
-                    if (i?.type === "Identifier")
-                      scopeCurrent.declarations.add(i.name);
-                    if (i?.type === "RestElement" && i.argument.type === "Identifier")
-                      scopeCurrent.declarations.add(i.argument.name);
-                  });
-                }
-              }
-            });
-          }
-          return;
-        // ====== Scope ======
-        case "BlockStatement":
-          pushScope(node);
-          return;
-        // ====== Reference ======
-        case "Identifier":
-          switch (parent?.type) {
-            case "CallExpression":
-              if (parent.callee === node || parent.arguments.includes(node))
-                scopeCurrent.references.add(node.name);
-              return;
-            case "MemberExpression":
-              if (parent.object === node)
-                scopeCurrent.references.add(node.name);
-              return;
-            case "VariableDeclarator":
-              if (parent.init === node)
-                scopeCurrent.references.add(node.name);
-              return;
-            case "SpreadElement":
-              if (parent.argument === node)
-                scopeCurrent.references.add(node.name);
-              return;
-            case "ClassDeclaration":
-              if (parent.superClass === node)
-                scopeCurrent.references.add(node.name);
-              return;
-            case "Property":
-              if (parent.value === node)
-                scopeCurrent.references.add(node.name);
-              return;
-            case "TemplateLiteral":
-              if (parent.expressions.includes(node))
-                scopeCurrent.references.add(node.name);
-              return;
-            case "AssignmentExpression":
-              if (parent.right === node)
-                scopeCurrent.references.add(node.name);
-              return;
-            case "IfStatement":
-            case "WhileStatement":
-            case "DoWhileStatement":
-              if (parent.test === node)
-                scopeCurrent.references.add(node.name);
-              return;
-            case "SwitchStatement":
-              if (parent.discriminant === node)
-                scopeCurrent.references.add(node.name);
-              return;
-          }
-          if (parent?.type.includes("Expression"))
-            scopeCurrent.references.add(node.name);
-      }
-    },
-    leave(node, parent, prop, index) {
-      additionalWalk?.leave?.call(this, node, parent, prop, index);
-      switch (node.type) {
-        case "BlockStatement":
-          popScope(node);
-      }
-    }
-  });
-  const unmatched = /* @__PURE__ */ new Set();
-  for (const scope of scopes) {
-    for (const name of scope.references) {
-      let defined = false;
-      let parent = scope;
-      while (parent) {
-        if (parent.declarations.has(name)) {
-          defined = true;
-          break;
-        }
-        parent = parent?.parent;
-      }
-      if (!defined)
-        unmatched.add(name);
-    }
-  }
-  return {
-    unmatched,
-    scopes
-  };
-}
-function createVirtualImportsAcronWalker(importMap, virtualImports = []) {
-  const imports = [];
-  const ranges = [];
-  return {
-    imports,
-    ranges,
-    walk: {
-      enter(node) {
-        if (node.type === "ImportDeclaration") {
-          if (virtualImports.includes(node.source.value)) {
-            ranges.push([node.start, node.end]);
-            node.specifiers.forEach((i) => {
-              if (i.type === "ImportSpecifier" && i.imported.type === "Identifier") {
-                const original = importMap.get(i.imported.name);
-                if (!original)
-                  throw new Error(`[unimport] failed to find "${i.imported.name}" imported from "${node.source.value}"`);
-                imports.push({
-                  from: original.from,
-                  name: original.name,
-                  as: i.local.name
-                });
-              }
-            });
-          }
-        }
-      }
-    }
-  };
-}
-
-const detectAcorn = {
-  __proto__: null,
-  createVirtualImportsAcronWalker: createVirtualImportsAcronWalker,
-  detectImportsAcorn: detectImportsAcorn,
-  traveseScopes: traveseScopes
-};
-
-export { createUnimport as c, toExports as t, unplugin as u };