initial commit

node_modules/unimport/dist/addons.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+const vueTemplate = require('./shared/unimport.7b88c06e.cjs');
+require('pathe');
+require('mlly');
+require('magic-string');
+require('strip-literal');
+
+
+
+exports.vueTemplateAddon = vueTemplate.vueTemplateAddon;

node_modules/unimport/dist/addons.d.ts

@@ -0,0 +1,6 @@
+import { m as Addon } from './types-0d3b142b.js';
+import 'magic-string';
+
+declare const vueTemplateAddon: () => Addon;
+
+export { vueTemplateAddon };

node_modules/unimport/dist/addons.mjs

@@ -0,0 +1,5 @@
+export { v as vueTemplateAddon } from './shared/unimport.bbd7571a.mjs';
+import 'pathe';
+import 'mlly';
+import 'magic-string';
+import 'strip-literal';

node_modules/unimport/dist/index.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+const context = require('./shared/unimport.e56b747d.cjs');
+const vueTemplate = require('./shared/unimport.7b88c06e.cjs');
+require('fs');
+require('fast-glob');
+require('pathe');
+require('mlly');
+require('scule');
+require('local-pkg');
+require('os');
+require('pkg-types');
+require('magic-string');
+require('strip-literal');
+
+async function installGlobalAutoImports(imports, options = {}) {
+  const {
+    globalObject = globalThis,
+    overrides = false
+  } = options;
+  imports = Array.isArray(imports) ? imports : await imports.getImports();
+  await Promise.all(
+    imports.map(async (i) => {
+      if (i.disabled) {
+        return;
+      }
+      const as = i.as || i.name;
+      if (overrides || !(as in globalObject)) {
+        const module = await import(i.from);
+        globalObject[as] = module[i.name];
+      }
+    })
+  );
+  return globalObject;
+}
+
+exports.builtinPresets = context.builtinPresets;
+exports.createUnimport = context.createUnimport;
+exports.resolveBuiltinPresets = context.resolveBuiltinPresets;
+exports.resolvePreset = context.resolvePreset;
+exports.scanDirExports = context.scanDirExports;
+exports.scanExports = context.scanExports;
+exports.addImportToCode = vueTemplate.addImportToCode;
+exports.dedupeImports = vueTemplate.dedupeImports;
+exports.defineUnimportPreset = vueTemplate.defineUnimportPreset;
+exports.excludeRE = vueTemplate.excludeRE;
+exports.getMagicString = vueTemplate.getMagicString;
+exports.getString = vueTemplate.getString;
+exports.importAsRE = vueTemplate.importAsRE;
+exports.matchRE = vueTemplate.matchRE;
+exports.normalizeImports = vueTemplate.normalizeImports;
+exports.resolveIdAbsolute = vueTemplate.resolveIdAbsolute;
+exports.separatorRE = vueTemplate.separatorRE;
+exports.stripCommentsAndStrings = vueTemplate.stripCommentsAndStrings;
+exports.toExports = vueTemplate.toExports;
+exports.toImports = vueTemplate.toImports;
+exports.toTypeDeclarationFile = vueTemplate.toTypeDeclarationFile;
+exports.toTypeDeclarationItems = vueTemplate.toTypeDeclarationItems;
+exports.installGlobalAutoImports = installGlobalAutoImports;

node_modules/unimport/dist/index.d.ts

@@ -0,0 +1,51 @@
+import { P as Preset, I as Import, B as BuiltinPresetName, a as InlinePreset, T as TypeDeclarationOptions, b as ImportInjectionResult, S as ScanDirExportsOptions, U as UnimportOptions, c as Thenable, d as InjectImportsOptions, e as InstallGlobalOptions } from './types-0d3b142b.js';
+export { m as Addon, A as AddonsOptions, B as BuiltinPresetName, I as Import, h as ImportCommon, b as ImportInjectionResult, g as ImportName, d as InjectImportsOptions, a as InlinePreset, e as InstallGlobalOptions, M as ModuleId, j as PackagePreset, l as PathFromResolver, P as Preset, i as PresetImport, S as ScanDirExportsOptions, c as Thenable, T as TypeDeclarationOptions, k as UnimportContext, U as UnimportOptions, f as builtinPresets } from './types-0d3b142b.js';
+import MagicString from 'magic-string';
+import * as mlly from 'mlly';
+
+declare function resolvePreset(preset: Preset): Promise<Import[]>;
+declare function resolveBuiltinPresets(presets: (BuiltinPresetName | Preset)[]): Promise<Import[]>;
+
+declare const excludeRE: RegExp[];
+declare const importAsRE: RegExp;
+declare const separatorRE: RegExp;
+/**                                                           |       |
+ *                    destructing   case&ternary    non-call  |  id   |
+ *                         ↓             ↓             ↓      |       |*/
+declare const matchRE: RegExp;
+declare function stripCommentsAndStrings(code: string): string;
+declare function defineUnimportPreset(preset: InlinePreset): InlinePreset;
+declare function toImports(imports: Import[], isCJS?: boolean): string;
+declare function dedupeImports(imports: Import[], warn: (msg: string) => void): Import[];
+declare function toExports(imports: Import[], fileDir?: string): string;
+declare function toTypeDeclarationItems(imports: Import[], options?: TypeDeclarationOptions): string[];
+declare function toTypeDeclarationFile(imports: Import[], options?: TypeDeclarationOptions): string;
+declare function getString(code: string | MagicString): string;
+declare function getMagicString(code: string | MagicString): MagicString;
+declare function addImportToCode(code: string | MagicString, imports: Import[], isCJS?: boolean, mergeExisting?: boolean): ImportInjectionResult;
+declare function normalizeImports(imports: Import[]): Import[];
+declare function resolveIdAbsolute(id: string, parentId?: string): Promise<any>;
+
+declare function scanDirExports(dir: string | string[], options?: ScanDirExportsOptions): Promise<Import[]>;
+declare function scanExports(filepath: string): Promise<Import[]>;
+
+type Unimport = ReturnType<typeof createUnimport>;
+declare function createUnimport(opts: Partial<UnimportOptions>): {
+    clearDynamicImports: () => void;
+    modifyDynamicImports: (fn: (imports: Import[]) => Thenable<void | Import[]>) => Promise<void>;
+    getImports: () => Promise<Import[]>;
+    detectImports: (code: string | MagicString) => Promise<{
+        s: MagicString;
+        strippedCode: string;
+        isCJSContext: boolean;
+        matchedImports: Import[];
+    }>;
+    injectImports: (code: string | MagicString, id?: string, options?: InjectImportsOptions) => Promise<ImportInjectionResult>;
+    toExports: (filepath?: string) => Promise<string>;
+    parseVirtualImports: (code: string) => mlly.ParsedStaticImport[];
+    generateTypeDeclarations: (options?: TypeDeclarationOptions) => Promise<string>;
+};
+
+declare function installGlobalAutoImports(imports: Import[] | Unimport, options?: InstallGlobalOptions): Promise<any>;
+
+export { Unimport, addImportToCode, createUnimport, dedupeImports, defineUnimportPreset, excludeRE, getMagicString, getString, importAsRE, installGlobalAutoImports, matchRE, normalizeImports, resolveBuiltinPresets, resolveIdAbsolute, resolvePreset, scanDirExports, scanExports, separatorRE, stripCommentsAndStrings, toExports, toImports, toTypeDeclarationFile, toTypeDeclarationItems };

node_modules/unimport/dist/index.mjs

@@ -0,0 +1,35 @@
+export { b as builtinPresets, d as createUnimport, a as resolveBuiltinPresets, r as resolvePreset, s as scanDirExports, c as scanExports } from './shared/unimport.1330341c.mjs';
+export { k as addImportToCode, b as dedupeImports, d as defineUnimportPreset, e as excludeRE, j as getMagicString, h as getString, i as importAsRE, m as matchRE, n as normalizeImports, r as resolveIdAbsolute, s as separatorRE, a as stripCommentsAndStrings, c as toExports, t as toImports, g as toTypeDeclarationFile, f as toTypeDeclarationItems } from './shared/unimport.bbd7571a.mjs';
+import 'fs';
+import 'fast-glob';
+import 'pathe';
+import 'mlly';
+import 'scule';
+import 'local-pkg';
+import 'os';
+import 'pkg-types';
+import 'magic-string';
+import 'strip-literal';
+
+async function installGlobalAutoImports(imports, options = {}) {
+  const {
+    globalObject = globalThis,
+    overrides = false
+  } = options;
+  imports = Array.isArray(imports) ? imports : await imports.getImports();
+  await Promise.all(
+    imports.map(async (i) => {
+      if (i.disabled) {
+        return;
+      }
+      const as = i.as || i.name;
+      if (overrides || !(as in globalObject)) {
+        const module = await import(i.from);
+        globalObject[as] = module[i.name];
+      }
+    })
+  );
+  return globalObject;
+}
+
+export { installGlobalAutoImports };

node_modules/unimport/dist/shared/unimport.1330341c.mjs

@@ -0,0 +1,841 @@
+import { readFileSync, existsSync, promises, accessSync, constants } from 'fs';
+import fg from 'fast-glob';
+import { join, dirname, normalize, parse } from 'pathe';
+import { resolveModuleExportNames, findExports, findStaticImports, parseStaticImport, detectSyntax } from 'mlly';
+import { camelCase } from 'scule';
+import { d as defineUnimportPreset, v as vueTemplateAddon, n as normalizeImports, b as dedupeImports, c as toExports, j as getMagicString, a as stripCommentsAndStrings, m as matchRE, e as excludeRE, s as separatorRE, i as importAsRE, k as addImportToCode, g as toTypeDeclarationFile } from './unimport.bbd7571a.mjs';
+import { resolveModule } from 'local-pkg';
+import os from 'os';
+import { resolvePackageJSON, readPackageJSON } from 'pkg-types';
+
+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 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 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 CommonCompositionAPI = [
+  "onActivated",
+  "onBeforeMount",
+  "onBeforeUnmount",
+  "onBeforeUpdate",
+  "onErrorCaptured",
+  "onDeactivated",
+  "onMounted",
+  "onServerPrefetch",
+  "onUnmounted",
+  "onUpdated",
+  "useAttrs",
+  "useSlots",
+  "computed",
+  "customRef",
+  "isReadonly",
+  "isRef",
+  "markRaw",
+  "reactive",
+  "readonly",
+  "ref",
+  "shallowReactive",
+  "shallowReadonly",
+  "shallowRef",
+  "triggerRef",
+  "toRaw",
+  "toRef",
+  "toRefs",
+  "unref",
+  "watch",
+  "watchEffect",
+  "defineComponent",
+  "defineAsyncComponent",
+  "getCurrentInstance",
+  "h",
+  "inject",
+  "nextTick",
+  "provide",
+  "useCssModule",
+  "createApp",
+  "effectScope",
+  "EffectScope",
+  "getCurrentScope",
+  "onScopeDispose"
+];
+const vue = defineUnimportPreset({
+  from: "vue",
+  imports: [
+    ...CommonCompositionAPI,
+    "onRenderTracked",
+    "onRenderTriggered",
+    "resolveComponent",
+    "useCssVars"
+  ]
+});
+
+const vueMacros = defineUnimportPreset({
+  from: "vue/macros",
+  imports: [
+    "$",
+    "$$",
+    "$ref",
+    "$shallowRef",
+    "$toRef",
+    "$customRef",
+    "$computed"
+  ]
+});
+
+const vueDemi = defineUnimportPreset({
+  from: "vue-demi",
+  imports: CommonCompositionAPI
+});
+
+const vueI18n = defineUnimportPreset({
+  from: "vue-i18n",
+  imports: [
+    "useI18n"
+  ]
+});
+
+const vueRouter = defineUnimportPreset({
+  from: "vue-router",
+  imports: [
+    "useRouter",
+    "useRoute"
+  ]
+});
+
+const vueCompositionApi = defineUnimportPreset({
+  from: "@vue/composition-api",
+  imports: CommonCompositionAPI
+});
+
+let _cache;
+const vueuseCore = () => {
+  const excluded = ["toRefs", "utils"];
+  if (!_cache) {
+    try {
+      const corePath = resolveModule("@vueuse/core") || process.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: [
+    "createStore",
+    "createLogger",
+    "mapState",
+    "mapGetters",
+    "mapActions",
+    "mapMutations",
+    "createNamespacedHelpers",
+    "useStore"
+  ]
+});
+
+const vitest = defineUnimportPreset({
+  from: "vitest",
+  imports: [
+    "suite",
+    "test",
+    "describe",
+    "it",
+    "chai",
+    "expect",
+    "assert",
+    "vitest",
+    "vi",
+    "beforeAll",
+    "afterAll",
+    "beforeEach",
+    "afterEach"
+  ]
+});
+
+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 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 builtinPresets = {
+  "@vue/composition-api": vueCompositionApi,
+  "@vueuse/core": vueuseCore,
+  "@vueuse/head": vueuseHead,
+  pinia,
+  preact,
+  quasar,
+  react,
+  "react-router": reactRouter,
+  "react-router-dom": reactRouterDom,
+  svelte,
+  "svelte/animate": svelteAnimate,
+  "svelte/easing": svelteEasing,
+  "svelte/motion": svelteMotion,
+  "svelte/store": svelteStore,
+  "svelte/transition": svelteTransition,
+  "vee-validate": veeValidate,
+  vitepress,
+  "vue-demi": vueDemi,
+  "vue-i18n": vueI18n,
+  "vue-router": vueRouter,
+  vue,
+  "vue/macros": vueMacros,
+  vuex,
+  vitest,
+  "uni-app": uniApp,
+  "solid-js": solid,
+  "solid-app-router": solidAppRouter
+};
+
+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 (e) {
+    return false;
+  }
+}
+
+const commonProps = ["from", "priority", "disabled"];
+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();
+}
+
+async function scanDirExports(dir, options) {
+  const dirs = (Array.isArray(dir) ? dir : [dir]).map((d) => normalize(d));
+  const fileFilter = options?.fileFilter || (() => true);
+  const filePatterns = options?.filePatterns || ["*.{ts,js,mjs,cjs,mts,cts}"];
+  const result = await Promise.all(
+    dirs.map(
+      async (i) => await fg(
+        [i, ...filePatterns.map((p) => join(i, p))],
+        {
+          absolute: true,
+          cwd: options?.cwd || process.cwd(),
+          onlyFiles: true,
+          followSymbolicLinks: true
+        }
+      ).then(
+        (r) => r.map((f) => normalize(f)).sort()
+      )
+    )
+  );
+  const files = Array.from(new Set(result.flat())).filter(fileFilter);
+  const fileExports = await Promise.all(files.map(scanExports));
+  return fileExports.flat();
+}
+async function scanExports(filepath) {
+  const imports = [];
+  const code = await promises.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;
+    }
+    imports.push({ name: "default", as: camelCase(name), from: filepath });
+  }
+  for (const exp of exports) {
+    if (exp.type === "named") {
+      for (const name of exp.names) {
+        imports.push({ name, as: name, from: filepath });
+      }
+    } else if (exp.type === "declaration") {
+      if (exp.name) {
+        imports.push({ name: exp.name, as: exp.name, from: filepath });
+      }
+    }
+  }
+  return imports;
+}
+
+function createUnimport(opts) {
+  let _combinedImports;
+  const _map = /* @__PURE__ */ new Map();
+  const addons = [];
+  if (Array.isArray(opts.addons)) {
+    addons.push(...opts.addons);
+  } else if (opts.addons?.vueTemplate) {
+    addons.push(vueTemplateAddon());
+  }
+  opts.addons = addons;
+  opts.commentsDisable = opts.commentsDisable ?? ["@unimport-disable", "@imports-disable"];
+  opts.commentsDebug = opts.commentsDebug ?? ["@unimport-debug", "@imports-debug"];
+  const ctx = {
+    staticImports: [...opts.imports || []].filter(Boolean),
+    dynamicImports: [],
+    async getImports() {
+      await resolvePromise;
+      return updateImports();
+    },
+    async getImportMap() {
+      await ctx.getImports();
+      return _map;
+    },
+    invalidate() {
+      _combinedImports = void 0;
+    },
+    resolveId: (id, parentId) => opts.resolveId?.(id, parentId),
+    addons,
+    options: opts
+  };
+  const resolvePromise = resolveBuiltinPresets(opts.presets || []).then((r) => {
+    ctx.staticImports.unshift(...r);
+    _combinedImports = void 0;
+    updateImports();
+  });
+  function updateImports() {
+    if (!_combinedImports) {
+      const imports = normalizeImports(dedupeImports([...ctx.staticImports, ...ctx.dynamicImports], opts.warn || console.warn)).filter((i) => !i.disabled);
+      _map.clear();
+      for (const _import of imports) {
+        _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();
+  }
+  async function generateTypeDeclarations(options) {
+    const opts2 = {
+      resolvePath: (i) => i.from.replace(/\.ts$/, ""),
+      ...options
+    };
+    let dts = toTypeDeclarationFile(await ctx.getImports(), opts2);
+    for (const addon of ctx.addons) {
+      dts = await addon.declaration?.call(ctx, dts, opts2) ?? dts;
+    }
+    return dts;
+  }
+  return {
+    clearDynamicImports,
+    modifyDynamicImports,
+    getImports: () => ctx.getImports(),
+    detectImports: (code) => detectImports(code, ctx),
+    injectImports: (code, id, options) => injectImports(code, id, ctx, options),
+    toExports: async (filepath) => toExports(await ctx.getImports(), filepath),
+    parseVirtualImports: (code) => parseVirtualImports(code, ctx),
+    generateTypeDeclarations
+  };
+}
+function parseVirtualImports(code, ctx) {
+  if (ctx.options.virtualImports?.length) {
+    return findStaticImports(code).filter((i) => ctx.options.virtualImports.includes(i.specifier)).map((i) => parseStaticImport(i));
+  }
+  return [];
+}
+async function detectImports(code, ctx, options) {
+  const s = getMagicString(code);
+  const original = s.original;
+  const strippedCode = stripCommentsAndStrings(original);
+  const syntax = detectSyntax(strippedCode);
+  const isCJSContext = syntax.hasCJS && !syntax.hasESM;
+  let matchedImports = [];
+  const map = await ctx.getImportMap();
+  if (options?.autoImport !== false) {
+    const identifiers = new Set(
+      Array.from(strippedCode.matchAll(matchRE)).map((i) => {
+        if (i[1] === ".") {
+          return "";
+        }
+        const end = strippedCode[i.index + i[0].length];
+        if (end === ":" && !["?", "case"].includes(i[1].trim())) {
+          return "";
+        }
+        return i[2];
+      }).filter(Boolean)
+    );
+    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();
+          identifiers.delete(identifier);
+        }
+      }
+    }
+    matchedImports = Array.from(identifiers).map((name) => map.get(name)).filter((i) => i && !i.disabled);
+    for (const addon of ctx.addons) {
+      matchedImports = await addon.matchImports?.call(ctx, identifiers, matchedImports) || matchedImports;
+    }
+  }
+  if (options?.transformVirtualImports !== false && options?.transformVirtualImoports !== false && ctx.options.virtualImports?.length) {
+    const virtualImports = parseVirtualImports(original, ctx);
+    virtualImports.forEach((i) => {
+      s.remove(i.start, i.end);
+      Object.entries(i.namedImports || {}).forEach(([name, as]) => {
+        const original2 = map.get(name);
+        if (!original2) {
+          throw new Error(`[unimport] failed to find "${name}" imported from "${i.specifier}"`);
+        }
+        matchedImports.push({
+          from: original2.from,
+          name: original2.name,
+          as
+        });
+      });
+    });
+  }
+  return {
+    s,
+    strippedCode,
+    isCJSContext,
+    matchedImports
+  };
+}
+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();
+      }
+    };
+  }
+  for (const addon of ctx.addons) {
+    await addon.transform?.call(ctx, s, id);
+  }
+  const { isCJSContext, matchedImports } = 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);
+}
+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);
+}
+
+export { resolveBuiltinPresets as a, builtinPresets as b, scanExports as c, createUnimport as d, resolvePreset as r, scanDirExports as s };

node_modules/unimport/dist/shared/unimport.7b88c06e.cjs

@@ -0,0 +1,270 @@
+'use strict';
+
+const pathe = require('pathe');
+const mlly = require('mlly');
+const MagicString = require('magic-string');
+const stripLiteral = require('strip-literal');
+
+const excludeRE = [
+  /\b(import|export)\b(.+?)\bfrom\b/gs,
+  /\bfunction\s*([\w_$]+?)\s*\(/gs,
+  /\bclass\s*([\w_$]+?)\s*{/gs,
+  /\b(?:const|let|var)\s+?(\[.*?\]|\{.*?\}|.+?)\s*?[=;\n]/gs
+];
+const importAsRE = /^.*\sas\s+/;
+const separatorRE = /[,[\]{}\n]|\bimport\b/g;
+const matchRE = /(^|\.\.\.|(?:\bcase|\?)\s+|[^\w_$\/)])([\w_$]+)\s*(?=[.()[\]}:;?+\-*&|`<>,\n]|\b(?:instanceof|in)\b|$)/g;
+const regexRE = /\/[^\s]*?(?<!\\)(?<!\[[^\]]*)\/[gimsuy]*/g;
+function stripCommentsAndStrings(code) {
+  return stripLiteral.stripLiteral(code).replace(regexRE, 'new RegExp("")');
+}
+function defineUnimportPreset(preset) {
+  return preset;
+}
+function toImports(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 === "") {
+        entries.push(
+          isCJS ? `require('${name}');` : `import '${name}';`
+        );
+        return false;
+      } else if (i.name === "default") {
+        entries.push(
+          isCJS ? `const { default: ${i.as} } = require('${name}');` : `import ${i.as} from '${name}';`
+        );
+        return false;
+      } else if (i.name === "*") {
+        entries.push(
+          isCJS ? `const ${i.as} = require('${name}');` : `import * as ${i.as} from '${name}';`
+        );
+        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) => {
+    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`);
+    }
+    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) {
+  const map = toImportModuleMap(imports);
+  return Object.entries(map).flatMap(([name, imports2]) => {
+    name = name.replace(/\.[a-z]+$/, "");
+    if (fileDir && pathe.isAbsolute(name)) {
+      name = pathe.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 toTypeDeclarationItems(imports, options) {
+  return imports.map((i) => {
+    const from = options?.resolvePath?.(i) || i.from;
+    return `const ${i.as}: typeof import('${from}')${i.name !== "*" ? `['${i.name}']` : ""}`;
+  }).sort();
+}
+function toTypeDeclarationFile(imports, options) {
+  const items = toTypeDeclarationItems(imports, options);
+  const {
+    exportHelper = true
+  } = options || {};
+  let declaration = "";
+  if (exportHelper) {
+    declaration += "export {}\n";
+  }
+  declaration += "declare global {\n" + items.map((i) => "  " + i).join("\n") + "\n}";
+  return declaration;
+}
+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) {
+  const map = {};
+  for (const _import of imports) {
+    if (!map[_import.from]) {
+      map[_import.from] = /* @__PURE__ */ new Set();
+    }
+    map[_import.from].add(_import);
+  }
+  return map;
+}
+function getString(code) {
+  if (typeof code === "string") {
+    return code;
+  }
+  return code.toString();
+}
+function getMagicString(code) {
+  if (typeof code === "string") {
+    return new MagicString(code);
+  }
+  return code;
+}
+function addImportToCode(code, imports, isCJS = false, mergeExisting = false) {
+  let newImports = [];
+  const s = getMagicString(code);
+  if (mergeExisting && !isCJS) {
+    const existing = mlly.findStaticImports(s.original).map((i) => mlly.parseStaticImport(i));
+    const map = /* @__PURE__ */ new Map();
+    imports.forEach((i) => {
+      const target = existing.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;
+  }
+  const newEntries = toImports(newImports, isCJS);
+  if (newEntries) {
+    s.prepend(newEntries + "\n");
+  }
+  return {
+    s,
+    get code() {
+      return s.toString();
+    }
+  };
+}
+function normalizeImports(imports) {
+  for (const _import of imports) {
+    _import.as = _import.as ?? _import.name;
+  }
+  return imports;
+}
+function resolveIdAbsolute(id, parentId) {
+  return mlly.resolvePath(id, {
+    url: parentId
+  });
+}
+
+const contextRE = /\b_ctx\.([\w_]+)\b/g;
+const UNREF_KEY = "_unimport_unref_";
+const vueTemplateAddon = () => ({
+  async transform(s) {
+    if (!s.original.includes("_ctx.")) {
+      return s;
+    }
+    const matches = Array.from(s.original.matchAll(contextRE));
+    const imports = await this.getImports();
+    const 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, `${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
+      });
+      s.prepend(toImports(targets));
+    }
+    return s;
+  },
+  async declaration(dts, options) {
+    const imports = await this.getImports();
+    const items = imports.map((i) => {
+      const from = options?.resolvePath?.(i) || i.from;
+      return `readonly ${i.as}: UnwrapRef<typeof import('${from}')${i.name !== "*" ? `['${i.name}']` : ""}>`;
+    }).sort();
+    return dts + `
+// for vue template auto import
+import { UnwrapRef } from 'vue'
+declare module 'vue' {
+  interface ComponentCustomProperties {
+${items.map((i) => "    " + i).join("\n")}
+  }
+}
+`;
+  }
+});
+
+exports.addImportToCode = addImportToCode;
+exports.dedupeImports = dedupeImports;
+exports.defineUnimportPreset = defineUnimportPreset;
+exports.excludeRE = excludeRE;
+exports.getMagicString = getMagicString;
+exports.getString = getString;
+exports.importAsRE = importAsRE;
+exports.matchRE = matchRE;
+exports.normalizeImports = normalizeImports;
+exports.resolveIdAbsolute = resolveIdAbsolute;
+exports.separatorRE = separatorRE;
+exports.stripCommentsAndStrings = stripCommentsAndStrings;
+exports.toExports = toExports;
+exports.toImports = toImports;
+exports.toTypeDeclarationFile = toTypeDeclarationFile;
+exports.toTypeDeclarationItems = toTypeDeclarationItems;
+exports.vueTemplateAddon = vueTemplateAddon;

node_modules/unimport/dist/shared/unimport.bbd7571a.mjs

@@ -0,0 +1,252 @@
+import { isAbsolute, relative } from 'pathe';
+import { findStaticImports, parseStaticImport, resolvePath } from 'mlly';
+import MagicString from 'magic-string';
+import { stripLiteral } from 'strip-literal';
+
+const excludeRE = [
+  /\b(import|export)\b(.+?)\bfrom\b/gs,
+  /\bfunction\s*([\w_$]+?)\s*\(/gs,
+  /\bclass\s*([\w_$]+?)\s*{/gs,
+  /\b(?:const|let|var)\s+?(\[.*?\]|\{.*?\}|.+?)\s*?[=;\n]/gs
+];
+const importAsRE = /^.*\sas\s+/;
+const separatorRE = /[,[\]{}\n]|\bimport\b/g;
+const matchRE = /(^|\.\.\.|(?:\bcase|\?)\s+|[^\w_$\/)])([\w_$]+)\s*(?=[.()[\]}:;?+\-*&|`<>,\n]|\b(?:instanceof|in)\b|$)/g;
+const regexRE = /\/[^\s]*?(?<!\\)(?<!\[[^\]]*)\/[gimsuy]*/g;
+function stripCommentsAndStrings(code) {
+  return stripLiteral(code).replace(regexRE, 'new RegExp("")');
+}
+function defineUnimportPreset(preset) {
+  return preset;
+}
+function toImports(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 === "") {
+        entries.push(
+          isCJS ? `require('${name}');` : `import '${name}';`
+        );
+        return false;
+      } else if (i.name === "default") {
+        entries.push(
+          isCJS ? `const { default: ${i.as} } = require('${name}');` : `import ${i.as} from '${name}';`
+        );
+        return false;
+      } else if (i.name === "*") {
+        entries.push(
+          isCJS ? `const ${i.as} = require('${name}');` : `import * as ${i.as} from '${name}';`
+        );
+        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) => {
+    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`);
+    }
+    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) {
+  const map = toImportModuleMap(imports);
+  return Object.entries(map).flatMap(([name, imports2]) => {
+    name = name.replace(/\.[a-z]+$/, "");
+    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 toTypeDeclarationItems(imports, options) {
+  return imports.map((i) => {
+    const from = options?.resolvePath?.(i) || i.from;
+    return `const ${i.as}: typeof import('${from}')${i.name !== "*" ? `['${i.name}']` : ""}`;
+  }).sort();
+}
+function toTypeDeclarationFile(imports, options) {
+  const items = toTypeDeclarationItems(imports, options);
+  const {
+    exportHelper = true
+  } = options || {};
+  let declaration = "";
+  if (exportHelper) {
+    declaration += "export {}\n";
+  }
+  declaration += "declare global {\n" + items.map((i) => "  " + i).join("\n") + "\n}";
+  return declaration;
+}
+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) {
+  const map = {};
+  for (const _import of imports) {
+    if (!map[_import.from]) {
+      map[_import.from] = /* @__PURE__ */ new Set();
+    }
+    map[_import.from].add(_import);
+  }
+  return map;
+}
+function getString(code) {
+  if (typeof code === "string") {
+    return code;
+  }
+  return code.toString();
+}
+function getMagicString(code) {
+  if (typeof code === "string") {
+    return new MagicString(code);
+  }
+  return code;
+}
+function addImportToCode(code, imports, isCJS = false, mergeExisting = false) {
+  let newImports = [];
+  const s = getMagicString(code);
+  if (mergeExisting && !isCJS) {
+    const existing = findStaticImports(s.original).map((i) => parseStaticImport(i));
+    const map = /* @__PURE__ */ new Map();
+    imports.forEach((i) => {
+      const target = existing.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;
+  }
+  const newEntries = toImports(newImports, isCJS);
+  if (newEntries) {
+    s.prepend(newEntries + "\n");
+  }
+  return {
+    s,
+    get code() {
+      return s.toString();
+    }
+  };
+}
+function normalizeImports(imports) {
+  for (const _import of imports) {
+    _import.as = _import.as ?? _import.name;
+  }
+  return imports;
+}
+function resolveIdAbsolute(id, parentId) {
+  return resolvePath(id, {
+    url: parentId
+  });
+}
+
+const contextRE = /\b_ctx\.([\w_]+)\b/g;
+const UNREF_KEY = "_unimport_unref_";
+const vueTemplateAddon = () => ({
+  async transform(s) {
+    if (!s.original.includes("_ctx.")) {
+      return s;
+    }
+    const matches = Array.from(s.original.matchAll(contextRE));
+    const imports = await this.getImports();
+    const 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, `${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
+      });
+      s.prepend(toImports(targets));
+    }
+    return s;
+  },
+  async declaration(dts, options) {
+    const imports = await this.getImports();
+    const items = imports.map((i) => {
+      const from = options?.resolvePath?.(i) || i.from;
+      return `readonly ${i.as}: UnwrapRef<typeof import('${from}')${i.name !== "*" ? `['${i.name}']` : ""}>`;
+    }).sort();
+    return dts + `
+// for vue template auto import
+import { UnwrapRef } from 'vue'
+declare module 'vue' {
+  interface ComponentCustomProperties {
+${items.map((i) => "    " + i).join("\n")}
+  }
+}
+`;
+  }
+});
+
+export { stripCommentsAndStrings as a, dedupeImports as b, toExports as c, defineUnimportPreset as d, excludeRE as e, toTypeDeclarationItems as f, toTypeDeclarationFile as g, getString as h, importAsRE as i, getMagicString as j, addImportToCode as k, matchRE as m, normalizeImports as n, resolveIdAbsolute as r, separatorRE as s, toImports as t, vueTemplateAddon as v };

node_modules/unimport/dist/shared/unimport.e56b747d.cjs

@@ -0,0 +1,848 @@
+'use strict';
+
+const fs = require('fs');
+const fg = require('fast-glob');
+const pathe = require('pathe');
+const mlly = require('mlly');
+const scule = require('scule');
+const vueTemplate = require('./unimport.7b88c06e.cjs');
+const localPkg = require('local-pkg');
+const os = require('os');
+const pkgTypes = require('pkg-types');
+
+const pinia = vueTemplate.defineUnimportPreset({
+  from: "pinia",
+  imports: [
+    "acceptHMRUpdate",
+    "createPinia",
+    "defineStore",
+    "getActivePinia",
+    "mapActions",
+    "mapGetters",
+    "mapState",
+    "mapStores",
+    "mapWritableState",
+    "setActivePinia",
+    "setMapStoreSuffix",
+    "storeToRefs"
+  ]
+});
+
+const preact = vueTemplate.defineUnimportPreset({
+  from: "preact",
+  imports: [
+    "useState",
+    "useCallback",
+    "useMemo",
+    "useEffect",
+    "useRef",
+    "useContext",
+    "useReducer"
+  ]
+});
+
+const quasar = vueTemplate.defineUnimportPreset({
+  from: "quasar",
+  imports: [
+    "useQuasar",
+    "useDialogPluginComponent",
+    "useFormChild",
+    "useMeta"
+  ]
+});
+
+const react = vueTemplate.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 = vueTemplate.defineUnimportPreset({
+  from: "react-router",
+  imports: [
+    ...ReactRouterHooks
+  ]
+});
+
+const reactRouterDom = vueTemplate.defineUnimportPreset({
+  from: "react-router-dom",
+  imports: [
+    ...ReactRouterHooks,
+    "useLinkClickHandler",
+    "useSearchParams",
+    "Link",
+    "NavLink",
+    "Navigate",
+    "Outlet",
+    "Route",
+    "Routes"
+  ]
+});
+
+const svelteAnimate = vueTemplate.defineUnimportPreset({
+  from: "svelte/animate",
+  imports: [
+    "flip"
+  ]
+});
+const svelteEasing = vueTemplate.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 = vueTemplate.defineUnimportPreset({
+  from: "svelte/store",
+  imports: [
+    "writable",
+    "readable",
+    "derived",
+    "get"
+  ]
+});
+const svelteMotion = vueTemplate.defineUnimportPreset({
+  from: "svelte/motion",
+  imports: [
+    "tweened",
+    "spring"
+  ]
+});
+const svelteTransition = vueTemplate.defineUnimportPreset({
+  from: "svelte/transition",
+  imports: [
+    "fade",
+    "blur",
+    "fly",
+    "slide",
+    "scale",
+    "draw",
+    "crossfade"
+  ]
+});
+const svelte = vueTemplate.defineUnimportPreset({
+  from: "svelte",
+  imports: [
+    "onMount",
+    "beforeUpdate",
+    "afterUpdate",
+    "onDestroy",
+    "tick",
+    "setContext",
+    "getContext",
+    "hasContext",
+    "getAllContexts",
+    "createEventDispatcher"
+  ]
+});
+
+const veeValidate = vueTemplate.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 = vueTemplate.defineUnimportPreset({
+  from: "vitepress",
+  imports: [
+    "useData",
+    "useRoute",
+    "useRouter",
+    "withBase"
+  ]
+});
+
+const CommonCompositionAPI = [
+  "onActivated",
+  "onBeforeMount",
+  "onBeforeUnmount",
+  "onBeforeUpdate",
+  "onErrorCaptured",
+  "onDeactivated",
+  "onMounted",
+  "onServerPrefetch",
+  "onUnmounted",
+  "onUpdated",
+  "useAttrs",
+  "useSlots",
+  "computed",
+  "customRef",
+  "isReadonly",
+  "isRef",
+  "markRaw",
+  "reactive",
+  "readonly",
+  "ref",
+  "shallowReactive",
+  "shallowReadonly",
+  "shallowRef",
+  "triggerRef",
+  "toRaw",
+  "toRef",
+  "toRefs",
+  "unref",
+  "watch",
+  "watchEffect",
+  "defineComponent",
+  "defineAsyncComponent",
+  "getCurrentInstance",
+  "h",
+  "inject",
+  "nextTick",
+  "provide",
+  "useCssModule",
+  "createApp",
+  "effectScope",
+  "EffectScope",
+  "getCurrentScope",
+  "onScopeDispose"
+];
+const vue = vueTemplate.defineUnimportPreset({
+  from: "vue",
+  imports: [
+    ...CommonCompositionAPI,
+    "onRenderTracked",
+    "onRenderTriggered",
+    "resolveComponent",
+    "useCssVars"
+  ]
+});
+
+const vueMacros = vueTemplate.defineUnimportPreset({
+  from: "vue/macros",
+  imports: [
+    "$",
+    "$$",
+    "$ref",
+    "$shallowRef",
+    "$toRef",
+    "$customRef",
+    "$computed"
+  ]
+});
+
+const vueDemi = vueTemplate.defineUnimportPreset({
+  from: "vue-demi",
+  imports: CommonCompositionAPI
+});
+
+const vueI18n = vueTemplate.defineUnimportPreset({
+  from: "vue-i18n",
+  imports: [
+    "useI18n"
+  ]
+});
+
+const vueRouter = vueTemplate.defineUnimportPreset({
+  from: "vue-router",
+  imports: [
+    "useRouter",
+    "useRoute"
+  ]
+});
+
+const vueCompositionApi = vueTemplate.defineUnimportPreset({
+  from: "@vue/composition-api",
+  imports: CommonCompositionAPI
+});
+
+let _cache;
+const vueuseCore = () => {
+  const excluded = ["toRefs", "utils"];
+  if (!_cache) {
+    try {
+      const corePath = localPkg.resolveModule("@vueuse/core") || process.cwd();
+      const path = localPkg.resolveModule("@vueuse/core/indexes.json") || localPkg.resolveModule("@vueuse/metadata/index.json") || localPkg.resolveModule("@vueuse/metadata/index.json", { paths: [corePath] });
+      const indexesJson = JSON.parse(fs.readFileSync(path, "utf-8"));
+      _cache = vueTemplate.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 = vueTemplate.defineUnimportPreset({
+  from: "@vueuse/head",
+  imports: [
+    "useHead"
+  ]
+});
+
+const vuex = vueTemplate.defineUnimportPreset({
+  from: "vuex",
+  imports: [
+    "createStore",
+    "createLogger",
+    "mapState",
+    "mapGetters",
+    "mapActions",
+    "mapMutations",
+    "createNamespacedHelpers",
+    "useStore"
+  ]
+});
+
+const vitest = vueTemplate.defineUnimportPreset({
+  from: "vitest",
+  imports: [
+    "suite",
+    "test",
+    "describe",
+    "it",
+    "chai",
+    "expect",
+    "assert",
+    "vitest",
+    "vi",
+    "beforeAll",
+    "afterAll",
+    "beforeEach",
+    "afterEach"
+  ]
+});
+
+const uniApp = vueTemplate.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 solidCore = vueTemplate.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 = vueTemplate.defineUnimportPreset({
+  from: "solid-js/store",
+  imports: [
+    "createStore",
+    "produce",
+    "reconcile",
+    "createMutable"
+  ]
+});
+const solidWeb = vueTemplate.defineUnimportPreset({
+  from: "solid-js/web",
+  imports: [
+    "Dynamic",
+    "hydrate",
+    "render",
+    "renderToString",
+    "renderToStringAsync",
+    "renderToStream",
+    "isServer",
+    "Portal"
+  ]
+});
+const solid = vueTemplate.defineUnimportPreset({
+  from: "solid-js",
+  imports: [
+    solidCore,
+    solidStore,
+    solidWeb
+  ]
+});
+
+const solidAppRouter = vueTemplate.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 builtinPresets = {
+  "@vue/composition-api": vueCompositionApi,
+  "@vueuse/core": vueuseCore,
+  "@vueuse/head": vueuseHead,
+  pinia,
+  preact,
+  quasar,
+  react,
+  "react-router": reactRouter,
+  "react-router-dom": reactRouterDom,
+  svelte,
+  "svelte/animate": svelteAnimate,
+  "svelte/easing": svelteEasing,
+  "svelte/motion": svelteMotion,
+  "svelte/store": svelteStore,
+  "svelte/transition": svelteTransition,
+  "vee-validate": veeValidate,
+  vitepress,
+  "vue-demi": vueDemi,
+  "vue-i18n": vueI18n,
+  "vue-router": vueRouter,
+  vue,
+  "vue/macros": vueMacros,
+  vuex,
+  vitest,
+  "uni-app": uniApp,
+  "solid-js": solid,
+  "solid-app-router": solidAppRouter
+};
+
+const CACHE_PATH = /* @__PURE__ */ pathe.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 pkgTypes.resolvePackageJSON(name, { url });
+  const packageJson = await pkgTypes.readPackageJSON(packageJsonPath);
+  const version = packageJson.version;
+  const cachePath = pathe.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 && fs.existsSync(cachePath)) {
+    return JSON.parse(await fs.promises.readFile(cachePath, "utf-8"));
+  }
+  const scanned = await mlly.resolveModuleExportNames(name, { url });
+  if (useCache) {
+    await fs.promises.mkdir(pathe.dirname(cachePath), { recursive: true });
+    await fs.promises.writeFile(cachePath, JSON.stringify(scanned), "utf-8");
+  }
+  return scanned;
+}
+function isWritable(filename) {
+  try {
+    fs.accessSync(filename, fs.constants.W_OK);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+const commonProps = ["from", "priority", "disabled"];
+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();
+}
+
+async function scanDirExports(dir, options) {
+  const dirs = (Array.isArray(dir) ? dir : [dir]).map((d) => pathe.normalize(d));
+  const fileFilter = options?.fileFilter || (() => true);
+  const filePatterns = options?.filePatterns || ["*.{ts,js,mjs,cjs,mts,cts}"];
+  const result = await Promise.all(
+    dirs.map(
+      async (i) => await fg(
+        [i, ...filePatterns.map((p) => pathe.join(i, p))],
+        {
+          absolute: true,
+          cwd: options?.cwd || process.cwd(),
+          onlyFiles: true,
+          followSymbolicLinks: true
+        }
+      ).then(
+        (r) => r.map((f) => pathe.normalize(f)).sort()
+      )
+    )
+  );
+  const files = Array.from(new Set(result.flat())).filter(fileFilter);
+  const fileExports = await Promise.all(files.map(scanExports));
+  return fileExports.flat();
+}
+async function scanExports(filepath) {
+  const imports = [];
+  const code = await fs.promises.readFile(filepath, "utf-8");
+  const exports = mlly.findExports(code);
+  const defaultExport = exports.find((i) => i.type === "default");
+  if (defaultExport) {
+    let name = pathe.parse(filepath).name;
+    if (name === "index") {
+      name = pathe.parse(filepath.split("/").slice(0, -1).join("/")).name;
+    }
+    imports.push({ name: "default", as: scule.camelCase(name), from: filepath });
+  }
+  for (const exp of exports) {
+    if (exp.type === "named") {
+      for (const name of exp.names) {
+        imports.push({ name, as: name, from: filepath });
+      }
+    } else if (exp.type === "declaration") {
+      if (exp.name) {
+        imports.push({ name: exp.name, as: exp.name, from: filepath });
+      }
+    }
+  }
+  return imports;
+}
+
+function createUnimport(opts) {
+  let _combinedImports;
+  const _map = /* @__PURE__ */ new Map();
+  const addons = [];
+  if (Array.isArray(opts.addons)) {
+    addons.push(...opts.addons);
+  } else if (opts.addons?.vueTemplate) {
+    addons.push(vueTemplate.vueTemplateAddon());
+  }
+  opts.addons = addons;
+  opts.commentsDisable = opts.commentsDisable ?? ["@unimport-disable", "@imports-disable"];
+  opts.commentsDebug = opts.commentsDebug ?? ["@unimport-debug", "@imports-debug"];
+  const ctx = {
+    staticImports: [...opts.imports || []].filter(Boolean),
+    dynamicImports: [],
+    async getImports() {
+      await resolvePromise;
+      return updateImports();
+    },
+    async getImportMap() {
+      await ctx.getImports();
+      return _map;
+    },
+    invalidate() {
+      _combinedImports = void 0;
+    },
+    resolveId: (id, parentId) => opts.resolveId?.(id, parentId),
+    addons,
+    options: opts
+  };
+  const resolvePromise = resolveBuiltinPresets(opts.presets || []).then((r) => {
+    ctx.staticImports.unshift(...r);
+    _combinedImports = void 0;
+    updateImports();
+  });
+  function updateImports() {
+    if (!_combinedImports) {
+      const imports = vueTemplate.normalizeImports(vueTemplate.dedupeImports([...ctx.staticImports, ...ctx.dynamicImports], opts.warn || console.warn)).filter((i) => !i.disabled);
+      _map.clear();
+      for (const _import of imports) {
+        _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();
+  }
+  async function generateTypeDeclarations(options) {
+    const opts2 = {
+      resolvePath: (i) => i.from.replace(/\.ts$/, ""),
+      ...options
+    };
+    let dts = vueTemplate.toTypeDeclarationFile(await ctx.getImports(), opts2);
+    for (const addon of ctx.addons) {
+      dts = await addon.declaration?.call(ctx, dts, opts2) ?? dts;
+    }
+    return dts;
+  }
+  return {
+    clearDynamicImports,
+    modifyDynamicImports,
+    getImports: () => ctx.getImports(),
+    detectImports: (code) => detectImports(code, ctx),
+    injectImports: (code, id, options) => injectImports(code, id, ctx, options),
+    toExports: async (filepath) => vueTemplate.toExports(await ctx.getImports(), filepath),
+    parseVirtualImports: (code) => parseVirtualImports(code, ctx),
+    generateTypeDeclarations
+  };
+}
+function parseVirtualImports(code, ctx) {
+  if (ctx.options.virtualImports?.length) {
+    return mlly.findStaticImports(code).filter((i) => ctx.options.virtualImports.includes(i.specifier)).map((i) => mlly.parseStaticImport(i));
+  }
+  return [];
+}
+async function detectImports(code, ctx, options) {
+  const s = vueTemplate.getMagicString(code);
+  const original = s.original;
+  const strippedCode = vueTemplate.stripCommentsAndStrings(original);
+  const syntax = mlly.detectSyntax(strippedCode);
+  const isCJSContext = syntax.hasCJS && !syntax.hasESM;
+  let matchedImports = [];
+  const map = await ctx.getImportMap();
+  if (options?.autoImport !== false) {
+    const identifiers = new Set(
+      Array.from(strippedCode.matchAll(vueTemplate.matchRE)).map((i) => {
+        if (i[1] === ".") {
+          return "";
+        }
+        const end = strippedCode[i.index + i[0].length];
+        if (end === ":" && !["?", "case"].includes(i[1].trim())) {
+          return "";
+        }
+        return i[2];
+      }).filter(Boolean)
+    );
+    for (const regex of vueTemplate.excludeRE) {
+      for (const match of strippedCode.matchAll(regex)) {
+        const segments = [...match[1]?.split(vueTemplate.separatorRE) || [], ...match[2]?.split(vueTemplate.separatorRE) || []];
+        for (const segment of segments) {
+          const identifier = segment.replace(vueTemplate.importAsRE, "").trim();
+          identifiers.delete(identifier);
+        }
+      }
+    }
+    matchedImports = Array.from(identifiers).map((name) => map.get(name)).filter((i) => i && !i.disabled);
+    for (const addon of ctx.addons) {
+      matchedImports = await addon.matchImports?.call(ctx, identifiers, matchedImports) || matchedImports;
+    }
+  }
+  if (options?.transformVirtualImports !== false && options?.transformVirtualImoports !== false && ctx.options.virtualImports?.length) {
+    const virtualImports = parseVirtualImports(original, ctx);
+    virtualImports.forEach((i) => {
+      s.remove(i.start, i.end);
+      Object.entries(i.namedImports || {}).forEach(([name, as]) => {
+        const original2 = map.get(name);
+        if (!original2) {
+          throw new Error(`[unimport] failed to find "${name}" imported from "${i.specifier}"`);
+        }
+        matchedImports.push({
+          from: original2.from,
+          name: original2.name,
+          as
+        });
+      });
+    });
+  }
+  return {
+    s,
+    strippedCode,
+    isCJSContext,
+    matchedImports
+  };
+}
+async function injectImports(code, id, ctx, options) {
+  const s = vueTemplate.getMagicString(code);
+  if (ctx.options.commentsDisable?.some((c) => s.original.includes(c))) {
+    return {
+      s,
+      get code() {
+        return s.toString();
+      }
+    };
+  }
+  for (const addon of ctx.addons) {
+    await addon.transform?.call(ctx, s, id);
+  }
+  const { isCJSContext, matchedImports } = 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 vueTemplate.addImportToCode(s, imports, isCJSContext, options?.mergeExisting);
+}
+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);
+}
+
+exports.builtinPresets = builtinPresets;
+exports.createUnimport = createUnimport;
+exports.resolveBuiltinPresets = resolveBuiltinPresets;
+exports.resolvePreset = resolvePreset;
+exports.scanDirExports = scanDirExports;
+exports.scanExports = scanExports;

node_modules/unimport/dist/types-0d3b142b.d.ts

@@ -0,0 +1,226 @@
+import MagicString from 'magic-string';
+
+declare const builtinPresets: {
+    '@vue/composition-api': InlinePreset;
+    '@vueuse/core': () => Preset;
+    '@vueuse/head': InlinePreset;
+    pinia: InlinePreset;
+    preact: InlinePreset;
+    quasar: InlinePreset;
+    react: InlinePreset;
+    'react-router': InlinePreset;
+    'react-router-dom': InlinePreset;
+    svelte: InlinePreset;
+    'svelte/animate': InlinePreset;
+    'svelte/easing': InlinePreset;
+    'svelte/motion': InlinePreset;
+    'svelte/store': InlinePreset;
+    'svelte/transition': InlinePreset;
+    'vee-validate': InlinePreset;
+    vitepress: InlinePreset;
+    'vue-demi': InlinePreset;
+    'vue-i18n': InlinePreset;
+    'vue-router': InlinePreset;
+    vue: InlinePreset;
+    'vue/macros': InlinePreset;
+    vuex: InlinePreset;
+    vitest: InlinePreset;
+    'uni-app': InlinePreset;
+    'solid-js': InlinePreset;
+    'solid-app-router': InlinePreset;
+};
+type BuiltinPresetName = keyof typeof builtinPresets;
+
+type ModuleId = string;
+type ImportName = string;
+interface ImportCommon {
+    /** Module specifier to import from */
+    from: ModuleId;
+    /**
+     * Priority of the import, if multiple imports have the same name, the one with the highest priority will be used
+     * @default 1
+     */
+    priority?: number;
+    /** If this import is disabled */
+    disabled?: boolean;
+}
+interface Import extends ImportCommon {
+    /** Import name to be detected */
+    name: ImportName;
+    /** Import as this name */
+    as?: ImportName;
+}
+type PresetImport = ImportName | [name: ImportName, as?: ImportName, from?: ModuleId] | Exclude<Import, 'from'>;
+interface InlinePreset extends ImportCommon {
+    imports: (PresetImport | InlinePreset)[];
+}
+/**
+ * Auto extract exports from a package for auto import
+ */
+interface PackagePreset {
+    /**
+     * Name of the package
+     */
+    package: string;
+    /**
+     * Path of the importer
+     * @default process.cwd()
+     */
+    url?: string;
+    /**
+     * RegExp, string, or custom function to exclude names of the extracted imports
+     */
+    ignore?: (string | RegExp | ((name: string) => boolean))[];
+    /**
+     * Use local cache if exits
+     * @default true
+     */
+    cache?: boolean;
+}
+type Preset = InlinePreset | PackagePreset;
+interface UnimportContext {
+    staticImports: Import[];
+    dynamicImports: Import[];
+    getImports(): Promise<Import[]>;
+    getImportMap(): Promise<Map<string, Import>>;
+    addons: Addon[];
+    invalidate(): void;
+    resolveId(id: string, parentId?: string): Thenable<string | null | undefined | void>;
+    options: Partial<UnimportOptions>;
+}
+interface AddonsOptions {
+    /**
+     * Enable auto import inside for Vue's <template>
+     *
+     * @default false
+     */
+    vueTemplate?: boolean;
+}
+interface UnimportOptions {
+    /**
+     * Auto import items
+     */
+    imports: Import[];
+    /**
+     * Auto import preset
+     */
+    presets: (Preset | BuiltinPresetName)[];
+    /**
+     * Custom warning function
+     * @default console.warn
+     */
+    warn: (msg: string) => void;
+    /**
+     * Custom debug log function
+     * @default console.log
+     */
+    debugLog: (msg: string) => void;
+    /**
+     * Unimport Addons
+     * To use built-in addons, use `addons: { vueTemplate: true }`
+     *
+     * Built-in addons:
+     * - vueTemplate: enable auto import inside for Vue's <template>
+     *
+     * @default {}
+     */
+    addons: AddonsOptions | Addon[];
+    /**
+     * Name of virtual modules that exposed all the registed auto-imports
+     * @default []
+     */
+    virtualImports: string[];
+    /**
+     * Custom resolver to auto import id
+     */
+    resolveId?: (id: string, importee?: string) => Thenable<string | void>;
+    /**
+     * Custom magic comments to be opt-out for auto import, per file/module
+     *
+     * @default ['@unimport-disable', '@imports-disable']
+     */
+    commentsDisable?: string[];
+    /**
+     * Custom magic comments to debug auto import, printed to console
+     *
+     * @default ['@unimport-debug', '@imports-debug']
+     */
+    commentsDebug?: string[];
+}
+type PathFromResolver = (_import: Import) => string | undefined;
+interface ScanDirExportsOptions {
+    /**
+     * Glob patterns for matching files
+     *
+     * @default ['*.{ts,js,mjs,cjs,mts,cts}']
+     */
+    filePatterns?: string[];
+    /**
+     * Custom function to filter scanned files
+     */
+    fileFilter?: (file: string) => boolean;
+    /**
+     * Current working directory
+     *
+     * @default process.cwd()
+     */
+    cwd?: string;
+}
+interface TypeDeclarationOptions {
+    /**
+     * Custom resolver for path of the import
+     */
+    resolvePath?: PathFromResolver;
+    /**
+     * Append `export {}` to the end of the file
+     *
+     * @default true
+     */
+    exportHelper?: boolean;
+}
+interface InjectImportsOptions {
+    /**
+     * Merge the existing imports
+     *
+     * @default false
+     */
+    mergeExisting?: boolean;
+    /**
+     * If the module should be auto imported
+     *
+     * @default true
+     */
+    autoImport?: boolean;
+    /**
+     * If the module should be transformed for virtual modules.
+     * Only available when `virtualImports` is set.
+     *
+     * @default true
+     */
+    transformVirtualImports?: boolean;
+    /** @deprecated use `virtualImports` instead */
+    transformVirtualImoports?: boolean;
+}
+type Thenable<T> = Promise<T> | T;
+interface Addon {
+    transform?: (this: UnimportContext, code: MagicString, id: string | undefined) => Thenable<MagicString>;
+    declaration?: (this: UnimportContext, dts: string, options: TypeDeclarationOptions) => Thenable<string>;
+    matchImports?: (this: UnimportContext, identifiers: Set<string>, matched: Import[]) => Thenable<Import[] | void>;
+}
+interface InstallGlobalOptions {
+    /**
+     * @default globalThis
+     */
+    globalObject?: any;
+    /**
+     * Overrides the existing property
+     * @default false
+     */
+    overrides?: boolean;
+}
+interface ImportInjectionResult {
+    s: MagicString;
+    code: string;
+}
+
+export { AddonsOptions as A, BuiltinPresetName as B, Import as I, ModuleId as M, Preset as P, ScanDirExportsOptions as S, TypeDeclarationOptions as T, UnimportOptions as U, InlinePreset as a, ImportInjectionResult as b, Thenable as c, InjectImportsOptions as d, InstallGlobalOptions as e, builtinPresets as f, ImportName as g, ImportCommon as h, PresetImport as i, PackagePreset as j, UnimportContext as k, PathFromResolver as l, Addon as m };

node_modules/unimport/dist/unplugin.cjs

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const fs = require('fs');
+const unplugin$1 = require('unplugin');
+const pluginutils = require('@rollup/pluginutils');
+const MagicString = require('magic-string');
+const context = require('./shared/unimport.e56b747d.cjs');
+require('fast-glob');
+require('pathe');
+require('mlly');
+require('scule');
+require('./shared/unimport.7b88c06e.cjs');
+require('strip-literal');
+require('local-pkg');
+require('os');
+require('pkg-types');
+
+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 = unplugin$1.createUnplugin((options = {}) => {
+  const ctx = context.createUnimport(options);
+  const filter = pluginutils.createFilter(
+    toArray(options.include || []).length ? options.include : defaultIncludes,
+    options.exclude || defaultExcludes
+  );
+  const dts = options.dts === true ? "unimport.d.ts" : options.dts;
+  return {
+    name: "unimport",
+    enforce: "post",
+    transformInclude(id) {
+      return filter(id);
+    },
+    async transform(code, id) {
+      const s = new MagicString(code);
+      await ctx.injectImports(s, id);
+      if (!s.hasChanged()) {
+        return;
+      }
+      return {
+        code: s.toString(),
+        map: s.generateMap()
+      };
+    },
+    async buildStart() {
+      if (options.dirs?.length) {
+        await ctx.modifyDynamicImports(async (imports) => {
+          imports.push(...await context.scanDirExports(options.dirs));
+        });
+      }
+      if (dts) {
+        return fs.promises.writeFile(dts, await ctx.generateTypeDeclarations(), "utf-8");
+      }
+    }
+  };
+});
+
+exports.default = unplugin;
+exports.defaultExcludes = defaultExcludes;
+exports.defaultIncludes = defaultIncludes;

node_modules/unimport/dist/unplugin.d.ts

@@ -0,0 +1,16 @@
+import * as unplugin from 'unplugin';
+import { FilterPattern } from '@rollup/pluginutils';
+import { U as UnimportOptions } from './types-0d3b142b.js';
+import 'magic-string';
+
+interface UnimportPluginOptions extends UnimportOptions {
+    include: FilterPattern;
+    exclude: FilterPattern;
+    dts: boolean | string;
+    dirs: string[];
+}
+declare const defaultIncludes: RegExp[];
+declare const defaultExcludes: RegExp[];
+declare const _default: unplugin.UnpluginInstance<Partial<UnimportPluginOptions>, boolean>;
+
+export { UnimportPluginOptions, _default as default, defaultExcludes, defaultIncludes };

node_modules/unimport/dist/unplugin.mjs

@@ -0,0 +1,58 @@
+import { promises } from 'fs';
+import { createUnplugin } from 'unplugin';
+import { createFilter } from '@rollup/pluginutils';
+import MagicString from 'magic-string';
+import { d as createUnimport, s as scanDirExports } from './shared/unimport.1330341c.mjs';
+import 'fast-glob';
+import 'pathe';
+import 'mlly';
+import 'scule';
+import './shared/unimport.bbd7571a.mjs';
+import 'strip-literal';
+import 'local-pkg';
+import 'os';
+import 'pkg-types';
+
+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;
+  return {
+    name: "unimport",
+    enforce: "post",
+    transformInclude(id) {
+      return filter(id);
+    },
+    async transform(code, id) {
+      const s = new MagicString(code);
+      await ctx.injectImports(s, id);
+      if (!s.hasChanged()) {
+        return;
+      }
+      return {
+        code: s.toString(),
+        map: s.generateMap()
+      };
+    },
+    async buildStart() {
+      if (options.dirs?.length) {
+        await ctx.modifyDynamicImports(async (imports) => {
+          imports.push(...await scanDirExports(options.dirs));
+        });
+      }
+      if (dts) {
+        return promises.writeFile(dts, await ctx.generateTypeDeclarations(), "utf-8");
+      }
+    }
+  };
+});
+
+export { unplugin as default, defaultExcludes, defaultIncludes };