wxt 0.0.1

package/dist/index.cjs

@@ -0,0 +1,1482 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  build: () => build2,
+  createServer: () => createServer2,
+  defineConfig: () => defineConfig,
+  defineRunnerConfig: () => defineRunnerConfig,
+  version: () => version
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/core/utils/getInternalConfig.ts
+var import_node_path3 = __toESM(require("path"), 1);
+var vite = __toESM(require("vite"), 1);
+var import_consola2 = require("consola");
+
+// src/core/utils/importTsFile.ts
+var import_consola = require("consola");
+var import_jiti = __toESM(require("jiti"), 1);
+var import_babel = __toESM(require("jiti/dist/babel"), 1);
+var import_path = require("path");
+var import_unimport = require("unimport");
+async function importTsFile(root, path5) {
+  const clientImports = await (0, import_unimport.scanExports)(
+    (0, import_path.resolve)(root, "node_modules/wxt/dist/client/index.js")
+  );
+  const jiti = (0, import_jiti.default)(__filename, {
+    cache: false,
+    esmResolve: true,
+    interopDefault: true,
+    transform(opts) {
+      opts.source = opts.source.replace(/^import ['"].*\.css['"];?$/gm, "");
+      opts.source = opts.source.replace(
+        /^import\s+.*\s+from ['"]webextension-polyfill['"];?$/gm,
+        ""
+      );
+      if (opts.filename === path5) {
+        const imports = clientImports.map((i) => `import { ${i.name} } from "${i.from}";`).join("\n") + "\n";
+        opts.source = imports + opts.source;
+      }
+      return (0, import_babel.default)(opts);
+    }
+  });
+  try {
+    return await jiti(path5);
+  } catch (err) {
+    import_consola.consola.error(`Failed to import file: ${path5}`);
+    throw err;
+  }
+}
+
+// src/core/utils/network.ts
+var import_node_dns = __toESM(require("dns"), 1);
+
+// src/core/utils/promises.ts
+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) => {
+    import_node_dns.default.resolve("google.com", (err) => {
+      if (err == null) {
+        res(false);
+      } else {
+        res(true);
+      }
+    });
+  });
+  return withTimeout(isOffline2, 1e3).catch(() => true);
+}
+async function isOnline() {
+  const offline = await isOffline();
+  return !offline;
+}
+async function fetchCached(url, config) {
+  let content = "";
+  if (await isOnline()) {
+    const res = await fetch(url);
+    if (res.status < 300) {
+      content = await res.text();
+      await config.fsCache.set(url, content);
+    } else {
+      config.logger.debug(
+        `Failed to download "${url}", falling back to cache...`
+      );
+    }
+  }
+  if (!content)
+    content = await config.fsCache.get(url) ?? "";
+  if (!content)
+    throw Error(
+      `Offline and "${url}" has not been cached. Try again when online.`
+    );
+  return content;
+}
+
+// src/core/vite-plugins/download.ts
+function download(config) {
+  return {
+    name: "wxt:download",
+    resolveId(id) {
+      if (id.startsWith("url:"))
+        return "\0" + id;
+    },
+    async load(id) {
+      if (!id.startsWith("\0url:"))
+        return;
+      const url = id.replace("\0url:", "");
+      return await fetchCached(url, config);
+    }
+  };
+}
+
+// src/core/vite-plugins/unimport.ts
+var import_unimport2 = require("unimport");
+
+// src/core/utils/auto-imports.ts
+var import_vite = require("vite");
+function getUnimportOptions(config) {
+  const defaultOptions = {
+    debugLog: config.logger.debug,
+    imports: [
+      { name: "*", as: "browser", from: "webextension-polyfill" },
+      { name: "defineConfig", from: "wxt" }
+    ],
+    presets: [{ package: "wxt/client" }],
+    warn: config.logger.warn,
+    dirs: ["components", "composables", "hooks", "utils"]
+  };
+  return (0, import_vite.mergeConfig)(
+    defaultOptions,
+    config.imports
+  );
+}
+
+// src/core/vite-plugins/unimport.ts
+function unimport(config) {
+  const options = getUnimportOptions(config);
+  const unimport2 = (0, import_unimport2.createUnimport)(options);
+  return {
+    name: "wxt:unimport",
+    async config() {
+      await unimport2.scanImportsFromDir(void 0, { cwd: config.srcDir });
+    },
+    async transform(code, id) {
+      return unimport2.injectImports(code, id);
+    }
+  };
+}
+
+// src/core/vite-plugins/multipageMove.ts
+var import_node_path2 = require("path");
+
+// src/core/utils/entrypoints.ts
+var import_node_path = __toESM(require("path"), 1);
+function getEntrypointName(entrypointsDir, inputPath) {
+  const relativePath = import_node_path.default.relative(entrypointsDir, inputPath);
+  const name = relativePath.split(/[\.\/]/, 2)[0];
+  return name;
+}
+function getEntrypointOutputFile(entrypoint, ext) {
+  return (0, import_node_path.resolve)(entrypoint.outputDir, `${entrypoint.name}${ext}`);
+}
+function getEntrypointBundlePath(entrypoint, outDir, ext) {
+  return (0, import_node_path.relative)(outDir, getEntrypointOutputFile(entrypoint, ext));
+}
+
+// src/core/vite-plugins/multipageMove.ts
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+function multipageMove(entrypoints, config) {
+  return {
+    name: "wxt:multipage-move",
+    async writeBundle(_, bundle) {
+      for (const oldBundlePath in bundle) {
+        const entrypoint = entrypoints.find(
+          (entry) => !!entry.inputPath.endsWith(oldBundlePath)
+        );
+        if (entrypoint == null) {
+          config.logger.debug("No entrypoint found for", oldBundlePath);
+          continue;
+        }
+        const newBundlePath = getEntrypointBundlePath(
+          entrypoint,
+          config.outDir,
+          (0, import_node_path2.extname)(oldBundlePath)
+        );
+        if (newBundlePath === oldBundlePath) {
+          config.logger.debug(
+            "HTML file is already in the correct location",
+            oldBundlePath
+          );
+          continue;
+        }
+        const oldAbsPath = (0, import_node_path2.resolve)(config.outDir, oldBundlePath);
+        const newAbsPath = (0, import_node_path2.resolve)(config.outDir, newBundlePath);
+        await (0, import_fs_extra.ensureDir)((0, import_node_path2.dirname)(newAbsPath));
+        await import_fs_extra.default.move(oldAbsPath, newAbsPath);
+        const renamedChunk = {
+          ...bundle[oldBundlePath],
+          fileName: newBundlePath
+        };
+        delete bundle[oldBundlePath];
+        bundle[newBundlePath] = renamedChunk;
+      }
+    }
+  };
+}
+
+// src/core/vite-plugins/devHtmlPrerender.ts
+var import_linkedom = require("linkedom");
+var import_path2 = require("path");
+function devHtmlPrerender(config) {
+  return {
+    apply: "build",
+    name: "wxt:dev-html-prerender",
+    async transform(html, id) {
+      const server = config.server;
+      if (config.command !== "serve" || server == null || !id.endsWith(".html"))
+        return;
+      const originalUrl = `${server.origin}${id}`;
+      const name = getEntrypointName(config.entrypointsDir, id);
+      const url = `${server.origin}/${name}.html`;
+      const serverHtml = await server.transformIndexHtml(
+        url,
+        html,
+        originalUrl
+      );
+      const { document } = (0, import_linkedom.parseHTML)(serverHtml);
+      const pointToDevServer = (querySelector, attr) => {
+        document.querySelectorAll(querySelector).forEach((element) => {
+          const src = element.getAttribute(attr);
+          if (!src)
+            return;
+          if ((0, import_path2.isAbsolute)(src)) {
+            element.setAttribute(attr, server.origin + src);
+          } else if (src.startsWith(".")) {
+            const abs = (0, import_path2.resolve)((0, import_path2.dirname)(id), src);
+            const pathname = (0, import_path2.relative)(config.root, abs);
+            element.setAttribute(attr, `${server.origin}/${pathname}`);
+          }
+        });
+      };
+      pointToDevServer("script[type=module]", "src");
+      pointToDevServer("link[rel=stylesheet]", "href");
+      const newHtml = document.toString();
+      config.logger.debug("Transformed " + id);
+      config.logger.debug("Old HTML:\n" + html);
+      config.logger.debug("New HTML:\n" + newHtml);
+      return newHtml;
+    }
+  };
+}
+
+// src/core/vite-plugins/virtualEntrypoint.ts
+var import_fs_extra2 = __toESM(require("fs-extra"), 1);
+var import_path3 = require("path");
+function virtualEntrypoin(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 = id.substring(index + virtualId.length);
+      return resolvedVirtualId + inputPath;
+    },
+    async load(id) {
+      if (!id.startsWith(resolvedVirtualId))
+        return;
+      const inputPath = id.replace(resolvedVirtualId, "");
+      const template = await import_fs_extra2.default.readFile(
+        (0, import_path3.resolve)(config.root, `node_modules/wxt/templates/virtual-${type}.ts`),
+        "utf-8"
+      );
+      return template.replaceAll("{{moduleId}}", inputPath);
+    }
+  };
+}
+
+// src/core/utils/createFsCache.ts
+var import_fs_extra3 = __toESM(require("fs-extra"), 1);
+var import_path4 = require("path");
+function createFsCache(wxtDir) {
+  const getPath = (key) => (0, import_path4.resolve)(wxtDir, "cache", encodeURIComponent(key));
+  return {
+    async set(key, value) {
+      const path5 = getPath(key);
+      await (0, import_fs_extra3.ensureDir)((0, import_path4.dirname)(path5));
+      await import_fs_extra3.default.writeFile(path5, value, "utf-8");
+    },
+    async get(key) {
+      const path5 = getPath(key);
+      try {
+        return await import_fs_extra3.default.readFile(path5, "utf-8");
+      } catch {
+        return void 0;
+      }
+    }
+  };
+}
+
+// src/core/utils/globals.ts
+function getGlobals(config) {
+  return [
+    {
+      name: "__MANIFEST_VERSION__",
+      value: config.manifestVersion,
+      type: `2 | 3`
+    },
+    {
+      name: "__BROWSER__",
+      value: config.browser,
+      type: `"chromium" | "firefox"`
+    },
+    {
+      name: "__IS_CHROME__",
+      value: config.browser === "chrome",
+      type: `boolean`
+    },
+    {
+      name: "__IS_FIREFOX__",
+      value: config.browser === "firefox",
+      type: `boolean`
+    },
+    {
+      name: "__IS_SAFARI__",
+      value: config.browser === "safari",
+      type: `boolean`
+    },
+    {
+      name: "__IS_EDGE__",
+      value: config.browser === "edge",
+      type: `boolean`
+    },
+    {
+      name: "__IS_OPERA__",
+      value: config.browser === "opera",
+      type: `boolean`
+    }
+  ];
+}
+
+// src/core/utils/getInternalConfig.ts
+var import_c12 = require("c12");
+async function getInternalConfig(config, command) {
+  const root = config.root ? import_node_path3.default.resolve(config.root) : process.cwd();
+  const mode = config.mode ?? (command === "build" ? "production" : "development");
+  const browser = config.browser ?? "chrome";
+  const manifestVersion = config.manifestVersion ?? (browser == "firefox" ? 2 : 3);
+  const outBaseDir = import_node_path3.default.resolve(root, ".output");
+  const outDir = import_node_path3.default.resolve(outBaseDir, `${browser}-mv${manifestVersion}`);
+  const logger = config.logger ?? import_consola2.consola;
+  const baseConfig = {
+    root,
+    outDir,
+    outBaseDir,
+    storeIds: config.storeIds ?? {},
+    browser,
+    manifestVersion,
+    mode,
+    command,
+    logger,
+    vite: config.vite ?? {},
+    manifest: config.manifest ?? {},
+    imports: config.imports ?? {},
+    runnerConfig: await (0, import_c12.loadConfig)({
+      name: "web-ext",
+      cwd: root,
+      globalRc: true,
+      rcFile: ".webextrc",
+      overrides: config.runner
+    })
+  };
+  let userConfig = {
+    mode
+  };
+  if (config.configFile !== false) {
+    userConfig = await importTsFile(
+      root,
+      import_node_path3.default.resolve(root, config.configFile ?? "wxt.config.ts")
+    );
+  }
+  const merged = vite.mergeConfig(
+    baseConfig,
+    userConfig
+  );
+  const srcDir = userConfig.srcDir ? (0, import_node_path3.resolve)(root, userConfig.srcDir) : root;
+  const entrypointsDir = (0, import_node_path3.resolve)(
+    srcDir,
+    userConfig.entrypointsDir ?? "entrypoints"
+  );
+  const publicDir = (0, import_node_path3.resolve)(srcDir, userConfig.publicDir ?? "public");
+  const wxtDir = (0, import_node_path3.resolve)(srcDir, ".wxt");
+  const typesDir = (0, import_node_path3.resolve)(wxtDir, "types");
+  const finalConfig = {
+    ...merged,
+    srcDir,
+    entrypointsDir,
+    publicDir,
+    wxtDir,
+    typesDir,
+    fsCache: createFsCache(wxtDir)
+  };
+  finalConfig.vite.root = root;
+  finalConfig.vite.configFile = false;
+  finalConfig.vite.logLevel = "silent";
+  finalConfig.vite.build ??= {};
+  finalConfig.vite.build.outDir = outDir;
+  finalConfig.vite.build.emptyOutDir = false;
+  finalConfig.vite.plugins ??= [];
+  finalConfig.vite.plugins.push(download(finalConfig));
+  finalConfig.vite.plugins.push(devHtmlPrerender(finalConfig));
+  finalConfig.vite.plugins.push(unimport(finalConfig));
+  finalConfig.vite.plugins.push(
+    virtualEntrypoin("background", finalConfig)
+  );
+  finalConfig.vite.plugins.push(
+    virtualEntrypoin("content-script", finalConfig)
+  );
+  finalConfig.vite.define ??= {};
+  getGlobals(finalConfig).forEach((global) => {
+    finalConfig.vite.define[global.name] = JSON.stringify(global.value);
+  });
+  return finalConfig;
+}
+
+// src/core/build/findEntrypoints.ts
+var import_path5 = require("path");
+var import_fs_extra4 = __toESM(require("fs-extra"), 1);
+var import_picomatch = __toESM(require("picomatch"), 1);
+var import_linkedom2 = require("linkedom");
+var import_json5 = __toESM(require("json5"), 1);
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+async function findEntrypoints(config) {
+  const relativePaths = await (0, import_fast_glob.default)("**/*", {
+    cwd: config.entrypointsDir
+  });
+  relativePaths.sort();
+  const pathGlobs = Object.keys(PATH_GLOB_TO_TYPE_MAP);
+  const existingNames = {};
+  const entrypoints = [];
+  await Promise.all(
+    relativePaths.map(async (relativePath) => {
+      const path5 = (0, import_path5.resolve)(config.entrypointsDir, relativePath);
+      const matchingGlob = pathGlobs.find(
+        (glob3) => import_picomatch.default.isMatch(relativePath, glob3)
+      );
+      if (matchingGlob == null) {
+        return config.logger.warn(
+          `${relativePath} does not match any known entrypoint. Known entrypoints:
+${JSON.stringify(
+            PATH_GLOB_TO_TYPE_MAP,
+            null,
+            2
+          )}`
+        );
+      }
+      const type = PATH_GLOB_TO_TYPE_MAP[matchingGlob];
+      if (type === "ignored")
+        return;
+      let entrypoint;
+      switch (type) {
+        case "popup":
+          entrypoint = await getPopupEntrypoint(config, path5);
+          break;
+        case "options":
+          entrypoint = await getOptionsEntrypoint(config, path5);
+          break;
+        case "background":
+          entrypoint = await getBackgroundEntrypoint(config, path5);
+          break;
+        case "content-script":
+          entrypoint = await getContentScriptEntrypoint(
+            config,
+            relativePath.split(".", 2)[0],
+            path5
+          );
+          break;
+        default:
+          entrypoint = {
+            type,
+            name: getEntrypointName(config.entrypointsDir, path5),
+            inputPath: path5,
+            outputDir: config.outDir
+          };
+      }
+      const withSameName = existingNames[entrypoint.name];
+      if (withSameName) {
+        throw Error(
+          `Multiple entrypoints with the name "${entrypoint.name}" detected, but only one is allowed: ${[
+            (0, import_path5.relative)(config.root, withSameName.inputPath),
+            (0, import_path5.relative)(config.root, entrypoint.inputPath)
+          ].join(", ")}`
+        );
+      }
+      entrypoints.push(entrypoint);
+      existingNames[entrypoint.name] = entrypoint;
+    })
+  );
+  return entrypoints;
+}
+async function getPopupEntrypoint(config, path5) {
+  const options = {};
+  const content = await import_fs_extra4.default.readFile(path5, "utf-8");
+  const { document } = (0, import_linkedom2.parseHTML)(content);
+  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 = import_json5.default.parse(defaultIconContent);
+    } catch (err) {
+      config.logger.fatal(
+        `Failed to parse default_icon meta tag content as JSON5. content=${defaultIconContent}`,
+        err
+      );
+    }
+  }
+  const mv2KeyContent = document.querySelector("meta[name='manifest.type']")?.getAttribute("content");
+  if (mv2KeyContent) {
+    options.mv2Key = mv2KeyContent === "page_action" ? "page_action" : "browser_action";
+  }
+  return {
+    type: "popup",
+    name: "popup",
+    options,
+    inputPath: path5,
+    outputDir: config.outDir
+  };
+}
+async function getOptionsEntrypoint(config, path5) {
+  const options = {};
+  const content = await import_fs_extra4.default.readFile(path5, "utf-8");
+  const { document } = (0, import_linkedom2.parseHTML)(content);
+  const openInTabContent = document.querySelector("meta[name='manifest.open_in_tab']")?.getAttribute("content");
+  if (openInTabContent) {
+    options.openInTab = Boolean(openInTabContent);
+  }
+  const chromeStyleContent = document.querySelector("meta[name='manifest.chrome_style']")?.getAttribute("content");
+  if (chromeStyleContent) {
+    options.chromeStyle = Boolean(chromeStyleContent);
+  }
+  const browserStyleContent = document.querySelector("meta[name='manifest.browser_style']")?.getAttribute("content");
+  if (browserStyleContent) {
+    options.browserStyle = Boolean(browserStyleContent);
+  }
+  return {
+    type: "options",
+    name: "options",
+    options,
+    inputPath: path5,
+    outputDir: config.outDir
+  };
+}
+async function getBackgroundEntrypoint(config, path5) {
+  const { main: _, ...options } = await importTsFile(config.root, path5);
+  if (options == null) {
+    throw Error("Background script does not have a default export");
+  }
+  return {
+    type: "background",
+    name: "background",
+    inputPath: path5,
+    outputDir: config.outDir,
+    options
+  };
+}
+async function getContentScriptEntrypoint(config, name, path5) {
+  const { main: _, ...options } = await importTsFile(
+    config.root,
+    path5
+  );
+  if (options == null) {
+    throw Error(`Content script ${name} does not have a default export`);
+  }
+  return {
+    type: "content-script",
+    name: getEntrypointName(config.entrypointsDir, path5),
+    inputPath: path5,
+    outputDir: (0, import_path5.resolve)(config.outDir, "content-scripts"),
+    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.ts": "background",
+  "*.content.ts?(x)": "content-script",
+  "*.content/index.ts?(x)": "content-script",
+  "popup.html": "popup",
+  "popup/index.html": "popup",
+  "options.html": "options",
+  "options/index.html": "options",
+  "*.html": "unlisted-page",
+  "*/index.html": "unlisted-page",
+  "*.ts": "unlisted-script",
+  // Don't warn about any files in subdirectories, like CSS or JS entrypoints for HTML files
+  "*/*": "ignored"
+};
+
+// src/core/build/buildEntrypoints.ts
+var vite2 = __toESM(require("vite"), 1);
+
+// src/core/utils/groupEntrypoints.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"
+};
+
+// src/core/utils/removeEmptyDirs.ts
+var import_fs_extra5 = __toESM(require("fs-extra"), 1);
+var import_path6 = __toESM(require("path"), 1);
+async function removeEmptyDirs(dir) {
+  const files = await import_fs_extra5.default.readdir(dir);
+  for (const file of files) {
+    const filePath = import_path6.default.join(dir, file);
+    const stats = await import_fs_extra5.default.stat(filePath);
+    if (stats.isDirectory()) {
+      await removeEmptyDirs(filePath);
+    }
+  }
+  try {
+    await import_fs_extra5.default.rmdir(dir);
+  } catch {
+  }
+}
+
+// src/core/build/buildEntrypoints.ts
+var import_fast_glob2 = __toESM(require("fast-glob"), 1);
+var import_fs_extra6 = __toESM(require("fs-extra"), 1);
+var import_path7 = require("path");
+async function buildEntrypoints(entrypoints, config) {
+  const groups = groupEntrypoints(entrypoints);
+  const outputs = [];
+  for (const group of groups) {
+    const output = Array.isArray(group) ? await buildMultipleEntrypoints(group, config) : await buildSingleEntrypoint(group, config);
+    outputs.push(output);
+  }
+  const publicOutput = await copyPublicDirectory(config);
+  outputs.push(publicOutput);
+  await removeEmptyDirs(config.outDir);
+  return outputs.flat();
+}
+async function buildSingleEntrypoint(entrypoint, config) {
+  const isVirtual = ["background", "content-script"].includes(entrypoint.type);
+  const entry = isVirtual ? `virtual:wxt-${entrypoint.type}?${entrypoint.inputPath}` : entrypoint.inputPath;
+  const libMode = {
+    build: {
+      lib: {
+        entry,
+        formats: ["iife"],
+        name: entrypoint.name,
+        fileName: entrypoint.name
+      },
+      rollupOptions: {
+        output: {
+          entryFileNames: getEntrypointBundlePath(
+            entrypoint,
+            config.outDir,
+            ".js"
+          ),
+          // Output content script CSS to assets/ with a hash to prevent conflicts. Defaults to
+          // "[name].[ext]" in lib mode, which usually results in "style.css". That means multiple
+          // content scripts with styles would overwrite each other if it weren't changed below.
+          assetFileNames: `assets/${entrypoint.name}-[hash].[ext]`
+        }
+      }
+    }
+  };
+  const entryConfig = vite2.mergeConfig(
+    libMode,
+    config.vite
+  );
+  const result = await vite2.build(entryConfig);
+  return getBuildOutput(result);
+}
+async function buildMultipleEntrypoints(entrypoints, config) {
+  const multiPage = {
+    plugins: [multipageMove(entrypoints, config)],
+    build: {
+      rollupOptions: {
+        input: entrypoints.reduce((input, entry) => {
+          input[entry.name] = entry.inputPath;
+          return input;
+        }, {})
+      }
+    }
+  };
+  const entryConfig = vite2.mergeConfig(
+    multiPage,
+    config.vite
+  );
+  const result = await vite2.build(entryConfig);
+  return getBuildOutput(result);
+}
+function getBuildOutput(result) {
+  if ("on" in result)
+    throw Error("wxt does not support vite watch mode.");
+  if (Array.isArray(result))
+    return result.flatMap(({ output }) => output);
+  return result.output;
+}
+async function copyPublicDirectory(config) {
+  if (!await import_fs_extra6.default.exists(config.publicDir))
+    return [];
+  const files = await (0, import_fast_glob2.default)("**/*", { cwd: config.publicDir });
+  const outputs = [];
+  for (const file of files) {
+    const srcPath = (0, import_path7.resolve)(config.publicDir, file);
+    const outPath = (0, import_path7.resolve)(config.outDir, file);
+    await import_fs_extra6.default.ensureDir((0, import_path7.dirname)(outPath));
+    await import_fs_extra6.default.copyFile(srcPath, outPath);
+    outputs.push({
+      type: "asset",
+      fileName: file,
+      name: file,
+      needsCodeReference: false,
+      source: await import_fs_extra6.default.readFile(srcPath)
+    });
+  }
+  return outputs;
+}
+
+// src/core/utils/manifest.ts
+var import_fs_extra7 = __toESM(require("fs-extra"), 1);
+var import_path8 = require("path");
+
+// src/core/utils/ContentSecurityPolicy.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/manifest.ts
+async function writeManifest(manifest, output, config) {
+  const str = config.mode === "production" ? JSON.stringify(manifest) : JSON.stringify(manifest, null, 2);
+  await import_fs_extra7.default.ensureDir(config.outDir);
+  await import_fs_extra7.default.writeFile((0, import_path8.resolve)(config.outDir, "manifest.json"), str, "utf-8");
+  output.unshift({
+    type: "asset",
+    fileName: "manifest.json",
+    name: "manifest",
+    needsCodeReference: false,
+    source: str
+  });
+}
+async function generateMainfest(entrypoints, buildOutput, config) {
+  const pkg = await getPackageJson(config);
+  if (pkg.version == null)
+    throw Error("package.json does not include a version");
+  if (pkg.name == null)
+    throw Error("package.json does not include a name");
+  if (pkg.description == null)
+    throw Error("package.json does not include a description");
+  const manifest = {
+    manifest_version: config.manifestVersion,
+    name: pkg.name,
+    short_name: pkg.shortName,
+    version: simplifyVersion(pkg.version),
+    version_name: config.browser === "firefox" ? void 0 : pkg.version,
+    ...config.manifest
+  };
+  addEntrypoints(manifest, entrypoints, buildOutput, config);
+  if (config.command === "serve")
+    addDevModeCsp(manifest, config);
+  return manifest;
+}
+async function getPackageJson(config) {
+  return await import_fs_extra7.default.readJson((0, import_path8.resolve)(config.root, "package.json"));
+}
+function simplifyVersion(versionName) {
+  const version3 = /^((0|[1-9][0-9]{0,8})([.](0|[1-9][0-9]{0,8})){0,3}).*$/.exec(
+    versionName
+  )?.[1];
+  if (version3 == null)
+    throw Error(
+      `Cannot simplify package.json version "${versionName}" to a valid extension version, "X.Y.Z"`
+    );
+  return version3;
+}
+function addEntrypoints(manifest, entrypoints, buildOutput, config) {
+  const entriesByType = entrypoints.reduce((map, entrypoint) => {
+    map[entrypoint.type] ??= [];
+    map[entrypoint.type]?.push(entrypoint);
+    return map;
+  }, {});
+  const background = entriesByType["background"]?.[0];
+  const bookmarks = entriesByType["bookmarks"]?.[0];
+  const contentScripts = entriesByType["content-script"];
+  const devtools = entriesByType["devtools"]?.[0];
+  const history = entriesByType["history"]?.[0];
+  const newtab = entriesByType["newtab"]?.[0];
+  const options = entriesByType["options"]?.[0];
+  const popup = entriesByType["popup"]?.[0];
+  const sandboxes = entriesByType["sandbox"];
+  const sidepanels = entriesByType["sidepanel"];
+  if (background) {
+    const script = getEntrypointBundlePath(background, config.outDir, ".js");
+    if (manifest.manifest_version === 3) {
+      manifest.background = {
+        type: background.options.type,
+        service_worker: script
+      };
+    } else {
+      manifest.background = {
+        persistent: background.options.persistent,
+        scripts: [script]
+      };
+    }
+  }
+  if (bookmarks) {
+    if (config.browser === "firefox") {
+      config.logger.warn(
+        "Bookmarks are not supported by Firefox. chrome_url_overrides.bookmarks was not added to the manifest"
+      );
+    } else {
+      manifest.chrome_url_overrides ??= {};
+      manifest.chrome_url_overrides.bookmarks = getEntrypointBundlePath(
+        bookmarks,
+        config.outDir,
+        ".html"
+      );
+    }
+  }
+  if (history) {
+    if (config.browser === "firefox") {
+      config.logger.warn(
+        "Bookmarks are not supported by Firefox. chrome_url_overrides.history was not added to the manifest"
+      );
+    } else {
+      manifest.chrome_url_overrides ??= {};
+      manifest.chrome_url_overrides.history = getEntrypointBundlePath(
+        history,
+        config.outDir,
+        ".html"
+      );
+    }
+  }
+  if (newtab) {
+    manifest.chrome_url_overrides ??= {};
+    manifest.chrome_url_overrides.newtab = getEntrypointBundlePath(
+      newtab,
+      config.outDir,
+      ".html"
+    );
+  }
+  if (popup) {
+    const default_popup = getEntrypointBundlePath(
+      popup,
+      config.outDir,
+      ".html"
+    );
+    const options2 = {
+      default_icon: popup.options.defaultIcon,
+      default_title: popup.options.defaultTitle
+    };
+    if (manifest.manifest_version === 3) {
+      manifest.action = {
+        ...options2,
+        default_popup
+      };
+    } else {
+      manifest[popup.options.mv2Key ?? "browser_action"] = {
+        ...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) {
+    if (config.command === "serve") {
+      const permissionsKey = config.manifestVersion === 2 ? "permissions" : "host_permissions";
+      const hostPermissions = new Set(manifest[permissionsKey] ?? []);
+      contentScripts.forEach((script) => {
+        script.options.matches.forEach((matchPattern) => {
+          hostPermissions.add(matchPattern);
+        });
+      });
+      manifest[permissionsKey] = Array.from(hostPermissions).sort();
+    } else {
+      const hashToEntrypointsMap = contentScripts.reduce((map, script) => {
+        const hash = JSON.stringify(script.options);
+        if (!map.has(hash)) {
+          map.set(hash, [script]);
+        } else {
+          map.get(hash)?.push(script);
+        }
+        return map;
+      }, /* @__PURE__ */ new Map());
+      manifest.content_scripts = Array.from(hashToEntrypointsMap.entries()).map(
+        ([, scripts]) => ({
+          ...scripts[0].options,
+          // TOOD: Sorting css and js arrays here so we get consistent test results... but we
+          // shouldn't have to. Where is the inconsistency coming from?
+          css: getContentScriptCssFiles(scripts, buildOutput)?.sort(),
+          js: scripts.map(
+            (entry) => getEntrypointBundlePath(entry, config.outDir, ".js")
+          ).sort()
+        })
+      );
+    }
+  }
+}
+function addDevModeCsp(manifest, config) {
+  const permission = `http://${config.server?.hostname ?? ""}/*`;
+  const allowedCsp = config.server?.origin ?? "http://localhost:*";
+  if (manifest.manifest_version === 3) {
+    manifest.host_permissions ??= [];
+    if (!manifest.host_permissions.includes(permission))
+      manifest.host_permissions.push(permission);
+  } else {
+    manifest.permissions ??= [];
+    if (!manifest.permissions.includes(permission))
+      manifest.permissions.push(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 getContentScriptCssFiles(contentScripts, buildOutput) {
+  const css = [];
+  contentScripts.forEach((script) => {
+    const cssRegex = new RegExp(`^assets/${script.name}-[a-f0-9]{8}.css$`);
+    const relatedCss = buildOutput.find(
+      (chunk) => chunk.fileName.match(cssRegex)
+    );
+    if (relatedCss)
+      css.push(relatedCss.fileName);
+  });
+  if (css.length > 0)
+    return css;
+  return void 0;
+}
+
+// src/core/log/printBuildSummary.ts
+var import_path9 = __toESM(require("path"), 1);
+
+// src/core/log/printTable.ts
+function printTable(log, 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(str);
+}
+
+// src/core/log/printBuildSummary.ts
+var import_picocolors = __toESM(require("picocolors"), 1);
+var import_fs_extra8 = __toESM(require("fs-extra"), 1);
+var import_filesize = require("filesize");
+async function printBuildSummary(output, config) {
+  const chunks = output.sort((l, r) => {
+    const lWeight = CHUNK_SORT_WEIGHTS[l.fileName] ?? CHUNK_SORT_WEIGHTS[(0, import_path9.extname)(l.fileName)] ?? DEFAULT_SORT_WEIGHT;
+    const rWeight = CHUNK_SORT_WEIGHTS[r.fileName] ?? CHUNK_SORT_WEIGHTS[(0, import_path9.extname)(r.fileName)] ?? DEFAULT_SORT_WEIGHT;
+    const diff = lWeight - rWeight;
+    if (diff !== 0)
+      return diff;
+    return l.fileName.localeCompare(r.fileName);
+  });
+  let totalSize = 0;
+  const chunkRows = await Promise.all(
+    chunks.map(async (chunk, i) => {
+      const file = [
+        (0, import_path9.relative)(process.cwd(), config.outDir) + import_path9.default.sep,
+        chunk.fileName
+      ];
+      const ext = (0, import_path9.extname)(chunk.fileName);
+      const prefix = i === chunks.length - 1 ? "  \u2514\u2500" : "  \u251C\u2500";
+      const color = CHUNK_COLORS[ext] ?? DEFAULT_COLOR;
+      const stats = await import_fs_extra8.default.lstat((0, import_path9.resolve)(config.outDir, chunk.fileName));
+      totalSize += stats.size;
+      const size = String((0, import_filesize.filesize)(stats.size));
+      return [
+        `${import_picocolors.default.gray(prefix)} ${import_picocolors.default.dim(file[0])}${color(file[1])}`,
+        import_picocolors.default.dim(size)
+      ];
+    })
+  );
+  printTable(config.logger.log, chunkRows);
+  config.logger.log(
+    `${import_picocolors.default.cyan("\u03A3 Total size:")} ${String((0, import_filesize.filesize)(totalSize))}`
+  );
+}
+var DEFAULT_SORT_WEIGHT = 100;
+var CHUNK_SORT_WEIGHTS = {
+  "manifest.json": 0,
+  ".html": 1,
+  ".js": 2,
+  ".css": 3
+};
+var DEFAULT_COLOR = import_picocolors.default.blue;
+var CHUNK_COLORS = {
+  ".html": import_picocolors.default.green,
+  ".css": import_picocolors.default.magenta,
+  ".js": import_picocolors.default.cyan
+};
+
+// src/index.ts
+var import_fs_extra10 = __toESM(require("fs-extra"), 1);
+
+// src/core/build/generateTypesDir.ts
+var import_unimport3 = require("unimport");
+var import_fs_extra9 = __toESM(require("fs-extra"), 1);
+var import_path10 = require("path");
+async function generateTypesDir(entrypoints, config) {
+  await import_fs_extra9.default.ensureDir(config.typesDir);
+  const references = [];
+  references.push(await writeImportsDeclarationFile(config));
+  references.push(await writePathsDeclarationFile(entrypoints, config));
+  references.push(await writeGlobalsDeclarationFile(config));
+  const mainReference = await writeMainDeclarationFile(references, config);
+  await writeTsConfigFile(mainReference, config);
+}
+async function writeImportsDeclarationFile(config) {
+  const filePath = (0, import_path10.resolve)(config.typesDir, "imports.d.ts");
+  const unimport2 = (0, import_unimport3.createUnimport)(getUnimportOptions(config));
+  await unimport2.scanImportsFromDir(void 0, { cwd: config.srcDir });
+  await import_fs_extra9.default.writeFile(
+    filePath,
+    ["// Generated by wxt", await unimport2.generateTypeDeclarations()].join(
+      "\n"
+    ) + "\n"
+  );
+  return filePath;
+}
+async function writePathsDeclarationFile(entrypoints, config) {
+  const filePath = (0, import_path10.resolve)(config.typesDir, "paths.d.ts");
+  await import_fs_extra9.default.writeFile(
+    filePath,
+    [
+      "// Generated by wxt",
+      "type EntrypointPath =",
+      ...entrypoints.map((entry) => {
+        const path5 = getEntrypointBundlePath(
+          entry,
+          config.outDir,
+          entry.inputPath.endsWith(".html") ? ".html" : ".js"
+        );
+        return `  | "/${path5}"`;
+      }).sort()
+    ].join("\n") + "\n"
+  );
+  return filePath;
+}
+async function writeGlobalsDeclarationFile(config) {
+  const filePath = (0, import_path10.resolve)(config.typesDir, "globals.d.ts");
+  const globals = getGlobals(config);
+  await import_fs_extra9.default.writeFile(
+    filePath,
+    [
+      "// Generated by wxt",
+      "export {}",
+      "declare global {",
+      ...globals.map((global) => `  const ${global.name}: ${global.type};`),
+      "}"
+    ].join("\n") + "\n",
+    "utf-8"
+  );
+  return filePath;
+}
+async function writeMainDeclarationFile(references, config) {
+  const dir = config.wxtDir;
+  const filePath = (0, import_path10.resolve)(dir, "wxt.d.ts");
+  await import_fs_extra9.default.writeFile(
+    filePath,
+    [
+      "// Generated by wxt",
+      ...references.map(
+        (ref) => `/// <reference types="./${(0, import_path10.relative)(dir, ref)}" />`
+      )
+    ].join("\n") + "\n"
+  );
+  return filePath;
+}
+async function writeTsConfigFile(mainReference, config) {
+  const dir = config.wxtDir;
+  await import_fs_extra9.default.writeFile(
+    (0, import_path10.resolve)(dir, "tsconfig.json"),
+    `{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "noEmit": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+
+    /* Type Checking */
+    "strict": true,
+
+    /* Completeness */
+    "skipLibCheck": true
+  },
+  "include": [
+    "${(0, import_path10.relative)(dir, config.root)}/**/*",
+    "./${(0, import_path10.relative)(dir, mainReference)}"
+  ],
+  "exclude": ["${(0, import_path10.relative)(dir, config.outBaseDir)}"]
+}`
+  );
+}
+
+// src/index.ts
+var import_picocolors2 = __toESM(require("picocolors"), 1);
+var vite3 = __toESM(require("vite"), 1);
+
+// src/core/utils/findOpenPort.ts
+var import_node_net = __toESM(require("net"), 1);
+function findOpenPort(startPort, endPort) {
+  return findOpenPortRecursive(startPort, startPort, endPort);
+}
+function findOpenPortRecursive(port, startPort, endPort) {
+  return new Promise((resolve13, reject) => {
+    if (port > endPort)
+      return reject(
+        Error(`Could not find open port between ${startPort}-${endPort}`)
+      );
+    const server = import_node_net.default.createServer();
+    server.listen(port, () => {
+      server.once("close", () => resolve13(port));
+      server.close();
+    });
+    server.on(
+      "error",
+      () => resolve13(findOpenPortRecursive(port + 1, startPort, endPort))
+    );
+  });
+}
+
+// src/core/utils/formatDuration.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`;
+}
+
+// src/core/runners/createWebExtRunner.ts
+function createWebExtRunner() {
+  let runner;
+  return {
+    async openBrowser(config) {
+      if (config.browser === "safari") {
+        config.logger.warn("Cannot open safari automatically.");
+        return;
+      }
+      const webExtLogger = await import("web-ext/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");
+      runner = await webExt.default.cmd.run(finalConfig, options);
+    },
+    async closeBrowser() {
+      return await runner?.exit();
+    }
+  };
+}
+var WARN_LOG_LEVEL = 40;
+var ERROR_LOG_LEVEL = 50;
+
+// package.json
+var version = "0.0.1";
+
+// src/core/utils/defineConfig.ts
+function defineConfig(config) {
+  return config;
+}
+
+// src/core/utils/defineRunnerConfig.ts
+function defineRunnerConfig(config) {
+  return config;
+}
+
+// src/index.ts
+async function build2(config) {
+  const internalConfig = await getInternalConfig(config, "build");
+  return await buildInternal(internalConfig);
+}
+async function createServer2(config) {
+  const port = await findOpenPort(3e3, 3010);
+  const hostname = "localhost";
+  const origin = `http://${hostname}:${port}`;
+  const serverConfig = {
+    server: {
+      origin
+    }
+  };
+  const internalConfig = await getInternalConfig(
+    vite3.mergeConfig(serverConfig, config ?? {}),
+    "serve"
+  );
+  const runner = createWebExtRunner();
+  const viteServer = await vite3.createServer(internalConfig.vite);
+  const server = {
+    ...viteServer,
+    async listen(port2, isRestart) {
+      const res = await viteServer.listen(port2, isRestart);
+      if (!isRestart) {
+        internalConfig.logger.success(`Started dev server @ ${origin}`);
+        internalConfig.logger.info("Opening browser...");
+        await runner.openBrowser(internalConfig);
+        internalConfig.logger.success("Opened!");
+      }
+      return res;
+    },
+    logger: internalConfig.logger,
+    port,
+    hostname,
+    origin
+  };
+  internalConfig.logger.info("Created dev server");
+  internalConfig.server = server;
+  await buildInternal(internalConfig);
+  return server;
+}
+async function buildInternal(config) {
+  const verb = config.command === "serve" ? "Pre-rendering" : "Building";
+  const target = `${config.browser}-mv${config.manifestVersion}`;
+  config.logger.info(
+    `${verb} ${import_picocolors2.default.cyan(target)} for ${import_picocolors2.default.cyan(config.mode)} with ${import_picocolors2.default.green(
+      `Vite ${vite3.version}`
+    )}`
+  );
+  const startTime = Date.now();
+  await import_fs_extra10.default.rm(config.outDir, { recursive: true, force: true });
+  await import_fs_extra10.default.ensureDir(config.outDir);
+  const entrypoints = await findEntrypoints(config);
+  await generateTypesDir(entrypoints, config);
+  const output = await buildEntrypoints(entrypoints, config);
+  const manifest = await generateMainfest(entrypoints, output, config);
+  await writeManifest(manifest, output, config);
+  config.logger.success(
+    `Built extension in ${formatDuration(Date.now() - startTime)}`
+  );
+  await printBuildSummary(output, config);
+  return output;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  build,
+  createServer,
+  defineConfig,
+  defineRunnerConfig,
+  version
+});
+//# sourceMappingURL=index.cjs.map