wxt 0.18.9 → 0.18.11

package/dist/cli.js

@@ -12,7 +12,7 @@ import cac from "cac";
 
 // src/core/utils/fs.ts
 import fs3 from "fs-extra";
-import glob from "fast-glob";
+import glob2 from "fast-glob";
 
 // src/core/utils/paths.ts
 import systemPath from "node:path";
@@ -46,7 +46,7 @@ var npm = {
   overridesKey: "overrides",
   async downloadDependency(id, downloadDir) {
     await ensureDir(downloadDir);
-    const { execa } = await import("./execa-ATHZH2Y4.js");
+    const { execa } = await import("./execa-QLUM2B3W.js");
     const res = await execa("npm", ["pack", id, "--json"], {
       cwd: downloadDir
     });
@@ -58,7 +58,7 @@ var npm = {
     if (options?.all) {
       args.push("--depth", "Infinity");
     }
-    const { execa } = await import("./execa-ATHZH2Y4.js");
+    const { execa } = await import("./execa-QLUM2B3W.js");
     const res = await execa("npm", args, { cwd: options?.cwd });
     const project = JSON.parse(res.stdout);
     return flattenNpmListOutput([project]);
@@ -111,7 +111,7 @@ var bun = {
     if (options?.all) {
       args.push("--all");
     }
-    const { execa } = await import("./execa-ATHZH2Y4.js");
+    const { execa } = await import("./execa-QLUM2B3W.js");
     const res = await execa("bun", args, { cwd: options?.cwd });
     return dedupeDependencies(
       res.stdout.split("\n").slice(1).map((line) => line.trim()).map((line) => /.* (@?\S+)@(\S+)$/.exec(line)).filter((match) => !!match).map(([_, name, version2]) => ({ name, version: version2 }))
@@ -130,7 +130,7 @@ var yarn = {
     if (options?.all) {
       args.push("--depth", "Infinity");
     }
-    const { execa } = await import("./execa-ATHZH2Y4.js");
+    const { execa } = await import("./execa-QLUM2B3W.js");
     const res = await execa("yarn", args, { cwd: options?.cwd });
     const tree = res.stdout.split("\n").map((line) => JSON.parse(line)).find((line) => line.type === "tree")?.data;
     if (tree == null) throw Error("'yarn list --json' did not output a tree");
@@ -166,7 +166,7 @@ var pnpm = {
     if (typeof process !== "undefined" && process.env.WXT_PNPM_IGNORE_WORKSPACE === "true") {
       args.push("--ignore-workspace");
     }
-    const { execa } = await import("./execa-ATHZH2Y4.js");
+    const { execa } = await import("./execa-QLUM2B3W.js");
     const res = await execa("pnpm", args, { cwd: options?.cwd });
     const projects = JSON.parse(res.stdout);
     return flattenNpmListOutput(projects);
@@ -548,38 +548,6 @@ async function removeEmptyDirs(dir) {
   }
 }
 
-// src/core/builders/vite/plugins/unimport.ts
-import { createUnimport } from "unimport";
-import { extname as extname2 } from "path";
-var ENABLED_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".js",
-  ".jsx",
-  ".ts",
-  ".tsx",
-  ".vue",
-  ".svelte"
-]);
-function unimport(config) {
-  const options = config.imports;
-  if (options === false) return [];
-  const unimport2 = createUnimport(options);
-  return {
-    name: "wxt:unimport",
-    async config() {
-      await unimport2.scanImportsFromDir(void 0, { cwd: config.srcDir });
-    },
-    async transform(code, id) {
-      if (id.includes("node_modules")) return;
-      if (!ENABLED_EXTENSIONS.has(extname2(id))) return;
-      const injected = await unimport2.injectImports(code, id);
-      return {
-        code: injected.code,
-        map: injected.s.generateMap({ hires: "boundary", source: id })
-      };
-    }
-  };
-}
-
 // src/core/utils/virtual-modules.ts
 var virtualEntrypointTypes = [
   "content-script-main-world",
@@ -978,7 +946,7 @@ import { ViteNodeServer } from "vite-node/server";
 import { ViteNodeRunner } from "vite-node/client";
 import { installSourcemapsSupport } from "vite-node/source-map";
 async function createViteBuilder(wxtConfig, hooks, server) {
-  const vite = await import("vite");
+  const vite2 = await import("vite");
   const getBaseConfig = async () => {
     const config = await wxtConfig.vite(wxtConfig.env);
     config.root = wxtConfig.root;
@@ -1000,7 +968,6 @@ async function createViteBuilder(wxtConfig, hooks, server) {
     config.plugins.push(
       download(wxtConfig),
       devHtmlPrerender(wxtConfig, server),
-      unimport(wxtConfig),
       resolveVirtualModules(wxtConfig),
       devServerGlobals(wxtConfig, server),
       tsconfigPaths(wxtConfig),
@@ -1123,7 +1090,7 @@ async function createViteBuilder(wxtConfig, hooks, server) {
   };
   return {
     name: "Vite",
-    version: vite.version,
+    version: vite2.version,
     async importEntrypoint(path11) {
       switch (wxtConfig.experimental.entrypointImporter) {
         default:
@@ -1138,10 +1105,10 @@ async function createViteBuilder(wxtConfig, hooks, server) {
               removeEntrypointMainFunction(wxtConfig, path11)
             ]
           };
-          const config = vite.mergeConfig(baseConfig, envConfig);
-          const server2 = await vite.createServer(config);
+          const config = vite2.mergeConfig(baseConfig, envConfig);
+          const server2 = await vite2.createServer(config);
           await server2.listen();
-          const runtime = await vite.createViteRuntime(server2, { hmr: false });
+          const runtime = await vite2.createViteRuntime(server2, { hmr: false });
           const module = await runtime.executeUrl(path11);
           await server2.close();
           return module.default;
@@ -1157,10 +1124,13 @@ async function createViteBuilder(wxtConfig, hooks, server) {
               removeEntrypointMainFunction(wxtConfig, path11)
             ]
           };
-          const config = vite.mergeConfig(baseConfig, envConfig);
-          const server2 = await vite.createServer(config);
+          const config = vite2.mergeConfig(baseConfig, envConfig);
+          const server2 = await vite2.createServer(config);
           await server2.pluginContainer.buildStart({});
-          const node = new ViteNodeServer(server2);
+          const node = new ViteNodeServer(
+            // @ts-ignore: Some weird type error...
+            server2
+          );
           installSourcemapsSupport({
             getSourceMap: (source) => node.getSourceMap(source)
           });
@@ -1189,13 +1159,13 @@ async function createViteBuilder(wxtConfig, hooks, server) {
       else if (group.inputPath.endsWith(".css"))
         entryConfig = getCssConfig(group);
       else entryConfig = getLibModeConfig(group);
-      const buildConfig = vite.mergeConfig(await getBaseConfig(), entryConfig);
+      const buildConfig = vite2.mergeConfig(await getBaseConfig(), entryConfig);
       await hooks.callHook(
         "vite:build:extendConfig",
         toArray(group),
         buildConfig
       );
-      const result = await vite.build(buildConfig);
+      const result = await vite2.build(buildConfig);
       return {
         entrypoints: group,
         chunks: getBuildOutputChunks(result)
@@ -1211,9 +1181,9 @@ async function createViteBuilder(wxtConfig, hooks, server) {
         }
       };
       const baseConfig = await getBaseConfig();
-      const finalConfig = vite.mergeConfig(baseConfig, serverConfig);
+      const finalConfig = vite2.mergeConfig(baseConfig, serverConfig);
       await hooks.callHook("vite:devServer:extendConfig", finalConfig);
-      const viteServer = await vite.createServer(finalConfig);
+      const viteServer = await vite2.createServer(finalConfig);
       const server2 = {
         async listen() {
           await viteServer.listen(info.port);
@@ -1261,6 +1231,126 @@ function getRollupEntry(entrypoint) {
   return entrypoint.inputPath;
 }
 
+// src/modules.ts
+import * as vite from "vite";
+import glob from "fast-glob";
+function defineWxtModule(module) {
+  if (typeof module === "function") return { setup: module };
+  return module;
+}
+function addViteConfig(wxt2, viteConfig) {
+  wxt2.hooks.hook("ready", (wxt3) => {
+    const userVite = wxt3.config.vite;
+    wxt3.config.vite = async (env) => {
+      const fromUser = await userVite(env);
+      const fromModule = viteConfig(env) ?? {};
+      return vite.mergeConfig(fromModule, fromUser);
+    };
+  });
+}
+
+// src/builtin-modules/unimport.ts
+import { createUnimport } from "unimport";
+import { extname as extname2 } from "node:path";
+var unimport_default = defineWxtModule({
+  name: "wxt:built-in:unimport",
+  setup(wxt2) {
+    const options = wxt2.config.imports;
+    if (options === false) return;
+    let unimport;
+    wxt2.hooks.hook("ready", () => {
+      const addModuleImports = (module) => {
+        if (!module.imports) return;
+        options.imports ??= [];
+        options.imports.push(...module.imports);
+      };
+      wxt2.config.builtinModules.forEach(addModuleImports);
+      wxt2.config.userModules.forEach(addModuleImports);
+    });
+    wxt2.hooks.afterEach((event) => {
+      if (event.name === "ready") {
+        unimport = createUnimport(options);
+      }
+    });
+    wxt2.hooks.hook("prepare:types", async (_, entries) => {
+      await unimport.init();
+      entries.push(await getImportsDeclarationEntry(unimport));
+      if (options.eslintrc.enabled === false) return;
+      entries.push(
+        await getEslintConfigEntry(unimport, options.eslintrc.enabled, options)
+      );
+    });
+    addViteConfig(wxt2, () => ({
+      plugins: [vitePlugin(unimport)]
+    }));
+  }
+});
+function vitePlugin(unimport) {
+  const ENABLED_EXTENSIONS = /* @__PURE__ */ new Set([
+    ".js",
+    ".jsx",
+    ".ts",
+    ".tsx",
+    ".vue",
+    ".svelte"
+  ]);
+  return {
+    name: "wxt:unimport",
+    async transform(code, id) {
+      if (id.includes("node_modules")) return;
+      if (!ENABLED_EXTENSIONS.has(extname2(id))) return;
+      const injected = await unimport.injectImports(code, id);
+      return {
+        code: injected.code,
+        map: injected.s.generateMap({ hires: "boundary", source: id })
+      };
+    }
+  };
+}
+async function getImportsDeclarationEntry(unimport) {
+  await unimport.init();
+  return {
+    path: "types/imports.d.ts",
+    text: [
+      "// Generated by wxt",
+      await unimport.generateTypeDeclarations(),
+      ""
+    ].join("\n"),
+    tsReference: true
+  };
+}
+async function getEslintConfigEntry(unimport, version2, options) {
+  const globals2 = (await unimport.getImports()).map((i) => i.as ?? i.name).filter(Boolean).sort().reduce((globals3, name) => {
+    globals3[name] = options.eslintrc.globalsPropValue;
+    return globals3;
+  }, {});
+  if (version2 <= 8) return getEslint8ConfigEntry(options, globals2);
+  else return getEslint9ConfigEntry(options, globals2);
+}
+function getEslint8ConfigEntry(options, globals2) {
+  return {
+    path: options.eslintrc.filePath,
+    text: JSON.stringify({ globals: globals2 }, null, 2) + "\n"
+  };
+}
+function getEslint9ConfigEntry(options, globals2) {
+  return {
+    path: options.eslintrc.filePath,
+    text: `const globals = ${JSON.stringify(globals2, null, 2)}
+
+export default {
+  languageOptions: {
+    globals,
+    sourceType: "module",
+  },
+};
+`
+  };
+}
+
+// src/builtin-modules/index.ts
+var builtinModules = [unimport_default];
+
 // src/core/wxt.ts
 var wxt;
 async function registerWxt(command, inlineConfig = {}, getServer) {
@@ -1282,18 +1372,16 @@ async function registerWxt(command, inlineConfig = {}, getServer) {
     builder,
     server
   };
-  for (const module of config.modules) {
+  const initModule = async (module) => {
     if (module.hooks) wxt.hooks.addHooks(module.hooks);
-    if (wxt.config.imports !== false && module.imports) {
-      wxt.config.imports.imports ??= [];
-      wxt.config.imports.imports.push(...module.imports);
-    }
     await module.setup?.(
       wxt,
       // @ts-expect-error: Untyped configKey field
       module.configKey ? config[module.configKey] : void 0
     );
-  }
+  };
+  for (const builtinModule of builtinModules) await initModule(builtinModule);
+  for (const userModule of config.userModules) await initModule(userModule);
   wxt.hooks.addHooks(config.hooks);
   await wxt.hooks.callHook("ready", wxt);
 }
@@ -1307,7 +1395,7 @@ async function writeFileIfDifferent(file, newContents) {
 }
 async function getPublicFiles() {
   if (!await fs3.exists(wxt.config.publicDir)) return [];
-  const files = await glob("**/*", { cwd: wxt.config.publicDir });
+  const files = await glob2("**/*", { cwd: wxt.config.publicDir });
   return files.map(unnormalizePath);
 }
 
@@ -1341,13 +1429,17 @@ async function copyPublicDirectory() {
   await wxt.hooks.callHook("build:publicAssets", wxt, files);
   if (files.length === 0) return [];
   const publicAssets = [];
-  for (const { absoluteSrc, relativeDest } of files) {
-    const absoluteDest = resolve6(wxt.config.outDir, relativeDest);
+  for (const file of files) {
+    const absoluteDest = resolve6(wxt.config.outDir, file.relativeDest);
     await fs4.ensureDir(dirname3(absoluteDest));
-    await fs4.copyFile(absoluteSrc, absoluteDest);
+    if ("absoluteSrc" in file) {
+      await fs4.copyFile(file.absoluteSrc, absoluteDest);
+    } else {
+      await fs4.writeFile(absoluteDest, file.contents, "utf8");
+    }
     publicAssets.push({
       type: "asset",
-      fileName: relativeDest
+      fileName: file.relativeDest
     });
   }
   return publicAssets;
@@ -1451,12 +1543,12 @@ import fs5 from "fs-extra";
 import { minimatch } from "minimatch";
 import { parseHTML as parseHTML3 } from "linkedom";
 import JSON5 from "json5";
-import glob2 from "fast-glob";
+import glob3 from "fast-glob";
 import pc2 from "picocolors";
 async function findEntrypoints() {
   await fs5.mkdir(wxt.config.wxtDir, { recursive: true });
   await fs5.writeJson(resolve7(wxt.config.wxtDir, "tsconfig.json"), {});
-  const relativePaths = await glob2(Object.keys(PATH_GLOB_TO_TYPE_MAP), {
+  const relativePaths = await glob3(Object.keys(PATH_GLOB_TO_TYPE_MAP), {
     cwd: wxt.config.entrypointsDir
   });
   relativePaths.sort();
@@ -1465,7 +1557,7 @@ async function findEntrypoints() {
     const inputPath = resolve7(wxt.config.entrypointsDir, relativePath);
     const name = getEntrypointName(wxt.config.entrypointsDir, inputPath);
     const matchingGlob = pathGlobs.find(
-      (glob7) => minimatch(relativePath, glob7)
+      (glob8) => minimatch(relativePath, glob8)
     );
     if (matchingGlob) {
       const type = PATH_GLOB_TO_TYPE_MAP[matchingGlob];
@@ -1826,9 +1918,8 @@ var PATH_GLOB_TO_TYPE_MAP = {
 var CONTENT_SCRIPT_OUT_DIR = "content-scripts";
 
 // src/core/utils/building/generate-wxt-dir.ts
-import { createUnimport as createUnimport2 } from "unimport";
 import fs6 from "fs-extra";
-import { relative as relative4, resolve as resolve8 } from "path";
+import { dirname as dirname4, relative as relative4, resolve as resolve8 } from "node:path";
 import path5 from "node:path";
 
 // src/core/utils/i18n.ts
@@ -1871,41 +1962,32 @@ function parseI18nMessages(messagesJson) {
 // src/core/utils/building/generate-wxt-dir.ts
 async function generateTypesDir(entrypoints) {
   await fs6.ensureDir(wxt.config.typesDir);
-  const references = [];
-  if (wxt.config.imports !== false) {
-    const unimport2 = createUnimport2(wxt.config.imports);
-    references.push(await writeImportsDeclarationFile(unimport2));
-    if (wxt.config.imports.eslintrc.enabled) {
-      await writeImportsEslintFile(unimport2, wxt.config.imports);
-    }
-  }
-  references.push(await writePathsDeclarationFile(entrypoints));
-  references.push(await writeI18nDeclarationFile());
-  references.push(await writeGlobalsDeclarationFile());
-  const mainReference = await writeMainDeclarationFile(references);
-  await writeTsConfigFile(mainReference);
-}
-async function writeImportsDeclarationFile(unimport2) {
-  const filePath = resolve8(wxt.config.typesDir, "imports.d.ts");
-  await unimport2.scanImportsFromDir(void 0, { cwd: wxt.config.srcDir });
-  await writeFileIfDifferent(
-    filePath,
-    ["// Generated by wxt", await unimport2.generateTypeDeclarations()].join(
-      "\n"
-    ) + "\n"
-  );
-  return filePath;
-}
-async function writeImportsEslintFile(unimport2, options) {
-  const globals2 = {};
-  const eslintrc = { globals: globals2 };
-  (await unimport2.getImports()).map((i) => i.as ?? i.name).filter(Boolean).sort().forEach((name) => {
-    eslintrc.globals[name] = options.eslintrc.globalsPropValue;
+  const entries = [
+    // Hard-coded entries
+    { module: "wxt/vite-builder-env" }
+  ];
+  wxt.config.userModules.forEach((module) => {
+    if (module.type === "node_module" && module.configKey != null)
+      entries.push({ module: module.id });
   });
-  await fs6.writeJson(options.eslintrc.filePath, eslintrc, { spaces: 2 });
+  entries.push(await getPathsDeclarationEntry(entrypoints));
+  entries.push(await getI18nDeclarationEntry());
+  entries.push(await getGlobalsDeclarationEntry());
+  entries.push(await getTsConfigEntry());
+  await wxt.hooks.callHook("prepare:types", wxt, entries);
+  entries.push(getMainDeclarationEntry(entries));
+  const absoluteFileEntries = entries.filter((entry) => "path" in entry).map((entry) => ({
+    ...entry,
+    path: resolve8(wxt.config.wxtDir, entry.path)
+  }));
+  await Promise.all(
+    absoluteFileEntries.map(async (file) => {
+      await fs6.ensureDir(dirname4(file.path));
+      await writeFileIfDifferent(file.path, file.text);
+    })
+  );
 }
-async function writePathsDeclarationFile(entrypoints) {
-  const filePath = resolve8(wxt.config.typesDir, "paths.d.ts");
+async function getPathsDeclarationEntry(entrypoints) {
   const unions = entrypoints.map(
     (entry) => getEntrypointBundlePath(
       entry,
@@ -1926,14 +2008,13 @@ declare module "wxt/browser" {
   }
 }
 `;
-  await writeFileIfDifferent(
-    filePath,
-    template.replace("{{ union }}", unions || "    | never")
-  );
-  return filePath;
+  return {
+    path: "types/paths.d.ts",
+    text: template.replace("{{ union }}", unions || "    | never"),
+    tsReference: true
+  };
 }
-async function writeI18nDeclarationFile() {
-  const filePath = resolve8(wxt.config.typesDir, "i18n.d.ts");
+async function getI18nDeclarationEntry() {
   const defaultLocale = wxt.config.manifest.default_locale;
   const template = `// Generated by wxt
 import "wxt/browser";
@@ -1979,18 +2060,17 @@ declare module "wxt/browser" {
       options?: GetMessageOptions,
     ): string;`;
   });
-  await writeFileIfDifferent(
-    filePath,
-    template.replace("{{ overrides }}", overrides.join("\n"))
-  );
-  return filePath;
+  return {
+    path: "types/i18n.d.ts",
+    text: template.replace("{{ overrides }}", overrides.join("\n")),
+    tsReference: true
+  };
 }
-async function writeGlobalsDeclarationFile() {
-  const filePath = resolve8(wxt.config.typesDir, "globals.d.ts");
+async function getGlobalsDeclarationEntry() {
   const globals2 = [...getGlobals(wxt.config), ...getEntrypointGlobals("")];
-  await writeFileIfDifferent(
-    filePath,
-    [
+  return {
+    path: "types/globals.d.ts",
+    text: [
       "// Generated by wxt",
       "export {}",
       "interface ImportMetaEnv {",
@@ -1998,34 +2078,29 @@ async function writeGlobalsDeclarationFile() {
       "}",
       "interface ImportMeta {",
       "  readonly env: ImportMetaEnv",
-      "}"
-    ].join("\n") + "\n"
-  );
-  return filePath;
+      "}",
+      ""
+    ].join("\n"),
+    tsReference: true
+  };
 }
-async function writeMainDeclarationFile(references) {
-  const dir = wxt.config.wxtDir;
-  const filePath = resolve8(dir, "wxt.d.ts");
-  await writeFileIfDifferent(
-    filePath,
-    [
-      "// Generated by wxt",
-      `/// <reference types="wxt/vite-builder-env" />`,
-      ...references.map(
-        (ref) => `/// <reference types="./${normalizePath(relative4(dir, ref))}" />`
-      ),
-      // Add references to modules installed from NPM to the TS project so
-      // their type augmentation can update InlineConfig correctly. Local
-      // modules defined in <root>/modules are already apart of the project, so
-      // we don't need to add them.
-      ...wxt.config.modules.filter(
-        (module) => module.type === "node_module" && module.configKey != null
-      ).map((module) => `/// <reference types="${module.id}" />`)
-    ].join("\n") + "\n"
-  );
-  return filePath;
+function getMainDeclarationEntry(references) {
+  const lines = ["// Generated by wxt"];
+  references.forEach((ref) => {
+    if ("module" in ref) {
+      return lines.push(`/// <reference types="${ref.module}" />`);
+    } else if (ref.tsReference) {
+      const absolutePath = resolve8(wxt.config.wxtDir, ref.path);
+      const relativePath = relative4(wxt.config.wxtDir, absolutePath);
+      lines.push(`/// <reference types="./${normalizePath(relativePath)}" />`);
+    }
+  });
+  return {
+    path: "wxt.d.ts",
+    text: lines.join("\n") + "\n"
+  };
 }
-async function writeTsConfigFile(mainReference) {
+async function getTsConfigEntry() {
   const dir = wxt.config.wxtDir;
   const getTsconfigPath = (path11) => normalizePath(relative4(dir, path11));
   const paths = Object.entries(wxt.config.alias).flatMap(([alias, absolutePath]) => {
@@ -2035,9 +2110,7 @@ async function writeTsConfigFile(mainReference) {
       `      "${alias}/*": ["${aliasPath}/*"]`
     ];
   }).join(",\n");
-  await writeFileIfDifferent(
-    resolve8(dir, "tsconfig.json"),
-    `{
+  const text = `{
   "compilerOptions": {
     "target": "ESNext",
     "module": "ESNext",
@@ -2054,11 +2127,14 @@ ${paths}
   },
   "include": [
     "${getTsconfigPath(wxt.config.root)}/**/*",
-    "./${getTsconfigPath(mainReference)}"
+    "./wxt.d.ts"
   ],
   "exclude": ["${getTsconfigPath(wxt.config.outBaseDir)}"]
-}`
-  );
+}`;
+  return {
+    path: "tsconfig.json",
+    text
+  };
 }
 
 // src/core/utils/building/resolve-config.ts
@@ -2067,13 +2143,13 @@ import path6 from "node:path";
 
 // src/core/utils/cache.ts
 import fs7, { ensureDir as ensureDir3 } from "fs-extra";
-import { dirname as dirname4, resolve as resolve9 } from "path";
+import { dirname as dirname5, resolve as resolve9 } from "path";
 function createFsCache(wxtDir) {
   const getPath = (key) => resolve9(wxtDir, "cache", encodeURIComponent(key));
   return {
     async set(key, value) {
       const path11 = getPath(key);
-      await ensureDir3(dirname4(path11));
+      await ensureDir3(dirname5(path11));
       await writeFileIfDifferent(path11, value);
     },
     async get(key) {
@@ -2089,31 +2165,23 @@ function createFsCache(wxtDir) {
 
 // src/core/utils/building/resolve-config.ts
 import defu from "defu";
-
-// src/core/utils/package.ts
-import { resolve as resolve10 } from "node:path";
 import fs8 from "fs-extra";
-async function getPackageJson() {
-  const file = resolve10(wxt.config.root, "package.json");
+import glob4 from "fast-glob";
+
+// src/core/utils/eslint.ts
+async function getEslintVersion() {
   try {
-    return await fs8.readJson(file);
-  } catch (err) {
-    wxt.logger.debug(
-      `Failed to read package.json at: ${file}. Returning undefined.`
+    const require2 = (await import("node:module")).default.createRequire(
+      import.meta.url
     );
-    return {};
+    const { ESLint } = require2("eslint");
+    return ESLint.version?.split(".") ?? [];
+  } catch (error) {
+    return [];
   }
 }
-function isModuleInstalled(name) {
-  return import(
-    /* @vite-ignore */
-    name
-  ).then(() => true).catch(() => false);
-}
 
 // src/core/utils/building/resolve-config.ts
-import fs9 from "fs-extra";
-import glob3 from "fast-glob";
 async function resolveConfig(inlineConfig, command) {
   let userConfig = {};
   let userConfigMetadata;
@@ -2190,14 +2258,20 @@ async function resolveConfig(inlineConfig, command) {
       hostname: "localhost"
     };
   }
-  const modules = await resolveWxtModules(modulesDir, mergedConfig.modules);
-  const moduleOptions = modules.reduce((map, module) => {
-    if (module.configKey) {
-      map[module.configKey] = // @ts-expect-error
-      mergedConfig[module.configKey];
-    }
-    return map;
-  }, {});
+  const userModules = await resolveWxtUserModules(
+    modulesDir,
+    mergedConfig.modules
+  );
+  const moduleOptions = userModules.reduce(
+    (map, module) => {
+      if (module.configKey) {
+        map[module.configKey] = // @ts-expect-error
+        mergedConfig[module.configKey];
+      }
+      return map;
+    },
+    {}
+  );
   return {
     browser,
     command,
@@ -2207,7 +2281,7 @@ async function resolveConfig(inlineConfig, command) {
     filterEntrypoints,
     env,
     fsCache: createFsCache(wxtDir),
-    imports: await getUnimportOptions(wxtDir, logger, mergedConfig),
+    imports: await getUnimportOptions(wxtDir, srcDir, logger, mergedConfig),
     logger,
     manifest: await resolveManifestConfig(env, mergedConfig.manifest),
     manifestVersion,
@@ -2221,7 +2295,7 @@ async function resolveConfig(inlineConfig, command) {
     srcDir,
     typesDir,
     wxtDir,
-    zip: resolveZipConfig(root, mergedConfig),
+    zip: resolveZipConfig(root, outBaseDir, mergedConfig),
     transformManifest: mergedConfig.transformManifest,
     analysis: resolveAnalysisConfig(root, mergedConfig),
     userConfigMetadata: userConfigMetadata ?? {},
@@ -2236,7 +2310,8 @@ async function resolveConfig(inlineConfig, command) {
     },
     hooks: mergedConfig.hooks ?? {},
     vite: mergedConfig.vite ?? (() => ({})),
-    modules,
+    builtinModules,
+    userModules,
     plugins: [],
     ...moduleOptions
   };
@@ -2265,7 +2340,7 @@ async function mergeInlineConfig(inlineConfig, userConfig) {
     ...builderConfig
   };
 }
-function resolveZipConfig(root, mergedConfig) {
+function resolveZipConfig(root, outBaseDir, mergedConfig) {
   const downloadedPackagesDir = path6.resolve(root, ".wxt/local_modules");
   return {
     name: void 0,
@@ -2284,6 +2359,8 @@ function resolveZipConfig(root, mergedConfig) {
       // Tests
       "**/__tests__/**",
       "**/*.+(test|spec).?(c|m)+(j|t)s?(x)",
+      // Output directory
+      `${path6.relative(root, outBaseDir)}/**`,
       // From user
       ...mergedConfig.zip?.excludeSources ?? []
     ],
@@ -2308,18 +2385,8 @@ function resolveAnalysisConfig(root, mergedConfig) {
     keepArtifacts: mergedConfig.analysis?.keepArtifacts ?? false
   };
 }
-async function getUnimportOptions(wxtDir, logger, config) {
+async function getUnimportOptions(wxtDir, srcDir, logger, config) {
   if (config.imports === false) return false;
-  const enabledConfig = config.imports?.eslintrc?.enabled;
-  let enabled;
-  switch (enabledConfig) {
-    case void 0:
-    case "auto":
-      enabled = await isModuleInstalled("eslint");
-      break;
-    default:
-      enabled = enabledConfig;
-  }
   const defaultOptions = {
     debugLog: logger.debug,
     imports: [
@@ -2334,23 +2401,48 @@ async function getUnimportOptions(wxtDir, logger, config) {
     ],
     warn: logger.warn,
     dirs: ["components", "composables", "hooks", "utils"],
-    eslintrc: {
-      enabled,
-      filePath: path6.resolve(wxtDir, "eslintrc-auto-import.json"),
-      globalsPropValue: true
-    }
+    dirsScanOptions: {
+      cwd: srcDir
+    },
+    eslintrc: await getUnimportEslintOptions(wxtDir, config.imports?.eslintrc)
   };
   return defu(
     config.imports ?? {},
     defaultOptions
   );
 }
+async function getUnimportEslintOptions(wxtDir, options) {
+  const rawEslintEnabled = options?.enabled ?? "auto";
+  let eslintEnabled;
+  switch (rawEslintEnabled) {
+    case "auto":
+      const version2 = await getEslintVersion();
+      let major = parseInt(version2[0]);
+      if (major <= 8) eslintEnabled = 8;
+      else if (major >= 9) eslintEnabled = 9;
+      else eslintEnabled = 8;
+      break;
+    case true:
+      eslintEnabled = 8;
+      break;
+    default:
+      eslintEnabled = rawEslintEnabled;
+  }
+  return {
+    enabled: eslintEnabled,
+    filePath: path6.resolve(
+      wxtDir,
+      eslintEnabled === 9 ? "eslint-auto-imports.mjs" : "eslintrc-auto-import.json"
+    ),
+    globalsPropValue: true
+  };
+}
 async function resolveWxtModuleDir() {
   const requireResolve = __require?.resolve ?? (await import("node:module")).default.createRequire(import.meta.url).resolve;
   return path6.resolve(requireResolve("wxt"), "../..");
 }
 async function isDirMissing(dir) {
-  return !await fs9.exists(dir);
+  return !await fs8.exists(dir);
 }
 function logMissingDir(logger, name, expected) {
   logger.warn(
@@ -2364,19 +2456,19 @@ var COMMAND_MODES = {
   serve: "development"
 };
 async function mergeBuilderConfig(inlineConfig, userConfig) {
-  const vite = await import("vite").catch(() => void 0);
-  if (vite) {
+  const vite2 = await import("vite").catch(() => void 0);
+  if (vite2) {
     return {
       vite: async (env) => {
         const resolvedInlineConfig = await inlineConfig.vite?.(env) ?? {};
         const resolvedUserConfig = await userConfig.vite?.(env) ?? {};
-        return vite.mergeConfig(resolvedUserConfig, resolvedInlineConfig);
+        return vite2.mergeConfig(resolvedUserConfig, resolvedInlineConfig);
       }
     };
   }
   throw Error("Builder not found. Make sure vite is installed.");
 }
-async function resolveWxtModules(modulesDir, modules = []) {
+async function resolveWxtUserModules(modulesDir, modules = []) {
   const npmModules = await Promise.all(
     modules.map(async (moduleId) => {
       const mod = await import(
@@ -2393,7 +2485,7 @@ async function resolveWxtModules(modulesDir, modules = []) {
       };
     })
   );
-  const localModulePaths = await glob3(["*.[tj]s", "*/index.[tj]s"], {
+  const localModulePaths = await glob4(["*.[tj]s", "*/index.[tj]s"], {
     cwd: modulesDir,
     onlyFiles: true
   }).catch(() => []);
@@ -2464,23 +2556,23 @@ var ENTRY_TYPE_TO_GROUP_MAP = {
 
 // src/core/utils/building/import-entrypoint.ts
 import createJITI from "jiti";
-import { createUnimport as createUnimport3 } from "unimport";
-import fs10 from "fs-extra";
-import { relative as relative5, resolve as resolve11 } from "node:path";
+import { createUnimport as createUnimport2 } from "unimport";
+import fs9 from "fs-extra";
+import { relative as relative5, resolve as resolve10 } from "node:path";
 import { transformSync } from "esbuild";
 import { fileURLToPath } from "node:url";
 async function importEntrypointFile(path11) {
   wxt.logger.debug("Loading file metadata:", path11);
   const normalPath = normalizePath(path11);
-  const unimport2 = createUnimport3({
+  const unimport = createUnimport2({
     ...wxt.config.imports,
     // Only allow specific imports, not all from the project
     dirs: []
   });
-  await unimport2.init();
-  const text = await fs10.readFile(path11, "utf-8");
+  await unimport.init();
+  const text = await fs9.readFile(path11, "utf-8");
   const textNoImports = removeProjectImportStatements(text);
-  const { code } = await unimport2.injectImports(textNoImports);
+  const { code } = await unimport.injectImports(textNoImports);
   wxt.logger.debug(
     ["Text:", text, "No imports:", textNoImports, "Code:", code].join("\n")
   );
@@ -2491,7 +2583,7 @@ async function importEntrypointFile(path11) {
       debug: wxt.config.debug,
       esmResolve: true,
       alias: {
-        "webextension-polyfill": resolve11(
+        "webextension-polyfill": resolve10(
           wxt.config.wxtModuleDir,
           "dist/virtual/mock-browser.js"
         )
@@ -2556,12 +2648,12 @@ import pc5 from "picocolors";
 import fs13 from "fs-extra";
 
 // src/core/utils/log/printBuildSummary.ts
-import { resolve as resolve12 } from "path";
+import { resolve as resolve11 } from "path";
 
 // src/core/utils/log/printFileList.ts
 import path7 from "node:path";
 import pc3 from "picocolors";
-import fs11 from "fs-extra";
+import fs10 from "fs-extra";
 import { filesize } from "filesize";
 
 // src/core/utils/log/printTable.ts
@@ -2599,7 +2691,7 @@ async function printFileList(log, header, baseDir, files) {
       ];
       const prefix = i === files.length - 1 ? "  \u2514\u2500" : "  \u251C\u2500";
       const color = getChunkColor(file);
-      const stats = await fs11.lstat(file);
+      const stats = await fs10.lstat(file);
       totalSize += stats.size;
       const size = String(filesize(stats.size));
       return [
@@ -2640,7 +2732,7 @@ async function printBuildSummary(log, header, output) {
     return l.fileName.localeCompare(r.fileName);
   });
   const files = chunks.map(
-    (chunk) => resolve12(wxt.config.outDir, chunk.fileName)
+    (chunk) => resolve11(wxt.config.outDir, chunk.fileName)
   );
   await printFileList(log, header, wxt.config.outDir, files);
 }
@@ -2662,7 +2754,7 @@ function getChunkSortWeight(filename) {
 import pc4 from "picocolors";
 
 // package.json
-var version = "0.18.8";
+var version = "0.18.10";
 
 // src/core/utils/log/printHeader.ts
 function printHeader() {
@@ -2671,7 +2763,7 @@ function printHeader() {
 }
 
 // src/core/utils/building/internal-build.ts
-import glob4 from "fast-glob";
+import glob5 from "fast-glob";
 
 // src/core/utils/manifest.ts
 import fs12 from "fs-extra";
@@ -2779,6 +2871,21 @@ function getContentScriptJs(config, entrypoint) {
   return [getEntrypointBundlePath(entrypoint, config.outDir, ".js")];
 }
 
+// src/core/utils/package.ts
+import { resolve as resolve12 } from "node:path";
+import fs11 from "fs-extra";
+async function getPackageJson() {
+  const file = resolve12(wxt.config.root, "package.json");
+  try {
+    return await fs11.readJson(file);
+  } catch (err) {
+    wxt.logger.debug(
+      `Failed to read package.json at: ${file}. Returning undefined.`
+    );
+    return {};
+  }
+}
+
 // src/core/utils/manifest.ts
 import defu2 from "defu";
 async function writeManifest(manifest, output) {
@@ -3436,7 +3543,7 @@ async function internalBuild() {
   return output;
 }
 async function combineAnalysisStats() {
-  const unixFiles = await glob4(`${wxt.config.analysis.outputName}-*.json`, {
+  const unixFiles = await glob5(`${wxt.config.analysis.outputName}-*.json`, {
     cwd: wxt.config.analysis.outputDir,
     absolute: true
   });
@@ -3466,12 +3573,12 @@ function printValidationResults({
     return map;
   }, /* @__PURE__ */ new Map());
   Array.from(entrypointErrors.entries()).forEach(([entrypoint, errors2]) => {
-    consola.log(relative6(cwd, entrypoint.inputPath));
+    wxt.logger.log(relative6(cwd, entrypoint.inputPath));
     console.log();
     errors2.forEach((err) => {
       const type = err.type === "error" ? pc5.red("ERROR") : pc5.yellow("WARN");
       const recieved = pc5.dim(`(recieved: ${JSON.stringify(err.value)})`);
-      consola.log(`  - ${type} ${err.message} ${recieved}`);
+      wxt.logger.log(`  - ${type} ${err.message} ${recieved}`);
     });
     console.log();
   });
@@ -3485,35 +3592,40 @@ async function build(config) {
 
 // src/core/clean.ts
 import path8 from "node:path";
-import glob5 from "fast-glob";
+import glob6 from "fast-glob";
 import fs14 from "fs-extra";
 import pc6 from "picocolors";
-async function clean(root = process.cwd()) {
-  consola.info("Cleaning Project");
+async function clean(config) {
+  if (typeof config === "string") {
+    config = { root: config };
+  }
+  await registerWxt("build", config);
+  wxt.logger.info("Cleaning Project");
+  const root = wxt.config.root;
   const tempDirs = [
     "node_modules/.vite",
     "node_modules/.cache",
     "**/.wxt",
-    ".output/*"
+    `${path8.relative(root, wxt.config.outBaseDir)}/*`
   ];
-  consola.debug("Looking for:", tempDirs.map(pc6.cyan).join(", "));
-  const directories = await glob5(tempDirs, {
-    cwd: path8.resolve(root),
+  wxt.logger.debug("Looking for:", tempDirs.map(pc6.cyan).join(", "));
+  const directories = await glob6(tempDirs, {
+    cwd: root,
     absolute: true,
     onlyDirectories: true,
     deep: 2
   });
   if (directories.length === 0) {
-    consola.debug("No generated files found.");
+    wxt.logger.debug("No generated files found.");
     return;
   }
-  consola.debug(
+  wxt.logger.debug(
     "Found:",
     directories.map((dir) => pc6.cyan(path8.relative(root, dir))).join(", ")
   );
   for (const directory of directories) {
     await fs14.rm(directory, { force: true, recursive: true });
-    consola.debug("Deleted " + pc6.cyan(path8.relative(root, directory)));
+    wxt.logger.debug("Deleted " + pc6.cyan(path8.relative(root, directory)));
   }
 }
 
@@ -3776,19 +3888,19 @@ function createFileReloader(server) {
         switch (changes.type) {
           case "extension-reload":
             server.reloadExtension();
-            consola.success(`Reloaded extension`);
+            wxt.logger.success(`Reloaded extension`);
             break;
           case "html-reload":
             const { reloadedNames } = reloadHtmlPages(
               changes.rebuildGroups,
               server
             );
-            consola.success(`Reloaded: ${getFilenameList(reloadedNames)}`);
+            wxt.logger.success(`Reloaded: ${getFilenameList(reloadedNames)}`);
             break;
           case "content-script-reload":
             reloadContentScripts(changes.changedSteps, server);
             const rebuiltNames = changes.rebuildGroups.flat().map((entry) => entry.name);
-            consola.success(`Reloaded: ${getFilenameList(rebuiltNames)}`);
+            wxt.logger.success(`Reloaded: ${getFilenameList(rebuiltNames)}`);
             break;
         }
       } catch (err) {
@@ -3989,7 +4101,7 @@ import path10 from "node:path";
 import fs16 from "fs-extra";
 import { minimatch as minimatch2 } from "minimatch";
 import JSZip from "jszip";
-import glob6 from "fast-glob";
+import glob7 from "fast-glob";
 async function zip(config) {
   await registerWxt("build", config);
   const output = await internalBuild();
@@ -4037,7 +4149,7 @@ async function zip(config) {
 }
 async function zipDir(directory, outputPath, options) {
   const archive = new JSZip();
-  const files = (await glob6("**/*", {
+  const files = (await glob7("**/*", {
     cwd: directory,
     // Ignore node_modules, otherwise this glob step takes forever
     ignore: ["**/node_modules"],
@@ -4155,7 +4267,7 @@ function createAliasedCommand(base, name, alias, bin, docsUrl) {
       const args = process.argv.slice(
         process.argv.indexOf(aliasedCommand.name) + 1
       );
-      const { execa } = await import("./execa-ATHZH2Y4.js");
+      const { execa } = await import("./execa-QLUM2B3W.js");
       await execa(bin, args, {
         stdio: "inherit"
       });
@@ -4242,9 +4354,9 @@ cli.command("prepare [root]", "prepare typescript project").option("-c, --config
     });
   })
 );
-cli.command("clean [root]", "clean generated files and caches").alias("cleanup").action(
+cli.command("clean [root]", "clean generated files and caches").alias("cleanup").option("-c, --config <file>", "use specified config file").action(
   wrapAction(async (root, flags) => {
-    await clean(root);
+    await clean({ root, configFile: flags.config, debug: flags.debug });
   })
 );
 cli.command("init [directory]", "initialize a new project").option("-t, --template <template>", "template to use").option("--pm <packageManager>", "which package manager to use").action(