wxt 0.11.1 → 0.12.0

package/dist/cli.js

@@ -0,0 +1,3119 @@
+import "./chunk-VBXJIVYU.js";
+
+// src/cli.ts
+import cac from "cac";
+
+// package.json
+var version = "0.12.0";
+
+// src/core/utils/fs.ts
+import fs from "fs-extra";
+import glob from "fast-glob";
+
+// src/core/utils/paths.ts
+import systemPath from "node:path";
+import normalize from "normalize-path";
+function normalizePath(path7) {
+  return normalize(path7);
+}
+function unnormalizePath(path7) {
+  return systemPath.normalize(path7);
+}
+var CSS_EXTENSIONS = ["css", "scss", "sass", "less", "styl", "stylus"];
+var CSS_EXTENSIONS_PATTERN = `+(${CSS_EXTENSIONS.join("|")})`;
+
+// src/core/utils/fs.ts
+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 getPublicFiles(config) {
+  if (!await fs.exists(config.publicDir))
+    return [];
+  const files = await glob("**/*", { cwd: config.publicDir });
+  return files.map(unnormalizePath);
+}
+
+// src/core/utils/building/build-entrypoints.ts
+import fs2 from "fs-extra";
+import { dirname, resolve } 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));
+  }
+  const publicAssets = await copyPublicDirectory(config);
+  return { publicAssets, steps };
+}
+async function copyPublicDirectory(config) {
+  const files = await getPublicFiles(config);
+  if (files.length === 0)
+    return [];
+  const publicAssets = [];
+  for (const file of files) {
+    const srcPath = resolve(config.publicDir, file);
+    const outPath = resolve(config.outDir, file);
+    await fs2.ensureDir(dirname(outPath));
+    await fs2.copyFile(srcPath, outPath);
+    publicAssets.push({
+      type: "asset",
+      fileName: file
+    });
+  }
+  return publicAssets;
+}
+
+// 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 relative2, resolve as resolve3 } from "path";
+import fs3 from "fs-extra";
+import { minimatch } from "minimatch";
+import { parseHTML } from "linkedom";
+import JSON5 from "json5";
+import glob2 from "fast-glob";
+
+// src/core/utils/entrypoints.ts
+import path, { relative, resolve as resolve2 } from "node:path";
+function getEntrypointName(entrypointsDir, inputPath) {
+  const relativePath = path.relative(entrypointsDir, inputPath);
+  const name = relativePath.split(/[\.\/\\]/, 2)[0];
+  return name;
+}
+function getEntrypointOutputFile(entrypoint, ext) {
+  return resolve2(entrypoint.outputDir, `${entrypoint.name}${ext}`);
+}
+function getEntrypointBundlePath(entrypoint, outDir, ext) {
+  return normalizePath(
+    relative(outDir, getEntrypointOutputFile(entrypoint, ext))
+  );
+}
+function resolvePerBrowserOption(option, browser) {
+  if (typeof option === "object" && !Array.isArray(option))
+    return option[browser];
+  return option;
+}
+
+// src/core/utils/constants.ts
+var VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";
+
+// src/core/utils/building/find-entrypoints.ts
+async function findEntrypoints(config) {
+  const relativePaths = await glob2(Object.keys(PATH_GLOB_TO_TYPE_MAP), {
+    cwd: config.entrypointsDir
+  });
+  relativePaths.sort();
+  const pathGlobs = Object.keys(PATH_GLOB_TO_TYPE_MAP);
+  const entrypointInfos = relativePaths.reduce((results, relativePath) => {
+    const inputPath = resolve3(config.entrypointsDir, relativePath);
+    const name = getEntrypointName(config.entrypointsDir, inputPath);
+    const matchingGlob = pathGlobs.find(
+      (glob5) => minimatch(relativePath, glob5)
+    );
+    if (matchingGlob) {
+      const type = PATH_GLOB_TO_TYPE_MAP[matchingGlob];
+      results.push({ name, inputPath, type });
+    }
+    return results;
+  }, []);
+  preventNoEntrypoints(config, entrypointInfos);
+  preventDuplicateEntrypointNames(config, entrypointInfos);
+  let hasBackground = false;
+  const entrypoints = await Promise.all(
+    entrypointInfos.map(async (info) => {
+      const { type } = info;
+      switch (type) {
+        case "popup":
+          return await getPopupEntrypoint(config, info);
+        case "options":
+          return await getOptionsEntrypoint(config, info);
+        case "background":
+          hasBackground = true;
+          return await getBackgroundEntrypoint(config, info);
+        case "content-script":
+          return await getContentScriptEntrypoint(config, info);
+        case "unlisted-page":
+          return await getUnlistedPageEntrypoint(config, info);
+        case "unlisted-script":
+          return await getUnlistedScriptEntrypoint(config, info);
+        case "content-script-style":
+          return {
+            ...info,
+            type,
+            outputDir: resolve3(config.outDir, CONTENT_SCRIPT_OUT_DIR),
+            options: {
+              include: void 0,
+              exclude: void 0
+            }
+          };
+        default:
+          return {
+            ...info,
+            type,
+            outputDir: config.outDir,
+            options: {
+              include: void 0,
+              exclude: void 0
+            }
+          };
+      }
+    })
+  );
+  if (config.command === "serve" && !hasBackground) {
+    entrypoints.push(
+      await getBackgroundEntrypoint(config, {
+        inputPath: VIRTUAL_NOOP_BACKGROUND_MODULE_ID,
+        name: "background",
+        type: "background"
+      })
+    );
+  }
+  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 preventDuplicateEntrypointNames(config, files) {
+  const namesToPaths = files.reduce(
+    (map, { name, inputPath }) => {
+      map[name] ??= [];
+      map[name].push(inputPath);
+      return map;
+    },
+    {}
+  );
+  const errorLines = Object.entries(namesToPaths).reduce(
+    (lines, [name, absolutePaths]) => {
+      if (absolutePaths.length > 1) {
+        lines.push(`- ${name}`);
+        absolutePaths.forEach((absolutePath) => {
+          lines.push(`  - ${relative2(config.root, absolutePath)}`);
+        });
+      }
+      return lines;
+    },
+    []
+  );
+  if (errorLines.length > 0) {
+    const errorContent = errorLines.join("\n");
+    throw Error(
+      `Multiple entrypoints with the same name detected, only one entrypoint for each name is allowed.
+
+${errorContent}`
+    );
+  }
+}
+function preventNoEntrypoints(config, files) {
+  if (files.length === 0) {
+    throw Error(`No entrypoints found in ${config.entrypointsDir}`);
+  }
+}
+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, { inputPath, name }) {
+  const content = await fs3.readFile(inputPath, "utf-8");
+  const { document } = parseHTML(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,
+    outputDir: config.outDir
+  };
+}
+async function getOptionsEntrypoint(config, { inputPath, name }) {
+  const content = await fs3.readFile(inputPath, "utf-8");
+  const { document } = parseHTML(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,
+    outputDir: config.outDir
+  };
+}
+async function getUnlistedPageEntrypoint(config, { inputPath, name }) {
+  const content = await fs3.readFile(inputPath, "utf-8");
+  const { document } = parseHTML(content);
+  return {
+    type: "unlisted-page",
+    name: getEntrypointName(config.entrypointsDir, inputPath),
+    inputPath,
+    outputDir: config.outDir,
+    options: getHtmlBaseOptions(document)
+  };
+}
+async function getUnlistedScriptEntrypoint(config, { inputPath, name }) {
+  const defaultExport = await importEntrypointFile(
+    inputPath,
+    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,
+    outputDir: config.outDir,
+    options
+  };
+}
+async function getBackgroundEntrypoint(config, { inputPath, name }) {
+  let options = {};
+  if (inputPath !== VIRTUAL_NOOP_BACKGROUND_MODULE_ID) {
+    const defaultExport = await importEntrypointFile(
+      inputPath,
+      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,
+    outputDir: config.outDir,
+    options: {
+      ...options,
+      type: resolvePerBrowserOption(options.type, config.browser),
+      persistent: resolvePerBrowserOption(options.persistent, config.browser)
+    }
+  };
+}
+async function getContentScriptEntrypoint(config, { inputPath, name }) {
+  const { main: _, ...options } = await importEntrypointFile(inputPath, 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,
+    outputDir: resolve3(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?(x)": "unlisted-script",
+  "*/index.[jt]s?(x)": "unlisted-script",
+  [`*.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style",
+  [`*/index.${CSS_EXTENSIONS_PATTERN}`]: "unlisted-style"
+};
+var CONTENT_SCRIPT_OUT_DIR = "content-scripts";
+
+// src/core/utils/building/generate-wxt-dir.ts
+import { createUnimport } from "unimport";
+import fs4 from "fs-extra";
+import { relative as relative3, resolve as resolve4 } from "path";
+
+// src/core/utils/unimport.ts
+import { defu } from "defu";
+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" },
+      { package: "wxt/storage" }
+    ],
+    warn: config.logger.warn,
+    dirs: ["components", "composables", "hooks", "utils"]
+  };
+  return defu(config.imports, defaultOptions);
+}
+
+// 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(entrypointName) {
+  return [
+    {
+      name: surroundInUnderscore("ENTRYPOINT"),
+      value: entrypointName,
+      type: `string`
+    }
+  ];
+}
+function surroundInUnderscore(name) {
+  return `__${name}__`;
+}
+
+// src/core/utils/building/generate-wxt-dir.ts
+import path2 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 fs4.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 = resolve4(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 = resolve4(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 = resolve4(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 fs4.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 = resolve4(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 = resolve4(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;
+}
+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(
+    resolve4(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/utils/building/get-internal-config.ts
+import { loadConfig } from "c12";
+import path3 from "node:path";
+
+// src/core/utils/cache.ts
+import fs5, { ensureDir } from "fs-extra";
+import { dirname as dirname2, resolve as resolve5 } from "path";
+function createFsCache(wxtDir) {
+  const getPath = (key) => resolve5(wxtDir, "cache", encodeURIComponent(key));
+  return {
+    async set(key, value) {
+      const path7 = getPath(key);
+      await ensureDir(dirname2(path7));
+      await writeFileIfDifferent(path7, value);
+    },
+    async get(key) {
+      const path7 = getPath(key);
+      try {
+        return await fs5.readFile(path7, "utf-8");
+      } catch {
+        return void 0;
+      }
+    }
+  };
+}
+
+// src/core/utils/building/get-internal-config.ts
+import consola, { LogLevels } from "consola";
+
+// src/core/builders/vite/plugins/devHtmlPrerender.ts
+import { parseHTML as parseHTML2 } from "linkedom";
+import { dirname as dirname3, isAbsolute, relative as relative4, resolve as resolve6 } from "node:path";
+var reactRefreshPreamble = "";
+function devHtmlPrerender(config) {
+  const htmlReloadId = "@wxt/reload-html";
+  const resolvedHtmlReloadId = resolve6(
+    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 } = parseHTML2(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 = resolve6(dirname3(id), src);
+              const pathname = relative4(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.transformHtml(url, html, originalUrl);
+        const { document } = parseHTML2(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/builders/vite/plugins/devServerGlobals.ts
+function devServerGlobals(config) {
+  return {
+    name: "wxt:dev-server-globals",
+    config() {
+      if (config.server == null || config.command == "build")
+        return;
+      return {
+        define: {
+          __DEV_SERVER_PROTOCOL__: JSON.stringify("ws:"),
+          __DEV_SERVER_HOSTNAME__: JSON.stringify(config.server.hostname),
+          __DEV_SERVER_PORT__: JSON.stringify(config.server.port)
+        }
+      };
+    }
+  };
+}
+
+// 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 resolve7, join } from "node:path";
+import fs6, { 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 = resolve7(config.outDir, oldBundlePath);
+        const newAbsPath = resolve7(config.outDir, newBundlePath);
+        await ensureDir2(dirname4(newAbsPath));
+        await fs6.move(oldAbsPath, newAbsPath, { overwrite: true });
+        const renamedChunk = {
+          ...bundle[oldBundlePath],
+          fileName: newBundlePath
+        };
+        delete bundle[oldBundlePath];
+        bundle[newBundlePath] = renamedChunk;
+      }
+      removeEmptyDirs(config.outDir);
+    }
+  };
+}
+async function removeEmptyDirs(dir) {
+  const files = await fs6.readdir(dir);
+  for (const file of files) {
+    const filePath = join(dir, file);
+    const stats = await fs6.stat(filePath);
+    if (stats.isDirectory()) {
+      await removeEmptyDirs(filePath);
+    }
+  }
+  try {
+    await fs6.rmdir(dir);
+  } catch {
+  }
+}
+
+// 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 fs7 from "fs-extra";
+import { resolve as resolve8 } 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 = normalizePath(id.substring(index + virtualId.length));
+      return resolvedVirtualId + inputPath;
+    },
+    async load(id) {
+      if (!id.startsWith(resolvedVirtualId))
+        return;
+      const inputPath = id.replace(resolvedVirtualId, "");
+      const template = await fs7.readFile(
+        resolve8(
+          config.root,
+          `node_modules/wxt/dist/virtual/${type}-entrypoint.js`
+        ),
+        "utf-8"
+      );
+      return template.replace(`virtual:user-${type}`, inputPath);
+    }
+  };
+}
+
+// src/core/builders/vite/plugins/tsconfigPaths.ts
+function tsconfigPaths(config) {
+  return {
+    name: "wxt:aliases",
+    async config() {
+      return {
+        resolve: {
+          alias: config.alias
+        }
+      };
+    }
+  };
+}
+
+// src/core/builders/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)`;
+      }
+    }
+  };
+}
+
+// src/core/builders/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/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`
+  });
+}
+
+// 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
+      };
+    }
+  };
+}
+
+// src/core/builders/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/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-isolated-world", wxtConfig),
+      virtualEntrypoint("content-script-main-world", 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) => {
+    let virtualEntrypointType;
+    switch (entrypoint.type) {
+      case "background":
+      case "unlisted-script":
+        virtualEntrypointType = entrypoint.type;
+        break;
+      case "content-script":
+        virtualEntrypointType = entrypoint.options.world === "MAIN" ? "content-script-main-world" : "content-script-isolated-world";
+        break;
+    }
+    const entry = virtualEntrypointType ? `virtual:wxt-${virtualEntrypointType}?${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 defu2 from "defu";
+async function getInternalConfig(inlineConfig, command, server) {
+  let userConfig = {};
+  let userConfigMetadata;
+  if (inlineConfig.configFile !== false) {
+    const { config: loadedConfig, ...metadata } = await loadConfig({
+      name: "wxt",
+      cwd: inlineConfig.root ?? process.cwd(),
+      rcFile: false,
+      jitiOptions: {
+        esmResolve: true
+      }
+    });
+    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 = path3.resolve(
+    inlineConfig.root ?? userConfig.root ?? process.cwd()
+  );
+  const wxtDir = path3.resolve(root, ".wxt");
+  const srcDir = path3.resolve(root, mergedConfig.srcDir ?? root);
+  const entrypointsDir = path3.resolve(
+    srcDir,
+    mergedConfig.entrypointsDir ?? "entrypoints"
+  );
+  const publicDir = path3.resolve(srcDir, mergedConfig.publicDir ?? "public");
+  const typesDir = path3.resolve(wxtDir, "types");
+  const outBaseDir = path3.resolve(root, mergedConfig.outDir ?? ".output");
+  const outDir = path3.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 alias = Object.fromEntries(
+    Object.entries({
+      ...mergedConfig.alias,
+      "@": srcDir,
+      "~": srcDir,
+      "@@": root,
+      "~~": root
+    }).map(([key, value]) => [key, path3.resolve(root, value)])
+  );
+  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,
+    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 ?? {},
+    alias,
+    experimental: {
+      includeBrowserPolyfill: mergedConfig.experimental?.includeBrowserPolyfill ?? true
+    },
+    server
+  };
+  const builder = await craeteViteBuilder(
+    inlineConfig,
+    userConfig,
+    finalConfig
+  );
+  return {
+    ...finalConfig,
+    builder
+  };
+}
+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 = defu2(inlineConfig.imports ?? {}, userConfig.imports ?? {});
+  }
+  const manifest = async (env) => {
+    const user = await resolveManifestConfig(env, userConfig.manifest);
+    const inline = await resolveManifestConfig(env, inlineConfig.manifest);
+    return defu2(inline, user);
+  };
+  const runner = defu2(
+    inlineConfig.runner ?? {},
+    userConfig.runner ?? {}
+  );
+  const zip2 = defu2(
+    inlineConfig.zip ?? {},
+    userConfig.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,
+    outDir: inlineConfig.outDir ?? userConfig.outDir,
+    zip: zip2,
+    analysis: {
+      enabled: inlineConfig.analysis?.enabled ?? userConfig.analysis?.enabled,
+      template: inlineConfig.analysis?.template ?? userConfig.analysis?.template
+    },
+    alias: {
+      ...userConfig.alias,
+      ...inlineConfig.alias
+    },
+    experimental: {
+      ...userConfig.experimental,
+      ...inlineConfig.experimental
+    },
+    vite: void 0,
+    transformManifest: void 0
+  };
+}
+function resolveInternalZipConfig(root, mergedConfig) {
+  return {
+    name: void 0,
+    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 ?? []
+    ]
+  };
+}
+
+// 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 fs8 from "fs-extra";
+import { resolve as resolve9 } from "node: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 { defineUnlistedScript, defineContentScript, defineBackground } from 'wxt/sandbox';
+
+${noImports}`;
+}
+
+// src/core/utils/building/import-entrypoint.ts
+import { transformSync } from "esbuild";
+import { fileURLToPath } from "node:url";
+async function importEntrypointFile(path7, config) {
+  config.logger.debug("Loading file metadata:", path7);
+  const normalPath = normalizePath(path7);
+  const unimport2 = createUnimport3({
+    ...getUnimportOptions(config),
+    // Only allow specific imports, not all from the project
+    dirs: []
+  });
+  await unimport2.init();
+  const text = await fs8.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(
+    typeof __filename !== "undefined" ? __filename : fileURLToPath(import.meta.url),
+    {
+      cache: false,
+      debug: config.debug,
+      esmResolve: true,
+      alias: {
+        "webextension-polyfill": resolve9(
+          config.root,
+          "node_modules/wxt/dist/virtual/mock-browser.js"
+        )
+      },
+      // Continue using node to load TS files even if `bun run --bun` is detected. Jiti does not
+      // respect the custom transform function when using it's native bun option.
+      experimentalBun: false,
+      // 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 fs12 from "fs-extra";
+
+// src/core/utils/log/printBuildSummary.ts
+import { resolve as resolve10 } from "path";
+
+// src/core/utils/log/printFileList.ts
+import path4 from "node:path";
+import pc2 from "picocolors";
+import fs9 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 = [
+        path4.relative(process.cwd(), baseDir) + path4.sep,
+        path4.relative(baseDir, file)
+      ];
+      const prefix = i === files.length - 1 ? "  \u2514\u2500" : "  \u251C\u2500";
+      const color = getChunkColor(file);
+      const stats = await fs9.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) => resolve10(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";
+function printHeader() {
+  console.log();
+  consola2.log(`${pc3.gray("WXT")} ${pc3.gray(pc3.bold(version))}`);
+}
+
+// src/core/utils/building/internal-build.ts
+import glob3 from "fast-glob";
+
+// src/core/utils/manifest.ts
+import fs11 from "fs-extra";
+import { resolve as resolve12 } 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 resolve11 } from "node:path";
+import fs10 from "fs-extra";
+async function getPackageJson(config) {
+  const file = resolve11(config.root, "package.json");
+  try {
+    return await fs10.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 defu3 from "defu";
+async function writeManifest(manifest, output, config) {
+  const str = config.mode === "production" ? JSON.stringify(manifest) : JSON.stringify(manifest, null, 2);
+  await fs11.ensureDir(config.outDir);
+  await writeFileIfDifferent(resolve12(config.outDir, "manifest.json"), str);
+  output.publicAssets.unshift({
+    type: "asset",
+    fileName: "manifest.json"
+  });
+}
+async function generateMainfest(entrypoints, buildOutput, config) {
+  const pkg = await getPackageJson(config);
+  const versionName = config.manifest.version_name ?? pkg?.version;
+  const version2 = config.manifest.version ?? simplifyVersion(pkg?.version);
+  const baseManifest = {
+    manifest_version: config.manifestVersion,
+    name: pkg?.name,
+    description: pkg?.description,
+    version: version2,
+    version_name: (
+      // Firefox doesn't support version_name
+      config.browser === "firefox" || versionName === version2 ? void 0 : versionName
+    ),
+    short_name: pkg?.shortName,
+    icons: discoverIcons(buildOutput)
+  };
+  const userManifest = config.manifest;
+  const manifest = defu3(
+    userManifest,
+    baseManifest
+  );
+  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 version2 = /^((0|[1-9][0-9]{0,8})([.](0|[1-9][0-9]{0,8})){0,3}).*$/.exec(
+    versionName
+  )?.[1];
+  if (version2 == null)
+    throw Error(
+      `Cannot simplify package.json version "${versionName}" to a valid extension version, "X.Y.Z"`
+    );
+  return version2;
+}
+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 (config.browser === "firefox" && config.manifestVersion === 3) {
+      manifest.background = {
+        type: background.options.type,
+        scripts: [script]
+      };
+    } else if (config.manifestVersion === 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$/,
+    // icon-16.png
+    /^icon-([0-9]+)x[0-9]+\.png$/,
+    // icon-16x16.png
+    /^icon@([0-9]+)w\.png$/,
+    // icon@16w.png
+    /^icon@([0-9]+)h\.png$/,
+    // icon@16h.png
+    /^icon@([0-9]+)\.png$/,
+    // icon@16.png
+    /^icons?[\/\\]([0-9]+)\.png$/,
+    // icon/16.png | icons/16.png
+    /^icons?[\/\\]([0-9]+)x[0-9]+\.png$/
+    // icon/16x16.png | icons/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, normalizePath(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(
+      `${config.builder.name} ${config.builder.version}`
+    )}`
+  );
+  const startTime = Date.now();
+  await fs12.rm(config.outDir, { recursive: true, force: true });
+  await fs12.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-4F7CCWCA.js");
+  const unixFiles = await glob3(`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/build.ts
+async function build(config) {
+  const internalConfig = await getInternalConfig(config ?? {}, "build");
+  return await internalBuild(internalConfig);
+}
+
+// src/core/clean.ts
+import path5 from "node:path";
+import glob4 from "fast-glob";
+import fs13 from "fs-extra";
+import { consola as consola3 } from "consola";
+import pc5 from "picocolors";
+async function clean(root = process.cwd()) {
+  consola3.info("Cleaning Project");
+  const tempDirs = [
+    "node_modules/.vite",
+    "node_modules/.cache",
+    "**/.wxt",
+    ".output/*"
+  ];
+  consola3.debug("Looking for:", tempDirs.map(pc5.cyan).join(", "));
+  const directories = await glob4(tempDirs, {
+    cwd: path5.resolve(root),
+    absolute: true,
+    onlyDirectories: true,
+    deep: 2
+  });
+  if (directories.length === 0) {
+    consola3.debug("No generated files found.");
+    return;
+  }
+  consola3.debug(
+    "Found:",
+    directories.map((dir) => pc5.cyan(path5.relative(root, dir))).join(", ")
+  );
+  for (const directory of directories) {
+    await fs13.rm(directory, { force: true, recursive: true });
+    consola3.debug("Deleted " + pc5.cyan(path5.relative(root, directory)));
+  }
+}
+
+// src/core/runners/wsl.ts
+import { relative as relative5 } from "node:path";
+function createWslRunner() {
+  return {
+    async openBrowser(config) {
+      config.logger.warn(
+        `Cannot open browser when using WSL. Load "${relative5(
+          process.cwd(),
+          config.outDir
+        )}" as an unpacked extension manually`
+      );
+    },
+    async closeBrowser() {
+    }
+  };
+}
+
+// src/core/runners/web-ext.ts
+function createWebExtRunner() {
+  let runner;
+  return {
+    async openBrowser(config) {
+      config.logger.info("Opening browser...");
+      if (config.browser === "firefox" && config.manifestVersion === 3) {
+        throw Error(
+          "Dev mode does not support Firefox MV3. For alternatives, see https://github.com/wxt-dev/wxt/issues/230#issuecomment-1806881653"
+        );
+      }
+      const webExtLogger = await import("web-ext-run/util/logger");
+      webExtLogger.consoleStream.write = ({ level, msg, name }) => {
+        if (level >= ERROR_LOG_LEVEL)
+          config.logger.error(name, msg);
+        if (level >= WARN_LOG_LEVEL)
+          config.logger.warn(msg);
+      };
+      const wxtUserConfig = config.runnerConfig.config;
+      const userConfig = {
+        console: wxtUserConfig?.openConsole,
+        devtools: wxtUserConfig?.openDevtools,
+        startUrl: wxtUserConfig?.startUrls,
+        ...config.browser === "firefox" ? {
+          firefox: wxtUserConfig?.binaries?.firefox,
+          firefoxProfile: wxtUserConfig?.firefoxProfile,
+          prefs: wxtUserConfig?.firefoxPrefs,
+          args: wxtUserConfig?.firefoxArgs
+        } : {
+          chromiumBinary: wxtUserConfig?.binaries?.[config.browser],
+          chromiumProfile: wxtUserConfig?.chromiumProfile,
+          args: wxtUserConfig?.chromiumArgs
+        }
+      };
+      const finalConfig = {
+        ...userConfig,
+        target: config.browser === "firefox" ? "firefox-desktop" : "chromium",
+        sourceDir: config.outDir,
+        // WXT handles reloads, so disable auto-reload behaviors in web-ext
+        noReload: true,
+        noInput: true
+      };
+      const options = {
+        // Don't call `process.exit(0)` after starting web-ext
+        shouldExitProgram: false
+      };
+      config.logger.debug("web-ext config:", finalConfig);
+      config.logger.debug("web-ext options:", options);
+      const webExt = await import("web-ext-run");
+      runner = await webExt.default.cmd.run(finalConfig, options);
+      config.logger.success("Opened!");
+    },
+    async closeBrowser() {
+      return await runner?.exit();
+    }
+  };
+}
+var WARN_LOG_LEVEL = 40;
+var ERROR_LOG_LEVEL = 50;
+
+// src/core/runners/safari.ts
+import { relative as relative6 } from "node:path";
+function createSafariRunner() {
+  return {
+    async openBrowser(config) {
+      config.logger.warn(
+        `Cannot Safari using web-ext. Load "${relative6(
+          process.cwd(),
+          config.outDir
+        )}" as an unpacked extension manually`
+      );
+    },
+    async closeBrowser() {
+    }
+  };
+}
+
+// src/core/runners/manual.ts
+import { relative as relative7 } from "node:path";
+function createManualRunner() {
+  return {
+    async openBrowser(config) {
+      config.logger.info(
+        `Load "${relative7(
+          process.cwd(),
+          config.outDir
+        )}" as an unpacked extension manually`
+      );
+    },
+    async closeBrowser() {
+    }
+  };
+}
+
+// src/core/utils/wsl.ts
+async function isWsl() {
+  const { default: isWsl2 } = await import("is-wsl");
+  return isWsl2;
+}
+
+// src/core/runners/index.ts
+async function createExtensionRunner(config) {
+  if (config.browser === "safari")
+    return createSafariRunner();
+  if (await isWsl())
+    return createWslRunner();
+  if (config.runnerConfig.config?.disabled)
+    return createManualRunner();
+  return createWebExtRunner();
+}
+
+// src/core/create-server.ts
+import { consola as consola4 } from "consola";
+import { Mutex } from "async-mutex";
+import pc6 from "picocolors";
+import { relative as relative8 } from "node:path";
+async function createServer(inlineConfig) {
+  const port = await getPort();
+  const hostname = "localhost";
+  const origin = `http://${hostname}:${port}`;
+  const serverInfo = {
+    port,
+    hostname,
+    origin
+  };
+  const server = {
+    ...serverInfo,
+    watcher: void 0,
+    // Filled out later down below
+    ws: void 0,
+    // Filled out later down below
+    currentOutput: void 0,
+    // Filled out later down below
+    async start() {
+      await builderServer.listen();
+      config.logger.success(`Started dev server @ ${serverInfo.origin}`);
+      server.currentOutput = await internalBuild(config);
+      await runner.openBrowser(config);
+    },
+    transformHtml(url, html, originalUrl) {
+      return builderServer.transformHtml(url, html, originalUrl);
+    },
+    reloadContentScript(contentScript) {
+      server.ws.send("wxt:reload-content-script", contentScript);
+    },
+    reloadPage(path7) {
+      server.ws.send("wxt:reload-page", path7);
+    },
+    reloadExtension() {
+      server.ws.send("wxt:reload-extension");
+    }
+  };
+  const getLatestConfig = () => getInternalConfig(inlineConfig ?? {}, "serve", server);
+  let config = await getLatestConfig();
+  const [runner, builderServer] = await Promise.all([
+    createExtensionRunner(config),
+    config.builder.createServer(server)
+  ]);
+  server.watcher = builderServer.watcher;
+  server.ws = builderServer.ws;
+  server.ws.on("wxt:background-initialized", () => {
+    reloadContentScripts(server.currentOutput.steps, config, server);
+  });
+  const reloadOnChange = createFileReloader({
+    server,
+    getLatestConfig,
+    updateConfig(newConfig) {
+      config = newConfig;
+    }
+  });
+  server.watcher.on("all", reloadOnChange);
+  return server;
+}
+async function getPort() {
+  const { default: getPort2, portNumbers } = await import("get-port");
+  return await getPort2({ port: portNumbers(3e3, 3010) });
+}
+function createFileReloader(options) {
+  const { server, getLatestConfig, updateConfig } = options;
+  const fileChangedMutex = new Mutex();
+  const changeQueue = [];
+  return async (event, path7) => {
+    const config = await getLatestConfig();
+    updateConfig(config);
+    if (path7.startsWith(config.outBaseDir))
+      return;
+    changeQueue.push([event, path7]);
+    await fileChangedMutex.runExclusive(async () => {
+      const fileChanges = changeQueue.splice(0, changeQueue.length);
+      if (fileChanges.length === 0)
+        return;
+      const changes = detectDevChanges(fileChanges, server.currentOutput);
+      if (changes.type === "no-change")
+        return;
+      config.logger.info(
+        `Changed: ${Array.from(new Set(fileChanges.map((change) => change[1]))).map((file) => pc6.dim(relative8(config.root, file))).join(", ")}`
+      );
+      const rebuiltNames = changes.rebuildGroups.flat().map((entry) => {
+        return pc6.cyan(
+          relative8(config.outDir, getEntrypointOutputFile(entry, ""))
+        );
+      }).join(pc6.dim(", "));
+      const { output: newOutput } = await rebuild(
+        config,
+        // TODO: this excludes new entrypoints, so they're not built until the dev command is restarted
+        changes.rebuildGroups,
+        changes.cachedOutput
+      );
+      server.currentOutput = newOutput;
+      switch (changes.type) {
+        case "extension-reload":
+          server.reloadExtension();
+          break;
+        case "html-reload":
+          reloadHtmlPages(changes.rebuildGroups, server, config);
+          break;
+        case "content-script-reload":
+          reloadContentScripts(changes.changedSteps, config, server);
+          break;
+      }
+      consola4.success(`Reloaded: ${rebuiltNames}`);
+    });
+  };
+}
+function reloadContentScripts(steps, config, server) {
+  if (config.manifestVersion === 3) {
+    steps.forEach((step) => {
+      const entry = step.entrypoints;
+      if (Array.isArray(entry) || entry.type !== "content-script")
+        return;
+      const js = [getEntrypointBundlePath(entry, config.outDir, ".js")];
+      const cssMap = getContentScriptsCssMap(server.currentOutput, [entry]);
+      const css = getContentScriptCssFiles([entry], cssMap);
+      server.reloadContentScript({
+        allFrames: resolvePerBrowserOption(
+          entry.options.allFrames,
+          config.browser
+        ),
+        excludeMatches: resolvePerBrowserOption(
+          entry.options.excludeMatches,
+          config.browser
+        ),
+        matches: resolvePerBrowserOption(entry.options.matches, config.browser),
+        runAt: resolvePerBrowserOption(entry.options.runAt, config.browser),
+        // @ts-expect-error: Chrome accepts this, not typed in webextension-polyfill (https://developer.chrome.com/docs/extensions/reference/scripting/#type-RegisteredContentScript)
+        world: resolvePerBrowserOption(entry.options.world, config.browser),
+        js,
+        css
+      });
+    });
+  } else {
+    server.reloadExtension();
+  }
+}
+function reloadHtmlPages(groups, server, config) {
+  groups.flat().forEach((entry) => {
+    const path7 = getEntrypointBundlePath(entry, config.outDir, ".html");
+    server.reloadPage(path7);
+  });
+}
+
+// src/core/initialize.ts
+import prompts from "prompts";
+import { consola as consola5 } from "consola";
+import { downloadTemplate } from "giget";
+import fs14 from "fs-extra";
+import path6 from "node:path";
+import pc7 from "picocolors";
+async function initialize(options) {
+  consola5.info("Initalizing new project");
+  const templates = await listTemplates();
+  const defaultTemplate = templates.find(
+    (template) => template.name === options.template?.toLowerCase().trim()
+  );
+  const input = await prompts(
+    [
+      {
+        name: "directory",
+        type: () => options.directory == null ? "text" : void 0,
+        message: "Project Directory",
+        initial: options.directory
+      },
+      {
+        name: "template",
+        type: () => defaultTemplate == null ? "select" : void 0,
+        message: "Choose a template",
+        choices: templates.map((template) => ({
+          title: TEMPLATE_COLORS[template.name]?.(template.name) ?? template.name,
+          value: template
+        }))
+      },
+      {
+        name: "packageManager",
+        type: () => options.packageManager == null ? "select" : void 0,
+        message: "Package Manager",
+        choices: [
+          { title: pc7.red("npm"), value: "npm" },
+          { title: pc7.yellow("pnpm"), value: "pnpm" },
+          { title: pc7.cyan("yarn"), value: "yarn" },
+          {
+            title: `${pc7.magenta("bun")}${pc7.gray(" (experimental)")}`,
+            value: "bun"
+          }
+        ]
+      }
+    ],
+    {
+      onCancel: () => process.exit(1)
+    }
+  );
+  input.directory ??= options.directory;
+  input.template ??= defaultTemplate;
+  input.packageManager ??= options.packageManager;
+  await cloneProject(input);
+  const cdPath = path6.relative(process.cwd(), path6.resolve(input.directory));
+  console.log();
+  consola5.log(
+    `\u2728 WXT project created with the ${TEMPLATE_COLORS[input.template.name]?.(input.template.name) ?? input.template.name} template.`
+  );
+  console.log();
+  consola5.log("Next steps:");
+  let step = 0;
+  if (cdPath !== "")
+    consola5.log(`  ${++step}.`, pc7.cyan(`cd ${cdPath}`));
+  consola5.log(`  ${++step}.`, pc7.cyan(`${input.packageManager} install`));
+  console.log();
+}
+async function listTemplates() {
+  try {
+    const res = await fetch(
+      "https://api.github.com/repos/wxt-dev/wxt/contents/templates",
+      {
+        headers: {
+          Accept: "application/vnd.github+json",
+          "X-GitHub-Api-Version": "2022-11-28"
+        }
+      }
+    );
+    if (res.status >= 300)
+      throw Error(`Request failed with status ${res.status} ${res.statusText}`);
+    const data = await res.json();
+    return data.filter((item) => item.type === "dir").map((item) => ({ name: item.name, path: item.path })).sort((l, r) => {
+      const lWeight = TEMPLATE_SORT_WEIGHT[l.name] ?? Number.MAX_SAFE_INTEGER;
+      const rWeight = TEMPLATE_SORT_WEIGHT[r.name] ?? Number.MAX_SAFE_INTEGER;
+      const diff = lWeight - rWeight;
+      if (diff !== 0)
+        return diff;
+      return l.name.localeCompare(r.name);
+    });
+  } catch (err) {
+    throw Error(`Cannot load templates: ${JSON.stringify(err, null, 2)}`);
+  }
+}
+async function cloneProject({
+  directory,
+  template,
+  packageManager
+}) {
+  const { default: ora } = await import("ora");
+  const spinner = ora("Downloading template").start();
+  try {
+    await downloadTemplate(`gh:wxt-dev/wxt/${template.path}`, {
+      dir: directory,
+      force: true
+    });
+    await fs14.move(
+      path6.join(directory, "_gitignore"),
+      path6.join(directory, ".gitignore")
+    ).catch(
+      (err) => consola5.warn("Failed to move _gitignore to .gitignore:", err)
+    );
+    if (packageManager === "pnpm") {
+      await fs14.writeFile(
+        path6.join(directory, ".npmrc"),
+        "shamefully-hoist=true\n"
+      );
+    }
+    spinner.succeed();
+  } catch (err) {
+    spinner.fail();
+    throw Error(`Failed to setup new project: ${JSON.stringify(err, null, 2)}`);
+  }
+}
+var TEMPLATE_COLORS = {
+  vanilla: pc7.blue,
+  vue: pc7.green,
+  react: pc7.cyan,
+  svelte: pc7.red,
+  solid: pc7.blue
+};
+var TEMPLATE_SORT_WEIGHT = {
+  vanilla: 0,
+  vue: 1,
+  react: 2
+};
+
+// src/core/prepare.ts
+async function prepare(config) {
+  const internalConfig = await getInternalConfig(config, "build");
+  internalConfig.logger.info("Generating types...");
+  const entrypoints = await findEntrypoints(internalConfig);
+  await generateTypesDir(entrypoints, internalConfig);
+}
+
+// src/core/zip.ts
+import zipdir from "zip-dir";
+import { dirname as dirname5, relative as relative9, resolve as resolve13 } from "node:path";
+import fs15 from "fs-extra";
+import { minimatch as minimatch2 } from "minimatch";
+async function zip(config) {
+  const internalConfig = await getInternalConfig(config ?? {}, "build");
+  const output = await internalBuild(internalConfig);
+  const start = Date.now();
+  internalConfig.logger.info("Zipping extension...");
+  const zipFiles = [];
+  const projectName = internalConfig.zip.name ?? kebabCaseAlphanumeric(
+    (await getPackageJson(internalConfig))?.name || dirname5(process.cwd())
+  );
+  const applyTemplate = (template) => template.replaceAll("{{name}}", projectName).replaceAll("{{browser}}", internalConfig.browser).replaceAll(
+    "{{version}}",
+    output.manifest.version_name ?? output.manifest.version
+  ).replaceAll("{{manifestVersion}}", `mv${internalConfig.manifestVersion}`);
+  await fs15.ensureDir(internalConfig.outBaseDir);
+  const outZipFilename = applyTemplate(internalConfig.zip.artifactTemplate);
+  const outZipPath = resolve13(internalConfig.outBaseDir, outZipFilename);
+  await zipdir(internalConfig.outDir, {
+    saveTo: outZipPath
+  });
+  zipFiles.push(outZipPath);
+  if (internalConfig.browser === "firefox") {
+    const sourcesZipFilename = applyTemplate(
+      internalConfig.zip.sourcesTemplate
+    );
+    const sourcesZipPath = resolve13(
+      internalConfig.outBaseDir,
+      sourcesZipFilename
+    );
+    await zipdir(internalConfig.zip.sourcesRoot, {
+      saveTo: sourcesZipPath,
+      filter(path7) {
+        const relativePath = relative9(internalConfig.zip.sourcesRoot, path7);
+        const matchedPattern = internalConfig.zip.ignoredSources.find(
+          (pattern) => minimatch2(relativePath, pattern)
+        );
+        return matchedPattern == null;
+      }
+    });
+    zipFiles.push(sourcesZipPath);
+  }
+  await printFileList(
+    internalConfig.logger.success,
+    `Zipped extension in ${formatDuration(Date.now() - start)}`,
+    internalConfig.outBaseDir,
+    zipFiles
+  );
+  return zipFiles;
+}
+
+// src/cli.ts
+import consola6, { LogLevels as LogLevels2 } from "consola";
+var cli = cac("wxt");
+cli.help();
+cli.version(version);
+cli.option("--debug", "enable debug mode");
+cli.command("[root]", "start dev server").option("-c, --config <file>", "use specified config file").option("-m, --mode <mode>", "set env mode").option("-b, --browser <browser>", "specify a browser").option("--mv3", "target manifest v3").option("--mv2", "target manifest v2").action(
+  wrapAction(async (root, flags) => {
+    const server = await createServer({
+      root,
+      mode: flags.mode,
+      browser: flags.browser,
+      manifestVersion: flags.mv3 ? 3 : flags.mv2 ? 2 : void 0,
+      configFile: flags.config,
+      debug: flags.debug
+    });
+    await server.start();
+    return { isOngoing: true };
+  })
+);
+cli.command("build [root]", "build for production").option("-c, --config <file>", "use specified config file").option("-m, --mode <mode>", "set env mode").option("-b, --browser <browser>", "specify a browser").option("--mv3", "target manifest v3").option("--mv2", "target manifest v2").option("--analyze", "visualize extension bundle").action(
+  wrapAction(async (root, flags) => {
+    await build({
+      root,
+      mode: flags.mode,
+      browser: flags.browser,
+      manifestVersion: flags.mv3 ? 3 : flags.mv2 ? 2 : void 0,
+      configFile: flags.config,
+      debug: flags.debug,
+      analysis: {
+        enabled: flags.analyze
+      }
+    });
+  })
+);
+cli.command("zip [root]", "build for production and zip output").option("-c, --config <file>", "use specified config file").option("-m, --mode <mode>", "set env mode").option("-b, --browser <browser>", "specify a browser").option("--mv3", "target manifest v3").option("--mv2", "target manifest v2").action(
+  wrapAction(async (root, flags) => {
+    await zip({
+      root,
+      mode: flags.mode,
+      browser: flags.browser,
+      manifestVersion: flags.mv3 ? 3 : flags.mv2 ? 2 : void 0,
+      configFile: flags.config,
+      debug: flags.debug
+    });
+  })
+);
+cli.command("prepare [root]", "prepare typescript project").option("-c, --config <file>", "use specified config file").action(
+  wrapAction(async (root, flags) => {
+    await prepare({
+      root,
+      configFile: flags.config,
+      debug: flags.debug
+    });
+  })
+);
+cli.command("clean [root]", "clean generated files and caches").alias("cleanup").action(
+  wrapAction(async (root, flags) => {
+    await clean(root);
+  })
+);
+cli.command("init [directory]", "initialize a new project").option("-t, --template <template>", "template to use").option("--pm <packageManager>", "which package manager to use").action(
+  wrapAction(
+    async (directory, flags) => {
+      await initialize({
+        directory,
+        template: flags.template,
+        packageManager: flags.pm
+      });
+    },
+    { disableFinishedLog: true }
+  )
+);
+cli.parse();
+function wrapAction(cb, options) {
+  return async (...args) => {
+    const isDebug = !!args.find((arg) => arg?.debug);
+    if (isDebug) {
+      consola6.level = LogLevels2.debug;
+    }
+    const startTime = Date.now();
+    try {
+      printHeader();
+      const status = await cb(...args);
+      if (!status?.isOngoing && !options?.disableFinishedLog)
+        consola6.success(
+          `Finished in ${formatDuration(Date.now() - startTime)}`
+        );
+    } catch (err) {
+      consola6.fail(
+        `Command failed after ${formatDuration(Date.now() - startTime)}`
+      );
+      consola6.error(err);
+      process.exit(1);
+    }
+  };
+}