wxt 0.18.9 → 0.18.10

package/dist/index.cjs

@@ -988,12 +988,12 @@ var require_isexe = __commonJS({
         if (typeof Promise !== "function") {
           throw new TypeError("callback not provided");
         }
-        return new Promise(function(resolve16, reject) {
+        return new Promise(function(resolve17, reject) {
           isexe(path12, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
-              resolve16(is);
+              resolve17(is);
             }
           });
         });
@@ -1060,27 +1060,27 @@ var require_which = __commonJS({
         opt = {};
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
       const found = [];
-      const step = (i2) => new Promise((resolve16, reject) => {
+      const step = (i2) => new Promise((resolve17, reject) => {
         if (i2 === pathEnv.length)
-          return opt.all && found.length ? resolve16(found) : reject(getNotFoundError(cmd));
+          return opt.all && found.length ? resolve17(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i2];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
         const pCmd = path12.join(pathPart, cmd);
         const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-        resolve16(subStep(p2, i2, 0));
+        resolve17(subStep(p2, i2, 0));
       });
-      const subStep = (p2, i2, ii) => new Promise((resolve16, reject) => {
+      const subStep = (p2, i2, ii) => new Promise((resolve17, reject) => {
         if (ii === pathExt.length)
-          return resolve16(step(i2 + 1));
+          return resolve17(step(i2 + 1));
         const ext = pathExt[ii];
         isexe(p2 + ext, { pathExt: pathExtExe }, (er, is) => {
           if (!er && is) {
             if (opt.all)
               found.push(p2 + ext);
             else
-              return resolve16(p2 + ext);
+              return resolve17(p2 + ext);
           }
-          return resolve16(subStep(p2, i2, ii + 1));
+          return resolve17(subStep(p2, i2, ii + 1));
         });
       });
       return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -2135,8 +2135,8 @@ var init_deferred = __esm({
     "use strict";
     createDeferred = () => {
       const methods = {};
-      const promise = new Promise((resolve16, reject) => {
-        Object.assign(methods, { resolve: resolve16, reject });
+      const promise = new Promise((resolve17, reject) => {
+        Object.assign(methods, { resolve: resolve17, reject });
       });
       return Object.assign(promise, methods);
     };
@@ -7476,11 +7476,11 @@ var init_concurrent = __esm({
       const promises = weakMap.get(stream);
       const promise = createDeferred();
       promises.push(promise);
-      const resolve16 = promise.resolve.bind(promise);
-      return { resolve: resolve16, promises };
+      const resolve17 = promise.resolve.bind(promise);
+      return { resolve: resolve17, promises };
     };
-    waitForConcurrentStreams = async ({ resolve: resolve16, promises }, subprocess) => {
-      resolve16();
+    waitForConcurrentStreams = async ({ resolve: resolve17, promises }, subprocess) => {
+      resolve17();
       const [isSubprocessExit] = await Promise.race([
         Promise.allSettled([true, subprocess]),
         Promise.all([false, ...promises])
@@ -8637,7 +8637,7 @@ var init_core2 = __esm({
 
 // ../../node_modules/.pnpm/consola@3.2.3/node_modules/consola/dist/shared/consola.06ad8a64.mjs
 function parseStack(stack) {
-  const cwd = process.cwd() + import_node_path14.sep;
+  const cwd = process.cwd() + import_node_path17.sep;
   const lines = stack.split("\n").splice(1).map((l2) => l2.trim().replace("file://", "").replace(cwd, ""));
   return lines;
 }
@@ -8645,12 +8645,12 @@ function writeStream(data, stream) {
   const write = stream.__write || stream.write;
   return write.call(stream, data);
 }
-var import_node_util11, import_node_path14, bracket, BasicReporter;
+var import_node_util11, import_node_path17, bracket, BasicReporter;
 var init_consola_06ad8a64 = __esm({
   "../../node_modules/.pnpm/consola@3.2.3/node_modules/consola/dist/shared/consola.06ad8a64.mjs"() {
     "use strict";
     import_node_util11 = require("util");
-    import_node_path14 = require("path");
+    import_node_path17 = require("path");
     bracket = (x) => x ? `[${x}]` : "";
     BasicReporter = class {
       formatStack(stack, opts) {
@@ -9053,7 +9053,7 @@ async function prompt(message, opts = {}) {
   }
   throw new Error(`Unknown prompt type: ${opts.type}`);
 }
-var import_node_process11, import_node_readline, import_node_tty3, import_tty, import_node_util12, import_node_path15, ESC, CSI, beep, cursor, scroll, erase, src, picocolors, tty4, isColorSupported2, formatter, replaceClose2, createColors2, picocolorsExports, l, m, G, K, Y, v, L, M, T, r, Z, H, q, p, J, b, W, Q, I, w, N, j, X, _, DD, uD, R, V, tD, h2, sD, iD, ED, oD, unicode, s, S_STEP_ACTIVE, S_STEP_CANCEL, S_STEP_ERROR, S_STEP_SUBMIT, S_BAR, S_BAR_END, S_RADIO_ACTIVE, S_RADIO_INACTIVE, S_CHECKBOX_ACTIVE, S_CHECKBOX_SELECTED, S_CHECKBOX_INACTIVE, symbol, text, confirm, select, multiselect;
+var import_node_process11, import_node_readline, import_node_tty3, import_tty, import_node_util12, import_node_path18, ESC, CSI, beep, cursor, scroll, erase, src, picocolors, tty4, isColorSupported2, formatter, replaceClose2, createColors2, picocolorsExports, l, m, G, K, Y, v, L, M, T, r, Z, H, q, p, J, b, W, Q, I, w, N, j, X, _, DD, uD, R, V, tD, h2, sD, iD, ED, oD, unicode, s, S_STEP_ACTIVE, S_STEP_CANCEL, S_STEP_ERROR, S_STEP_SUBMIT, S_BAR, S_BAR_END, S_RADIO_ACTIVE, S_RADIO_INACTIVE, S_CHECKBOX_ACTIVE, S_CHECKBOX_SELECTED, S_CHECKBOX_INACTIVE, symbol, text, confirm, select, multiselect;
 var init_prompt = __esm({
   "../../node_modules/.pnpm/consola@3.2.3/node_modules/consola/dist/chunks/prompt.mjs"() {
     "use strict";
@@ -9066,7 +9066,7 @@ var init_prompt = __esm({
     init_core2();
     init_consola_06ad8a64();
     import_node_util12 = require("util");
-    import_node_path15 = require("path");
+    import_node_path18 = require("path");
     ESC = "\x1B";
     CSI = `${ESC}[`;
     beep = "\x07";
@@ -10083,7 +10083,7 @@ module.exports = __toCommonJS(src_exports);
 
 // src/core/utils/fs.ts
 var import_fs_extra4 = __toESM(require("fs-extra"), 1);
-var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_fast_glob2 = __toESM(require("fast-glob"), 1);
 
 // src/core/utils/paths.ts
 var import_node_path = __toESM(require("path"), 1);
@@ -10612,38 +10612,6 @@ async function removeEmptyDirs(dir) {
   }
 }
 
-// src/core/builders/vite/plugins/unimport.ts
-var import_unimport = require("unimport");
-var import_path = require("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 = (0, import_unimport.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((0, import_path.extname)(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",
@@ -10662,7 +10630,7 @@ var virtualModuleNames = [
 
 // src/core/builders/vite/plugins/resolveVirtualModules.ts
 var import_fs_extra3 = __toESM(require("fs-extra"), 1);
-var import_path2 = require("path");
+var import_path = require("path");
 function resolveVirtualModules(config) {
   return virtualModuleNames.map((name) => {
     const virtualId = `virtual:wxt-${name}?`;
@@ -10679,7 +10647,7 @@ function resolveVirtualModules(config) {
         if (!id.startsWith(resolvedVirtualId)) return;
         const inputPath = id.replace(resolvedVirtualId, "");
         const template = await import_fs_extra3.default.readFile(
-          (0, import_path2.resolve)(config.wxtModuleDir, `dist/virtual/${name}.js`),
+          (0, import_path.resolve)(config.wxtModuleDir, `dist/virtual/${name}.js`),
           "utf-8"
         );
         return template.replace(`virtual:user-${name}`, inputPath);
@@ -11039,7 +11007,7 @@ var import_server = require("vite-node/server");
 var import_client = require("vite-node/client");
 var import_source_map = require("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;
@@ -11061,7 +11029,6 @@ async function createViteBuilder(wxtConfig, hooks, server) {
     config.plugins.push(
       download(wxtConfig),
       devHtmlPrerender(wxtConfig, server),
-      unimport(wxtConfig),
       resolveVirtualModules(wxtConfig),
       devServerGlobals(wxtConfig, server),
       tsconfigPaths(wxtConfig),
@@ -11184,7 +11151,7 @@ async function createViteBuilder(wxtConfig, hooks, server) {
   };
   return {
     name: "Vite",
-    version: vite.version,
+    version: vite2.version,
     async importEntrypoint(path12) {
       switch (wxtConfig.experimental.entrypointImporter) {
         default:
@@ -11199,10 +11166,10 @@ async function createViteBuilder(wxtConfig, hooks, server) {
               removeEntrypointMainFunction(wxtConfig, path12)
             ]
           };
-          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 module2 = await runtime.executeUrl(path12);
           await server2.close();
           return module2.default;
@@ -11218,8 +11185,8 @@ async function createViteBuilder(wxtConfig, hooks, server) {
               removeEntrypointMainFunction(wxtConfig, path12)
             ]
           };
-          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 import_server.ViteNodeServer(server2);
           (0, import_source_map.installSourcemapsSupport)({
@@ -11250,13 +11217,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)
@@ -11272,9 +11239,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);
@@ -11322,6 +11289,108 @@ function getRollupEntry(entrypoint) {
   return entrypoint.inputPath;
 }
 
+// src/modules.ts
+var vite = __toESM(require("vite"), 1);
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_node_path13 = require("path");
+function defineWxtModule(module2) {
+  if (typeof module2 === "function") return { setup: module2 };
+  return module2;
+}
+function addViteConfig(wxt2, viteConfig) {
+  wxt2.hooks.hook("ready", (wxt3) => {
+    const userVite = wxt3.config.vite;
+    wxt3.config.vite = async (env2) => {
+      const fromUser = await userVite(env2);
+      const fromModule = viteConfig(env2) ?? {};
+      return vite.mergeConfig(fromModule, fromUser);
+    };
+  });
+}
+
+// src/builtin-modules/unimport.ts
+var import_unimport = require("unimport");
+var import_node_path14 = require("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 = (module2) => {
+        if (!module2.imports) return;
+        options.imports ??= [];
+        options.imports.push(...module2.imports);
+      };
+      wxt2.config.builtinModules.forEach(addModuleImports);
+      wxt2.config.userModules.forEach(addModuleImports);
+    });
+    wxt2.hooks.afterEach((event) => {
+      if (event.name === "ready") {
+        unimport = (0, import_unimport.createUnimport)(options);
+      }
+    });
+    wxt2.hooks.hook("prepare:types", async (_2, entries) => {
+      await unimport.init();
+      entries.push(await getImportsDeclarationEntry(unimport));
+      if (!options.eslintrc.enabled) return;
+      entries.push(await getImportsEslintEntry(unimport, 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((0, import_node_path14.extname)(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 getImportsEslintEntry(unimport, options) {
+  const globals2 = {};
+  const eslintrc = { globals: globals2 };
+  (await unimport.getImports()).map((i2) => i2.as ?? i2.name).filter(Boolean).sort().forEach((name) => {
+    eslintrc.globals[name] = options.eslintrc.globalsPropValue;
+  });
+  return {
+    path: options.eslintrc.filePath,
+    text: JSON.stringify(eslintrc, null, 2) + "\n"
+  };
+}
+
+// src/builtin-modules/index.ts
+var builtinModules = [unimport_default];
+
 // src/core/wxt.ts
 var wxt;
 async function registerWxt(command, inlineConfig = {}, getServer) {
@@ -11343,18 +11412,16 @@ async function registerWxt(command, inlineConfig = {}, getServer) {
     builder,
     server
   };
-  for (const module2 of config.modules) {
+  const initModule = async (module2) => {
     if (module2.hooks) wxt.hooks.addHooks(module2.hooks);
-    if (wxt.config.imports !== false && module2.imports) {
-      wxt.config.imports.imports ??= [];
-      wxt.config.imports.imports.push(...module2.imports);
-    }
     await module2.setup?.(
       wxt,
       // @ts-expect-error: Untyped configKey field
       module2.configKey ? config[module2.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);
 }
@@ -11368,13 +11435,13 @@ async function writeFileIfDifferent(file, newContents) {
 }
 async function getPublicFiles() {
   if (!await import_fs_extra4.default.exists(wxt.config.publicDir)) return [];
-  const files = await (0, import_fast_glob.default)("**/*", { cwd: wxt.config.publicDir });
+  const files = await (0, import_fast_glob2.default)("**/*", { cwd: wxt.config.publicDir });
   return files.map(unnormalizePath);
 }
 
 // src/core/utils/building/build-entrypoints.ts
 var import_fs_extra5 = __toESM(require("fs-extra"), 1);
-var import_path3 = require("path");
+var import_path2 = require("path");
 var import_picocolors = __toESM(require("picocolors"), 1);
 async function buildEntrypoints(groups, spinner) {
   const steps = [];
@@ -11396,19 +11463,23 @@ async function buildEntrypoints(groups, spinner) {
 }
 async function copyPublicDirectory() {
   const files = (await getPublicFiles()).map((file) => ({
-    absoluteSrc: (0, import_path3.resolve)(wxt.config.publicDir, file),
+    absoluteSrc: (0, import_path2.resolve)(wxt.config.publicDir, file),
     relativeDest: file
   }));
   await wxt.hooks.callHook("build:publicAssets", wxt, files);
   if (files.length === 0) return [];
   const publicAssets = [];
-  for (const { absoluteSrc, relativeDest } of files) {
-    const absoluteDest = (0, import_path3.resolve)(wxt.config.outDir, relativeDest);
-    await import_fs_extra5.default.ensureDir((0, import_path3.dirname)(absoluteDest));
-    await import_fs_extra5.default.copyFile(absoluteSrc, absoluteDest);
+  for (const file of files) {
+    const absoluteDest = (0, import_path2.resolve)(wxt.config.outDir, file.relativeDest);
+    await import_fs_extra5.default.ensureDir((0, import_path2.dirname)(absoluteDest));
+    if ("absoluteSrc" in file) {
+      await import_fs_extra5.default.copyFile(file.absoluteSrc, absoluteDest);
+    } else {
+      await import_fs_extra5.default.writeFile(absoluteDest, file.contents, "utf8");
+    }
     publicAssets.push({
       type: "asset",
-      fileName: relativeDest
+      fileName: file.relativeDest
     });
   }
   return publicAssets;
@@ -11507,26 +11578,26 @@ function findEffectedSteps(changedFile, currentOutput) {
 }
 
 // src/core/utils/building/find-entrypoints.ts
-var import_path4 = require("path");
+var import_path3 = require("path");
 var import_fs_extra6 = __toESM(require("fs-extra"), 1);
 var import_minimatch = require("minimatch");
 var import_linkedom3 = require("linkedom");
 var import_json5 = __toESM(require("json5"), 1);
-var import_fast_glob2 = __toESM(require("fast-glob"), 1);
+var import_fast_glob3 = __toESM(require("fast-glob"), 1);
 var import_picocolors2 = __toESM(require("picocolors"), 1);
 async function findEntrypoints() {
   await import_fs_extra6.default.mkdir(wxt.config.wxtDir, { recursive: true });
-  await import_fs_extra6.default.writeJson((0, import_path4.resolve)(wxt.config.wxtDir, "tsconfig.json"), {});
-  const relativePaths = await (0, import_fast_glob2.default)(Object.keys(PATH_GLOB_TO_TYPE_MAP), {
+  await import_fs_extra6.default.writeJson((0, import_path3.resolve)(wxt.config.wxtDir, "tsconfig.json"), {});
+  const relativePaths = await (0, import_fast_glob3.default)(Object.keys(PATH_GLOB_TO_TYPE_MAP), {
     cwd: wxt.config.entrypointsDir
   });
   relativePaths.sort();
   const pathGlobs = Object.keys(PATH_GLOB_TO_TYPE_MAP);
   const entrypointInfos = relativePaths.reduce((results, relativePath) => {
-    const inputPath = (0, import_path4.resolve)(wxt.config.entrypointsDir, relativePath);
+    const inputPath = (0, import_path3.resolve)(wxt.config.entrypointsDir, relativePath);
     const name = getEntrypointName(wxt.config.entrypointsDir, inputPath);
     const matchingGlob = pathGlobs.find(
-      (glob7) => (0, import_minimatch.minimatch)(relativePath, glob7)
+      (glob8) => (0, import_minimatch.minimatch)(relativePath, glob8)
     );
     if (matchingGlob) {
       const type = PATH_GLOB_TO_TYPE_MAP[matchingGlob];
@@ -11565,7 +11636,7 @@ async function findEntrypoints() {
           return {
             ...info,
             type,
-            outputDir: (0, import_path4.resolve)(wxt.config.outDir, CONTENT_SCRIPT_OUT_DIR),
+            outputDir: (0, import_path3.resolve)(wxt.config.outDir, CONTENT_SCRIPT_OUT_DIR),
             options: {
               include: void 0,
               exclude: void 0
@@ -11639,7 +11710,7 @@ function preventDuplicateEntrypointNames(files) {
       if (absolutePaths.length > 1) {
         lines.push(`- ${name}`);
         absolutePaths.forEach((absolutePath) => {
-          lines.push(`  - ${(0, import_path4.relative)(wxt.config.root, absolutePath)}`);
+          lines.push(`  - ${(0, import_path3.relative)(wxt.config.root, absolutePath)}`);
         });
       }
       return lines;
@@ -11792,7 +11863,7 @@ async function getContentScriptEntrypoint({
     type: "content-script",
     name,
     inputPath,
-    outputDir: (0, import_path4.resolve)(wxt.config.outDir, CONTENT_SCRIPT_OUT_DIR),
+    outputDir: (0, import_path3.resolve)(wxt.config.outDir, CONTENT_SCRIPT_OUT_DIR),
     options: resolvePerBrowserOptions(options, wxt.config.browser),
     skipped
   };
@@ -11887,10 +11958,9 @@ var PATH_GLOB_TO_TYPE_MAP = {
 var CONTENT_SCRIPT_OUT_DIR = "content-scripts";
 
 // src/core/utils/building/generate-wxt-dir.ts
-var import_unimport2 = require("unimport");
 var import_fs_extra7 = __toESM(require("fs-extra"), 1);
-var import_path5 = require("path");
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_path15 = require("path");
+var import_node_path16 = __toESM(require("path"), 1);
 
 // src/core/utils/i18n.ts
 var predefinedMessages = {
@@ -11932,41 +12002,32 @@ function parseI18nMessages(messagesJson) {
 // src/core/utils/building/generate-wxt-dir.ts
 async function generateTypesDir(entrypoints) {
   await import_fs_extra7.default.ensureDir(wxt.config.typesDir);
-  const references = [];
-  if (wxt.config.imports !== false) {
-    const unimport2 = (0, import_unimport2.createUnimport)(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 = (0, import_path5.resolve)(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((i2) => i2.as ?? i2.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((module2) => {
+    if (module2.type === "node_module" && module2.configKey != null)
+      entries.push({ module: module2.id });
   });
-  await import_fs_extra7.default.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: (0, import_node_path15.resolve)(wxt.config.wxtDir, entry.path)
+  }));
+  await Promise.all(
+    absoluteFileEntries.map(async (file) => {
+      await import_fs_extra7.default.ensureDir((0, import_node_path15.dirname)(file.path));
+      await writeFileIfDifferent(file.path, file.text);
+    })
+  );
 }
-async function writePathsDeclarationFile(entrypoints) {
-  const filePath = (0, import_path5.resolve)(wxt.config.typesDir, "paths.d.ts");
+async function getPathsDeclarationEntry(entrypoints) {
   const unions = entrypoints.map(
     (entry) => getEntrypointBundlePath(
       entry,
@@ -11987,14 +12048,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 = (0, import_path5.resolve)(wxt.config.typesDir, "i18n.d.ts");
+async function getI18nDeclarationEntry() {
   const defaultLocale = wxt.config.manifest.default_locale;
   const template = `// Generated by wxt
 import "wxt/browser";
@@ -12017,7 +12077,7 @@ declare module "wxt/browser" {
 `;
   let messages;
   if (defaultLocale) {
-    const defaultLocalePath = import_node_path13.default.resolve(
+    const defaultLocalePath = import_node_path16.default.resolve(
       wxt.config.publicDir,
       "_locales",
       defaultLocale,
@@ -12040,18 +12100,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 = (0, import_path5.resolve)(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 {",
@@ -12059,36 +12118,31 @@ 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 = (0, import_path5.resolve)(dir, "wxt.d.ts");
-  await writeFileIfDifferent(
-    filePath,
-    [
-      "// Generated by wxt",
-      `/// <reference types="wxt/vite-builder-env" />`,
-      ...references.map(
-        (ref) => `/// <reference types="./${normalizePath((0, import_path5.relative)(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(
-        (module2) => module2.type === "node_module" && module2.configKey != null
-      ).map((module2) => `/// <reference types="${module2.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 = (0, import_node_path15.resolve)(wxt.config.wxtDir, ref.path);
+      const relativePath = (0, import_node_path15.relative)(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 = (path12) => normalizePath((0, import_path5.relative)(dir, path12));
+  const getTsconfigPath = (path12) => normalizePath((0, import_node_path15.relative)(dir, path12));
   const paths = Object.entries(wxt.config.alias).flatMap(([alias, absolutePath]) => {
     const aliasPath = getTsconfigPath(absolutePath);
     return [
@@ -12096,9 +12150,7 @@ async function writeTsConfigFile(mainReference) {
       `      "${alias}/*": ["${aliasPath}/*"]`
     ];
   }).join(",\n");
-  await writeFileIfDifferent(
-    (0, import_path5.resolve)(dir, "tsconfig.json"),
-    `{
+  const text2 = `{
   "compilerOptions": {
     "target": "ESNext",
     "module": "ESNext",
@@ -12115,26 +12167,29 @@ ${paths}
   },
   "include": [
     "${getTsconfigPath(wxt.config.root)}/**/*",
-    "./${getTsconfigPath(mainReference)}"
+    "./wxt.d.ts"
   ],
   "exclude": ["${getTsconfigPath(wxt.config.outBaseDir)}"]
-}`
-  );
+}`;
+  return {
+    path: "tsconfig.json",
+    text: text2
+  };
 }
 
 // src/core/utils/building/resolve-config.ts
 var import_c12 = require("c12");
-var import_node_path18 = __toESM(require("path"), 1);
+var import_node_path21 = __toESM(require("path"), 1);
 
 // src/core/utils/cache.ts
 var import_fs_extra8 = __toESM(require("fs-extra"), 1);
-var import_path6 = require("path");
+var import_path4 = require("path");
 function createFsCache(wxtDir) {
-  const getPath = (key) => (0, import_path6.resolve)(wxtDir, "cache", encodeURIComponent(key));
+  const getPath = (key) => (0, import_path4.resolve)(wxtDir, "cache", encodeURIComponent(key));
   return {
     async set(key, value) {
       const path12 = getPath(key);
-      await (0, import_fs_extra8.ensureDir)((0, import_path6.dirname)(path12));
+      await (0, import_fs_extra8.ensureDir)((0, import_path4.dirname)(path12));
       await writeFileIfDifferent(path12, value);
     },
     async get(key) {
@@ -12156,16 +12211,16 @@ var import_node_process13 = require("process");
 init_utils2();
 var import_node_tty4 = require("tty");
 var import_node_util13 = require("util");
-var import_node_path16 = require("path");
+var import_node_path19 = require("path");
 
 // src/core/utils/building/resolve-config.ts
 var import_defu = __toESM(require("defu"), 1);
 
 // src/core/utils/package.ts
-var import_node_path17 = require("path");
+var import_node_path20 = require("path");
 var import_fs_extra9 = __toESM(require("fs-extra"), 1);
 async function getPackageJson() {
-  const file = (0, import_node_path17.resolve)(wxt.config.root, "package.json");
+  const file = (0, import_node_path20.resolve)(wxt.config.root, "package.json");
   try {
     return await import_fs_extra9.default.readJson(file);
   } catch (err) {
@@ -12184,7 +12239,7 @@ function isModuleInstalled(name) {
 
 // src/core/utils/building/resolve-config.ts
 var import_fs_extra10 = __toESM(require("fs-extra"), 1);
-var import_fast_glob3 = __toESM(require("fast-glob"), 1);
+var import_fast_glob4 = __toESM(require("fast-glob"), 1);
 var import_meta = {};
 async function resolveConfig(inlineConfig, command) {
   let userConfig = {};
@@ -12210,28 +12265,28 @@ async function resolveConfig(inlineConfig, command) {
   const manifestVersion = mergedConfig.manifestVersion ?? (browser === "firefox" || browser === "safari" ? 2 : 3);
   const mode = mergedConfig.mode ?? COMMAND_MODES[command];
   const env2 = { browser, command, manifestVersion, mode };
-  const root = import_node_path18.default.resolve(
+  const root = import_node_path21.default.resolve(
     inlineConfig.root ?? userConfig.root ?? process.cwd()
   );
-  const wxtDir = import_node_path18.default.resolve(root, ".wxt");
+  const wxtDir = import_node_path21.default.resolve(root, ".wxt");
   const wxtModuleDir = await resolveWxtModuleDir();
-  const srcDir = import_node_path18.default.resolve(root, mergedConfig.srcDir ?? root);
-  const entrypointsDir = import_node_path18.default.resolve(
+  const srcDir = import_node_path21.default.resolve(root, mergedConfig.srcDir ?? root);
+  const entrypointsDir = import_node_path21.default.resolve(
     srcDir,
     mergedConfig.entrypointsDir ?? "entrypoints"
   );
-  const modulesDir = import_node_path18.default.resolve(srcDir, mergedConfig.modulesDir ?? "modules");
+  const modulesDir = import_node_path21.default.resolve(srcDir, mergedConfig.modulesDir ?? "modules");
   if (await isDirMissing(entrypointsDir)) {
     logMissingDir(logger, "Entrypoints", entrypointsDir);
   }
   const filterEntrypoints = !!mergedConfig.filterEntrypoints?.length ? new Set(mergedConfig.filterEntrypoints) : void 0;
-  const publicDir = import_node_path18.default.resolve(srcDir, mergedConfig.publicDir ?? "public");
+  const publicDir = import_node_path21.default.resolve(srcDir, mergedConfig.publicDir ?? "public");
   if (await isDirMissing(publicDir)) {
     logMissingDir(logger, "Public", publicDir);
   }
-  const typesDir = import_node_path18.default.resolve(wxtDir, "types");
-  const outBaseDir = import_node_path18.default.resolve(root, mergedConfig.outDir ?? ".output");
-  const outDir = import_node_path18.default.resolve(outBaseDir, `${browser}-mv${manifestVersion}`);
+  const typesDir = import_node_path21.default.resolve(wxtDir, "types");
+  const outBaseDir = import_node_path21.default.resolve(root, mergedConfig.outDir ?? ".output");
+  const outDir = import_node_path21.default.resolve(outBaseDir, `${browser}-mv${manifestVersion}`);
   const reloadCommand = mergedConfig.dev?.reloadCommand ?? "Alt+R";
   const runnerConfig = await (0, import_c12.loadConfig)({
     name: "web-ext",
@@ -12248,7 +12303,7 @@ async function resolveConfig(inlineConfig, command) {
       "~": srcDir,
       "@@": root,
       "~~": root
-    }).map(([key, value]) => [key, import_node_path18.default.resolve(root, value)])
+    }).map(([key, value]) => [key, import_node_path21.default.resolve(root, value)])
   );
   let devServerConfig;
   if (command === "serve") {
@@ -12262,14 +12317,20 @@ async function resolveConfig(inlineConfig, command) {
       hostname: "localhost"
     };
   }
-  const modules = await resolveWxtModules(modulesDir, mergedConfig.modules);
-  const moduleOptions = modules.reduce((map, module2) => {
-    if (module2.configKey) {
-      map[module2.configKey] = // @ts-expect-error
-      mergedConfig[module2.configKey];
-    }
-    return map;
-  }, {});
+  const userModules = await resolveWxtUserModules(
+    modulesDir,
+    mergedConfig.modules
+  );
+  const moduleOptions = userModules.reduce(
+    (map, module2) => {
+      if (module2.configKey) {
+        map[module2.configKey] = // @ts-expect-error
+        mergedConfig[module2.configKey];
+      }
+      return map;
+    },
+    {}
+  );
   return {
     browser,
     command,
@@ -12279,7 +12340,7 @@ async function resolveConfig(inlineConfig, command) {
     filterEntrypoints,
     env: env2,
     fsCache: createFsCache(wxtDir),
-    imports: await getUnimportOptions(wxtDir, logger, mergedConfig),
+    imports: await getUnimportOptions(wxtDir, srcDir, logger, mergedConfig),
     logger,
     manifest: await resolveManifestConfig(env2, mergedConfig.manifest),
     manifestVersion,
@@ -12308,7 +12369,8 @@ async function resolveConfig(inlineConfig, command) {
     },
     hooks: mergedConfig.hooks ?? {},
     vite: mergedConfig.vite ?? (() => ({})),
-    modules,
+    builtinModules,
+    userModules,
     plugins: [],
     ...moduleOptions
   };
@@ -12338,7 +12400,7 @@ async function mergeInlineConfig(inlineConfig, userConfig) {
   };
 }
 function resolveZipConfig(root, mergedConfig) {
-  const downloadedPackagesDir = import_node_path18.default.resolve(root, ".wxt/local_modules");
+  const downloadedPackagesDir = import_node_path21.default.resolve(root, ".wxt/local_modules");
   return {
     name: void 0,
     sourcesTemplate: "{{name}}-{{version}}-sources.zip",
@@ -12364,12 +12426,12 @@ function resolveZipConfig(root, mergedConfig) {
   };
 }
 function resolveAnalysisConfig(root, mergedConfig) {
-  const analysisOutputFile = import_node_path18.default.resolve(
+  const analysisOutputFile = import_node_path21.default.resolve(
     root,
     mergedConfig.analysis?.outputFile ?? "stats.html"
   );
-  const analysisOutputDir = import_node_path18.default.dirname(analysisOutputFile);
-  const analysisOutputName = import_node_path18.default.parse(analysisOutputFile).name;
+  const analysisOutputDir = import_node_path21.default.dirname(analysisOutputFile);
+  const analysisOutputName = import_node_path21.default.parse(analysisOutputFile).name;
   return {
     enabled: mergedConfig.analysis?.enabled ?? false,
     open: mergedConfig.analysis?.open ?? false,
@@ -12380,17 +12442,17 @@ 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) {
+  const rawEslintEnabled = config.imports?.eslintrc?.enabled;
+  let eslintEnabled;
+  switch (rawEslintEnabled) {
     case void 0:
     case "auto":
-      enabled = await isModuleInstalled("eslint");
+      eslintEnabled = await isModuleInstalled("eslint");
       break;
     default:
-      enabled = enabledConfig;
+      eslintEnabled = rawEslintEnabled;
   }
   const defaultOptions = {
     debugLog: logger.debug,
@@ -12406,9 +12468,12 @@ async function getUnimportOptions(wxtDir, logger, config) {
     ],
     warn: logger.warn,
     dirs: ["components", "composables", "hooks", "utils"],
+    dirsScanOptions: {
+      cwd: srcDir
+    },
     eslintrc: {
-      enabled,
-      filePath: import_node_path18.default.resolve(wxtDir, "eslintrc-auto-import.json"),
+      enabled: eslintEnabled,
+      filePath: import_node_path21.default.resolve(wxtDir, "eslintrc-auto-import.json"),
       globalsPropValue: true
     }
   };
@@ -12419,7 +12484,7 @@ async function getUnimportOptions(wxtDir, logger, config) {
 }
 async function resolveWxtModuleDir() {
   const requireResolve = require?.resolve ?? (await import("module")).default.createRequire(import_meta.url).resolve;
-  return import_node_path18.default.resolve(requireResolve("wxt"), "../..");
+  return import_node_path21.default.resolve(requireResolve("wxt"), "../..");
 }
 async function isDirMissing(dir) {
   return !await import_fs_extra10.default.exists(dir);
@@ -12427,7 +12492,7 @@ async function isDirMissing(dir) {
 function logMissingDir(logger, name, expected) {
   logger.warn(
     `${name} directory not found: ./${normalizePath(
-      import_node_path18.default.relative(process.cwd(), expected)
+      import_node_path21.default.relative(process.cwd(), expected)
     )}`
   );
 }
@@ -12436,19 +12501,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 (env2) => {
         const resolvedInlineConfig = await inlineConfig.vite?.(env2) ?? {};
         const resolvedUserConfig = await userConfig.vite?.(env2) ?? {};
-        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(
@@ -12465,13 +12530,13 @@ async function resolveWxtModules(modulesDir, modules = []) {
       };
     })
   );
-  const localModulePaths = await (0, import_fast_glob3.default)(["*.[tj]s", "*/index.[tj]s"], {
+  const localModulePaths = await (0, import_fast_glob4.default)(["*.[tj]s", "*/index.[tj]s"], {
     cwd: modulesDir,
     onlyFiles: true
   }).catch(() => []);
   const localModules = await Promise.all(
     localModulePaths.map(async (file) => {
-      const absolutePath = normalizePath(import_node_path18.default.resolve(modulesDir, file));
+      const absolutePath = normalizePath(import_node_path21.default.resolve(modulesDir, file));
       const { config } = await (0, import_c12.loadConfig)({
         configFile: absolutePath,
         globalRc: false,
@@ -12538,22 +12603,22 @@ var ENTRY_TYPE_TO_GROUP_MAP = {
 var import_jiti = __toESM(require("jiti"), 1);
 var import_unimport3 = require("unimport");
 var import_fs_extra11 = __toESM(require("fs-extra"), 1);
-var import_node_path19 = require("path");
+var import_node_path22 = require("path");
 var import_esbuild = require("esbuild");
 var import_node_url3 = require("url");
 var import_meta2 = {};
 async function importEntrypointFile(path12) {
   wxt.logger.debug("Loading file metadata:", path12);
   const normalPath = normalizePath(path12);
-  const unimport2 = (0, import_unimport3.createUnimport)({
+  const unimport = (0, import_unimport3.createUnimport)({
     ...wxt.config.imports,
     // Only allow specific imports, not all from the project
     dirs: []
   });
-  await unimport2.init();
+  await unimport.init();
   const text2 = await import_fs_extra11.default.readFile(path12, "utf-8");
   const textNoImports = removeProjectImportStatements(text2);
-  const { code } = await unimport2.injectImports(textNoImports);
+  const { code } = await unimport.injectImports(textNoImports);
   wxt.logger.debug(
     ["Text:", text2, "No imports:", textNoImports, "Code:", code].join("\n")
   );
@@ -12564,7 +12629,7 @@ async function importEntrypointFile(path12) {
       debug: wxt.config.debug,
       esmResolve: true,
       alias: {
-        "webextension-polyfill": (0, import_node_path19.resolve)(
+        "webextension-polyfill": (0, import_node_path22.resolve)(
           wxt.config.wxtModuleDir,
           "dist/virtual/mock-browser.js"
         )
@@ -12597,7 +12662,7 @@ async function importEntrypointFile(path12) {
     const res = await jiti(path12);
     return res.default;
   } catch (err) {
-    const filePath = (0, import_node_path19.relative)(wxt.config.root, path12);
+    const filePath = (0, import_node_path22.relative)(wxt.config.root, path12);
     if (err instanceof ReferenceError) {
       const variableName = err.message.replace(" is not defined", "");
       throw Error(
@@ -12629,10 +12694,10 @@ var import_picocolors5 = __toESM(require("picocolors"), 1);
 var import_fs_extra14 = __toESM(require("fs-extra"), 1);
 
 // src/core/utils/log/printBuildSummary.ts
-var import_path7 = require("path");
+var import_path5 = require("path");
 
 // src/core/utils/log/printFileList.ts
-var import_node_path20 = __toESM(require("path"), 1);
+var import_node_path23 = __toESM(require("path"), 1);
 var import_picocolors3 = __toESM(require("picocolors"), 1);
 var import_fs_extra12 = __toESM(require("fs-extra"), 1);
 var import_filesize = require("filesize");
@@ -12667,8 +12732,8 @@ async function printFileList(log, header, baseDir, files) {
   const fileRows = await Promise.all(
     files.map(async (file, i2) => {
       const parts = [
-        import_node_path20.default.relative(process.cwd(), baseDir) + import_node_path20.default.sep,
-        import_node_path20.default.relative(baseDir, file)
+        import_node_path23.default.relative(process.cwd(), baseDir) + import_node_path23.default.sep,
+        import_node_path23.default.relative(baseDir, file)
       ];
       const prefix = i2 === files.length - 1 ? "  \u2514\u2500" : "  \u251C\u2500";
       const color = getChunkColor(file);
@@ -12713,7 +12778,7 @@ async function printBuildSummary(log, header, output) {
     return l2.fileName.localeCompare(r2.fileName);
   });
   const files = chunks.map(
-    (chunk) => (0, import_path7.resolve)(wxt.config.outDir, chunk.fileName)
+    (chunk) => (0, import_path5.resolve)(wxt.config.outDir, chunk.fileName)
   );
   await printFileList(log, header, wxt.config.outDir, files);
 }
@@ -12735,14 +12800,14 @@ function getChunkSortWeight(filename) {
 var import_picocolors4 = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "0.18.8";
+var version = "0.18.9";
 
 // src/core/utils/building/internal-build.ts
-var import_fast_glob4 = __toESM(require("fast-glob"), 1);
+var import_fast_glob5 = __toESM(require("fast-glob"), 1);
 
 // src/core/utils/manifest.ts
 var import_fs_extra13 = __toESM(require("fs-extra"), 1);
-var import_path8 = require("path");
+var import_path6 = require("path");
 
 // src/core/utils/content-security-policy.ts
 var ContentSecurityPolicy = class _ContentSecurityPolicy {
@@ -12851,7 +12916,7 @@ var import_defu2 = __toESM(require("defu"), 1);
 async function writeManifest(manifest, output) {
   const str = wxt.config.mode === "production" ? JSON.stringify(manifest) : JSON.stringify(manifest, null, 2);
   await import_fs_extra13.default.ensureDir(wxt.config.outDir);
-  await writeFileIfDifferent((0, import_path8.resolve)(wxt.config.outDir, "manifest.json"), str);
+  await writeFileIfDifferent((0, import_path6.resolve)(wxt.config.outDir, "manifest.json"), str);
   output.publicAssets.unshift({
     type: "asset",
     fileName: "manifest.json"
@@ -13386,7 +13451,7 @@ async function rebuild(allEntrypoints, entrypointGroups, existingOutput = {
 }
 
 // src/core/utils/building/internal-build.ts
-var import_node_path21 = require("path");
+var import_node_path24 = require("path");
 
 // src/core/utils/validation.ts
 function validateEntrypoints(entrypoints) {
@@ -13485,7 +13550,7 @@ async function internalBuild() {
   }
   if (wxt.config.analysis.enabled) {
     await combineAnalysisStats();
-    const statsPath = (0, import_node_path21.relative)(wxt.config.root, wxt.config.analysis.outputFile);
+    const statsPath = (0, import_node_path24.relative)(wxt.config.root, wxt.config.analysis.outputFile);
     wxt.logger.info(
       `Analysis complete:
   ${import_picocolors5.default.gray("\u2514\u2500")} ${import_picocolors5.default.yellow(statsPath)}`
@@ -13503,7 +13568,7 @@ async function internalBuild() {
   return output;
 }
 async function combineAnalysisStats() {
-  const unixFiles = await (0, import_fast_glob4.default)(`${wxt.config.analysis.outputName}-*.json`, {
+  const unixFiles = await (0, import_fast_glob5.default)(`${wxt.config.analysis.outputName}-*.json`, {
     cwd: wxt.config.analysis.outputDir,
     absolute: true
   });
@@ -13533,7 +13598,7 @@ function printValidationResults({
     return map;
   }, /* @__PURE__ */ new Map());
   Array.from(entrypointErrors.entries()).forEach(([entrypoint, errors2]) => {
-    consola.log((0, import_node_path21.relative)(cwd, entrypoint.inputPath));
+    consola.log((0, import_node_path24.relative)(cwd, entrypoint.inputPath));
     console.log();
     errors2.forEach((err) => {
       const type = err.type === "error" ? import_picocolors5.default.red("ERROR") : import_picocolors5.default.yellow("WARN");
@@ -13551,8 +13616,8 @@ async function build(config) {
 }
 
 // src/core/clean.ts
-var import_node_path22 = __toESM(require("path"), 1);
-var import_fast_glob5 = __toESM(require("fast-glob"), 1);
+var import_node_path25 = __toESM(require("path"), 1);
+var import_fast_glob6 = __toESM(require("fast-glob"), 1);
 var import_fs_extra15 = __toESM(require("fs-extra"), 1);
 var import_picocolors6 = __toESM(require("picocolors"), 1);
 async function clean(root = process.cwd()) {
@@ -13564,8 +13629,8 @@ async function clean(root = process.cwd()) {
     ".output/*"
   ];
   consola.debug("Looking for:", tempDirs.map(import_picocolors6.default.cyan).join(", "));
-  const directories = await (0, import_fast_glob5.default)(tempDirs, {
-    cwd: import_node_path22.default.resolve(root),
+  const directories = await (0, import_fast_glob6.default)(tempDirs, {
+    cwd: import_node_path25.default.resolve(root),
     absolute: true,
     onlyDirectories: true,
     deep: 2
@@ -13576,11 +13641,11 @@ async function clean(root = process.cwd()) {
   }
   consola.debug(
     "Found:",
-    directories.map((dir) => import_picocolors6.default.cyan(import_node_path22.default.relative(root, dir))).join(", ")
+    directories.map((dir) => import_picocolors6.default.cyan(import_node_path25.default.relative(root, dir))).join(", ")
   );
   for (const directory of directories) {
     await import_fs_extra15.default.rm(directory, { force: true, recursive: true });
-    consola.debug("Deleted " + import_picocolors6.default.cyan(import_node_path22.default.relative(root, directory)));
+    consola.debug("Deleted " + import_picocolors6.default.cyan(import_node_path25.default.relative(root, directory)));
   }
 }
 
@@ -13595,12 +13660,12 @@ function defineRunnerConfig(config) {
 }
 
 // src/core/runners/wsl.ts
-var import_node_path23 = require("path");
+var import_node_path26 = require("path");
 function createWslRunner() {
   return {
     async openBrowser() {
       wxt.logger.warn(
-        `Cannot open browser when using WSL. Load "${(0, import_node_path23.relative)(
+        `Cannot open browser when using WSL. Load "${(0, import_node_path26.relative)(
           process.cwd(),
           wxt.config.outDir
         )}" as an unpacked extension manually`
@@ -13687,12 +13752,12 @@ var DEFAULT_CHROMIUM_PREFS = {
 };
 
 // src/core/runners/safari.ts
-var import_node_path24 = require("path");
+var import_node_path27 = require("path");
 function createSafariRunner() {
   return {
     async openBrowser() {
       wxt.logger.warn(
-        `Cannot Safari using web-ext. Load "${(0, import_node_path24.relative)(
+        `Cannot Safari using web-ext. Load "${(0, import_node_path27.relative)(
           process.cwd(),
           wxt.config.outDir
         )}" as an unpacked extension manually`
@@ -13704,12 +13769,12 @@ function createSafariRunner() {
 }
 
 // src/core/runners/manual.ts
-var import_node_path25 = require("path");
+var import_node_path28 = require("path");
 function createManualRunner() {
   return {
     async openBrowser() {
       wxt.logger.info(
-        `Load "${(0, import_node_path25.relative)(
+        `Load "${(0, import_node_path28.relative)(
           process.cwd(),
           wxt.config.outDir
         )}" as an unpacked extension manually`
@@ -13737,7 +13802,7 @@ async function createExtensionRunner() {
 // src/core/create-server.ts
 var import_async_mutex = require("async-mutex");
 var import_picocolors7 = __toESM(require("picocolors"), 1);
-var import_node_path26 = require("path");
+var import_node_path29 = require("path");
 async function createServer(inlineConfig) {
   await registerWxt("serve", inlineConfig, async (config) => {
     const { port, hostname } = config.dev.server;
@@ -13839,7 +13904,7 @@ function createFileReloader(server) {
         return;
       }
       wxt.logger.info(
-        `Changed: ${Array.from(new Set(fileChanges)).map((file) => import_picocolors7.default.dim((0, import_node_path26.relative)(wxt.config.root, file))).join(", ")}`
+        `Changed: ${Array.from(new Set(fileChanges)).map((file) => import_picocolors7.default.dim((0, import_node_path29.relative)(wxt.config.root, file))).join(", ")}`
       );
       const allEntrypoints = await findEntrypoints();
       try {
@@ -13928,7 +13993,7 @@ function getExternalOutputDependencies(server) {
 var import_prompts = __toESM(require("prompts"), 1);
 var import_giget = require("giget");
 var import_fs_extra16 = __toESM(require("fs-extra"), 1);
-var import_node_path27 = __toESM(require("path"), 1);
+var import_node_path30 = __toESM(require("path"), 1);
 var import_picocolors8 = __toESM(require("picocolors"), 1);
 async function initialize(options) {
   consola.info("Initalizing new project");
@@ -13980,13 +14045,13 @@ async function initialize(options) {
     const isEmpty = (await import_fs_extra16.default.readdir(input.directory)).length === 0;
     if (!isEmpty) {
       consola.error(
-        `The directory ${import_node_path27.default.resolve(input.directory)} is not empty. Aborted.`
+        `The directory ${import_node_path30.default.resolve(input.directory)} is not empty. Aborted.`
       );
       process.exit(1);
     }
   }
   await cloneProject(input);
-  const cdPath = import_node_path27.default.relative(process.cwd(), import_node_path27.default.resolve(input.directory));
+  const cdPath = import_node_path30.default.relative(process.cwd(), import_node_path30.default.resolve(input.directory));
   console.log();
   consola.log(
     `\u2728 WXT project created with the ${TEMPLATE_COLORS[input.template.name]?.(input.template.name) ?? input.template.name} template.`
@@ -14029,8 +14094,8 @@ async function cloneProject({
       force: true
     });
     await import_fs_extra16.default.move(
-      import_node_path27.default.join(directory, "_gitignore"),
-      import_node_path27.default.join(directory, ".gitignore")
+      import_node_path30.default.join(directory, "_gitignore"),
+      import_node_path30.default.join(directory, ".gitignore")
     ).catch(
       (err) => consola.warn("Failed to move _gitignore to .gitignore:", err)
     );
@@ -14062,11 +14127,11 @@ async function prepare(config) {
 }
 
 // src/core/zip.ts
-var import_node_path28 = __toESM(require("path"), 1);
+var import_node_path31 = __toESM(require("path"), 1);
 var import_fs_extra17 = __toESM(require("fs-extra"), 1);
 var import_minimatch2 = require("minimatch");
 var import_jszip = __toESM(require("jszip"), 1);
-var import_fast_glob6 = __toESM(require("fast-glob"), 1);
+var import_fast_glob7 = __toESM(require("fast-glob"), 1);
 async function zip(config) {
   await registerWxt("build", config);
   const output = await internalBuild();
@@ -14074,7 +14139,7 @@ async function zip(config) {
   wxt.logger.info("Zipping extension...");
   const zipFiles = [];
   const projectName = wxt.config.zip.name ?? kebabCaseAlphanumeric(
-    (await getPackageJson())?.name || import_node_path28.default.dirname(process.cwd())
+    (await getPackageJson())?.name || import_node_path31.default.dirname(process.cwd())
   );
   const applyTemplate = (template) => template.replaceAll("{{name}}", projectName).replaceAll("{{browser}}", wxt.config.browser).replaceAll(
     "{{version}}",
@@ -14082,13 +14147,13 @@ async function zip(config) {
   ).replaceAll("{{mode}}", wxt.config.mode).replaceAll("{{manifestVersion}}", `mv${wxt.config.manifestVersion}`);
   await import_fs_extra17.default.ensureDir(wxt.config.outBaseDir);
   const outZipFilename = applyTemplate(wxt.config.zip.artifactTemplate);
-  const outZipPath = import_node_path28.default.resolve(wxt.config.outBaseDir, outZipFilename);
+  const outZipPath = import_node_path31.default.resolve(wxt.config.outBaseDir, outZipFilename);
   await zipDir(wxt.config.outDir, outZipPath);
   zipFiles.push(outZipPath);
   if (wxt.config.browser === "firefox") {
     const { overrides, files: downloadedPackages } = await downloadPrivatePackages();
     const sourcesZipFilename = applyTemplate(wxt.config.zip.sourcesTemplate);
-    const sourcesZipPath = import_node_path28.default.resolve(
+    const sourcesZipPath = import_node_path31.default.resolve(
       wxt.config.outBaseDir,
       sourcesZipFilename
     );
@@ -14114,7 +14179,7 @@ async function zip(config) {
 }
 async function zipDir(directory, outputPath, options) {
   const archive = new import_jszip.default();
-  const files = (await (0, import_fast_glob6.default)("**/*", {
+  const files = (await (0, import_fast_glob7.default)("**/*", {
     cwd: directory,
     // Ignore node_modules, otherwise this glob step takes forever
     ignore: ["**/node_modules"],
@@ -14127,11 +14192,11 @@ async function zipDir(directory, outputPath, options) {
   const filesToZip = [
     ...files,
     ...(options?.additionalFiles ?? []).map(
-      (file) => import_node_path28.default.relative(directory, file)
+      (file) => import_node_path31.default.relative(directory, file)
     )
   ];
   for (const file of filesToZip) {
-    const absolutePath = import_node_path28.default.resolve(directory, file);
+    const absolutePath = import_node_path31.default.resolve(directory, file);
     if (file.endsWith(".json")) {
       const content = await import_fs_extra17.default.readFile(absolutePath, "utf-8");
       archive.file(
@@ -14180,14 +14245,14 @@ async function downloadPrivatePackages() {
 }
 function addOverridesToPackageJson(absolutePackageJsonPath, content, overrides) {
   if (Object.keys(overrides).length === 0) return content;
-  const packageJsonDir = import_node_path28.default.dirname(absolutePackageJsonPath);
+  const packageJsonDir = import_node_path31.default.dirname(absolutePackageJsonPath);
   const oldPackage = JSON.parse(content);
   const newPackage = {
     ...oldPackage,
     [wxt.pm.overridesKey]: { ...oldPackage[wxt.pm.overridesKey] }
   };
   Object.entries(overrides).forEach(([key, absolutePath]) => {
-    newPackage[wxt.pm.overridesKey][key] = "file://./" + normalizePath(import_node_path28.default.relative(packageJsonDir, absolutePath));
+    newPackage[wxt.pm.overridesKey][key] = "file://./" + normalizePath(import_node_path31.default.relative(packageJsonDir, absolutePath));
   });
   return JSON.stringify(newPackage, null, 2);
 }