wxt 0.10.4 → 0.11.0

package/dist/{chunk-RSHXTUF4.js → chunk-6V4H2CZ4.js}

@@ -1,22 +1,112 @@
 // package.json
-var version = "0.10.4";
+var version = "0.11.0";
 
-// src/core/utils/entrypoints.ts
-import path, { relative, resolve } from "node:path";
+// src/core/utils/arrays.ts
+function every(array, predicate) {
+  for (let i = 0; i < array.length; i++)
+    if (!predicate(array[i], i))
+      return false;
+  return true;
+}
 
 // src/core/utils/paths.ts
 import systemPath from "node:path";
 import normalize from "normalize-path";
-function normalizePath(path7) {
-  return normalize(path7);
+function normalizePath(path6) {
+  return normalize(path6);
 }
-function unnormalizePath(path7) {
-  return systemPath.normalize(path7);
+function unnormalizePath(path6) {
+  return systemPath.normalize(path6);
 }
 var CSS_EXTENSIONS = ["css", "scss", "sass", "less", "styl", "stylus"];
 var CSS_EXTENSIONS_PATTERN = `+(${CSS_EXTENSIONS.join("|")})`;
 
+// src/core/utils/building/detect-dev-changes.ts
+function detectDevChanges(changedFiles, currentOutput) {
+  if (currentOutput == null)
+    return { type: "no-change" };
+  const changedSteps = new Set(
+    changedFiles.flatMap(
+      (changedFile) => findEffectedSteps(changedFile, currentOutput)
+    )
+  );
+  if (changedSteps.size === 0)
+    return { type: "no-change" };
+  const unchangedOutput = {
+    manifest: currentOutput.manifest,
+    steps: [],
+    publicAssets: []
+  };
+  const changedOutput = {
+    manifest: currentOutput.manifest,
+    steps: [],
+    publicAssets: []
+  };
+  for (const step of currentOutput.steps) {
+    if (changedSteps.has(step)) {
+      changedOutput.steps.push(step);
+    } else {
+      unchangedOutput.steps.push(step);
+    }
+  }
+  for (const asset of currentOutput.publicAssets) {
+    if (changedSteps.has(asset)) {
+      changedOutput.publicAssets.push(asset);
+    } else {
+      unchangedOutput.publicAssets.push(asset);
+    }
+  }
+  const isOnlyHtmlChanges = changedFiles.length > 0 && every(changedFiles, ([_, file]) => file.endsWith(".html"));
+  if (isOnlyHtmlChanges) {
+    return {
+      type: "html-reload",
+      cachedOutput: unchangedOutput,
+      rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
+    };
+  }
+  const isOnlyContentScripts = changedOutput.steps.length > 0 && every(
+    changedOutput.steps.flatMap((step) => step.entrypoints),
+    (entry) => entry.type === "content-script"
+  );
+  if (isOnlyContentScripts) {
+    return {
+      type: "content-script-reload",
+      cachedOutput: unchangedOutput,
+      changedSteps: changedOutput.steps,
+      rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
+    };
+  }
+  return {
+    type: "extension-reload",
+    cachedOutput: unchangedOutput,
+    rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
+  };
+}
+function findEffectedSteps(changedFile, currentOutput) {
+  const changes = [];
+  const changedPath = normalizePath(changedFile[1]);
+  const isChunkEffected = (chunk) => (
+    // If it's an HTML file with the same path, is is effected because HTML files need to be pre-rendered
+    // fileName is normalized, relative bundle path
+    chunk.type === "asset" && changedPath.endsWith(chunk.fileName) || // If it's a chunk that depends on the changed file, it is effected
+    // moduleIds are absolute, normalized paths
+    chunk.type === "chunk" && chunk.moduleIds.includes(changedPath)
+  );
+  for (const step of currentOutput.steps) {
+    const effectedChunk = step.chunks.find((chunk) => isChunkEffected(chunk));
+    if (effectedChunk)
+      changes.push(step);
+  }
+  const effectedAsset = currentOutput.publicAssets.find(
+    (chunk) => isChunkEffected(chunk)
+  );
+  if (effectedAsset)
+    changes.push(effectedAsset);
+  return changes;
+}
+
 // src/core/utils/entrypoints.ts
+import path, { relative, resolve } from "node:path";
 function getEntrypointName(entrypointsDir, inputPath) {
   const relativePath = path.relative(entrypointsDir, inputPath);
   const name = relativePath.split(/[\.\/\\]/, 2)[0];
@@ -36,87 +126,69 @@ function resolvePerBrowserOption(option, browser) {
   return option;
 }
 
-// src/core/utils/time.ts
-function formatDuration(duration) {
-  if (duration < 1e3)
-    return `${duration} ms`;
-  if (duration < 1e4)
-    return `${(duration / 1e3).toFixed(3)} s`;
-  if (duration < 6e4)
-    return `${(duration / 1e3).toFixed(1)} s`;
-  return `${(duration / 1e3).toFixed(0)} s`;
-}
-function withTimeout(promise, duration) {
-  return new Promise((res, rej) => {
-    const timeout = setTimeout(() => {
-      rej(`Promise timed out after ${duration}ms`);
-    }, duration);
-    promise.then(res).catch(rej).finally(() => clearTimeout(timeout));
-  });
-}
+// src/core/utils/building/find-entrypoints.ts
+import { relative as relative4, resolve as resolve12 } from "path";
+import fs12 from "fs-extra";
+import { minimatch } from "minimatch";
+import { parseHTML as parseHTML2 } from "linkedom";
+import JSON5 from "json5";
 
-// src/core/utils/network.ts
-import dns from "node:dns";
-function isOffline() {
-  const isOffline2 = new Promise((res) => {
-    dns.resolve("google.com", (err) => {
-      if (err == null) {
-        res(false);
-      } else {
-        res(true);
-      }
-    });
-  });
-  return withTimeout(isOffline2, 1e3).catch(() => true);
+// src/core/utils/fs.ts
+import fs from "fs-extra";
+import glob from "fast-glob";
+async function writeFileIfDifferent(file, newContents) {
+  const existingContents = await fs.readFile(file, "utf-8").catch(() => void 0);
+  if (existingContents !== newContents) {
+    await fs.writeFile(file, newContents);
+  }
 }
-async function isOnline() {
-  const offline = await isOffline();
-  return !offline;
+async function getPublicFiles(config) {
+  if (!await fs.exists(config.publicDir))
+    return [];
+  const files = await glob("**/*", { cwd: config.publicDir });
+  return files.map(unnormalizePath);
 }
-async function fetchCached(url, config) {
-  let content = "";
-  if (await isOnline()) {
-    const res = await fetch(url);
-    if (res.status < 300) {
-      content = await res.text();
-      await config.fsCache.set(url, content);
-    } else {
-      config.logger.debug(
-        `Failed to download "${url}", falling back to cache...`
-      );
-    }
+
+// src/core/utils/building/build-entrypoints.ts
+import fs2 from "fs-extra";
+import { dirname, resolve as resolve2 } from "path";
+import pc from "picocolors";
+async function buildEntrypoints(groups, config, spinner) {
+  const steps = [];
+  for (let i = 0; i < groups.length; i++) {
+    const group = groups[i];
+    const groupNames = [group].flat().map((e) => e.name).join(pc.dim(", "));
+    spinner.text = pc.dim(`[${i + 1}/${groups.length}]`) + ` ${groupNames}`;
+    steps.push(await config.builder.build(group));
   }
-  if (!content)
-    content = await config.fsCache.get(url) ?? "";
-  if (!content)
-    throw Error(
-      `Offline and "${url}" has not been cached. Try again when online.`
-    );
-  return content;
+  const publicAssets = await copyPublicDirectory(config);
+  return { publicAssets, steps };
 }
-
-// src/core/vite-plugins/download.ts
-function download(config) {
-  return {
-    name: "wxt:download",
-    resolveId(id) {
-      if (id.startsWith("url:"))
-        return "\0" + id;
-    },
-    async load(id) {
-      if (!id.startsWith("\0url:"))
-        return;
-      const url = id.replace("\0url:", "");
-      return await fetchCached(url, config);
-    }
-  };
+async function copyPublicDirectory(config) {
+  const files = await getPublicFiles(config);
+  if (files.length === 0)
+    return [];
+  const publicAssets = [];
+  for (const file of files) {
+    const srcPath = resolve2(config.publicDir, file);
+    const outPath = resolve2(config.outDir, file);
+    await fs2.ensureDir(dirname(outPath));
+    await fs2.copyFile(srcPath, outPath);
+    publicAssets.push({
+      type: "asset",
+      fileName: file
+    });
+  }
+  return publicAssets;
 }
 
-// src/core/vite-plugins/unimport.ts
+// src/core/utils/building/generate-wxt-dir.ts
 import { createUnimport } from "unimport";
+import fs3 from "fs-extra";
+import { relative as relative2, resolve as resolve3 } from "path";
 
 // src/core/utils/unimport.ts
-import { mergeConfig } from "vite";
+import { defu } from "defu";
 function getUnimportOptions(config) {
   if (config.imports === false)
     return false;
@@ -135,54 +207,7 @@ function getUnimportOptions(config) {
     warn: config.logger.warn,
     dirs: ["components", "composables", "hooks", "utils"]
   };
-  return mergeConfig(
-    defaultOptions,
-    config.imports
-  );
-}
-
-// src/core/vite-plugins/unimport.ts
-import { extname } from "path";
-var ENABLED_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".js",
-  ".jsx",
-  ".ts",
-  ".tsx",
-  ".vue",
-  ".svelte"
-]);
-function unimport(config) {
-  const options = getUnimportOptions(config);
-  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(extname(id)))
-        return;
-      return unimport2.injectImports(code, id);
-    }
-  };
-}
-
-// src/core/vite-plugins/tsconfigPaths.ts
-function tsconfigPaths(config) {
-  return {
-    name: "wxt:aliases",
-    async config() {
-      return {
-        resolve: {
-          alias: config.alias
-        }
-      };
-    }
-  };
+  return defu(config.imports, defaultOptions);
 }
 
 // src/core/utils/globals.ts
@@ -230,7 +255,7 @@ function getGlobals(config) {
     }
   ];
 }
-function getEntrypointGlobals(config, entrypointName) {
+function getEntrypointGlobals(entrypointName) {
   return [
     {
       name: surroundInUnderscore("ENTRYPOINT"),
@@ -243,68 +268,253 @@ function surroundInUnderscore(name) {
   return `__${name}__`;
 }
 
-// src/core/vite-plugins/globals.ts
-function globals(config) {
-  return {
-    name: "wxt:globals",
-    config() {
-      const define = {};
-      for (const global of getGlobals(config)) {
-        define[global.name] = JSON.stringify(global.value);
-      }
-      return {
-        define
-      };
-    }
-  };
-}
-
-// src/core/vite-plugins/webextensionPolyfillAlias.ts
+// src/core/utils/building/generate-wxt-dir.ts
 import path2 from "node:path";
-function webextensionPolyfillAlias(config) {
-  return {
-    name: "wxt:webextension-polyfill-test-alias",
-    config() {
-      return {
-        resolve: {
-          alias: {
-            "webextension-polyfill": path2.resolve(
-              config.root,
-              "node_modules/wxt/dist/virtual/mock-browser"
-            )
-          }
-        }
-      };
+
+// src/core/utils/i18n.ts
+var predefinedMessages = {
+  "@@extension_id": {
+    message: "<browser.runtime.id>",
+    description: "The extension or app ID; you might use this string to construct URLs for resources inside the extension. Even unlocalized extensions can use this message.\nNote: You can't use this message in a manifest file."
+  },
+  "@@ui_locale": {
+    message: "<browser.i18n.getUiLocale()>",
+    description: ""
+  },
+  "@@bidi_dir": {
+    message: "<ltr|rtl>",
+    description: 'The text direction for the current locale, either "ltr" for left-to-right languages such as English or "rtl" for right-to-left languages such as Japanese.'
+  },
+  "@@bidi_reversed_dir": {
+    message: "<rtl|ltr>",
+    description: `If the @@bidi_dir is "ltr", then this is "rtl"; otherwise, it's "ltr".`
+  },
+  "@@bidi_start_edge": {
+    message: "<left|right>",
+    description: `If the @@bidi_dir is "ltr", then this is "left"; otherwise, it's "right".`
+  },
+  "@@bidi_end_edge": {
+    message: "<right|left>",
+    description: `If the @@bidi_dir is "ltr", then this is "right"; otherwise, it's "left".`
+  }
+};
+function parseI18nMessages(messagesJson) {
+  return Object.entries({
+    ...predefinedMessages,
+    ...messagesJson
+  }).map(([name, details]) => ({
+    name,
+    ...details
+  }));
+}
+
+// src/core/utils/building/generate-wxt-dir.ts
+async function generateTypesDir(entrypoints, config) {
+  await fs3.ensureDir(config.typesDir);
+  const references = [];
+  const imports = getUnimportOptions(config);
+  if (imports !== false) {
+    references.push(await writeImportsDeclarationFile(config, imports));
+  }
+  references.push(await writePathsDeclarationFile(entrypoints, config));
+  references.push(await writeI18nDeclarationFile(config));
+  references.push(await writeGlobalsDeclarationFile(config));
+  const mainReference = await writeMainDeclarationFile(references, config);
+  await writeTsConfigFile(mainReference, config);
+}
+async function writeImportsDeclarationFile(config, unimportOptions) {
+  const filePath = resolve3(config.typesDir, "imports.d.ts");
+  const unimport2 = createUnimport(unimportOptions);
+  await unimport2.scanImportsFromDir(void 0, { cwd: config.srcDir });
+  await writeFileIfDifferent(
+    filePath,
+    ["// Generated by wxt", await unimport2.generateTypeDeclarations()].join(
+      "\n"
+    ) + "\n"
+  );
+  return filePath;
+}
+async function writePathsDeclarationFile(entrypoints, config) {
+  const filePath = resolve3(config.typesDir, "paths.d.ts");
+  const unions = entrypoints.map(
+    (entry) => getEntrypointBundlePath(
+      entry,
+      config.outDir,
+      entry.inputPath.endsWith(".html") ? ".html" : ".js"
+    )
+  ).concat(await getPublicFiles(config)).map(normalizePath).map((path6) => `    | "/${path6}"`).sort().join("\n");
+  const template = `// Generated by wxt
+import "wxt/browser";
+
+declare module "wxt/browser" {
+  export type PublicPath =
+{{ union }}
+  export interface WxtRuntime extends Runtime.Static {
+    getURL(path: PublicPath): string;
+  }
+}
+`;
+  await writeFileIfDifferent(
+    filePath,
+    template.replace("{{ union }}", unions || "    | never")
+  );
+  return filePath;
+}
+async function writeI18nDeclarationFile(config) {
+  const filePath = resolve3(config.typesDir, "i18n.d.ts");
+  const defaultLocale = config.manifest.default_locale;
+  const template = `// Generated by wxt
+import "wxt/browser";
+
+declare module "wxt/browser" {
+  /**
+   * See https://developer.chrome.com/docs/extensions/reference/i18n/#method-getMessage
+   */
+  interface GetMessageOptions {
+    /**
+     * See https://developer.chrome.com/docs/extensions/reference/i18n/#method-getMessage
+     */
+    escapeLt?: boolean
+  }
+
+  export interface WxtI18n extends I18n.Static {
+{{ overrides }}
+  }
+}
+`;
+  let messages;
+  if (defaultLocale) {
+    const defaultLocalePath = path2.resolve(
+      config.publicDir,
+      "_locales",
+      defaultLocale,
+      "messages.json"
+    );
+    const content = JSON.parse(await fs3.readFile(defaultLocalePath, "utf-8"));
+    messages = parseI18nMessages(content);
+  } else {
+    messages = parseI18nMessages({});
+  }
+  const overrides = messages.map((message) => {
+    return `    /**
+     * ${message.description ?? "No message description."}
+     *
+     * "${message.message}"
+     */
+    getMessage(
+      messageName: "${message.name}",
+      substitutions?: string | string[],
+      options?: GetMessageOptions,
+    ): string;`;
+  });
+  await writeFileIfDifferent(
+    filePath,
+    template.replace("{{ overrides }}", overrides.join("\n"))
+  );
+  return filePath;
+}
+async function writeGlobalsDeclarationFile(config) {
+  const filePath = resolve3(config.typesDir, "globals.d.ts");
+  const globals2 = [...getGlobals(config), ...getEntrypointGlobals("")];
+  await writeFileIfDifferent(
+    filePath,
+    [
+      "// Generated by wxt",
+      "export {}",
+      "declare global {",
+      ...globals2.map((global) => `  const ${global.name}: ${global.type};`),
+      "}"
+    ].join("\n") + "\n"
+  );
+  return filePath;
+}
+async function writeMainDeclarationFile(references, config) {
+  const dir = config.wxtDir;
+  const filePath = resolve3(dir, "wxt.d.ts");
+  await writeFileIfDifferent(
+    filePath,
+    [
+      "// Generated by wxt",
+      `/// <reference types="vite/client" />`,
+      ...references.map(
+        (ref) => `/// <reference types="./${normalizePath(relative2(dir, ref))}" />`
+      )
+    ].join("\n") + "\n"
+  );
+  return filePath;
+}
+async function writeTsConfigFile(mainReference, config) {
+  const dir = config.wxtDir;
+  const getTsconfigPath = (path6) => normalizePath(relative2(dir, path6));
+  const paths = Object.entries(config.alias).flatMap(([alias, absolutePath]) => {
+    const aliasPath = getTsconfigPath(absolutePath);
+    return [
+      `      "${alias}": ["${aliasPath}"]`,
+      `      "${alias}/*": ["${aliasPath}/*"]`
+    ];
+  }).join(",\n");
+  await writeFileIfDifferent(
+    resolve3(dir, "tsconfig.json"),
+    `{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "noEmit": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "paths": {
+${paths}
     }
-  };
+  },
+  "include": [
+    "${getTsconfigPath(config.root)}/**/*",
+    "./${getTsconfigPath(mainReference)}"
+  ],
+  "exclude": ["${getTsconfigPath(config.outBaseDir)}"]
+}`
+  );
 }
 
-// src/core/vite-plugins/webextensionPolyfillInlineDeps.ts
-function webextensionPolyfillInlineDeps() {
+// src/core/utils/building/get-internal-config.ts
+import { loadConfig } from "c12";
+import path4 from "node:path";
+
+// src/core/utils/cache.ts
+import fs4, { ensureDir } from "fs-extra";
+import { dirname as dirname2, resolve as resolve4 } from "path";
+function createFsCache(wxtDir) {
+  const getPath = (key) => resolve4(wxtDir, "cache", encodeURIComponent(key));
   return {
-    name: "wxt:testing-inline-deps",
-    config() {
-      const wxtModules = ["wxt/browser", "wxt/client"];
-      return {
-        test: {
-          server: {
-            deps: {
-              inline: [...wxtModules]
-            }
-          }
-        }
-      };
+    async set(key, value) {
+      const path6 = getPath(key);
+      await ensureDir(dirname2(path6));
+      await writeFileIfDifferent(path6, value);
+    },
+    async get(key) {
+      const path6 = getPath(key);
+      try {
+        return await fs4.readFile(path6, "utf-8");
+      } catch {
+        return void 0;
+      }
     }
   };
 }
 
-// src/core/vite-plugins/devHtmlPrerender.ts
+// src/core/utils/building/get-internal-config.ts
+import consola, { LogLevels } from "consola";
+
+// src/core/builders/vite/plugins/devHtmlPrerender.ts
 import { parseHTML } from "linkedom";
-import { dirname, isAbsolute, relative as relative2, resolve as resolve2 } from "path";
+import { dirname as dirname3, isAbsolute, relative as relative3, resolve as resolve5 } from "node:path";
 var reactRefreshPreamble = "";
 function devHtmlPrerender(config) {
   const htmlReloadId = "@wxt/reload-html";
-  const resolvedHtmlReloadId = resolve2(
+  const resolvedHtmlReloadId = resolve5(
     config.root,
     "node_modules/wxt/dist/virtual/reload-html.js"
   );
@@ -338,8 +548,8 @@ function devHtmlPrerender(config) {
             if (isAbsolute(src)) {
               element.setAttribute(attr, server.origin + src);
             } else if (src.startsWith(".")) {
-              const abs = resolve2(dirname(id), src);
-              const pathname = relative2(config.root, abs);
+              const abs = resolve5(dirname3(id), src);
+              const pathname = relative3(config.root, abs);
               element.setAttribute(attr, `${server.origin}/${pathname}`);
             }
           });
@@ -364,11 +574,7 @@ function devHtmlPrerender(config) {
         const originalUrl = `${server.origin}${ctx.path}`;
         const name = getEntrypointName(config.entrypointsDir, ctx.filename);
         const url = `${server.origin}/${name}.html`;
-        const serverHtml = await server.transformIndexHtml(
-          url,
-          html,
-          originalUrl
-        );
+        const serverHtml = await server.transformHtml(url, html, originalUrl);
         const { document } = parseHTML(serverHtml);
         const reactRefreshScript = Array.from(
           document.querySelectorAll("script[type=module]")
@@ -416,59 +622,135 @@ function devHtmlPrerender(config) {
   ];
 }
 
-// src/core/vite-plugins/devServerGlobals.ts
-function devServerGlobals(internalConfig) {
+// src/core/builders/vite/plugins/devServerGlobals.ts
+function devServerGlobals(config) {
   return {
     name: "wxt:dev-server-globals",
     config() {
-      if (internalConfig.server == null || internalConfig.command == "build")
+      if (config.server == null || config.command == "build")
         return;
       return {
         define: {
           __DEV_SERVER_PROTOCOL__: JSON.stringify("ws:"),
-          __DEV_SERVER_HOSTNAME__: JSON.stringify(
-            internalConfig.server.hostname
-          ),
-          __DEV_SERVER_PORT__: JSON.stringify(internalConfig.server.port)
+          __DEV_SERVER_HOSTNAME__: JSON.stringify(config.server.hostname),
+          __DEV_SERVER_PORT__: JSON.stringify(config.server.port)
         }
       };
     }
   };
 }
 
-// src/core/vite-plugins/multipageMove.ts
-import { dirname as dirname2, extname as extname2, resolve as resolve3 } from "node:path";
-import fs, { ensureDir } from "fs-extra";
-function multipageMove(entrypoints, config) {
-  return {
-    name: "wxt:multipage-move",
-    async writeBundle(_, bundle) {
-      for (const oldBundlePath in bundle) {
-        const entrypoint = entrypoints.find(
-          (entry) => !!normalizePath(entry.inputPath).endsWith(oldBundlePath)
-        );
-        if (entrypoint == null) {
-          config.logger.debug(
-            `No entrypoint found for ${oldBundlePath}, leaving in chunks directory`
-          );
-          continue;
-        }
-        const newBundlePath = getEntrypointBundlePath(
-          entrypoint,
-          config.outDir,
-          extname2(oldBundlePath)
-        );
-        if (newBundlePath === oldBundlePath) {
-          config.logger.debug(
+// src/core/utils/network.ts
+import dns from "node:dns";
+
+// src/core/utils/time.ts
+function formatDuration(duration) {
+  if (duration < 1e3)
+    return `${duration} ms`;
+  if (duration < 1e4)
+    return `${(duration / 1e3).toFixed(3)} s`;
+  if (duration < 6e4)
+    return `${(duration / 1e3).toFixed(1)} s`;
+  return `${(duration / 1e3).toFixed(0)} s`;
+}
+function withTimeout(promise, duration) {
+  return new Promise((res, rej) => {
+    const timeout = setTimeout(() => {
+      rej(`Promise timed out after ${duration}ms`);
+    }, duration);
+    promise.then(res).catch(rej).finally(() => clearTimeout(timeout));
+  });
+}
+
+// src/core/utils/network.ts
+function isOffline() {
+  const isOffline2 = new Promise((res) => {
+    dns.resolve("google.com", (err) => {
+      if (err == null) {
+        res(false);
+      } else {
+        res(true);
+      }
+    });
+  });
+  return withTimeout(isOffline2, 1e3).catch(() => true);
+}
+async function isOnline() {
+  const offline = await isOffline();
+  return !offline;
+}
+async function fetchCached(url, config) {
+  let content = "";
+  if (await isOnline()) {
+    const res = await fetch(url);
+    if (res.status < 300) {
+      content = await res.text();
+      await config.fsCache.set(url, content);
+    } else {
+      config.logger.debug(
+        `Failed to download "${url}", falling back to cache...`
+      );
+    }
+  }
+  if (!content)
+    content = await config.fsCache.get(url) ?? "";
+  if (!content)
+    throw Error(
+      `Offline and "${url}" has not been cached. Try again when online.`
+    );
+  return content;
+}
+
+// src/core/builders/vite/plugins/download.ts
+function download(config) {
+  return {
+    name: "wxt:download",
+    resolveId(id) {
+      if (id.startsWith("url:"))
+        return "\0" + id;
+    },
+    async load(id) {
+      if (!id.startsWith("\0url:"))
+        return;
+      const url = id.replace("\0url:", "");
+      return await fetchCached(url, config);
+    }
+  };
+}
+
+// src/core/builders/vite/plugins/multipageMove.ts
+import { dirname as dirname4, extname, resolve as resolve6, join } from "node:path";
+import fs5, { ensureDir as ensureDir2 } from "fs-extra";
+function multipageMove(entrypoints, config) {
+  return {
+    name: "wxt:multipage-move",
+    async writeBundle(_, bundle) {
+      for (const oldBundlePath in bundle) {
+        const entrypoint = entrypoints.find(
+          (entry) => !!normalizePath(entry.inputPath).endsWith(oldBundlePath)
+        );
+        if (entrypoint == null) {
+          config.logger.debug(
+            `No entrypoint found for ${oldBundlePath}, leaving in chunks directory`
+          );
+          continue;
+        }
+        const newBundlePath = getEntrypointBundlePath(
+          entrypoint,
+          config.outDir,
+          extname(oldBundlePath)
+        );
+        if (newBundlePath === oldBundlePath) {
+          config.logger.debug(
             "HTML file is already in the correct location",
             oldBundlePath
           );
           continue;
         }
-        const oldAbsPath = resolve3(config.outDir, oldBundlePath);
-        const newAbsPath = resolve3(config.outDir, newBundlePath);
-        await ensureDir(dirname2(newAbsPath));
-        await fs.move(oldAbsPath, newAbsPath, { overwrite: true });
+        const oldAbsPath = resolve6(config.outDir, oldBundlePath);
+        const newAbsPath = resolve6(config.outDir, newBundlePath);
+        await ensureDir2(dirname4(newAbsPath));
+        await fs5.move(oldAbsPath, newAbsPath, { overwrite: true });
         const renamedChunk = {
           ...bundle[oldBundlePath],
           fileName: newBundlePath
@@ -476,13 +758,59 @@ function multipageMove(entrypoints, config) {
         delete bundle[oldBundlePath];
         bundle[newBundlePath] = renamedChunk;
       }
+      removeEmptyDirs(config.outDir);
     }
   };
 }
+async function removeEmptyDirs(dir) {
+  const files = await fs5.readdir(dir);
+  for (const file of files) {
+    const filePath = join(dir, file);
+    const stats = await fs5.stat(filePath);
+    if (stats.isDirectory()) {
+      await removeEmptyDirs(filePath);
+    }
+  }
+  try {
+    await fs5.rmdir(dir);
+  } catch {
+  }
+}
 
-// src/core/vite-plugins/virtualEntrypoint.ts
-import fs2 from "fs-extra";
-import { resolve as resolve4 } from "path";
+// src/core/builders/vite/plugins/unimport.ts
+import { createUnimport as createUnimport2 } 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 = getUnimportOptions(config);
+  if (options === false)
+    return [];
+  const unimport2 = createUnimport2(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;
+      return unimport2.injectImports(code, id);
+    }
+  };
+}
+
+// src/core/builders/vite/plugins/virtualEntrypoint.ts
+import fs6 from "fs-extra";
+import { resolve as resolve7 } from "path";
 function virtualEntrypoint(type, config) {
   const virtualId = `virtual:wxt-${type}?`;
   const resolvedVirtualId = `\0${virtualId}`;
@@ -499,8 +827,8 @@ function virtualEntrypoint(type, config) {
       if (!id.startsWith(resolvedVirtualId))
         return;
       const inputPath = id.replace(resolvedVirtualId, "");
-      const template = await fs2.readFile(
-        resolve4(
+      const template = await fs6.readFile(
+        resolve7(
           config.root,
           `node_modules/wxt/dist/virtual/${type}-entrypoint.js`
         ),
@@ -511,7 +839,24 @@ function virtualEntrypoint(type, config) {
   };
 }
 
-// src/core/vite-plugins/noopBackground.ts
+// src/core/builders/vite/plugins/tsconfigPaths.ts
+function tsconfigPaths(config) {
+  return {
+    name: "wxt:aliases",
+    async config() {
+      return {
+        resolve: {
+          alias: config.alias
+        }
+      };
+    }
+  };
+}
+
+// src/core/utils/constants.ts
+var VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";
+
+// src/core/builders/vite/plugins/noopBackground.ts
 function noopBackground() {
   const virtualModuleId = VIRTUAL_NOOP_BACKGROUND_MODULE_ID;
   const resolvedVirtualModuleId = "\0" + virtualModuleId;
@@ -529,9 +874,8 @@ export default defineBackground(() => void 0)`;
     }
   };
 }
-var VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";
 
-// src/core/vite-plugins/cssEntrypoints.ts
+// src/core/builders/vite/plugins/cssEntrypoints.ts
 function cssEntrypoints(entrypoint, config) {
   return {
     name: "wxt:css-entrypoint",
@@ -543,570 +887,322 @@ function cssEntrypoints(entrypoint, config) {
               assetFileNames: () => getEntrypointBundlePath(entrypoint, config.outDir, ".css")
             }
           }
-        }
-      };
-    },
-    generateBundle(_, bundle) {
-      Object.keys(bundle).forEach((file) => {
-        if (file.endsWith(".js"))
-          delete bundle[file];
-      });
-    }
-  };
-}
-
-// src/core/vite-plugins/bundleAnalysis.ts
-import { visualizer } from "rollup-plugin-visualizer";
-var increment = 0;
-function bundleAnalysis() {
-  return visualizer({
-    emitFile: true,
-    template: "raw-data",
-    filename: `stats-${increment++}.json`
-  });
-}
-
-// src/core/vite-plugins/excludeBrowserPolyfill.ts
-function excludeBrowserPolyfill(config) {
-  const virtualId = "virtual:wxt-webextension-polyfill-disabled";
-  return {
-    name: "wxt:exclude-browser-polyfill",
-    config() {
-      if (config.experimental.includeBrowserPolyfill)
-        return;
-      return {
-        resolve: {
-          alias: {
-            "webextension-polyfill": virtualId
-          }
-        }
-      };
-    },
-    load(id) {
-      if (id === virtualId) {
-        return "export default chrome";
-      }
-    }
-  };
-}
-
-// src/core/utils/arrays.ts
-function every(array, predicate) {
-  for (let i = 0; i < array.length; i++)
-    if (!predicate(array[i], i))
-      return false;
-  return true;
-}
-
-// src/core/utils/building/detect-dev-changes.ts
-function detectDevChanges(changedFiles, currentOutput) {
-  if (currentOutput == null)
-    return { type: "no-change" };
-  const changedSteps = new Set(
-    changedFiles.flatMap(
-      (changedFile) => findEffectedSteps(changedFile, currentOutput)
-    )
-  );
-  if (changedSteps.size === 0)
-    return { type: "no-change" };
-  const unchangedOutput = {
-    manifest: currentOutput.manifest,
-    steps: [],
-    publicAssets: []
-  };
-  const changedOutput = {
-    manifest: currentOutput.manifest,
-    steps: [],
-    publicAssets: []
-  };
-  for (const step of currentOutput.steps) {
-    if (changedSteps.has(step)) {
-      changedOutput.steps.push(step);
-    } else {
-      unchangedOutput.steps.push(step);
-    }
-  }
-  for (const asset of currentOutput.publicAssets) {
-    if (changedSteps.has(asset)) {
-      changedOutput.publicAssets.push(asset);
-    } else {
-      unchangedOutput.publicAssets.push(asset);
-    }
-  }
-  const isOnlyHtmlChanges = changedFiles.length > 0 && every(changedFiles, ([_, file]) => file.endsWith(".html"));
-  if (isOnlyHtmlChanges) {
-    return {
-      type: "html-reload",
-      cachedOutput: unchangedOutput,
-      rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
-    };
-  }
-  const isOnlyContentScripts = changedOutput.steps.length > 0 && every(
-    changedOutput.steps.flatMap((step) => step.entrypoints),
-    (entry) => entry.type === "content-script"
-  );
-  if (isOnlyContentScripts) {
-    return {
-      type: "content-script-reload",
-      cachedOutput: unchangedOutput,
-      changedSteps: changedOutput.steps,
-      rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
-    };
-  }
-  return {
-    type: "extension-reload",
-    cachedOutput: unchangedOutput,
-    rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
-  };
-}
-function findEffectedSteps(changedFile, currentOutput) {
-  const changes = [];
-  const changedPath = normalizePath(changedFile[1]);
-  const isChunkEffected = (chunk) => (
-    // If it's an HTML file with the same path, is is effected because HTML files need to be pre-rendered
-    // fileName is normalized, relative bundle path
-    chunk.type === "asset" && changedPath.endsWith(chunk.fileName) || // If it's a chunk that depends on the changed file, it is effected
-    // moduleIds are absolute, normalized paths
-    chunk.type === "chunk" && chunk.moduleIds.includes(changedPath)
-  );
-  for (const step of currentOutput.steps) {
-    const effectedChunk = step.chunks.find((chunk) => isChunkEffected(chunk));
-    if (effectedChunk)
-      changes.push(step);
-  }
-  const effectedAsset = currentOutput.publicAssets.find(
-    (chunk) => isChunkEffected(chunk)
-  );
-  if (effectedAsset)
-    changes.push(effectedAsset);
-  return changes;
-}
-
-// src/core/utils/building/find-entrypoints.ts
-import { relative as relative4, resolve as resolve12 } from "path";
-import fs12 from "fs-extra";
-import { minimatch } from "minimatch";
-import { parseHTML as parseHTML2 } from "linkedom";
-import JSON5 from "json5";
-
-// src/core/utils/building/build-entrypoints.ts
-import * as vite from "vite";
-
-// src/core/utils/fs.ts
-import fs3 from "fs-extra";
-import glob from "fast-glob";
-import path3 from "node:path";
-async function writeFileIfDifferent(file, newContents) {
-  const existingContents = await fs3.readFile(file, "utf-8").catch(() => void 0);
-  if (existingContents !== newContents) {
-    await fs3.writeFile(file, newContents);
-  }
-}
-async function getPublicFiles(config) {
-  if (!await fs3.exists(config.publicDir))
-    return [];
-  const files = await glob("**/*", { cwd: config.publicDir });
-  return files.map(unnormalizePath);
-}
-async function removeEmptyDirs(dir) {
-  const files = await fs3.readdir(dir);
-  for (const file of files) {
-    const filePath = path3.join(dir, file);
-    const stats = await fs3.stat(filePath);
-    if (stats.isDirectory()) {
-      await removeEmptyDirs(filePath);
-    }
-  }
-  try {
-    await fs3.rmdir(dir);
-  } catch {
-  }
-}
-
-// src/core/utils/building/build-entrypoints.ts
-import fs4 from "fs-extra";
-import { dirname as dirname3, resolve as resolve5 } from "path";
-import pc from "picocolors";
-async function buildEntrypoints(groups, config, spinner) {
-  const steps = [];
-  for (let i = 0; i < groups.length; i++) {
-    const group = groups[i];
-    spinner.text = pc.dim(`[${i + 1}/${groups.length}]`) + ` ${[group].flat().map((e) => e.name).join(pc.dim(", "))}`;
-    const step = Array.isArray(group) ? await buildMultipleEntrypoints(group, config) : await buildSingleEntrypoint(group, config);
-    steps.push(step);
-  }
-  const publicAssets = await copyPublicDirectory(config);
-  await removeEmptyDirs(config.outDir);
-  return { publicAssets, steps };
-}
-async function buildSingleEntrypoint(entrypoint, config) {
-  const isVirtual = [
-    "background",
-    "content-script",
-    "unlisted-script"
-  ].includes(entrypoint.type);
-  const entry = isVirtual ? `virtual:wxt-${entrypoint.type}?${entrypoint.inputPath}` : entrypoint.inputPath;
-  const plugins = [];
-  if (entrypoint.type === "content-script-style" || entrypoint.type === "unlisted-style") {
-    plugins.push(cssEntrypoints(entrypoint, config));
-  }
-  const libMode = {
-    mode: config.mode,
-    plugins,
-    build: {
-      lib: {
-        entry,
-        formats: ["iife"],
-        name: "_",
-        fileName: entrypoint.name
-      },
-      rollupOptions: {
-        output: {
-          // There's only a single output for this build, so we use the desired bundle path for the
-          // entry output (like "content-scripts/overlay.js")
-          entryFileNames: getEntrypointBundlePath(
-            entrypoint,
-            config.outDir,
-            ".js"
-          ),
-          // Output content script CSS to `content-scripts/`, but all other scripts are written to
-          // `assets/`.
-          assetFileNames: ({ name }) => {
-            if (entrypoint.type === "content-script" && name?.endsWith("css")) {
-              return `content-scripts/${entrypoint.name}.[ext]`;
-            } else {
-              return `assets/${entrypoint.name}.[ext]`;
-            }
-          }
-        }
-      }
-    },
-    define: {
-      // See https://github.com/aklinker1/vite-plugin-web-extension/issues/96
-      "process.env.NODE_ENV": JSON.stringify(config.mode)
-    }
-  };
-  for (const global of getEntrypointGlobals(config, entrypoint.name)) {
-    libMode.define[global.name] = JSON.stringify(global.value);
-  }
-  const entryConfig = vite.mergeConfig(
-    libMode,
-    await config.vite(config.env)
-  );
-  const result = await vite.build(entryConfig);
-  return {
-    entrypoints: entrypoint,
-    chunks: getBuildOutputChunks(result)
-  };
-}
-async function buildMultipleEntrypoints(entrypoints, config) {
-  const multiPage = {
-    mode: config.mode,
-    plugins: [multipageMove(entrypoints, config)],
-    build: {
-      rollupOptions: {
-        input: entrypoints.reduce((input, entry) => {
-          input[entry.name] = entry.inputPath;
-          return input;
-        }, {}),
-        output: {
-          // Include a hash to prevent conflicts
-          chunkFileNames: "chunks/[name]-[hash].js",
-          // Include a hash to prevent conflicts
-          entryFileNames: "chunks/[name]-[hash].js",
-          // We can't control the "name", so we need a hash to prevent conflicts
-          assetFileNames: "assets/[name]-[hash].[ext]"
-        }
-      }
-    },
-    define: {}
-  };
-  for (const global of getEntrypointGlobals(config, "html")) {
-    multiPage.define[global.name] = JSON.stringify(global.value);
-  }
-  const entryConfig = vite.mergeConfig(
-    multiPage,
-    await config.vite(config.env)
-  );
-  const result = await vite.build(entryConfig);
-  return {
-    entrypoints,
-    chunks: getBuildOutputChunks(result)
-  };
-}
-function getBuildOutputChunks(result) {
-  if ("on" in result)
-    throw Error("wxt does not support vite watch mode.");
-  if (Array.isArray(result))
-    return result.flatMap(({ output }) => output);
-  return result.output;
-}
-async function copyPublicDirectory(config) {
-  const files = await getPublicFiles(config);
-  if (files.length === 0)
-    return [];
-  const publicAssets = [];
-  for (const file of files) {
-    const srcPath = resolve5(config.publicDir, file);
-    const outPath = resolve5(config.outDir, file);
-    await fs4.ensureDir(dirname3(outPath));
-    await fs4.copyFile(srcPath, outPath);
-    publicAssets.push({
-      type: "asset",
-      fileName: file,
-      name: file,
-      needsCodeReference: false,
-      source: await fs4.readFile(srcPath)
-    });
-  }
-  return publicAssets;
-}
-
-// src/core/utils/building/generate-wxt-dir.ts
-import { createUnimport as createUnimport2 } from "unimport";
-import fs5 from "fs-extra";
-import { relative as relative3, resolve as resolve6 } from "path";
-import path4 from "node:path";
-
-// src/core/utils/i18n.ts
-var predefinedMessages = {
-  "@@extension_id": {
-    message: "<browser.runtime.id>",
-    description: "The extension or app ID; you might use this string to construct URLs for resources inside the extension. Even unlocalized extensions can use this message.\nNote: You can't use this message in a manifest file."
-  },
-  "@@ui_locale": {
-    message: "<browser.i18n.getUiLocale()>",
-    description: ""
-  },
-  "@@bidi_dir": {
-    message: "<ltr|rtl>",
-    description: 'The text direction for the current locale, either "ltr" for left-to-right languages such as English or "rtl" for right-to-left languages such as Japanese.'
-  },
-  "@@bidi_reversed_dir": {
-    message: "<rtl|ltr>",
-    description: `If the @@bidi_dir is "ltr", then this is "rtl"; otherwise, it's "ltr".`
-  },
-  "@@bidi_start_edge": {
-    message: "<left|right>",
-    description: `If the @@bidi_dir is "ltr", then this is "left"; otherwise, it's "right".`
-  },
-  "@@bidi_end_edge": {
-    message: "<right|left>",
-    description: `If the @@bidi_dir is "ltr", then this is "right"; otherwise, it's "left".`
-  }
-};
-function parseI18nMessages(messagesJson) {
-  return Object.entries({
-    ...predefinedMessages,
-    ...messagesJson
-  }).map(([name, details]) => ({
-    name,
-    ...details
-  }));
-}
-
-// src/core/utils/building/generate-wxt-dir.ts
-async function generateTypesDir(entrypoints, config) {
-  await fs5.ensureDir(config.typesDir);
-  const references = [];
-  const imports = getUnimportOptions(config);
-  if (imports !== false) {
-    references.push(await writeImportsDeclarationFile(config, imports));
-  }
-  references.push(await writePathsDeclarationFile(entrypoints, config));
-  references.push(await writeI18nDeclarationFile(config));
-  references.push(await writeGlobalsDeclarationFile(config));
-  const mainReference = await writeMainDeclarationFile(references, config);
-  await writeTsConfigFile(mainReference, config);
-}
-async function writeImportsDeclarationFile(config, unimportOptions) {
-  const filePath = resolve6(config.typesDir, "imports.d.ts");
-  const unimport2 = createUnimport2(unimportOptions);
-  await unimport2.scanImportsFromDir(void 0, { cwd: config.srcDir });
-  await writeFileIfDifferent(
-    filePath,
-    ["// Generated by wxt", await unimport2.generateTypeDeclarations()].join(
-      "\n"
-    ) + "\n"
-  );
-  return filePath;
-}
-async function writePathsDeclarationFile(entrypoints, config) {
-  const filePath = resolve6(config.typesDir, "paths.d.ts");
-  const unions = entrypoints.map(
-    (entry) => getEntrypointBundlePath(
-      entry,
-      config.outDir,
-      entry.inputPath.endsWith(".html") ? ".html" : ".js"
-    )
-  ).concat(await getPublicFiles(config)).map(normalizePath).map((path7) => `    | "/${path7}"`).sort().join("\n");
-  const template = `// Generated by wxt
-import "wxt/browser";
-
-declare module "wxt/browser" {
-  export type PublicPath =
-{{ union }}
-  export interface WxtRuntime extends Runtime.Static {
-    getURL(path: PublicPath): string;
-  }
-}
-`;
-  await writeFileIfDifferent(
-    filePath,
-    template.replace("{{ union }}", unions || "    | never")
-  );
-  return filePath;
-}
-async function writeI18nDeclarationFile(config) {
-  const filePath = resolve6(config.typesDir, "i18n.d.ts");
-  const defaultLocale = config.manifest.default_locale;
-  const template = `// Generated by wxt
-import "wxt/browser";
-
-declare module "wxt/browser" {
-  /**
-   * See https://developer.chrome.com/docs/extensions/reference/i18n/#method-getMessage
-   */
-  interface GetMessageOptions {
-    /**
-     * See https://developer.chrome.com/docs/extensions/reference/i18n/#method-getMessage
-     */
-    escapeLt?: boolean
-  }
-
-  export interface WxtI18n extends I18n.Static {
-{{ overrides }}
-  }
+        }
+      };
+    },
+    generateBundle(_, bundle) {
+      Object.keys(bundle).forEach((file) => {
+        if (file.endsWith(".js"))
+          delete bundle[file];
+      });
+    }
+  };
 }
-`;
-  let messages;
-  if (defaultLocale) {
-    const defaultLocalePath = path4.resolve(
-      config.publicDir,
-      "_locales",
-      defaultLocale,
-      "messages.json"
-    );
-    const content = JSON.parse(await fs5.readFile(defaultLocalePath, "utf-8"));
-    messages = parseI18nMessages(content);
-  } else {
-    messages = parseI18nMessages({});
-  }
-  const overrides = messages.map((message) => {
-    return `    /**
-     * ${message.description ?? "No message description."}
-     *
-     * "${message.message}"
-     */
-    getMessage(
-      messageName: "${message.name}",
-      substitutions?: string | string[],
-      options?: GetMessageOptions,
-    ): string;`;
+
+// src/core/builders/vite/plugins/bundleAnalysis.ts
+import { visualizer } from "rollup-plugin-visualizer";
+var increment = 0;
+function bundleAnalysis() {
+  return visualizer({
+    emitFile: true,
+    template: "raw-data",
+    filename: `stats-${increment++}.json`
   });
-  await writeFileIfDifferent(
-    filePath,
-    template.replace("{{ overrides }}", overrides.join("\n"))
-  );
-  return filePath;
-}
-async function writeGlobalsDeclarationFile(config) {
-  const filePath = resolve6(config.typesDir, "globals.d.ts");
-  const globals2 = [...getGlobals(config), ...getEntrypointGlobals(config, "")];
-  await writeFileIfDifferent(
-    filePath,
-    [
-      "// Generated by wxt",
-      "export {}",
-      "declare global {",
-      ...globals2.map((global) => `  const ${global.name}: ${global.type};`),
-      "}"
-    ].join("\n") + "\n"
-  );
-  return filePath;
 }
-async function writeMainDeclarationFile(references, config) {
-  const dir = config.wxtDir;
-  const filePath = resolve6(dir, "wxt.d.ts");
-  await writeFileIfDifferent(
-    filePath,
-    [
-      "// Generated by wxt",
-      `/// <reference types="vite/client" />`,
-      ...references.map(
-        (ref) => `/// <reference types="./${normalizePath(relative3(dir, ref))}" />`
-      )
-    ].join("\n") + "\n"
-  );
-  return filePath;
+
+// src/core/builders/vite/plugins/globals.ts
+function globals(config) {
+  return {
+    name: "wxt:globals",
+    config() {
+      const define = {};
+      for (const global of getGlobals(config)) {
+        define[global.name] = JSON.stringify(global.value);
+      }
+      return {
+        define
+      };
+    }
+  };
 }
-async function writeTsConfigFile(mainReference, config) {
-  const dir = config.wxtDir;
-  const getTsconfigPath = (path7) => normalizePath(relative3(dir, path7));
-  const paths = Object.entries(config.alias).flatMap(([alias, absolutePath]) => {
-    const aliasPath = getTsconfigPath(absolutePath);
-    return [
-      `      "${alias}": ["${aliasPath}"]`,
-      `      "${alias}/*": ["${aliasPath}/*"]`
-    ];
-  }).join(",\n");
-  await writeFileIfDifferent(
-    resolve6(dir, "tsconfig.json"),
-    `{
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "noEmit": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "paths": {
-${paths}
+
+// src/core/builders/vite/plugins/webextensionPolyfillAlias.ts
+import path3 from "node:path";
+function webextensionPolyfillAlias(config) {
+  return {
+    name: "wxt:webextension-polyfill-test-alias",
+    config() {
+      return {
+        resolve: {
+          alias: {
+            "webextension-polyfill": path3.resolve(
+              config.root,
+              "node_modules/wxt/dist/virtual/mock-browser"
+            )
+          }
+        }
+      };
     }
-  },
-  "include": [
-    "${getTsconfigPath(config.root)}/**/*",
-    "./${getTsconfigPath(mainReference)}"
-  ],
-  "exclude": ["${getTsconfigPath(config.outBaseDir)}"]
-}`
-  );
+  };
 }
 
-// src/core/utils/building/get-internal-config.ts
-import { loadConfig } from "c12";
-import path5 from "node:path";
-import * as vite2 from "vite";
+// src/core/builders/vite/plugins/webextensionPolyfillInlineDeps.ts
+function webextensionPolyfillInlineDeps() {
+  return {
+    name: "wxt:testing-inline-deps",
+    config() {
+      const wxtModules = ["wxt/browser", "wxt/client"];
+      return {
+        test: {
+          server: {
+            deps: {
+              inline: [...wxtModules]
+            }
+          }
+        }
+      };
+    }
+  };
+}
 
-// src/core/utils/cache.ts
-import fs6, { ensureDir as ensureDir2 } from "fs-extra";
-import { dirname as dirname4, resolve as resolve7 } from "path";
-function createFsCache(wxtDir) {
-  const getPath = (key) => resolve7(wxtDir, "cache", encodeURIComponent(key));
+// src/core/builders/vite/plugins/excludeBrowserPolyfill.ts
+function excludeBrowserPolyfill(config) {
+  const virtualId = "virtual:wxt-webextension-polyfill-disabled";
   return {
-    async set(key, value) {
-      const path7 = getPath(key);
-      await ensureDir2(dirname4(path7));
-      await writeFileIfDifferent(path7, value);
+    name: "wxt:exclude-browser-polyfill",
+    config() {
+      if (config.experimental.includeBrowserPolyfill)
+        return;
+      return {
+        resolve: {
+          alias: {
+            "webextension-polyfill": virtualId
+          }
+        }
+      };
     },
-    async get(key) {
-      const path7 = getPath(key);
-      try {
-        return await fs6.readFile(path7, "utf-8");
-      } catch {
-        return void 0;
+    load(id) {
+      if (id === virtualId) {
+        return "export default chrome";
+      }
+    }
+  };
+}
+
+// src/core/builders/vite/plugins/entrypointGroupGlobals.ts
+function entrypointGroupGlobals(entrypointGroup) {
+  return {
+    name: "wxt:entrypoint-group-globals",
+    config() {
+      const define = {};
+      let name = Array.isArray(entrypointGroup) ? "html" : entrypointGroup.name;
+      for (const global of getEntrypointGlobals(name)) {
+        define[global.name] = JSON.stringify(global.value);
+      }
+      return {
+        define
+      };
+    }
+  };
+}
+
+// src/core/builders/vite/index.ts
+async function craeteViteBuilder(inlineConfig, userConfig, wxtConfig) {
+  const vite = await import("vite");
+  const getBaseConfig = async () => {
+    const resolvedInlineConfig = await inlineConfig.vite?.(wxtConfig.env) ?? {};
+    const resolvedUserConfig = await userConfig.vite?.(wxtConfig.env) ?? {};
+    const config = vite.mergeConfig(
+      resolvedUserConfig,
+      resolvedInlineConfig
+    );
+    config.root = wxtConfig.root;
+    config.configFile = false;
+    config.logLevel = "warn";
+    config.mode = wxtConfig.mode;
+    config.build ??= {};
+    config.build.outDir = wxtConfig.outDir;
+    config.build.emptyOutDir = false;
+    config.plugins ??= [];
+    config.plugins.push(
+      download(wxtConfig),
+      devHtmlPrerender(wxtConfig),
+      unimport(wxtConfig),
+      virtualEntrypoint("background", wxtConfig),
+      virtualEntrypoint("content-script", wxtConfig),
+      virtualEntrypoint("unlisted-script", wxtConfig),
+      devServerGlobals(wxtConfig),
+      tsconfigPaths(wxtConfig),
+      noopBackground(),
+      globals(wxtConfig),
+      excludeBrowserPolyfill(wxtConfig)
+    );
+    if (wxtConfig.analysis.enabled) {
+      config.plugins.push(bundleAnalysis());
+    }
+    return config;
+  };
+  const getLibModeConfig = (entrypoint) => {
+    const isVirtual = [
+      "background",
+      "content-script",
+      "unlisted-script"
+    ].includes(entrypoint.type);
+    const entry = isVirtual ? `virtual:wxt-${entrypoint.type}?${entrypoint.inputPath}` : entrypoint.inputPath;
+    const plugins = [
+      entrypointGroupGlobals(entrypoint)
+    ];
+    if (entrypoint.type === "content-script-style" || entrypoint.type === "unlisted-style") {
+      plugins.push(cssEntrypoints(entrypoint, wxtConfig));
+    }
+    const libMode = {
+      mode: wxtConfig.mode,
+      plugins,
+      build: {
+        lib: {
+          entry,
+          formats: ["iife"],
+          name: "_",
+          fileName: entrypoint.name
+        },
+        rollupOptions: {
+          output: {
+            // There's only a single output for this build, so we use the desired bundle path for the
+            // entry output (like "content-scripts/overlay.js")
+            entryFileNames: getEntrypointBundlePath(
+              entrypoint,
+              wxtConfig.outDir,
+              ".js"
+            ),
+            // Output content script CSS to `content-scripts/`, but all other scripts are written to
+            // `assets/`.
+            assetFileNames: ({ name }) => {
+              if (entrypoint.type === "content-script" && name?.endsWith("css")) {
+                return `content-scripts/${entrypoint.name}.[ext]`;
+              } else {
+                return `assets/${entrypoint.name}.[ext]`;
+              }
+            }
+          }
+        }
+      },
+      define: {
+        // See https://github.com/aklinker1/vite-plugin-web-extension/issues/96
+        "process.env.NODE_ENV": JSON.stringify(wxtConfig.mode)
+      }
+    };
+    return libMode;
+  };
+  const getMultiPageConfig = (entrypoints) => {
+    return {
+      mode: wxtConfig.mode,
+      plugins: [
+        multipageMove(entrypoints, wxtConfig),
+        entrypointGroupGlobals(entrypoints)
+      ],
+      build: {
+        rollupOptions: {
+          input: entrypoints.reduce((input, entry) => {
+            input[entry.name] = entry.inputPath;
+            return input;
+          }, {}),
+          output: {
+            // Include a hash to prevent conflicts
+            chunkFileNames: "chunks/[name]-[hash].js",
+            // Include a hash to prevent conflicts
+            entryFileNames: "chunks/[name]-[hash].js",
+            // We can't control the "name", so we need a hash to prevent conflicts
+            assetFileNames: "assets/[name]-[hash].[ext]"
+          }
+        }
       }
+    };
+  };
+  const getCssConfig = (entrypoint) => {
+    return {
+      mode: wxtConfig.mode,
+      plugins: [entrypointGroupGlobals(entrypoint)],
+      build: {
+        rollupOptions: {
+          input: {
+            [entrypoint.name]: entrypoint.inputPath
+          },
+          output: {
+            assetFileNames: () => {
+              if (entrypoint.type === "content-script-style") {
+                return `content-scripts/${entrypoint.name}.[ext]`;
+              } else {
+                return `assets/${entrypoint.name}.[ext]`;
+              }
+            }
+          }
+        }
+      }
+    };
+  };
+  return {
+    name: "Vite",
+    version: vite.version,
+    async build(group) {
+      let entryConfig;
+      if (Array.isArray(group))
+        entryConfig = getMultiPageConfig(group);
+      else if (group.inputPath.endsWith(".css"))
+        entryConfig = getCssConfig(group);
+      else
+        entryConfig = getLibModeConfig(group);
+      const buildConfig = vite.mergeConfig(await getBaseConfig(), entryConfig);
+      const result = await vite.build(buildConfig);
+      return {
+        entrypoints: group,
+        chunks: getBuildOutputChunks(result)
+      };
+    },
+    async createServer(info) {
+      const serverConfig = {
+        server: {
+          port: info.port,
+          strictPort: true,
+          host: info.hostname,
+          origin: info.origin
+        }
+      };
+      const baseConfig = await getBaseConfig();
+      const viteServer = await vite.createServer(
+        vite.mergeConfig(baseConfig, serverConfig)
+      );
+      const server = {
+        async listen() {
+          await viteServer.listen(info.port);
+        },
+        transformHtml(...args) {
+          return viteServer.transformIndexHtml(...args);
+        },
+        ws: {
+          send(message, payload) {
+            return viteServer.ws.send(message, payload);
+          },
+          on(message, cb) {
+            viteServer.ws.on(message, cb);
+          }
+        },
+        watcher: viteServer.watcher
+      };
+      return server;
     }
   };
 }
+function getBuildOutputChunks(result) {
+  if ("on" in result)
+    throw Error("wxt does not support vite watch mode.");
+  if (Array.isArray(result))
+    return result.flatMap(({ output }) => output);
+  return result.output;
+}
 
 // src/core/utils/building/get-internal-config.ts
-import consola, { LogLevels } from "consola";
-import defu from "defu";
-async function getInternalConfig(inlineConfig, command) {
+import defu2 from "defu";
+async function getInternalConfig(inlineConfig, command, server) {
   let userConfig = {};
   let userConfigMetadata;
   if (inlineConfig.configFile !== false) {
@@ -1127,19 +1223,19 @@ async function getInternalConfig(inlineConfig, command) {
   const manifestVersion = mergedConfig.manifestVersion ?? (browser === "firefox" || browser === "safari" ? 2 : 3);
   const mode = mergedConfig.mode ?? (command === "build" ? "production" : "development");
   const env = { browser, command, manifestVersion, mode };
-  const root = path5.resolve(
+  const root = path4.resolve(
     inlineConfig.root ?? userConfig.root ?? process.cwd()
   );
-  const wxtDir = path5.resolve(root, ".wxt");
-  const srcDir = path5.resolve(root, mergedConfig.srcDir ?? root);
-  const entrypointsDir = path5.resolve(
+  const wxtDir = path4.resolve(root, ".wxt");
+  const srcDir = path4.resolve(root, mergedConfig.srcDir ?? root);
+  const entrypointsDir = path4.resolve(
     srcDir,
     mergedConfig.entrypointsDir ?? "entrypoints"
   );
-  const publicDir = path5.resolve(srcDir, mergedConfig.publicDir ?? "public");
-  const typesDir = path5.resolve(wxtDir, "types");
-  const outBaseDir = path5.resolve(root, mergedConfig.outDir ?? ".output");
-  const outDir = path5.resolve(outBaseDir, `${browser}-mv${manifestVersion}`);
+  const publicDir = path4.resolve(srcDir, mergedConfig.publicDir ?? "public");
+  const typesDir = path4.resolve(wxtDir, "types");
+  const outBaseDir = path4.resolve(root, mergedConfig.outDir ?? ".output");
+  const outDir = path4.resolve(outBaseDir, `${browser}-mv${manifestVersion}`);
   const runnerConfig = await loadConfig({
     name: "web-ext",
     cwd: root,
@@ -1155,7 +1251,7 @@ async function getInternalConfig(inlineConfig, command) {
       "~": srcDir,
       "@@": root,
       "~~": root
-    }).map(([key, value]) => [key, path5.resolve(root, value)])
+    }).map(([key, value]) => [key, path4.resolve(root, value)])
   );
   const finalConfig = {
     browser,
@@ -1176,8 +1272,6 @@ async function getInternalConfig(inlineConfig, command) {
     runnerConfig,
     srcDir,
     typesDir,
-    vite: () => ({}),
-    // Real value added after this object is initialized.
     wxtDir,
     zip: resolveInternalZipConfig(root, mergedConfig),
     transformManifest(manifest) {
@@ -1192,10 +1286,18 @@ async function getInternalConfig(inlineConfig, command) {
     alias,
     experimental: {
       includeBrowserPolyfill: mergedConfig.experimental?.includeBrowserPolyfill ?? true
-    }
+    },
+    server
+  };
+  const builder = await craeteViteBuilder(
+    inlineConfig,
+    userConfig,
+    finalConfig
+  );
+  return {
+    ...finalConfig,
+    builder
   };
-  finalConfig.vite = (env2) => resolveInternalViteConfig(env2, mergedConfig, finalConfig);
-  return finalConfig;
 }
 async function resolveManifestConfig(env, manifest) {
   return await (typeof manifest === "function" ? manifest(env) : manifest ?? {});
@@ -1207,26 +1309,18 @@ function mergeInlineConfig(inlineConfig, userConfig) {
   } else if (userConfig.imports == null && inlineConfig.imports == null) {
     imports = void 0;
   } else {
-    imports = vite2.mergeConfig(
-      userConfig.imports ?? {},
-      inlineConfig.imports ?? {}
-    );
+    imports = defu2(inlineConfig.imports ?? {}, userConfig.imports ?? {});
   }
   const manifest = async (env) => {
     const user = await resolveManifestConfig(env, userConfig.manifest);
     const inline = await resolveManifestConfig(env, inlineConfig.manifest);
-    return vite2.mergeConfig(user, inline);
+    return defu2(inline, user);
   };
-  const viteConfig = async (env) => {
-    const user = await userConfig.vite?.(env);
-    const inline = await inlineConfig.vite?.(env);
-    return vite2.mergeConfig(user ?? {}, inline ?? {});
-  };
-  const runner = defu(
+  const runner = defu2(
     inlineConfig.runner ?? {},
     userConfig.runner ?? {}
   );
-  const zip = defu(
+  const zip = defu2(
     inlineConfig.zip ?? {},
     userConfig.zip ?? {}
   );
@@ -1245,7 +1339,6 @@ function mergeInlineConfig(inlineConfig, userConfig) {
     runner,
     srcDir: inlineConfig.srcDir ?? userConfig.srcDir,
     outDir: inlineConfig.outDir ?? userConfig.outDir,
-    vite: viteConfig,
     zip,
     analysis: {
       enabled: inlineConfig.analysis?.enabled ?? userConfig.analysis?.enabled,
@@ -1259,6 +1352,7 @@ function mergeInlineConfig(inlineConfig, userConfig) {
       ...userConfig.experimental,
       ...inlineConfig.experimental
     },
+    vite: void 0,
     transformManifest: void 0
   };
 }
@@ -1283,38 +1377,6 @@ function resolveInternalZipConfig(root, mergedConfig) {
     ]
   };
 }
-async function resolveInternalViteConfig(env, mergedConfig, finalConfig) {
-  const internalVite = await mergedConfig.vite?.(env) ?? {};
-  internalVite.root = finalConfig.root;
-  internalVite.configFile = false;
-  internalVite.logLevel = "warn";
-  internalVite.mode = env.mode;
-  internalVite.build ??= {};
-  internalVite.build.outDir = finalConfig.outDir;
-  internalVite.build.emptyOutDir = false;
-  internalVite.plugins ??= [];
-  internalVite.plugins.push(download(finalConfig));
-  internalVite.plugins.push(devHtmlPrerender(finalConfig));
-  internalVite.plugins.push(unimport(finalConfig));
-  internalVite.plugins.push(
-    virtualEntrypoint("background", finalConfig)
-  );
-  internalVite.plugins.push(
-    virtualEntrypoint("content-script", finalConfig)
-  );
-  internalVite.plugins.push(
-    virtualEntrypoint("unlisted-script", finalConfig)
-  );
-  internalVite.plugins.push(devServerGlobals(finalConfig));
-  internalVite.plugins.push(tsconfigPaths(finalConfig));
-  internalVite.plugins.push(noopBackground());
-  if (finalConfig.analysis.enabled) {
-    internalVite.plugins.push(bundleAnalysis());
-  }
-  internalVite.plugins.push(globals(finalConfig));
-  internalVite.plugins.push(excludeBrowserPolyfill(finalConfig));
-  return internalVite;
-}
 
 // src/core/utils/building/group-entrypoints.ts
 function groupEntrypoints(entrypoints) {
@@ -1378,16 +1440,16 @@ ${noImports}`;
 
 // src/core/utils/building/import-entrypoint.ts
 import { transformSync } from "esbuild";
-async function importEntrypointFile(path7, config) {
-  config.logger.debug("Loading file metadata:", path7);
-  const normalPath = normalizePath(path7);
+async function importEntrypointFile(path6, config) {
+  config.logger.debug("Loading file metadata:", path6);
+  const normalPath = normalizePath(path6);
   const unimport2 = createUnimport3({
     ...getUnimportOptions(config),
     // Only allow specific imports, not all from the project
     dirs: []
   });
   await unimport2.init();
-  const text = await fs7.readFile(path7, "utf-8");
+  const text = await fs7.readFile(path6, "utf-8");
   const textNoImports = removeProjectImportStatements(text);
   const { code } = await unimport2.injectImports(textNoImports);
   config.logger.debug(
@@ -1418,7 +1480,7 @@ async function importEntrypointFile(path7, config) {
     }
   });
   try {
-    const res = await jiti(path7);
+    const res = await jiti(path6);
     return res.default;
   } catch (err) {
     config.logger.error(err);
@@ -1436,14 +1498,13 @@ function getEsbuildOptions(opts) {
 
 // src/core/utils/building/internal-build.ts
 import pc4 from "picocolors";
-import * as vite3 from "vite";
 import fs11 from "fs-extra";
 
 // src/core/utils/log/printBuildSummary.ts
 import { resolve as resolve9 } from "path";
 
 // src/core/utils/log/printFileList.ts
-import path6 from "node:path";
+import path5 from "node:path";
 import pc2 from "picocolors";
 import fs8 from "fs-extra";
 import { filesize } from "filesize";
@@ -1481,8 +1542,8 @@ async function printFileList(log, header, baseDir, files) {
   const fileRows = await Promise.all(
     files.map(async (file, i) => {
       const parts = [
-        path6.relative(process.cwd(), baseDir) + path6.sep,
-        path6.relative(baseDir, file)
+        path5.relative(process.cwd(), baseDir) + path5.sep,
+        path5.relative(baseDir, file)
       ];
       const prefix = i === files.length - 1 ? "  \u2514\u2500" : "  \u251C\u2500";
       const color = getChunkColor(file);
@@ -1673,37 +1734,34 @@ async function getPackageJson(config) {
 
 // src/core/utils/manifest.ts
 import { produce } from "immer";
-import defu2 from "defu";
+import defu3 from "defu";
 async function writeManifest(manifest, output, config) {
   const str = config.mode === "production" ? JSON.stringify(manifest) : JSON.stringify(manifest, null, 2);
   await fs10.ensureDir(config.outDir);
   await writeFileIfDifferent(resolve11(config.outDir, "manifest.json"), str);
   output.publicAssets.unshift({
     type: "asset",
-    fileName: "manifest.json",
-    name: "manifest",
-    needsCodeReference: false,
-    source: str
+    fileName: "manifest.json"
   });
 }
 async function generateMainfest(entrypoints, buildOutput, config) {
   const pkg = await getPackageJson(config);
   const versionName = config.manifest.version_name ?? pkg?.version;
-  const version3 = config.manifest.version ?? simplifyVersion(pkg?.version);
+  const version2 = config.manifest.version ?? simplifyVersion(pkg?.version);
   const baseManifest = {
     manifest_version: config.manifestVersion,
     name: pkg?.name,
     description: pkg?.description,
-    version: version3,
+    version: version2,
     version_name: (
       // Firefox doesn't support version_name
-      config.browser === "firefox" || versionName === version3 ? void 0 : versionName
+      config.browser === "firefox" || versionName === version2 ? void 0 : versionName
     ),
     short_name: pkg?.shortName,
     icons: discoverIcons(buildOutput)
   };
   const userManifest = config.manifest;
-  const manifest = defu2(
+  const manifest = defu3(
     userManifest,
     baseManifest
   );
@@ -1725,14 +1783,14 @@ async function generateMainfest(entrypoints, buildOutput, config) {
   return finalManifest;
 }
 function simplifyVersion(versionName) {
-  const version3 = /^((0|[1-9][0-9]{0,8})([.](0|[1-9][0-9]{0,8})){0,3}).*$/.exec(
+  const version2 = /^((0|[1-9][0-9]{0,8})([.](0|[1-9][0-9]{0,8})){0,3}).*$/.exec(
     versionName
   )?.[1];
-  if (version3 == null)
+  if (version2 == null)
     throw Error(
       `Cannot simplify package.json version "${versionName}" to a valid extension version, "X.Y.Z"`
     );
-  return version3;
+  return version2;
 }
 function addEntrypoints(manifest, entrypoints, buildOutput, config) {
   const entriesByType = entrypoints.reduce((map, entrypoint) => {
@@ -2104,7 +2162,7 @@ async function internalBuild(config) {
   const target = `${config.browser}-mv${config.manifestVersion}`;
   config.logger.info(
     `${verb} ${pc4.cyan(target)} for ${pc4.cyan(config.mode)} with ${pc4.green(
-      `Vite ${vite3.version}`
+      `${config.builder.name} ${config.builder.version}`
     )}`
   );
   const startTime = Date.now();
@@ -2130,7 +2188,7 @@ async function internalBuild(config) {
   return output;
 }
 async function combineAnalysisStats(config) {
-  const { execaCommand } = await import("./execa-Z7B33P3C.js");
+  const { execaCommand } = await import("./execa-4F7CCWCA.js");
   const unixFiles = await glob2(`stats-*.json`, {
     cwd: config.outDir,
     absolute: true
@@ -2153,7 +2211,7 @@ async function findEntrypoints(config) {
   let hasBackground = false;
   const possibleEntrypoints = await Promise.all(
     relativePaths.map(async (relativePath) => {
-      const path7 = resolve12(config.entrypointsDir, relativePath);
+      const path6 = resolve12(config.entrypointsDir, relativePath);
       const matchingGlob = pathGlobs.find(
         (glob4) => minimatch(relativePath, glob4)
       );
@@ -2173,23 +2231,23 @@ ${JSON.stringify(
         return;
       switch (type) {
         case "popup":
-          return await getPopupEntrypoint(config, path7);
+          return await getPopupEntrypoint(config, path6);
         case "options":
-          return await getOptionsEntrypoint(config, path7);
+          return await getOptionsEntrypoint(config, path6);
         case "background":
           hasBackground = true;
-          return await getBackgroundEntrypoint(config, path7);
+          return await getBackgroundEntrypoint(config, path6);
         case "content-script":
-          return await getContentScriptEntrypoint(config, path7);
+          return await getContentScriptEntrypoint(config, path6);
         case "unlisted-page":
-          return await getUnlistedPageEntrypoint(config, path7);
+          return await getUnlistedPageEntrypoint(config, path6);
         case "unlisted-script":
-          return await getUnlistedScriptEntrypoint(config, path7);
+          return await getUnlistedScriptEntrypoint(config, path6);
         case "content-script-style":
           return {
             type,
-            name: getEntrypointName(config.entrypointsDir, path7),
-            inputPath: path7,
+            name: getEntrypointName(config.entrypointsDir, path6),
+            inputPath: path6,
             outputDir: resolve12(config.outDir, CONTENT_SCRIPT_OUT_DIR),
             options: {
               include: void 0,
@@ -2199,8 +2257,8 @@ ${JSON.stringify(
         default:
           return {
             type,
-            name: getEntrypointName(config.entrypointsDir, path7),
-            inputPath: path7,
+            name: getEntrypointName(config.entrypointsDir, path6),
+            inputPath: path6,
             outputDir: config.outDir,
             options: {
               include: void 0,
@@ -2263,8 +2321,8 @@ function getHtmlBaseOptions(document) {
   }
   return options;
 }
-async function getPopupEntrypoint(config, path7) {
-  const content = await fs12.readFile(path7, "utf-8");
+async function getPopupEntrypoint(config, path6) {
+  const content = await fs12.readFile(path6, "utf-8");
   const { document } = parseHTML2(content);
   const options = getHtmlBaseOptions(document);
   const title = document.querySelector("title");
@@ -2293,12 +2351,12 @@ async function getPopupEntrypoint(config, path7) {
     type: "popup",
     name: "popup",
     options,
-    inputPath: path7,
+    inputPath: path6,
     outputDir: config.outDir
   };
 }
-async function getOptionsEntrypoint(config, path7) {
-  const content = await fs12.readFile(path7, "utf-8");
+async function getOptionsEntrypoint(config, path6) {
+  const content = await fs12.readFile(path6, "utf-8");
   const { document } = parseHTML2(content);
   const options = getHtmlBaseOptions(document);
   const openInTabContent = document.querySelector("meta[name='manifest.open_in_tab']")?.getAttribute("content");
@@ -2317,25 +2375,25 @@ async function getOptionsEntrypoint(config, path7) {
     type: "options",
     name: "options",
     options,
-    inputPath: path7,
+    inputPath: path6,
     outputDir: config.outDir
   };
 }
-async function getUnlistedPageEntrypoint(config, path7) {
-  const content = await fs12.readFile(path7, "utf-8");
+async function getUnlistedPageEntrypoint(config, path6) {
+  const content = await fs12.readFile(path6, "utf-8");
   const { document } = parseHTML2(content);
   return {
     type: "unlisted-page",
-    name: getEntrypointName(config.entrypointsDir, path7),
-    inputPath: path7,
+    name: getEntrypointName(config.entrypointsDir, path6),
+    inputPath: path6,
     outputDir: config.outDir,
     options: getHtmlBaseOptions(document)
   };
 }
-async function getUnlistedScriptEntrypoint(config, path7) {
-  const name = getEntrypointName(config.entrypointsDir, path7);
+async function getUnlistedScriptEntrypoint(config, path6) {
+  const name = getEntrypointName(config.entrypointsDir, path6);
   const defaultExport = await importEntrypointFile(
-    path7,
+    path6,
     config
   );
   if (defaultExport == null) {
@@ -2348,17 +2406,17 @@ async function getUnlistedScriptEntrypoint(config, path7) {
   return {
     type: "unlisted-script",
     name,
-    inputPath: path7,
+    inputPath: path6,
     outputDir: config.outDir,
     options
   };
 }
-async function getBackgroundEntrypoint(config, path7) {
+async function getBackgroundEntrypoint(config, path6) {
   const name = "background";
   let options = {};
-  if (path7 !== VIRTUAL_NOOP_BACKGROUND_MODULE_ID) {
+  if (path6 !== VIRTUAL_NOOP_BACKGROUND_MODULE_ID) {
     const defaultExport = await importEntrypointFile(
-      path7,
+      path6,
       config
     );
     if (defaultExport == null) {
@@ -2372,7 +2430,7 @@ async function getBackgroundEntrypoint(config, path7) {
   return {
     type: "background",
     name,
-    inputPath: path7,
+    inputPath: path6,
     outputDir: config.outDir,
     options: {
       ...options,
@@ -2381,9 +2439,9 @@ async function getBackgroundEntrypoint(config, path7) {
     }
   };
 }
-async function getContentScriptEntrypoint(config, path7) {
-  const name = getEntrypointName(config.entrypointsDir, path7);
-  const { main: _, ...options } = await importEntrypointFile(path7, config);
+async function getContentScriptEntrypoint(config, path6) {
+  const name = getEntrypointName(config.entrypointsDir, path6);
+  const { main: _, ...options } = await importEntrypointFile(path6, config);
   if (options == null) {
     throw Error(
       `${name}: Default export not found, did you forget to call "export default defineContentScript(...)"?`
@@ -2392,7 +2450,7 @@ async function getContentScriptEntrypoint(config, path7) {
   return {
     type: "content-script",
     name,
-    inputPath: path7,
+    inputPath: path6,
     outputDir: resolve12(config.outDir, CONTENT_SCRIPT_OUT_DIR),
     options
   };
@@ -2441,9 +2499,12 @@ var PATH_GLOB_TO_TYPE_MAP = {
 var CONTENT_SCRIPT_OUT_DIR = "content-scripts";
 
 export {
+  detectDevChanges,
   getEntrypointOutputFile,
   getEntrypointBundlePath,
   resolvePerBrowserOption,
+  findEntrypoints,
+  generateTypesDir,
   formatDuration,
   download,
   unimport,
@@ -2451,9 +2512,6 @@ export {
   globals,
   webextensionPolyfillAlias,
   webextensionPolyfillInlineDeps,
-  detectDevChanges,
-  findEntrypoints,
-  generateTypesDir,
   getInternalConfig,
   kebabCaseAlphanumeric,
   printFileList,