wxt 0.8.3 → 0.8.5

package/dist/chunk-NTYO6B6Y.js

@@ -0,0 +1,2390 @@
+// package.json
+var version = "0.8.5";
+
+// src/core/utils/entrypoints.ts
+import path, { relative, resolve } from "node:path";
+
+// src/core/utils/paths.ts
+import nodePath from "node:path";
+import * as vite from "vite";
+function normalizePath2(path7) {
+  return vite.normalizePath(path7);
+}
+function unnormalizePath(path7) {
+  return nodePath.normalize(path7);
+}
+var CSS_EXTENSIONS = ["css", "scss", "sass", "less", "styl", "stylus"];
+var CSS_EXTENSIONS_PATTERN = `+(${CSS_EXTENSIONS.join("|")})`;
+
+// src/core/utils/entrypoints.ts
+function getEntrypointName(entrypointsDir, inputPath) {
+  const relativePath = path.relative(entrypointsDir, inputPath);
+  const name = relativePath.split(/[\.\/\\]/, 2)[0];
+  return name;
+}
+function getEntrypointOutputFile(entrypoint, ext) {
+  return resolve(entrypoint.outputDir, `${entrypoint.name}${ext}`);
+}
+function getEntrypointBundlePath(entrypoint, outDir, ext) {
+  return normalizePath2(
+    relative(outDir, getEntrypointOutputFile(entrypoint, ext))
+  );
+}
+function resolvePerBrowserOption(option, browser) {
+  if (typeof option === "object" && !Array.isArray(option))
+    return 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/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);
+}
+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/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/vite-plugins/unimport.ts
+import { createUnimport } from "unimport";
+
+// src/core/utils/unimport.ts
+import { mergeConfig } from "vite";
+function getUnimportOptions(config) {
+  if (config.imports === false)
+    return false;
+  const defaultOptions = {
+    debugLog: config.logger.debug,
+    imports: [
+      { name: "defineConfig", from: "wxt" },
+      { name: "fakeBrowser", from: "wxt/testing" }
+    ],
+    presets: [
+      { package: "wxt/client" },
+      { package: "wxt/browser" },
+      { package: "wxt/sandbox" }
+    ],
+    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 = {
+  ".js": true,
+  ".jsx": true,
+  ".ts": true,
+  ".tsx": true,
+  ".vue": true,
+  ".svelte": true
+};
+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) {
+      const ext = extname(id);
+      if (ENABLED_EXTENSIONS[ext])
+        return unimport2.injectImports(code, id);
+    }
+  };
+}
+
+// src/core/vite-plugins/tsconfigPaths.ts
+function tsconfigPaths(config) {
+  return {
+    name: "wxt:aliases",
+    async config() {
+      return {
+        resolve: {
+          alias: {
+            "@@": config.root,
+            "~~": config.root,
+            "@": config.srcDir,
+            "~": config.srcDir
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/core/utils/globals.ts
+function getGlobals(config) {
+  return [
+    {
+      name: surroundInUnderscore("MANIFEST_VERSION"),
+      value: config.manifestVersion,
+      type: `2 | 3`
+    },
+    {
+      name: surroundInUnderscore("BROWSER"),
+      value: config.browser,
+      type: `string`
+    },
+    {
+      name: surroundInUnderscore("IS_CHROME"),
+      value: config.browser === "chrome",
+      type: `boolean`
+    },
+    {
+      name: surroundInUnderscore("IS_FIREFOX"),
+      value: config.browser === "firefox",
+      type: `boolean`
+    },
+    {
+      name: surroundInUnderscore("IS_SAFARI"),
+      value: config.browser === "safari",
+      type: `boolean`
+    },
+    {
+      name: surroundInUnderscore("IS_EDGE"),
+      value: config.browser === "edge",
+      type: `boolean`
+    },
+    {
+      name: surroundInUnderscore("IS_OPERA"),
+      value: config.browser === "opera",
+      type: `boolean`
+    },
+    {
+      name: surroundInUnderscore("COMMAND"),
+      value: config.command,
+      type: `"build" | "serve"`
+    }
+  ];
+}
+function getEntrypointGlobals(config, entrypointName) {
+  return [
+    {
+      name: surroundInUnderscore("ENTRYPOINT"),
+      value: entrypointName,
+      type: `string`
+    }
+  ];
+}
+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
+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/vite-plugins/devHtmlPrerender.ts
+import { parseHTML } from "linkedom";
+import { dirname, isAbsolute, relative as relative2, resolve as resolve2 } from "path";
+var reactRefreshPreamble = "";
+function devHtmlPrerender(config) {
+  const htmlReloadId = "@wxt/reload-html";
+  const resolvedHtmlReloadId = resolve2(
+    config.root,
+    "node_modules/wxt/dist/virtual/reload-html.js"
+  );
+  const virtualReactRefreshId = "@wxt/virtual-react-refresh";
+  const resolvedVirtualReactRefreshId = "\0" + virtualReactRefreshId;
+  return [
+    {
+      apply: "build",
+      name: "wxt:dev-html-prerender",
+      config() {
+        return {
+          resolve: {
+            alias: {
+              [htmlReloadId]: resolvedHtmlReloadId
+            }
+          }
+        };
+      },
+      // Convert scripts like src="./main.tsx" -> src="http://localhost:3000/entrypoints/popup/main.tsx"
+      // before the paths are replaced with their bundled path
+      transform(code, id) {
+        const server = config.server;
+        if (config.command !== "serve" || server == null || !id.endsWith(".html"))
+          return;
+        const { document } = parseHTML(code);
+        const pointToDevServer = (querySelector, attr) => {
+          document.querySelectorAll(querySelector).forEach((element) => {
+            const src = element.getAttribute(attr);
+            if (!src)
+              return;
+            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);
+              element.setAttribute(attr, `${server.origin}/${pathname}`);
+            }
+          });
+        };
+        pointToDevServer("script[type=module]", "src");
+        pointToDevServer("link[rel=stylesheet]", "href");
+        const reloader = document.createElement("script");
+        reloader.src = htmlReloadId;
+        reloader.type = "module";
+        document.head.appendChild(reloader);
+        const newHtml = document.toString();
+        config.logger.debug("transform " + id);
+        config.logger.debug("Old HTML:\n" + code);
+        config.logger.debug("New HTML:\n" + newHtml);
+        return newHtml;
+      },
+      // Pass the HTML through the dev server to add dev-mode specific code
+      async transformIndexHtml(html, ctx) {
+        const server = config.server;
+        if (config.command !== "serve" || server == null)
+          return;
+        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 { document } = parseHTML(serverHtml);
+        const reactRefreshScript = Array.from(
+          document.querySelectorAll("script[type=module]")
+        ).find((script) => script.innerHTML.includes("@react-refresh"));
+        if (reactRefreshScript) {
+          reactRefreshPreamble = reactRefreshScript.innerHTML;
+          const virtualScript = document.createElement("script");
+          virtualScript.type = "module";
+          virtualScript.src = `${server.origin}/${virtualReactRefreshId}`;
+          reactRefreshScript.replaceWith(virtualScript);
+        }
+        const viteClientScript = document.querySelector(
+          "script[src='/@vite/client']"
+        );
+        if (viteClientScript) {
+          viteClientScript.src = `${server.origin}${viteClientScript.src}`;
+        }
+        const newHtml = document.toString();
+        config.logger.debug("transformIndexHtml " + ctx.filename);
+        config.logger.debug("Old HTML:\n" + html);
+        config.logger.debug("New HTML:\n" + newHtml);
+        return newHtml;
+      }
+    },
+    {
+      name: "wxt:virtualize-react-refresh",
+      apply: "serve",
+      resolveId(id) {
+        if (id === `/${virtualReactRefreshId}`) {
+          return resolvedVirtualReactRefreshId;
+        }
+        if (id.startsWith("/chunks/")) {
+          return "\0noop";
+        }
+      },
+      load(id) {
+        if (id === resolvedVirtualReactRefreshId) {
+          return reactRefreshPreamble;
+        }
+        if (id === "\0noop") {
+          return "";
+        }
+      }
+    }
+  ];
+}
+
+// src/core/vite-plugins/devServerGlobals.ts
+function devServerGlobals(internalConfig) {
+  return {
+    name: "wxt:dev-server-globals",
+    config() {
+      if (internalConfig.server == null || internalConfig.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)
+        }
+      };
+    }
+  };
+}
+
+// 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) => !!normalizePath2(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(
+            "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 renamedChunk = {
+          ...bundle[oldBundlePath],
+          fileName: newBundlePath
+        };
+        delete bundle[oldBundlePath];
+        bundle[newBundlePath] = renamedChunk;
+      }
+    }
+  };
+}
+
+// src/core/vite-plugins/virtualEntrypoint.ts
+import fs2 from "fs-extra";
+import { resolve as resolve4 } from "path";
+function virtualEntrypoint(type, config) {
+  const virtualId = `virtual:wxt-${type}?`;
+  const resolvedVirtualId = `\0${virtualId}`;
+  return {
+    name: `wxt:virtual-entrypoint`,
+    resolveId(id) {
+      const index = id.indexOf(virtualId);
+      if (index === -1)
+        return;
+      const inputPath = normalizePath2(id.substring(index + virtualId.length));
+      return resolvedVirtualId + inputPath;
+    },
+    async load(id) {
+      if (!id.startsWith(resolvedVirtualId))
+        return;
+      const inputPath = id.replace(resolvedVirtualId, "");
+      const template = await fs2.readFile(
+        resolve4(
+          config.root,
+          `node_modules/wxt/dist/virtual/${type}-entrypoint.js`
+        ),
+        "utf-8"
+      );
+      return template.replace(`virtual:user-${type}`, inputPath);
+    }
+  };
+}
+
+// src/core/vite-plugins/noopBackground.ts
+function noopBackground() {
+  const virtualModuleId = VIRTUAL_NOOP_BACKGROUND_MODULE_ID;
+  const resolvedVirtualModuleId = "\0" + virtualModuleId;
+  return {
+    name: "wxt:noop-background",
+    resolveId(id) {
+      if (id === virtualModuleId)
+        return resolvedVirtualModuleId;
+    },
+    load(id) {
+      if (id === resolvedVirtualModuleId) {
+        return `import { defineBackground } from 'wxt/client';
+export default defineBackground(() => void 0)`;
+      }
+    }
+  };
+}
+var VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";
+
+// src/core/vite-plugins/cssEntrypoints.ts
+function cssEntrypoints(entrypoint, config) {
+  return {
+    name: "wxt:css-entrypoint",
+    config() {
+      return {
+        build: {
+          rollupOptions: {
+            output: {
+              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/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 = normalizePath2(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 vite2 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 = {
+    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 = vite2.mergeConfig(
+    libMode,
+    await config.vite(config.env)
+  );
+  const result = await vite2.build(entryConfig);
+  return {
+    entrypoints: entrypoint,
+    chunks: getBuildOutputChunks(result)
+  };
+}
+async function buildMultipleEntrypoints(entrypoints, config) {
+  const multiPage = {
+    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 = vite2.mergeConfig(
+    multiPage,
+    await config.vite(config.env)
+  );
+  const result = await vite2.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(normalizePath2).map((path7) => `    | "/${path7}"`).sort().join("\n");
+  const template = `// Generated by wxt
+import "wxt/browser";
+
+declare module "wxt/browser" {
+  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 }}
+  }
+}
+`;
+  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;`;
+  });
+  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="./${normalizePath2(relative3(dir, ref))}" />`
+      )
+    ].join("\n") + "\n"
+  );
+  return filePath;
+}
+async function writeTsConfigFile(mainReference, config) {
+  const dir = config.wxtDir;
+  const rootPath = normalizePath2(relative3(dir, config.root));
+  const srcPath = normalizePath2(relative3(dir, config.srcDir));
+  await writeFileIfDifferent(
+    resolve6(dir, "tsconfig.json"),
+    `{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "noEmit": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "strict": true,
+    "lib": ["DOM", "WebWorker"],
+    "skipLibCheck": true,
+    "paths": {
+      "@": ["${srcPath}"],
+      "@/*": ["${srcPath}/*"],
+      "~": ["${srcPath}"],
+      "~/*": ["${srcPath}/*"],
+      "@@": ["${rootPath}"],
+      "@@/*": ["${rootPath}/*"],
+      "~~": ["${rootPath}"],
+      "~~/*": ["${rootPath}/*"]
+    }
+  },
+  "include": [
+    "${normalizePath2(relative3(dir, config.root))}/**/*",
+    "./${normalizePath2(relative3(dir, mainReference))}"
+  ],
+  "exclude": ["${normalizePath2(relative3(dir, config.outBaseDir))}"]
+}`
+  );
+}
+
+// src/core/utils/building/get-internal-config.ts
+import { loadConfig } from "c12";
+import path5 from "node:path";
+import * as vite3 from "vite";
+
+// 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));
+  return {
+    async set(key, value) {
+      const path7 = getPath(key);
+      await ensureDir2(dirname4(path7));
+      await writeFileIfDifferent(path7, value);
+    },
+    async get(key) {
+      const path7 = getPath(key);
+      try {
+        return await fs6.readFile(path7, "utf-8");
+      } catch {
+        return void 0;
+      }
+    }
+  };
+}
+
+// src/core/utils/building/get-internal-config.ts
+import consola, { LogLevels } from "consola";
+async function getInternalConfig(inlineConfig, command) {
+  let userConfig = {};
+  let userConfigMetadata;
+  if (inlineConfig.configFile !== false) {
+    const { config: loadedConfig, ...metadata } = await loadConfig({
+      name: "wxt",
+      cwd: inlineConfig.root ?? process.cwd(),
+      rcFile: false
+    });
+    userConfig = loadedConfig ?? {};
+    userConfigMetadata = metadata;
+  }
+  const mergedConfig = mergeInlineConfig(inlineConfig, userConfig);
+  const debug = mergedConfig.debug ?? false;
+  const logger = mergedConfig.logger ?? consola;
+  if (debug)
+    logger.level = LogLevels.debug;
+  const browser = mergedConfig.browser ?? "chrome";
+  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(
+    inlineConfig.root ?? userConfig.root ?? process.cwd()
+  );
+  const wxtDir = path5.resolve(root, ".wxt");
+  const srcDir = path5.resolve(root, mergedConfig.srcDir ?? root);
+  const entrypointsDir = path5.resolve(
+    srcDir,
+    mergedConfig.entrypointsDir ?? "entrypoints"
+  );
+  const publicDir = path5.resolve(srcDir, mergedConfig.publicDir ?? "public");
+  const typesDir = path5.resolve(wxtDir, "types");
+  const outBaseDir = path5.resolve(root, ".output");
+  const outDir = path5.resolve(outBaseDir, `${browser}-mv${manifestVersion}`);
+  const runnerConfig = await loadConfig({
+    name: "web-ext",
+    cwd: root,
+    globalRc: true,
+    rcFile: ".webextrc",
+    overrides: inlineConfig.runner,
+    defaults: userConfig.runner
+  });
+  const finalConfig = {
+    browser,
+    command,
+    debug,
+    entrypointsDir,
+    env,
+    fsCache: createFsCache(wxtDir),
+    imports: mergedConfig.imports ?? {},
+    logger,
+    manifest: await resolveManifestConfig(env, mergedConfig.manifest),
+    manifestVersion,
+    mode,
+    outBaseDir,
+    outDir,
+    publicDir,
+    root,
+    runnerConfig,
+    srcDir,
+    typesDir,
+    vite: () => ({}),
+    // Real value added after this object is initialized.
+    wxtDir,
+    zip: resolveInternalZipConfig(root, mergedConfig),
+    transformManifest(manifest) {
+      userConfig.transformManifest?.(manifest);
+      inlineConfig.transformManifest?.(manifest);
+    },
+    analysis: {
+      enabled: mergedConfig.analysis?.enabled ?? false,
+      template: mergedConfig.analysis?.template ?? "treemap"
+    },
+    userConfigMetadata: userConfigMetadata ?? {}
+  };
+  finalConfig.vite = (env2) => resolveInternalViteConfig(env2, mergedConfig, finalConfig);
+  return finalConfig;
+}
+async function resolveManifestConfig(env, manifest) {
+  return await (typeof manifest === "function" ? manifest(env) : manifest ?? {});
+}
+function mergeInlineConfig(inlineConfig, userConfig) {
+  let imports;
+  if (inlineConfig.imports === false || userConfig.imports === false) {
+    imports = false;
+  } else if (userConfig.imports == null && inlineConfig.imports == null) {
+    imports = void 0;
+  } else {
+    imports = vite3.mergeConfig(
+      userConfig.imports ?? {},
+      inlineConfig.imports ?? {}
+    );
+  }
+  const manifest = async (env) => {
+    const user = await resolveManifestConfig(env, userConfig.manifest);
+    const inline = await resolveManifestConfig(env, inlineConfig.manifest);
+    return vite3.mergeConfig(user, inline);
+  };
+  const viteConfig = async (env) => {
+    const user = await userConfig.vite?.(env);
+    const inline = await inlineConfig.vite?.(env);
+    return vite3.mergeConfig(user ?? {}, inline ?? {});
+  };
+  const runner = vite3.mergeConfig(
+    userConfig.runner ?? {},
+    inlineConfig.runner ?? {}
+  );
+  const zip = vite3.mergeConfig(
+    userConfig.zip ?? {},
+    inlineConfig.zip ?? {}
+  );
+  return {
+    root: inlineConfig.root ?? userConfig.root,
+    browser: inlineConfig.browser ?? userConfig.browser,
+    manifestVersion: inlineConfig.manifestVersion ?? userConfig.manifestVersion,
+    configFile: inlineConfig.configFile,
+    debug: inlineConfig.debug ?? userConfig.debug,
+    entrypointsDir: inlineConfig.entrypointsDir ?? userConfig.entrypointsDir,
+    imports,
+    logger: inlineConfig.logger ?? userConfig.logger,
+    manifest,
+    mode: inlineConfig.mode ?? userConfig.mode,
+    publicDir: inlineConfig.publicDir ?? userConfig.publicDir,
+    runner,
+    srcDir: inlineConfig.srcDir ?? userConfig.srcDir,
+    vite: viteConfig,
+    zip,
+    analysis: {
+      enabled: inlineConfig.analysis?.enabled ?? userConfig.analysis?.enabled,
+      template: inlineConfig.analysis?.template ?? userConfig.analysis?.template
+    }
+  };
+}
+function resolveInternalZipConfig(root, mergedConfig) {
+  return {
+    sourcesTemplate: "{{name}}-{{version}}-sources.zip",
+    artifactTemplate: "{{name}}-{{version}}-{{browser}}.zip",
+    sourcesRoot: root,
+    ...mergedConfig.zip,
+    ignoredSources: [
+      "**/node_modules",
+      // WXT files
+      "**/web-ext.config.ts",
+      // Hidden files
+      "**/.*",
+      // Tests
+      "**/__tests__/**",
+      "**/*.+(test|spec).?(c|m)+(j|t)s?(x)",
+      // From user
+      ...mergedConfig.zip?.ignoredSources ?? []
+    ]
+  };
+}
+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));
+  return internalVite;
+}
+
+// src/core/utils/building/group-entrypoints.ts
+function groupEntrypoints(entrypoints) {
+  const groupIndexMap = {};
+  const groups = [];
+  for (const entry of entrypoints) {
+    const group = ENTRY_TYPE_TO_GROUP_MAP[entry.type];
+    if (group === "no-group") {
+      groups.push(entry);
+    } else {
+      let groupIndex = groupIndexMap[group];
+      if (groupIndex == null) {
+        groupIndex = groups.push([]) - 1;
+        groupIndexMap[group] = groupIndex;
+      }
+      groups[groupIndex].push(entry);
+    }
+  }
+  return groups;
+}
+var ENTRY_TYPE_TO_GROUP_MAP = {
+  sandbox: "sandbox-page",
+  popup: "extension-page",
+  newtab: "extension-page",
+  history: "extension-page",
+  options: "extension-page",
+  devtools: "extension-page",
+  bookmarks: "extension-page",
+  sidepanel: "extension-page",
+  "unlisted-page": "extension-page",
+  background: "no-group",
+  "content-script": "no-group",
+  "unlisted-script": "no-group",
+  "unlisted-style": "no-group",
+  "content-script-style": "no-group"
+};
+
+// src/core/utils/building/import-entrypoint.ts
+import createJITI from "jiti";
+import { createUnimport as createUnimport3 } from "unimport";
+import fs7 from "fs-extra";
+import { resolve as resolve8 } from "path";
+
+// src/core/utils/strings.ts
+function kebabCaseAlphanumeric(str) {
+  return str.toLowerCase().replace(/[^a-z0-9-\s]/g, "").replace(/\s+/g, "-");
+}
+function removeImportStatements(text) {
+  return text.replace(
+    /(import\s?[{\w][\s\S]*?from\s?["'][\s\S]*?["'];?|import\s?["'][\s\S]*?["'];?)/gm,
+    ""
+  );
+}
+function removeProjectImportStatements(text) {
+  const noImports = removeImportStatements(text);
+  return `import { defineContentScript, defineBackground } from 'wxt/client';
+import { defineUnlistedScript } from 'wxt/sandbox';
+
+${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 = normalizePath2(path7);
+  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 textNoImports = removeProjectImportStatements(text);
+  const { code } = await unimport2.injectImports(textNoImports);
+  config.logger.debug(
+    ["Text:", text, "No imports:", textNoImports, "Code:", code].join("\n")
+  );
+  const jiti = createJITI(__filename, {
+    cache: false,
+    debug: config.debug,
+    esmResolve: true,
+    alias: {
+      "webextension-polyfill": resolve8(
+        config.root,
+        "node_modules/wxt/dist/virtual/mock-browser.js"
+      )
+    },
+    // List of extensions to transform with esbuild
+    extensions: [".ts", ".cts", ".mts", ".tsx", ".js", ".cjs", ".mjs", ".jsx"],
+    transform(opts) {
+      const isEntrypoint = opts.filename === normalPath;
+      return transformSync(
+        // Use modified source code for entrypoints
+        isEntrypoint ? code : opts.source,
+        getEsbuildOptions(opts)
+      );
+    }
+  });
+  try {
+    const res = await jiti(path7);
+    return res.default;
+  } catch (err) {
+    config.logger.error(err);
+    throw err;
+  }
+}
+function getEsbuildOptions(opts) {
+  const isJsx = opts.filename?.endsWith("x");
+  return {
+    format: "cjs",
+    loader: isJsx ? "tsx" : "ts",
+    jsx: isJsx ? "automatic" : void 0
+  };
+}
+
+// src/core/utils/building/internal-build.ts
+import pc4 from "picocolors";
+import * as vite5 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 pc2 from "picocolors";
+import fs8 from "fs-extra";
+import { filesize } from "filesize";
+
+// src/core/utils/log/printTable.ts
+function printTable(log, header, rows, gap = 2) {
+  if (rows.length === 0)
+    return;
+  const columnWidths = rows.reduce(
+    (widths, row) => {
+      for (let i = 0; i < Math.max(widths.length, row.length); i++) {
+        widths[i] = Math.max(row[i]?.length ?? 0, widths[i] ?? 0);
+      }
+      return widths;
+    },
+    rows[0].map((column) => column.length)
+  );
+  let str = "";
+  rows.forEach((row, i) => {
+    row.forEach((col, j) => {
+      str += col.padEnd(columnWidths[j], " ");
+      if (j !== row.length - 1)
+        str += "".padEnd(gap, " ");
+    });
+    if (i !== rows.length - 1)
+      str += "\n";
+  });
+  log(`${header}
+${str}`);
+}
+
+// src/core/utils/log/printFileList.ts
+async function printFileList(log, header, baseDir, files) {
+  let totalSize = 0;
+  const fileRows = await Promise.all(
+    files.map(async (file, i) => {
+      const parts = [
+        path6.relative(process.cwd(), baseDir) + path6.sep,
+        path6.relative(baseDir, file)
+      ];
+      const prefix = i === files.length - 1 ? "  \u2514\u2500" : "  \u251C\u2500";
+      const color = getChunkColor(file);
+      const stats = await fs8.lstat(file);
+      totalSize += stats.size;
+      const size = String(filesize(stats.size));
+      return [
+        `${pc2.gray(prefix)} ${pc2.dim(parts[0])}${color(parts[1])}`,
+        pc2.dim(size)
+      ];
+    })
+  );
+  fileRows.push([`${pc2.cyan("\u03A3 Total size:")} ${String(filesize(totalSize))}`]);
+  printTable(log, header, fileRows);
+}
+var DEFAULT_COLOR = pc2.blue;
+var CHUNK_COLORS = {
+  ".js.map": pc2.gray,
+  ".cjs.map": pc2.gray,
+  ".mjs.map": pc2.gray,
+  ".html": pc2.green,
+  ".css": pc2.magenta,
+  ".js": pc2.cyan,
+  ".cjs": pc2.cyan,
+  ".mjs": pc2.cyan,
+  ".zip": pc2.yellow
+};
+function getChunkColor(filename) {
+  return Object.entries(CHUNK_COLORS).find(([key]) => filename.endsWith(key))?.[1] ?? DEFAULT_COLOR;
+}
+
+// src/core/utils/log/printBuildSummary.ts
+async function printBuildSummary(log, header, output, config) {
+  const chunks = [
+    ...output.steps.flatMap((step) => step.chunks),
+    ...output.publicAssets
+  ].sort((l, r) => {
+    const lWeight = getChunkSortWeight(l.fileName);
+    const rWeight = getChunkSortWeight(r.fileName);
+    const diff = lWeight - rWeight;
+    if (diff !== 0)
+      return diff;
+    return l.fileName.localeCompare(r.fileName);
+  });
+  const files = chunks.map((chunk) => resolve9(config.outDir, chunk.fileName));
+  await printFileList(log, header, config.outDir, files);
+}
+var DEFAULT_SORT_WEIGHT = 100;
+var CHUNK_SORT_WEIGHTS = {
+  "manifest.json": 0,
+  ".html": 1,
+  ".js.map": 2,
+  ".js": 2,
+  ".css": 3
+};
+function getChunkSortWeight(filename) {
+  return Object.entries(CHUNK_SORT_WEIGHTS).find(
+    ([key]) => filename.endsWith(key)
+  )?.[1] ?? DEFAULT_SORT_WEIGHT;
+}
+
+// src/core/utils/log/printHeader.ts
+import pc3 from "picocolors";
+import { consola as consola2 } from "consola";
+
+// src/core/utils/building/internal-build.ts
+import glob2 from "fast-glob";
+
+// src/core/utils/manifest.ts
+import fs10 from "fs-extra";
+import { resolve as resolve11 } from "path";
+
+// src/core/utils/content-security-policy.ts
+var ContentSecurityPolicy = class _ContentSecurityPolicy {
+  static DIRECTIVE_ORDER = {
+    "default-src": 0,
+    "script-src": 1,
+    "object-src": 2
+  };
+  data;
+  constructor(csp) {
+    if (csp) {
+      const sections = csp.split(";").map((section) => section.trim());
+      this.data = sections.reduce((data, section) => {
+        const [key, ...values] = section.split(" ").map((item) => item.trim());
+        if (key)
+          data[key] = values;
+        return data;
+      }, {});
+    } else {
+      this.data = {};
+    }
+  }
+  /**
+   * Ensure a set of values are listed under a directive.
+   */
+  add(directive, ...newValues) {
+    const values = this.data[directive] ?? [];
+    newValues.forEach((newValue) => {
+      if (!values.includes(newValue))
+        values.push(newValue);
+    });
+    this.data[directive] = values;
+    return this;
+  }
+  toString() {
+    const directives = Object.entries(this.data).sort(([l], [r]) => {
+      const lo = _ContentSecurityPolicy.DIRECTIVE_ORDER[l] ?? 2;
+      const ro = _ContentSecurityPolicy.DIRECTIVE_ORDER[r] ?? 2;
+      return lo - ro;
+    });
+    return directives.map((entry) => entry.flat().join(" ")).join("; ") + ";";
+  }
+};
+
+// src/core/utils/content-scripts.ts
+function hashContentScriptOptions(options, config) {
+  const simplifiedOptions = mapWxtOptionsToContentScript(options, config);
+  Object.keys(simplifiedOptions).forEach((key) => {
+    if (simplifiedOptions[key] == null)
+      delete simplifiedOptions[key];
+  });
+  const withDefaults = {
+    exclude_globs: [],
+    exclude_matches: [],
+    include_globs: [],
+    match_about_blank: false,
+    run_at: "document_idle",
+    all_frames: false,
+    // @ts-expect-error - not in type
+    match_origin_as_fallback: false,
+    world: "ISOLATED",
+    ...simplifiedOptions
+  };
+  return JSON.stringify(
+    Object.entries(withDefaults).map(([key, value]) => {
+      if (Array.isArray(value))
+        return [key, value.sort()];
+      else
+        return [key, value];
+    }).sort((l, r) => l[0].localeCompare(r[0]))
+  );
+}
+function mapWxtOptionsToContentScript(options, config) {
+  return {
+    matches: resolvePerBrowserOption(options.matches, config.browser),
+    all_frames: resolvePerBrowserOption(options.allFrames, config.browser),
+    match_about_blank: resolvePerBrowserOption(
+      options.matchAboutBlank,
+      config.browser
+    ),
+    exclude_globs: resolvePerBrowserOption(
+      options.excludeGlobs,
+      config.browser
+    ),
+    exclude_matches: resolvePerBrowserOption(
+      options.excludeMatches,
+      config.browser
+    ),
+    include_globs: resolvePerBrowserOption(
+      options.includeGlobs,
+      config.browser
+    ),
+    run_at: resolvePerBrowserOption(options.runAt, config.browser),
+    // @ts-expect-error: untyped chrome options
+    match_origin_as_fallback: resolvePerBrowserOption(
+      options.matchOriginAsFallback,
+      config.browser
+    ),
+    world: options.world
+  };
+}
+
+// src/core/utils/package.ts
+import { resolve as resolve10 } from "node:path";
+import fs9 from "fs-extra";
+async function getPackageJson(config) {
+  const file = resolve10(config.root, "package.json");
+  try {
+    return await fs9.readJson(file);
+  } catch (err) {
+    config.logger.debug(
+      `Failed to read package.json at: ${file}. Returning undefined.`
+    );
+    return {};
+  }
+}
+
+// src/core/utils/manifest.ts
+import { produce } from "immer";
+import * as vite4 from "vite";
+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
+  });
+}
+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 baseManifest = {
+    manifest_version: config.manifestVersion,
+    name: pkg?.name,
+    description: pkg?.description,
+    version: version3,
+    version_name: (
+      // Firefox doesn't support version_name
+      config.browser === "firefox" || versionName === version3 ? void 0 : versionName
+    ),
+    short_name: pkg?.shortName,
+    icons: discoverIcons(buildOutput)
+  };
+  const userManifest = config.manifest;
+  const manifest = vite4.mergeConfig(
+    baseManifest,
+    userManifest
+  );
+  addEntrypoints(manifest, entrypoints, buildOutput, config);
+  if (config.command === "serve")
+    addDevModeCsp(manifest, config);
+  if (config.command === "serve")
+    addDevModePermissions(manifest, config);
+  const finalManifest = produce(manifest, config.transformManifest);
+  if (finalManifest.name == null)
+    throw Error(
+      "Manifest 'name' is missing. Either:\n1. Set the name in your <rootDir>/package.json\n2. Set a name via the manifest option in your wxt.config.ts"
+    );
+  if (finalManifest.version == null) {
+    throw Error(
+      "Manifest 'version' is missing. Either:\n1. Add a version in your <rootDir>/package.json\n2. Pass the version via the manifest option in your wxt.config.ts"
+    );
+  }
+  return finalManifest;
+}
+function simplifyVersion(versionName) {
+  const version3 = /^((0|[1-9][0-9]{0,8})([.](0|[1-9][0-9]{0,8})){0,3}).*$/.exec(
+    versionName
+  )?.[1];
+  if (version3 == null)
+    throw Error(
+      `Cannot simplify package.json version "${versionName}" to a valid extension version, "X.Y.Z"`
+    );
+  return version3;
+}
+function addEntrypoints(manifest, entrypoints, buildOutput, config) {
+  const entriesByType = entrypoints.reduce((map, entrypoint) => {
+    map[entrypoint.type] ??= [];
+    map[entrypoint.type]?.push(entrypoint);
+    return map;
+  }, {});
+  const background = entriesByType["background"]?.[0];
+  const bookmarks = entriesByType["bookmarks"]?.[0];
+  const contentScripts = entriesByType["content-script"];
+  const devtools = entriesByType["devtools"]?.[0];
+  const history = entriesByType["history"]?.[0];
+  const newtab = entriesByType["newtab"]?.[0];
+  const options = entriesByType["options"]?.[0];
+  const popup = entriesByType["popup"]?.[0];
+  const sandboxes = entriesByType["sandbox"];
+  const sidepanels = entriesByType["sidepanel"];
+  if (background) {
+    const script = getEntrypointBundlePath(background, config.outDir, ".js");
+    if (manifest.manifest_version === 3) {
+      manifest.background = {
+        type: background.options.type,
+        service_worker: script
+      };
+    } else {
+      manifest.background = {
+        persistent: background.options.persistent,
+        scripts: [script]
+      };
+    }
+  }
+  if (bookmarks) {
+    if (config.browser === "firefox") {
+      config.logger.warn(
+        "Bookmarks are not supported by Firefox. chrome_url_overrides.bookmarks was not added to the manifest"
+      );
+    } else {
+      manifest.chrome_url_overrides ??= {};
+      manifest.chrome_url_overrides.bookmarks = getEntrypointBundlePath(
+        bookmarks,
+        config.outDir,
+        ".html"
+      );
+    }
+  }
+  if (history) {
+    if (config.browser === "firefox") {
+      config.logger.warn(
+        "Bookmarks are not supported by Firefox. chrome_url_overrides.history was not added to the manifest"
+      );
+    } else {
+      manifest.chrome_url_overrides ??= {};
+      manifest.chrome_url_overrides.history = getEntrypointBundlePath(
+        history,
+        config.outDir,
+        ".html"
+      );
+    }
+  }
+  if (newtab) {
+    manifest.chrome_url_overrides ??= {};
+    manifest.chrome_url_overrides.newtab = getEntrypointBundlePath(
+      newtab,
+      config.outDir,
+      ".html"
+    );
+  }
+  if (popup) {
+    const default_popup = getEntrypointBundlePath(
+      popup,
+      config.outDir,
+      ".html"
+    );
+    const options2 = {};
+    if (popup.options.defaultIcon)
+      options2.default_icon = popup.options.defaultIcon;
+    if (popup.options.defaultTitle)
+      options2.default_title = popup.options.defaultTitle;
+    if (popup.options.browserStyle)
+      options2.browser_style = popup.options.browserStyle;
+    if (manifest.manifest_version === 3) {
+      manifest.action = {
+        ...manifest.action ?? {},
+        ...options2,
+        default_popup
+      };
+    } else {
+      const key = popup.options.mv2Key ?? "browser_action";
+      manifest[key] = {
+        ...manifest[key] ?? {},
+        ...options2,
+        default_popup
+      };
+    }
+  }
+  if (devtools) {
+    manifest.devtools_page = getEntrypointBundlePath(
+      devtools,
+      config.outDir,
+      ".html"
+    );
+  }
+  if (options) {
+    const page = getEntrypointBundlePath(options, config.outDir, ".html");
+    manifest.options_ui = {
+      open_in_tab: options.options.openInTab,
+      browser_style: config.browser === "firefox" ? options.options.browserStyle : void 0,
+      chrome_style: config.browser !== "firefox" ? options.options.chromeStyle : void 0,
+      page
+    };
+  }
+  if (sandboxes?.length) {
+    if (config.browser === "firefox") {
+      config.logger.warn(
+        "Sandboxed pages not supported by Firefox. sandbox.pages was not added to the manifest"
+      );
+    } else {
+      manifest.sandbox = {
+        pages: sandboxes.map(
+          (entry) => getEntrypointBundlePath(entry, config.outDir, ".html")
+        )
+      };
+    }
+  }
+  if (sidepanels?.length) {
+    const defaultSidepanel = sidepanels.find((entry) => entry.name === "sidepanel") ?? sidepanels[0];
+    const page = getEntrypointBundlePath(
+      defaultSidepanel,
+      config.outDir,
+      ".html"
+    );
+    if (config.browser === "firefox") {
+      manifest.sidebar_action = {
+        // TODO: Add options to side panel
+        // ...defaultSidepanel.options,
+        default_panel: page
+      };
+    } else if (config.manifestVersion === 3) {
+      manifest.side_panel = {
+        default_path: page
+      };
+    } else {
+      config.logger.warn(
+        "Side panel not supported by Chromium using MV2. side_panel.default_path was not added to the manifest"
+      );
+    }
+  }
+  if (contentScripts?.length) {
+    const cssMap = getContentScriptsCssMap(buildOutput, contentScripts);
+    if (config.command === "serve" && config.manifestVersion === 3) {
+      const hostPermissions = new Set(manifest.host_permissions ?? []);
+      contentScripts.forEach((script) => {
+        const matches = resolvePerBrowserOption(
+          script.options.matches,
+          config.browser
+        );
+        matches.forEach((matchPattern) => {
+          hostPermissions.add(matchPattern);
+        });
+      });
+      hostPermissions.forEach(
+        (permission) => addHostPermission(manifest, permission)
+      );
+    } else {
+      const hashToEntrypointsMap = contentScripts.reduce((map, script) => {
+        const hash = hashContentScriptOptions(script.options, config);
+        if (map.has(hash))
+          map.get(hash)?.push(script);
+        else
+          map.set(hash, [script]);
+        return map;
+      }, /* @__PURE__ */ new Map());
+      const newContentScripts = Array.from(hashToEntrypointsMap.entries()).map(
+        ([, scripts]) => ({
+          ...mapWxtOptionsToContentScript(scripts[0].options, config),
+          css: getContentScriptCssFiles(scripts, cssMap),
+          js: scripts.map(
+            (entry) => getEntrypointBundlePath(entry, config.outDir, ".js")
+          )
+        })
+      );
+      if (newContentScripts.length >= 0) {
+        manifest.content_scripts ??= [];
+        manifest.content_scripts.push(...newContentScripts);
+      }
+    }
+    const contentScriptCssResources = getContentScriptCssWebAccessibleResources(
+      config,
+      contentScripts,
+      cssMap
+    );
+    if (contentScriptCssResources.length > 0) {
+      manifest.web_accessible_resources ??= [];
+      manifest.web_accessible_resources.push(...contentScriptCssResources);
+    }
+  }
+}
+function discoverIcons(buildOutput) {
+  const icons = [];
+  const iconRegex = [
+    /^icon-([0-9]+)\.(png|bmp|jpeg|jpg|ico|gif)$/,
+    // icon-16.png
+    /^icon-([0-9]+)x[0-9]+\.(png|bmp|jpeg|jpg|ico|gif)$/,
+    // icon-16x16.png
+    /^icon@([0-9]+)w\.(png|bmp|jpeg|jpg|ico|gif)$/,
+    // icon@16w.png
+    /^icon@([0-9]+)h\.(png|bmp|jpeg|jpg|ico|gif)$/,
+    // icon@16h.png
+    /^icon@([0-9]+)\.(png|bmp|jpeg|jpg|ico|gif)$/,
+    // icon@16.png
+    /^icon[\/\\]([0-9]+)\.(png|bmp|jpeg|jpg|ico|gif)$/,
+    // icon/16.png
+    /^icon[\/\\]([0-9]+)x[0-9]+\.(png|bmp|jpeg|jpg|ico|gif)$/
+    // icon/16x16.png
+  ];
+  buildOutput.publicAssets.forEach((asset) => {
+    let size;
+    for (const regex of iconRegex) {
+      const match = asset.fileName.match(regex);
+      if (match?.[1] != null) {
+        size = match[1];
+        break;
+      }
+    }
+    if (size == null)
+      return;
+    icons.push([size, normalizePath2(asset.fileName)]);
+  });
+  return icons.length > 0 ? Object.fromEntries(icons) : void 0;
+}
+function addDevModeCsp(manifest, config) {
+  const permission = `http://${config.server?.hostname ?? ""}/*`;
+  const allowedCsp = config.server?.origin ?? "http://localhost:*";
+  if (manifest.manifest_version === 3) {
+    addHostPermission(manifest, permission);
+  } else {
+    addPermission(manifest, permission);
+  }
+  const csp = new ContentSecurityPolicy(
+    manifest.manifest_version === 3 ? (
+      // @ts-expect-error: extension_pages is not typed
+      manifest.content_security_policy?.extension_pages ?? "script-src 'self' 'wasm-unsafe-eval'; object-src 'self';"
+    ) : manifest.content_security_policy ?? "script-src 'self'; object-src 'self';"
+    // default CSP for MV2
+  );
+  if (config.server)
+    csp.add("script-src", allowedCsp);
+  if (manifest.manifest_version === 3) {
+    manifest.content_security_policy ??= {};
+    manifest.content_security_policy.extension_pages = csp.toString();
+  } else {
+    manifest.content_security_policy = csp.toString();
+  }
+}
+function addDevModePermissions(manifest, config) {
+  addPermission(manifest, "tabs");
+  if (config.manifestVersion === 3)
+    addPermission(manifest, "scripting");
+}
+function getContentScriptCssFiles(contentScripts, contentScriptCssMap) {
+  const css = [];
+  contentScripts.forEach((script) => {
+    if (script.options.cssInjectionMode === "manual" || script.options.cssInjectionMode === "ui")
+      return;
+    const cssFile = contentScriptCssMap[script.name];
+    if (cssFile == null)
+      return;
+    if (cssFile)
+      css.push(cssFile);
+  });
+  if (css.length > 0)
+    return css;
+  return void 0;
+}
+function getContentScriptCssWebAccessibleResources(config, contentScripts, contentScriptCssMap) {
+  const resources = [];
+  contentScripts.forEach((script) => {
+    if (script.options.cssInjectionMode !== "ui")
+      return;
+    const cssFile = contentScriptCssMap[script.name];
+    if (cssFile == null)
+      return;
+    if (config.manifestVersion === 2) {
+      resources.push(cssFile);
+    } else {
+      resources.push({
+        resources: [cssFile],
+        matches: script.options.matches
+      });
+    }
+  });
+  return resources;
+}
+function getContentScriptsCssMap(buildOutput, scripts) {
+  const map = {};
+  const allChunks = buildOutput.steps.flatMap((step) => step.chunks);
+  scripts.forEach((script) => {
+    const relatedCss = allChunks.find(
+      (chunk) => chunk.fileName === `content-scripts/${script.name}.css`
+    );
+    if (relatedCss != null)
+      map[script.name] = relatedCss.fileName;
+  });
+  return map;
+}
+function addPermission(manifest, permission) {
+  manifest.permissions ??= [];
+  if (manifest.permissions.includes(permission))
+    return;
+  manifest.permissions.push(permission);
+}
+function addHostPermission(manifest, hostPermission) {
+  manifest.host_permissions ??= [];
+  if (manifest.host_permissions.includes(hostPermission))
+    return;
+  manifest.host_permissions.push(hostPermission);
+}
+
+// src/core/utils/building/rebuild.ts
+async function rebuild(config, entrypointGroups, existingOutput = {
+  steps: [],
+  publicAssets: []
+}) {
+  const { default: ora } = await import("ora");
+  const spinner = ora(`Preparing...`).start();
+  const allEntrypoints = await findEntrypoints(config);
+  await generateTypesDir(allEntrypoints, config).catch((err) => {
+    config.logger.warn("Failed to update .wxt directory:", err);
+    if (config.command === "build")
+      throw err;
+  });
+  const newOutput = await buildEntrypoints(entrypointGroups, config, spinner);
+  const mergedOutput = {
+    steps: [...existingOutput.steps, ...newOutput.steps],
+    publicAssets: [...existingOutput.publicAssets, ...newOutput.publicAssets]
+  };
+  const newManifest = await generateMainfest(
+    allEntrypoints,
+    mergedOutput,
+    config
+  );
+  const finalOutput = {
+    manifest: newManifest,
+    ...newOutput
+  };
+  await writeManifest(newManifest, finalOutput, config);
+  spinner.clear().stop();
+  return {
+    output: {
+      manifest: newManifest,
+      steps: [...existingOutput.steps, ...finalOutput.steps],
+      publicAssets: [
+        ...existingOutput.publicAssets,
+        ...finalOutput.publicAssets
+      ]
+    },
+    manifest: newManifest
+  };
+}
+
+// src/core/utils/building/internal-build.ts
+async function internalBuild(config) {
+  const verb = config.command === "serve" ? "Pre-rendering" : "Building";
+  const target = `${config.browser}-mv${config.manifestVersion}`;
+  config.logger.info(
+    `${verb} ${pc4.cyan(target)} for ${pc4.cyan(config.mode)} with ${pc4.green(
+      `Vite ${vite5.version}`
+    )}`
+  );
+  const startTime = Date.now();
+  await fs11.rm(config.outDir, { recursive: true, force: true });
+  await fs11.ensureDir(config.outDir);
+  const entrypoints = await findEntrypoints(config);
+  config.logger.debug("Detected entrypoints:", entrypoints);
+  const groups = groupEntrypoints(entrypoints);
+  const { output } = await rebuild(config, groups, void 0);
+  await printBuildSummary(
+    config.logger.success,
+    `Built extension in ${formatDuration(Date.now() - startTime)}`,
+    output,
+    config
+  );
+  if (config.analysis.enabled) {
+    await combineAnalysisStats(config);
+    config.logger.info(
+      `Analysis complete:
+  ${pc4.gray("\u2514\u2500")} ${pc4.yellow("stats.html")}`
+    );
+  }
+  return output;
+}
+async function combineAnalysisStats(config) {
+  const { execaCommand } = await import("./execa-WKZHVHC5.js");
+  const unixFiles = await glob2(`stats-*.json`, {
+    cwd: config.outDir,
+    absolute: true
+  });
+  const absolutePaths = unixFiles.map(unnormalizePath);
+  await execaCommand(
+    `rollup-plugin-visualizer ${absolutePaths.join(" ")} --template ${config.analysis.template}`,
+    { cwd: config.root, stdio: "inherit" }
+  );
+}
+
+// src/core/utils/building/find-entrypoints.ts
+import glob3 from "fast-glob";
+async function findEntrypoints(config) {
+  const relativePaths = await glob3("**/*", {
+    cwd: config.entrypointsDir
+  });
+  relativePaths.sort();
+  const pathGlobs = Object.keys(PATH_GLOB_TO_TYPE_MAP);
+  let hasBackground = false;
+  const possibleEntrypoints = await Promise.all(
+    relativePaths.map(async (relativePath) => {
+      const path7 = resolve12(config.entrypointsDir, relativePath);
+      const matchingGlob = pathGlobs.find(
+        (glob4) => minimatch(relativePath, glob4)
+      );
+      if (matchingGlob == null) {
+        config.logger.warn(
+          `${relativePath} does not match any known entrypoint. Known entrypoints:
+${JSON.stringify(
+            PATH_GLOB_TO_TYPE_MAP,
+            null,
+            2
+          )}`
+        );
+        return;
+      }
+      const type = PATH_GLOB_TO_TYPE_MAP[matchingGlob];
+      if (type === "ignored")
+        return;
+      switch (type) {
+        case "popup":
+          return await getPopupEntrypoint(config, path7);
+        case "options":
+          return await getOptionsEntrypoint(config, path7);
+        case "background":
+          hasBackground = true;
+          return await getBackgroundEntrypoint(config, path7);
+        case "content-script":
+          return await getContentScriptEntrypoint(config, path7);
+        case "unlisted-page":
+          return await getUnlistedPageEntrypoint(config, path7);
+        case "unlisted-script":
+          return await getUnlistedScriptEntrypoint(config, path7);
+        case "content-script-style":
+          return {
+            type,
+            name: getEntrypointName(config.entrypointsDir, path7),
+            inputPath: path7,
+            outputDir: resolve12(config.outDir, CONTENT_SCRIPT_OUT_DIR),
+            options: {
+              include: void 0,
+              exclude: void 0
+            }
+          };
+        default:
+          return {
+            type,
+            name: getEntrypointName(config.entrypointsDir, path7),
+            inputPath: path7,
+            outputDir: config.outDir,
+            options: {
+              include: void 0,
+              exclude: void 0
+            }
+          };
+      }
+    })
+  );
+  const entrypoints = possibleEntrypoints.filter(
+    (entry) => !!entry
+  );
+  const existingNames = {};
+  entrypoints.forEach((entrypoint) => {
+    const withSameName = existingNames[entrypoint.name];
+    if (withSameName) {
+      throw Error(
+        `Multiple entrypoints with the name "${entrypoint.name}" detected, but only one is allowed: ${[
+          relative4(config.root, withSameName.inputPath),
+          relative4(config.root, entrypoint.inputPath)
+        ].join(", ")}`
+      );
+    }
+    existingNames[entrypoint.name] = entrypoint;
+  });
+  if (config.command === "serve" && !hasBackground) {
+    entrypoints.push(
+      await getBackgroundEntrypoint(config, VIRTUAL_NOOP_BACKGROUND_MODULE_ID)
+    );
+  }
+  config.logger.debug("All entrypoints:", entrypoints);
+  const targetEntrypoints = entrypoints.filter((entry) => {
+    const { include, exclude } = entry.options;
+    if (include?.length && exclude?.length) {
+      config.logger.warn(
+        `The ${entry.name} entrypoint lists both include and exclude, but only one can be used per entrypoint. Entrypoint ignored.`
+      );
+      return false;
+    }
+    if (exclude?.length && !include?.length) {
+      return !exclude.includes(config.browser);
+    }
+    if (include?.length && !exclude?.length) {
+      return include.includes(config.browser);
+    }
+    return true;
+  });
+  config.logger.debug(`${config.browser} entrypoints:`, targetEntrypoints);
+  return targetEntrypoints;
+}
+function getHtmlBaseOptions(document) {
+  const options = {};
+  const includeContent = document.querySelector("meta[name='manifest.include']")?.getAttribute("content");
+  if (includeContent) {
+    options.include = JSON5.parse(includeContent);
+  }
+  const excludeContent = document.querySelector("meta[name='manifest.exclude']")?.getAttribute("content");
+  if (excludeContent) {
+    options.exclude = JSON5.parse(excludeContent);
+  }
+  return options;
+}
+async function getPopupEntrypoint(config, path7) {
+  const content = await fs12.readFile(path7, "utf-8");
+  const { document } = parseHTML2(content);
+  const options = getHtmlBaseOptions(document);
+  const title = document.querySelector("title");
+  if (title != null)
+    options.defaultTitle = title.textContent ?? void 0;
+  const defaultIconContent = document.querySelector("meta[name='manifest.default_icon']")?.getAttribute("content");
+  if (defaultIconContent) {
+    try {
+      options.defaultIcon = JSON5.parse(defaultIconContent);
+    } catch (err) {
+      config.logger.fatal(
+        `Failed to parse default_icon meta tag content as JSON5. content=${defaultIconContent}`,
+        err
+      );
+    }
+  }
+  const mv2TypeContent = document.querySelector("meta[name='manifest.type']")?.getAttribute("content");
+  if (mv2TypeContent) {
+    options.mv2Key = mv2TypeContent === "page_action" ? "page_action" : "browser_action";
+  }
+  const browserStyleContent = document.querySelector("meta[name='manifest.browser_style']")?.getAttribute("content");
+  if (browserStyleContent) {
+    options.browserStyle = browserStyleContent === "true";
+  }
+  return {
+    type: "popup",
+    name: "popup",
+    options,
+    inputPath: path7,
+    outputDir: config.outDir
+  };
+}
+async function getOptionsEntrypoint(config, path7) {
+  const content = await fs12.readFile(path7, "utf-8");
+  const { document } = parseHTML2(content);
+  const options = getHtmlBaseOptions(document);
+  const openInTabContent = document.querySelector("meta[name='manifest.open_in_tab']")?.getAttribute("content");
+  if (openInTabContent) {
+    options.openInTab = openInTabContent === "true";
+  }
+  const chromeStyleContent = document.querySelector("meta[name='manifest.chrome_style']")?.getAttribute("content");
+  if (chromeStyleContent) {
+    options.chromeStyle = chromeStyleContent === "true";
+  }
+  const browserStyleContent = document.querySelector("meta[name='manifest.browser_style']")?.getAttribute("content");
+  if (browserStyleContent) {
+    options.browserStyle = browserStyleContent === "true";
+  }
+  return {
+    type: "options",
+    name: "options",
+    options,
+    inputPath: path7,
+    outputDir: config.outDir
+  };
+}
+async function getUnlistedPageEntrypoint(config, path7) {
+  const content = await fs12.readFile(path7, "utf-8");
+  const { document } = parseHTML2(content);
+  return {
+    type: "unlisted-page",
+    name: getEntrypointName(config.entrypointsDir, path7),
+    inputPath: path7,
+    outputDir: config.outDir,
+    options: getHtmlBaseOptions(document)
+  };
+}
+async function getUnlistedScriptEntrypoint(config, path7) {
+  const name = getEntrypointName(config.entrypointsDir, path7);
+  const defaultExport = await importEntrypointFile(
+    path7,
+    config
+  );
+  if (defaultExport == null) {
+    throw Error(
+      `${name}: Default export not found, did you forget to call "export default defineUnlistedScript(...)"?`
+    );
+  }
+  const { main: _, ...moduleOptions } = defaultExport;
+  const options = moduleOptions;
+  return {
+    type: "unlisted-script",
+    name,
+    inputPath: path7,
+    outputDir: config.outDir,
+    options
+  };
+}
+async function getBackgroundEntrypoint(config, path7) {
+  const name = "background";
+  let options = {};
+  if (path7 !== VIRTUAL_NOOP_BACKGROUND_MODULE_ID) {
+    const defaultExport = await importEntrypointFile(
+      path7,
+      config
+    );
+    if (defaultExport == null) {
+      throw Error(
+        `${name}: Default export not found, did you forget to call "export default defineBackground(...)"?`
+      );
+    }
+    const { main: _, ...moduleOptions } = defaultExport;
+    options = moduleOptions;
+  }
+  return {
+    type: "background",
+    name,
+    inputPath: path7,
+    outputDir: config.outDir,
+    options: {
+      ...options,
+      type: resolvePerBrowserOption(options.type, config.browser),
+      persistent: resolvePerBrowserOption(options.persistent, config.browser)
+    }
+  };
+}
+async function getContentScriptEntrypoint(config, path7) {
+  const name = getEntrypointName(config.entrypointsDir, path7);
+  const { main: _, ...options } = await importEntrypointFile(path7, config);
+  if (options == null) {
+    throw Error(
+      `${name}: Default export not found, did you forget to call "export default defineContentScript(...)"?`
+    );
+  }
+  return {
+    type: "content-script",
+    name,
+    inputPath: path7,
+    outputDir: resolve12(config.outDir, CONTENT_SCRIPT_OUT_DIR),
+    options
+  };
+}
+var PATH_GLOB_TO_TYPE_MAP = {
+  "sandbox.html": "sandbox",
+  "sandbox/index.html": "sandbox",
+  "*.sandbox.html": "sandbox",
+  "*.sandbox/index.html": "sandbox",
+  "bookmarks.html": "bookmarks",
+  "bookmarks/index.html": "bookmarks",
+  "history.html": "history",
+  "history/index.html": "history",
+  "newtab.html": "newtab",
+  "newtab/index.html": "newtab",
+  "sidepanel.html": "sidepanel",
+  "sidepanel/index.html": "sidepanel",
+  "*.sidepanel.html": "sidepanel",
+  "*.sidepanel/index.html": "sidepanel",
+  "devtools.html": "devtools",
+  "devtools/index.html": "devtools",
+  "background.[jt]s": "background",
+  "background/index.[jt]s": "background",
+  [VIRTUAL_NOOP_BACKGROUND_MODULE_ID]: "background",
+  "content.[jt]s?(x)": "content-script",
+  "content/index.[jt]s?(x)": "content-script",
+  "*.content.[jt]s?(x)": "content-script",
+  "*.content/index.[jt]s?(x)": "content-script",
+  [`content.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
+  [`*.content.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
+  [`content/index.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
+  [`*.content/index.${CSS_EXTENSIONS_PATTERN}`]: "content-script-style",
+  "popup.html": "popup",
+  "popup/index.html": "popup",
+  "options.html": "options",
+  "options/index.html": "options",
+  "*.html": "unlisted-page",
+  "*/index.html": "unlisted-page",
+  "*.[jt]s": "unlisted-script",
+  "*/index.ts": "unlisted-script",
+  [`*.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style",
+  [`*/index.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style",
+  // Don't warn about any files in subdirectories, like CSS or JS entrypoints for HTML files or tests
+  "*/**": "ignored"
+};
+var CONTENT_SCRIPT_OUT_DIR = "content-scripts";
+
+export {
+  getEntrypointOutputFile,
+  getEntrypointBundlePath,
+  resolvePerBrowserOption,
+  formatDuration,
+  download,
+  unimport,
+  tsconfigPaths,
+  globals,
+  webextensionPolyfillAlias,
+  detectDevChanges,
+  findEntrypoints,
+  generateTypesDir,
+  getInternalConfig,
+  kebabCaseAlphanumeric,
+  printFileList,
+  version,
+  getPackageJson,
+  getContentScriptCssFiles,
+  getContentScriptsCssMap,
+  rebuild,
+  internalBuild
+};