wxt 0.0.1 → 0.0.2

package/dist/cli.cjs

@@ -0,0 +1,1768 @@
+#!/usr/bin/env node
+"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 __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
+));
+
+// src/cli/index.ts
+var import_cac = __toESM(require("cac"), 1);
+
+// package.json
+var version = "0.0.2";
+
+// src/core/utils/getInternalConfig.ts
+var import_node_path3 = __toESM(require("path"), 1);
+var vite2 = __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.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/vite-plugins/devHtmlPrerender.ts
+var vite = __toESM(require("vite"), 1);
+
+// 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/devHtmlPrerender.ts
+var import_linkedom = require("linkedom");
+var import_path2 = require("path");
+function devHtmlPrerender(config) {
+  return {
+    apply: "build",
+    name: "wxt:dev-html-prerender",
+    config(userConfig) {
+      return vite.mergeConfig(
+        {
+          resolve: {
+            alias: {
+              "@wxt/reload-html": (0, import_path2.resolve)(
+                config.root,
+                "node_modules/wxt/dist/virtual-modules/reload-html.js"
+              )
+            }
+          }
+        },
+        userConfig
+      );
+    },
+    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 reloader = document.createElement("script");
+      reloader.src = "@wxt/reload-html";
+      reloader.type = "module";
+      document.head.appendChild(reloader);
+      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/devServerGlobals.ts
+function devServerGlobals(internalConfig) {
+  return {
+    name: "wxt:dev-server-globals",
+    config(config) {
+      if (internalConfig.server == null || internalConfig.command == "build")
+        return;
+      config.define ??= {};
+      config.define.__DEV_SERVER_PROTOCOL__ = JSON.stringify("ws:");
+      config.define.__DEV_SERVER_HOSTNAME__ = JSON.stringify(
+        internalConfig.server.hostname
+      );
+      config.define.__DEV_SERVER_PORT__ = JSON.stringify(
+        internalConfig.server.port
+      );
+    }
+  };
+}
+
+// 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/multipageMove.ts
+var import_node_path2 = require("path");
+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, { overwrite: true });
+        const renamedChunk = {
+          ...bundle[oldBundlePath],
+          fileName: newBundlePath
+        };
+        delete bundle[oldBundlePath];
+        bundle[newBundlePath] = renamedChunk;
+      }
+    }
+  };
+}
+
+// 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/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/dist/virtual-modules/${type}-entrypoint.js`
+        ),
+        "utf-8"
+      );
+      return template.replace(`virtual:user-${type}`, 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`
+    },
+    {
+      name: "__COMMAND__",
+      value: config.command,
+      type: `"build" | "serve"`
+    }
+  ];
+}
+
+// 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 = vite2.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 = "warn";
+  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.plugins.push(devServerGlobals(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 vite3 = __toESM(require("vite"), 1);
+
+// 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(groups, config) {
+  const steps = [];
+  for (const group of groups) {
+    const step = Array.isArray(group) ? await buildMultipleEntrypoints(group, config) : await buildSingleEntrypoint(group, config);
+    steps.push(step);
+  }
+  const publicAssets = await copyPublicDirectory(config);
+  await removeEmptyDirs(config.outDir);
+  return { publicAssets, steps };
+}
+async function buildSingleEntrypoint(entrypoint, config) {
+  const isVirtual = ["background", "content-script"].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: {
+          // There's only a single output for this build, so we use the desired bundle path for the
+          // entry output (like "content-scripts/overlay.js")
+          entryFileNames: getEntrypointBundlePath(
+            entrypoint,
+            config.outDir,
+            ".js"
+          ),
+          // Output content script CSS to 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}.[ext]`
+        }
+      }
+    }
+  };
+  const entryConfig = vite3.mergeConfig(
+    libMode,
+    config.vite
+  );
+  const result = await vite3.build(entryConfig);
+  return {
+    entrypoints: entrypoint,
+    chunks: getBuildOutputChunks(result)
+  };
+}
+async function buildMultipleEntrypoints(entrypoints, config) {
+  const multiPage = {
+    plugins: [multipageMove(entrypoints, config)],
+    build: {
+      rollupOptions: {
+        input: entrypoints.reduce((input, entry) => {
+          input[entry.name] = entry.inputPath;
+          return input;
+        }, {}),
+        output: {
+          // Include a hash to prevent conflicts
+          chunkFileNames: "chunks/[name]-[hash].js",
+          // Include a hash to prevent conflicts
+          entryFileNames: "chunks/[name]-[hash].js",
+          // We can't control the "name", so we need a hash to prevent conflicts
+          assetFileNames: "assets/[name]-[hash].[ext]"
+        }
+      }
+    }
+  };
+  const entryConfig = vite3.mergeConfig(
+    multiPage,
+    config.vite
+  );
+  const result = await vite3.build(entryConfig);
+  return {
+    entrypoints,
+    chunks: getBuildOutputChunks(result)
+  };
+}
+function getBuildOutputChunks(result) {
+  if ("on" in result)
+    throw Error("wxt does not support vite watch mode.");
+  if (Array.isArray(result))
+    return result.flatMap(({ output }) => output);
+  return result.output;
+}
+async function copyPublicDirectory(config) {
+  const publicAssets = [];
+  if (!await import_fs_extra6.default.exists(config.publicDir))
+    return publicAssets;
+  const files = await (0, import_fast_glob2.default)("**/*", { cwd: config.publicDir });
+  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);
+    publicAssets.push({
+      type: "asset",
+      fileName: file,
+      name: file,
+      needsCodeReference: false,
+      source: await import_fs_extra6.default.readFile(srcPath)
+    });
+  }
+  return publicAssets;
+}
+
+// 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.publicAssets.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 = [];
+  const allChunks = buildOutput.steps.flatMap((step) => step.chunks);
+  contentScripts.forEach((script) => {
+    const relatedCss = allChunks.find(
+      (chunk) => chunk.fileName === `assets/${script.name}.css`
+    );
+    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.steps.flatMap((step) => step.chunks),
+    ...output.publicAssets
+  ].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 vite4 = __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;
+
+// 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/detectDevChanges.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.find(
+    ([_, file]) => !file.endsWith(".html")
+  );
+  if (isOnlyHtmlChanges) {
+    return {
+      type: "html-reload",
+      cachedOutput: unchangedOutput,
+      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 = 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
+    // TODO: use bundle path to support `<name>/index.html`?
+    chunk.type === "asset" && changedPath.endsWith(chunk.fileName) || // If it's a chunk that depends on the changed file, it is effected
+    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/index.ts
+var import_async_mutex = require("async-mutex");
+var import_consola3 = require("consola");
+var import_node_path4 = require("path");
+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
+    }
+  };
+  let internalConfig = await getInternalConfig(
+    vite4.mergeConfig(serverConfig, config ?? {}),
+    "serve"
+  );
+  const runner = createWebExtRunner();
+  let hasBuiltOnce = false;
+  let currentOutput;
+  const fileChangedMutex = new import_async_mutex.Mutex();
+  const changeQueue = [];
+  const viteServer = await vite4.createServer(internalConfig.vite);
+  viteServer.watcher.on("all", async (event, path5, stats) => {
+    if (!hasBuiltOnce || path5.startsWith(internalConfig.outBaseDir))
+      return;
+    changeQueue.push([event, path5]);
+    await fileChangedMutex.runExclusive(async () => {
+      const fileChanges = changeQueue.splice(0, changeQueue.length);
+      const changes = detectDevChanges(fileChanges, currentOutput);
+      if (changes.type === "no-change")
+        return;
+      import_consola3.consola.info(
+        `Changed: ${Array.from(new Set(fileChanges.map((change) => change[1]))).map((file) => import_picocolors2.default.dim((0, import_node_path4.relative)(internalConfig.root, file))).join(", ")}`
+      );
+      const rebuiltNames = changes.rebuildGroups.flat().map((entry) => {
+        return import_picocolors2.default.cyan(
+          (0, import_node_path4.relative)(internalConfig.outDir, getEntrypointOutputFile(entry, ""))
+        );
+      }).join(import_picocolors2.default.dim(", "));
+      internalConfig = await getInternalConfig(
+        vite4.mergeConfig(serverConfig, config ?? {}),
+        "serve"
+      );
+      internalConfig.server = server;
+      const { output: newOutput } = await rebuild(
+        internalConfig,
+        // TODO: this excludes new entrypoints, so they're not built until the dev command is restarted
+        changes.rebuildGroups,
+        changes.cachedOutput
+      );
+      currentOutput = newOutput;
+      switch (changes.type) {
+        case "extension-reload":
+          server.reloadExtension();
+          import_consola3.consola.success(`Reloaded extension: ${rebuiltNames}`);
+          break;
+        case "html-reload":
+          changes.rebuildGroups.flat().forEach((entry) => {
+            const path6 = getEntrypointBundlePath(
+              entry,
+              internalConfig.outDir,
+              ".html"
+            );
+            server.reloadPage(path6);
+          });
+          import_consola3.consola.success(`Reloaded pages: ${rebuiltNames}`);
+          break;
+      }
+    });
+  });
+  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;
+    },
+    port,
+    hostname,
+    origin,
+    reloadExtension: () => {
+      server.ws.send("wxt:reload-extension");
+    },
+    reloadPage: (path5) => {
+      server.ws.send("wxt:reload-page", path5);
+    }
+  };
+  internalConfig.logger.info("Created dev server");
+  internalConfig.server = server;
+  currentOutput = await buildInternal(internalConfig);
+  hasBuiltOnce = true;
+  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 ${vite4.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);
+  const groups = groupEntrypoints(entrypoints);
+  const { output } = await rebuild(config, groups);
+  config.logger.success(
+    `Built extension in ${formatDuration(Date.now() - startTime)}`
+  );
+  await printBuildSummary(output, config);
+  return output;
+}
+async function rebuild(config, entrypointGroups, existingOutput = {
+  steps: [],
+  publicAssets: []
+}) {
+  const allEntrypoints = await findEntrypoints(config);
+  await generateTypesDir(allEntrypoints, config);
+  const buildOutput = await buildEntrypoints(entrypointGroups, config);
+  const manifest = await generateMainfest(allEntrypoints, buildOutput, config);
+  const output = {
+    manifest,
+    ...buildOutput
+  };
+  await writeManifest(manifest, output, config);
+  return {
+    output: {
+      manifest,
+      steps: [...existingOutput.steps, ...output.steps],
+      publicAssets: [...existingOutput.publicAssets, ...output.publicAssets]
+    },
+    manifest
+  };
+}
+
+// src/cli/utils/defineCommand.ts
+var import_consola5 = require("consola");
+
+// src/core/log/printHeader.ts
+var import_picocolors3 = __toESM(require("picocolors"), 1);
+var import_consola4 = require("consola");
+function printHeader() {
+  console.log();
+  import_consola4.consola.log(`${import_picocolors3.default.gray("WXT")} ${import_picocolors3.default.gray(import_picocolors3.default.bold(version))}`);
+}
+
+// src/cli/utils/defineCommand.ts
+function defineCommand(cb) {
+  return async (...args) => {
+    const startTime = Date.now();
+    try {
+      printHeader();
+      const ongoing = await cb(...args);
+      if (!ongoing)
+        import_consola5.consola.success(
+          `Finished in ${formatDuration(Date.now() - startTime)}`
+        );
+    } catch (err) {
+      import_consola5.consola.fail(
+        `Command failed after ${formatDuration(Date.now() - startTime)}`
+      );
+      import_consola5.consola.error(err);
+      process.exit(1);
+    }
+  };
+}
+
+// src/cli/commands/build.ts
+var build3 = defineCommand(async (root, flags) => {
+  const mode = flags.mode ?? "production";
+  const cliConfig = {
+    root,
+    mode,
+    browser: flags.browser,
+    manifestVersion: flags.mv3 ? 3 : flags.mv2 ? 2 : void 0,
+    configFile: flags.config
+  };
+  await build2(cliConfig);
+});
+
+// src/cli/commands/dev.ts
+var dev = defineCommand(async (root, flags) => {
+  const mode = flags.mode ?? "development";
+  const cliConfig = {
+    root,
+    mode,
+    browser: flags.browser,
+    manifestVersion: flags.mv3 ? 3 : flags.mv2 ? 2 : void 0,
+    configFile: flags.config
+  };
+  const server = await createServer2(cliConfig);
+  await server.listen(server.port);
+  return true;
+});
+
+// src/cli/commands/init.ts
+var import_consola6 = require("consola");
+var init = defineCommand(async (directory) => {
+  import_consola6.consola.warn("wxt init: Not implemented");
+});
+
+// src/cli/commands/prepare.ts
+var prepare = defineCommand(async (root, flags) => {
+  const cliConfig = {
+    root,
+    configFile: flags.config
+  };
+  const config = await getInternalConfig(cliConfig, "build");
+  config.logger.info("Generating types...");
+  const entrypoints = await findEntrypoints(config);
+  await generateTypesDir(entrypoints, config);
+});
+
+// src/cli/commands/publish.ts
+var import_consola7 = require("consola");
+var publish = defineCommand(
+  async (root, { config: configFile }) => {
+    import_consola7.consola.warn("wxt publish: Not implemented");
+  }
+);
+
+// src/cli/index.ts
+var cli = (0, import_cac.default)("wxt");
+cli.help();
+cli.version(version);
+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(dev);
+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").action(build3);
+cli.command("prepare [root]", "prepare").option("-c, --config <file>", "use specified config file").action(prepare);
+cli.command("publish [root]", "publish to stores").action(publish);
+cli.command("init [directory]", "initialize a new project").action(init);
+cli.parse();
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/cli/index.ts", "../package.json", "../src/core/utils/getInternalConfig.ts", "../src/core/utils/importTsFile.ts", "../src/core/vite-plugins/devHtmlPrerender.ts", "../src/core/utils/entrypoints.ts", "../src/core/vite-plugins/devServerGlobals.ts", "../src/core/utils/network.ts", "../src/core/utils/promises.ts", "../src/core/vite-plugins/download.ts", "../src/core/vite-plugins/multipageMove.ts", "../src/core/vite-plugins/unimport.ts", "../src/core/utils/auto-imports.ts", "../src/core/vite-plugins/virtualEntrypoint.ts", "../src/core/utils/createFsCache.ts", "../src/core/utils/globals.ts", "../src/core/build/findEntrypoints.ts", "../src/core/build/buildEntrypoints.ts", "../src/core/utils/removeEmptyDirs.ts", "../src/core/utils/manifest.ts", "../src/core/utils/ContentSecurityPolicy.ts", "../src/core/log/printBuildSummary.ts", "../src/core/log/printTable.ts", "../src/index.ts", "../src/core/build/generateTypesDir.ts", "../src/core/utils/findOpenPort.ts", "../src/core/utils/formatDuration.ts", "../src/core/runners/createWebExtRunner.ts", "../src/core/utils/groupEntrypoints.ts", "../src/core/utils/detectDevChanges.ts", "../src/cli/utils/defineCommand.ts", "../src/core/log/printHeader.ts", "../src/cli/commands/build.ts", "../src/cli/commands/dev.ts", "../src/cli/commands/init.ts", "../src/cli/commands/prepare.ts", "../src/cli/commands/publish.ts"],
  "sourcesContent": ["#!/usr/bin/env node\n\nimport cac from 'cac';\nimport { version } from '../../package.json';\nimport * as commands from './commands';\n\nconst cli = cac('wxt');\ncli.help();\ncli.version(version);\n\n// DEV\ncli\n  .command('[root]', 'start dev server')\n  .option('-c, --config <file>', 'use specified config file')\n  .option('-m, --mode <mode>', 'set env mode')\n  .option('-b, --browser <browser>', 'specify a browser')\n  .option('--mv3', 'target manifest v3')\n  .option('--mv2', 'target manifest v2')\n  .action(commands.dev);\n\n// BUILD\ncli\n  .command('build [root]', 'build for production')\n  .option('-c, --config <file>', 'use specified config file')\n  .option('-m, --mode <mode>', 'set env mode')\n  .option('-b, --browser <browser>', 'specify a browser')\n  .option('--mv3', 'target manifest v3')\n  .option('--mv2', 'target manifest v2')\n  .action(commands.build);\n\n// PREPARE\ncli\n  .command('prepare [root]', 'prepare')\n  .option('-c, --config <file>', 'use specified config file')\n  .action(commands.prepare);\n\n// PUBLISH\ncli.command('publish [root]', 'publish to stores').action(commands.publish);\n\n// INIT\ncli\n  .command('init [directory]', 'initialize a new project')\n  .action(commands.init);\n\ncli.parse();\n", "{\n  \"name\": \"wxt\",\n  \"type\": \"module\",\n  \"version\": \"0.0.2\",\n  \"description\": \"Next gen framework for developing web extensions\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/aklinker1/wxt\"\n  },\n  \"keywords\": [\n    \"vite\",\n    \"chrome\",\n    \"web\",\n    \"extension\",\n    \"browser\",\n    \"bundler\",\n    \"framework\"\n  ],\n  \"author\": {\n    \"name\": \"Aaron Klinker\",\n    \"email\": \"aaronklinker1+wxt@gmail.com\"\n  },\n  \"license\": \"MIT\",\n  \"files\": [\n    \"dist\"\n  ],\n  \"bin\": \"dist/cli.cjs\",\n  \"main\": \"./dist/index.cjs\",\n  \"module\": \"./dist/index.js\",\n  \"types\": \"./dist/index.d.ts\",\n  \"exports\": {\n    \".\": {\n      \"require\": \"./dist/index.cjs\",\n      \"import\": \"./dist/index.js\",\n      \"types\": \"./dist/index.d.ts\"\n    },\n    \"./client\": {\n      \"require\": \"./dist/client.cjs\",\n      \"import\": \"./dist/client.js\",\n      \"types\": \"./dist/client.d.ts\"\n    }\n  },\n  \"scripts\": {\n    \"wxt\": \"tsx src/cli/index.ts\",\n    \"build\": \"tsx scripts/build.ts\",\n    \"format\": \"prettier --write .\",\n    \"format:check\": \"prettier --write .\",\n    \"compile\": \"tsc --noEmit\",\n    \"test\": \"vitest\",\n    \"test:coverage\": \"vitest run --coverage\",\n    \"prepare\": \"simple-git-hooks\",\n    \"prepublish\": \"pnpm -s build\"\n  },\n  \"dependencies\": {\n    \"async-mutex\": \"^0.4.0\",\n    \"c12\": \"^1.4.2\",\n    \"cac\": \"^6.7.14\",\n    \"consola\": \"^3.1.0\",\n    \"fast-glob\": \"^3.2.12\",\n    \"filesize\": \"^10.0.7\",\n    \"fs-extra\": \"^11.1.1\",\n    \"jiti\": \"^1.18.2\",\n    \"json5\": \"^2.2.3\",\n    \"linkedom\": \"^0.14.26\",\n    \"picocolors\": \"^1.0.0\",\n    \"picomatch\": \"^2.3.1\",\n    \"unimport\": \"^3.0.8\",\n    \"vite\": \"^4.3.9\",\n    \"web-ext\": \"^7.6.2\",\n    \"webextension-polyfill\": \"^0.10.0\"\n  },\n  \"devDependencies\": {\n    \"@faker-js/faker\": \"^8.0.2\",\n    \"@types/fs-extra\": \"^11.0.1\",\n    \"@types/lodash.merge\": \"^4.6.7\",\n    \"@types/node\": \"^20.3.1\",\n    \"@types/picomatch\": \"^2.3.0\",\n    \"@types/webextension-polyfill\": \"^0.10.0\",\n    \"@vitest/coverage-v8\": \"^0.32.2\",\n    \"lodash.merge\": \"^4.6.2\",\n    \"npm-run-all\": \"^4.1.5\",\n    \"ora\": \"^6.3.1\",\n    \"prettier\": \"^2.8.8\",\n    \"pretty-quick\": \"^3.1.3\",\n    \"simple-git-hooks\": \"^2.8.1\",\n    \"tsup\": \"^7.0.0\",\n    \"tsx\": \"^3.12.7\",\n    \"typescript\": \"^5.1.3\",\n    \"vitest\": \"^0.32.2\",\n    \"webextension-polyfill\": \"^0.10.0\"\n  },\n  \"peerDependencies\": {\n    \"webextension-polyfill\": \">=0.10.0\"\n  },\n  \"packageManager\": \"pnpm@8.6.3\",\n  \"simple-git-hooks\": {\n    \"pre-commit\": \"pnpm pretty-quick --staged\"\n  }\n}\n", "import {\n  ExtensionRunnerConfig,\n  InlineConfig,\n  InternalConfig,\n  UserConfig,\n} from '../types';\nimport path, { resolve } from 'node:path';\nimport * as vite from 'vite';\nimport { consola } from 'consola';\nimport { importTsFile } from './importTsFile';\nimport * as plugins from '../vite-plugins';\nimport { createFsCache } from './createFsCache';\nimport { getGlobals } from './globals';\nimport { loadConfig } from 'c12';\n\n/**\n * Given an inline config, discover the config file if necessary, merge the results, resolve any\n * relative paths, and apply any defaults.\n */\nexport async function getInternalConfig(\n  config: InlineConfig,\n  command: 'build' | 'serve',\n): Promise<InternalConfig> {\n  // Apply defaults to a base config\n  const root = config.root ? path.resolve(config.root) : process.cwd();\n  const mode =\n    config.mode ?? (command === 'build' ? 'production' : 'development');\n  const browser = config.browser ?? 'chrome';\n  const manifestVersion =\n    config.manifestVersion ?? (browser == 'firefox' ? 2 : 3);\n  const outBaseDir = path.resolve(root, '.output');\n  const outDir = path.resolve(outBaseDir, `${browser}-mv${manifestVersion}`);\n  const logger = config.logger ?? consola;\n\n  const baseConfig: InternalConfigNoUserDirs = {\n    root,\n    outDir,\n    outBaseDir,\n    storeIds: config.storeIds ?? {},\n    browser,\n    manifestVersion,\n    mode,\n    command,\n    logger,\n    vite: config.vite ?? {},\n    manifest: config.manifest ?? {},\n    imports: config.imports ?? {},\n    runnerConfig: await loadConfig<ExtensionRunnerConfig>({\n      name: 'web-ext',\n      cwd: root,\n      globalRc: true,\n      rcFile: '.webextrc',\n      overrides: config.runner,\n    }),\n  };\n\n  // Load user config from file\n  let userConfig: UserConfig = {\n    mode,\n  };\n  if (config.configFile !== false) {\n    userConfig = await importTsFile<UserConfig>(\n      root,\n      path.resolve(root, config.configFile ?? 'wxt.config.ts'),\n    );\n  }\n\n  // Merge inline and user configs\n  const merged = vite.mergeConfig(\n    baseConfig,\n    userConfig,\n  ) as InternalConfigNoUserDirs;\n\n  // Apply user config and create final config\n  const srcDir = userConfig.srcDir ? resolve(root, userConfig.srcDir) : root;\n  const entrypointsDir = resolve(\n    srcDir,\n    userConfig.entrypointsDir ?? 'entrypoints',\n  );\n  const publicDir = resolve(srcDir, userConfig.publicDir ?? 'public');\n  const wxtDir = resolve(srcDir, '.wxt');\n  const typesDir = resolve(wxtDir, 'types');\n\n  const finalConfig: InternalConfig = {\n    ...merged,\n    srcDir,\n    entrypointsDir,\n    publicDir,\n    wxtDir: wxtDir,\n    typesDir,\n    fsCache: createFsCache(wxtDir),\n  };\n\n  // Customize the default vite config\n  finalConfig.vite.root = root;\n  finalConfig.vite.configFile = false;\n  finalConfig.vite.logLevel = 'warn';\n\n  finalConfig.vite.build ??= {};\n  finalConfig.vite.build.outDir = outDir;\n  finalConfig.vite.build.emptyOutDir = false;\n\n  finalConfig.vite.plugins ??= [];\n  finalConfig.vite.plugins.push(plugins.download(finalConfig));\n  finalConfig.vite.plugins.push(plugins.devHtmlPrerender(finalConfig));\n  finalConfig.vite.plugins.push(plugins.unimport(finalConfig));\n  finalConfig.vite.plugins.push(\n    plugins.virtualEntrypoin('background', finalConfig),\n  );\n  finalConfig.vite.plugins.push(\n    plugins.virtualEntrypoin('content-script', finalConfig),\n  );\n  finalConfig.vite.plugins.push(plugins.devServerGlobals(finalConfig));\n\n  finalConfig.vite.define ??= {};\n  getGlobals(finalConfig).forEach((global) => {\n    finalConfig.vite.define![global.name] = JSON.stringify(global.value);\n  });\n\n  return finalConfig;\n}\n\n/**\n * Helper type for defining a base config, since user-configurable directories must be set after\n * reading in the user config.\n */\ntype InternalConfigNoUserDirs = Omit<\n  InternalConfig,\n  'srcDir' | 'publicDir' | 'entrypointsDir' | 'wxtDir' | 'typesDir' | 'fsCache'\n>;\n", "import { consola } from 'consola';\nimport createJITI from 'jiti';\nimport transform from 'jiti/dist/babel';\nimport { resolve } from 'path';\nimport { scanExports } from 'unimport';\n\nexport async function importTsFile<T>(root: string, path: string): Promise<T> {\n  const clientImports = await scanExports(\n    resolve(root, 'node_modules/wxt/dist/client.js'),\n  );\n  const jiti = createJITI(__filename, {\n    cache: false,\n    esmResolve: true,\n    interopDefault: true,\n\n    transform(opts) {\n      // Remove CSS imports from the source code - Jiti can't handle them.\n      opts.source = opts.source.replace(/^import ['\"].*\\.css['\"];?$/gm, '');\n      opts.source = opts.source.replace(\n        /^import\\s+.*\\s+from ['\"]webextension-polyfill['\"];?$/gm,\n        '',\n      );\n\n      // Append any wxt/client functions so babel doesn't complain about undefined variables\n      if (opts.filename === path) {\n        // TODO: Only append import if it isn't already imported\n        const imports =\n          clientImports\n            .map((i) => `import { ${i.name} } from \"${i.from}\";`)\n            .join('\\n') + '\\n';\n        opts.source = imports + opts.source;\n      }\n\n      // Call the default babel transformer with our modified source code\n      return transform(opts);\n    },\n  });\n  try {\n    return await jiti(path);\n  } catch (err) {\n    consola.error(`Failed to import file: ${path}`);\n    throw err;\n  }\n}\n", "import * as vite from 'vite';\nimport { InternalConfig } from '../types';\nimport { getEntrypointName } from '../utils/entrypoints';\nimport { parseHTML } from 'linkedom';\nimport { dirname, isAbsolute, relative, resolve } from 'path';\n\n/**\n * Pre-renders the HTML entrypoints when building the extension to connect to the dev server.\n */\nexport function devHtmlPrerender(config: InternalConfig): vite.Plugin {\n  return {\n    apply: 'build',\n    name: 'wxt:dev-html-prerender',\n    config(userConfig) {\n      return vite.mergeConfig(\n        {\n          resolve: {\n            alias: {\n              '@wxt/reload-html': resolve(\n                config.root,\n                'node_modules/wxt/dist/virtual-modules/reload-html.js',\n              ),\n            },\n          },\n        },\n        userConfig,\n      );\n    },\n    async transform(html, id) {\n      const server = config.server;\n      if (config.command !== 'serve' || server == null || !id.endsWith('.html'))\n        return;\n\n      const originalUrl = `${server.origin}${id}`;\n      const name = getEntrypointName(config.entrypointsDir, id);\n      const url = `${server.origin}/${name}.html`;\n      const serverHtml = await server.transformIndexHtml(\n        url,\n        html,\n        originalUrl,\n      );\n      const { document } = parseHTML(serverHtml);\n\n      const pointToDevServer = (querySelector: string, attr: string): void => {\n        document.querySelectorAll(querySelector).forEach((element) => {\n          const src = element.getAttribute(attr);\n          if (!src) return;\n\n          if (isAbsolute(src)) {\n            element.setAttribute(attr, server.origin + src);\n          } else if (src.startsWith('.')) {\n            const abs = resolve(dirname(id), src);\n            const pathname = relative(config.root, abs);\n            element.setAttribute(attr, `${server.origin}/${pathname}`);\n          }\n        });\n      };\n      pointToDevServer('script[type=module]', 'src');\n      pointToDevServer('link[rel=stylesheet]', 'href');\n\n      // Add a script to add page reloading\n      const reloader = document.createElement('script');\n      reloader.src = '@wxt/reload-html';\n      reloader.type = 'module';\n      document.head.appendChild(reloader);\n\n      const newHtml = document.toString();\n      config.logger.debug('Transformed ' + id);\n      config.logger.debug('Old HTML:\\n' + html);\n      config.logger.debug('New HTML:\\n' + newHtml);\n      return newHtml;\n    },\n  };\n}\n", "import { Entrypoint } from '../types';\nimport path, { relative, resolve } from 'node:path';\n\nexport function getEntrypointName(\n  entrypointsDir: string,\n  inputPath: string,\n  // type: Entrypoint['type'],\n): string {\n  const relativePath = path.relative(entrypointsDir, inputPath);\n  // Grab the string up to the first . or /\n  const name = relativePath.split(/[\\.\\/]/, 2)[0];\n\n  return name;\n}\n\nexport function getEntrypointOutputFile(\n  entrypoint: Entrypoint,\n  ext: string,\n): string {\n  return resolve(entrypoint.outputDir, `${entrypoint.name}${ext}`);\n}\n\n/**\n * Return's the entrypoint's output path relative to the output directory. Used for paths in the\n * manifest and rollup's bundle.\n */\nexport function getEntrypointBundlePath(\n  entrypoint: Entrypoint,\n  outDir: string,\n  ext: string,\n): string {\n  return relative(outDir, getEntrypointOutputFile(entrypoint, ext));\n}\n", "import { Plugin } from 'vite';\nimport { InternalConfig } from '../types';\n\n/**\n * Defines global constants about the dev server. Helps scripts connect to the server's web socket.\n */\nexport function devServerGlobals(internalConfig: InternalConfig): Plugin {\n  return {\n    name: 'wxt:dev-server-globals',\n    config(config) {\n      if (internalConfig.server == null || internalConfig.command == 'build')\n        return;\n\n      config.define ??= {};\n      config.define.__DEV_SERVER_PROTOCOL__ = JSON.stringify('ws:');\n      config.define.__DEV_SERVER_HOSTNAME__ = JSON.stringify(\n        internalConfig.server.hostname,\n      );\n      config.define.__DEV_SERVER_PORT__ = JSON.stringify(\n        internalConfig.server.port,\n      );\n    },\n  };\n}\n", "import dns from 'node:dns';\nimport { withTimeout } from './promises';\nimport { InternalConfig } from '../types';\n\nfunction isOffline(): Promise<boolean> {\n  const isOffline = new Promise<boolean>((res) => {\n    dns.resolve('google.com', (err) => {\n      if (err == null) {\n        res(false);\n      } else {\n        res(true);\n      }\n    });\n  });\n  return withTimeout(isOffline, 1e3).catch(() => true);\n}\n\nexport async function isOnline(): Promise<boolean> {\n  const offline = await isOffline();\n  return !offline;\n}\n\n/**\n * Fetches a URL with a simple GET request. Grabs it from cache if it doesn't exist, or throws an\n * error if it can't be resolved via the network or cache.\n */\nexport async function fetchCached(\n  url: string,\n  config: InternalConfig,\n): Promise<string> {\n  let content: string = '';\n\n  if (await isOnline()) {\n    const res = await fetch(url);\n    if (res.status < 300) {\n      content = await res.text();\n      await config.fsCache.set(url, content);\n    } else {\n      config.logger.debug(\n        `Failed to download \"${url}\", falling back to cache...`,\n      );\n    }\n  }\n\n  if (!content) content = (await config.fsCache.get(url)) ?? '';\n  if (!content)\n    throw Error(\n      `Offline and \"${url}\" has not been cached. Try again when online.`,\n    );\n\n  return content;\n}\n", "/**\n * Add a timeout to a promise.\n */\nexport function withTimeout<T>(\n  promise: Promise<T>,\n  duration: number,\n): Promise<T> {\n  return new Promise((res, rej) => {\n    const timeout = setTimeout(() => {\n      rej(`Promise timed out after ${duration}ms`);\n    }, duration);\n    promise\n      .then(res)\n      .catch(rej)\n      .finally(() => clearTimeout(timeout));\n  });\n}\n\n/**\n * @deprecated Don't use in production, just for testing and slowing things down.\n */\nexport function sleep(ms: number): Promise<void> {\n  return new Promise((res) => setTimeout(res, ms));\n}\n", "import { Plugin } from 'vite';\nimport { InternalConfig } from '../types';\nimport { fetchCached } from '../utils/network';\n\n/**\n * Downloads any URL imports, like Google Analytics, into virtual modules so they are bundled with\n * the extension instead of depending on remote code at runtime.\n *\n * @example\n * import \"url:https://google-tagmanager.com/gtag?id=XYZ\";\n */\nexport function download(config: InternalConfig): Plugin {\n  return {\n    name: 'wxt:download',\n    resolveId(id) {\n      if (id.startsWith('url:')) return '\\0' + id;\n    },\n    async load(id) {\n      if (!id.startsWith('\\0url:')) return;\n\n      // Load file from network or cache\n      const url = id.replace('\\0url:', '');\n      return await fetchCached(url, config);\n    },\n  };\n}\n", "import * as vite from 'vite';\nimport { Entrypoint, InternalConfig } from '../types';\nimport { dirname, extname, resolve } from 'node:path';\nimport { getEntrypointBundlePath } from '../utils/entrypoints';\nimport fs, { ensureDir } from 'fs-extra';\n\n/**\n * Ensures the HTML files output by a multipage build are in the correct location. This does two\n * things:\n *\n * 1. Moves the HMTL files to their final location at `<outDir>/<entrypoint.name>.html`.\n * 2. Updates the bundle so it summarizes the files correctly in the returned build output.\n *\n * Assets (JS and CSS) are output to the `<outDir>/assets` directory, and don't need to be modified.\n * HTML files access them via absolute URLs, so we don't need to update any import paths in the HTML\n * files either.\n */\nexport function multipageMove(\n  entrypoints: Entrypoint[],\n  config: InternalConfig,\n): vite.Plugin {\n  return {\n    name: 'wxt:multipage-move',\n    async writeBundle(_, bundle) {\n      for (const oldBundlePath in bundle) {\n        // oldBundlePath = 'entrypoints/popup.html' or 'entrypoints/o ptions/index.html'\n\n        // Find a matching entrypoint - oldBundlePath is the same as end end of the input path.\n        const entrypoint = entrypoints.find(\n          (entry) => !!entry.inputPath.endsWith(oldBundlePath),\n        );\n        if (entrypoint == null) {\n          config.logger.debug('No entrypoint found for', oldBundlePath);\n          continue;\n        }\n\n        // Get the new bundle path\n        const newBundlePath = getEntrypointBundlePath(\n          entrypoint,\n          config.outDir,\n          extname(oldBundlePath),\n        );\n        if (newBundlePath === oldBundlePath) {\n          config.logger.debug(\n            'HTML file is already in the correct location',\n            oldBundlePath,\n          );\n          continue;\n        }\n\n        // Move file and update bundle\n        // Do this inside a mutex lock so it only runs one at a time for concurrent multipage builds\n        const oldAbsPath = resolve(config.outDir, oldBundlePath);\n        const newAbsPath = resolve(config.outDir, newBundlePath);\n        await ensureDir(dirname(newAbsPath));\n        await fs.move(oldAbsPath, newAbsPath, { overwrite: true });\n\n        const renamedChunk = {\n          ...bundle[oldBundlePath],\n          fileName: newBundlePath,\n        };\n        delete bundle[oldBundlePath];\n        bundle[newBundlePath] = renamedChunk;\n      }\n    },\n  };\n}\n", "import { createUnimport } from 'unimport';\nimport { InternalConfig } from '../types';\nimport { getUnimportOptions } from '../utils/auto-imports';\nimport { Plugin } from 'vite';\n\n/**\n * Inject any global imports defined by unimport\n */\nexport function unimport(config: InternalConfig): Plugin {\n  const options = getUnimportOptions(config);\n  const unimport = createUnimport(options);\n\n  return {\n    name: 'wxt:unimport',\n    async config() {\n      await unimport.scanImportsFromDir(undefined, { cwd: config.srcDir });\n    },\n    async transform(code, id) {\n      return unimport.injectImports(code, id);\n    },\n  };\n}\n", "import { UnimportOptions } from 'unimport';\nimport { InternalConfig } from '../types';\nimport { mergeConfig } from 'vite';\n\nexport function getUnimportOptions(\n  config: InternalConfig,\n): Partial<UnimportOptions> {\n  const defaultOptions: Partial<UnimportOptions> = {\n    debugLog: config.logger.debug,\n    imports: [\n      { name: '*', as: 'browser', from: 'webextension-polyfill' },\n      { name: 'defineConfig', from: 'wxt' },\n    ],\n    presets: [{ package: 'wxt/client' }],\n    warn: config.logger.warn,\n    dirs: ['components', 'composables', 'hooks', 'utils'],\n  };\n\n  return mergeConfig(\n    defaultOptions,\n    config.imports,\n  ) as Partial<UnimportOptions>;\n}\n", "import { Plugin } from 'vite';\nimport { Entrypoint, InternalConfig } from '../types';\nimport fs from 'fs-extra';\nimport { resolve } from 'path';\n\n/**\n * Wraps a user's entrypoint with a vitual version with additional logic.\n */\nexport function virtualEntrypoin(\n  type: Entrypoint['type'],\n  config: InternalConfig,\n): Plugin {\n  const virtualId = `virtual:wxt-${type}?`;\n  const resolvedVirtualId = `\\0${virtualId}`;\n\n  return {\n    name: `wxt:virtual-entrypoint`,\n    resolveId(id) {\n      // Id doesn't start with prefix, it looks like this:\n      // /path/to/project/virtual:background?/path/to/project/entrypoints/background.ts\n      const index = id.indexOf(virtualId);\n      if (index === -1) return;\n\n      const inputPath = id.substring(index + virtualId.length);\n      return resolvedVirtualId + inputPath;\n    },\n    async load(id) {\n      if (!id.startsWith(resolvedVirtualId)) return;\n\n      const inputPath = id.replace(resolvedVirtualId, '');\n      const template = await fs.readFile(\n        resolve(\n          config.root,\n          `node_modules/wxt/dist/virtual-modules/${type}-entrypoint.js`,\n        ),\n        'utf-8',\n      );\n      return template.replace(`virtual:user-${type}`, inputPath);\n    },\n  };\n}\n", "import fs, { ensureDir } from 'fs-extra';\nimport { FsCache } from '../types';\nimport { dirname, resolve } from 'path';\n\n/**\n * A basic file system cache stored at `<srcDir>/.wxt/cache/<key>`. Just caches a string in a\n * file for the given key.\n *\n * @param srcDir Absolute path to source directory. See `InternalConfig.srcDir`\n */\nexport function createFsCache(wxtDir: string): FsCache {\n  const getPath = (key: string) =>\n    resolve(wxtDir, 'cache', encodeURIComponent(key));\n\n  return {\n    async set(key: string, value: string): Promise<void> {\n      const path = getPath(key);\n      await ensureDir(dirname(path));\n      await fs.writeFile(path, value, 'utf-8');\n    },\n    async get(key: string): Promise<string | undefined> {\n      const path = getPath(key);\n      try {\n        return await fs.readFile(path, 'utf-8');\n      } catch {\n        return undefined;\n      }\n    },\n  };\n}\n", "import { InternalConfig } from '../types';\n\nexport function getGlobals(\n  config: InternalConfig,\n): Array<{ name: string; value: any; type: string }> {\n  return [\n    {\n      name: '__MANIFEST_VERSION__',\n      value: config.manifestVersion,\n      type: `2 | 3`,\n    },\n    {\n      name: '__BROWSER__',\n      value: config.browser,\n      type: `\"chromium\" | \"firefox\"`,\n    },\n    {\n      name: '__IS_CHROME__',\n      value: config.browser === 'chrome',\n      type: `boolean`,\n    },\n    {\n      name: '__IS_FIREFOX__',\n      value: config.browser === 'firefox',\n      type: `boolean`,\n    },\n    {\n      name: '__IS_SAFARI__',\n      value: config.browser === 'safari',\n      type: `boolean`,\n    },\n    {\n      name: '__IS_EDGE__',\n      value: config.browser === 'edge',\n      type: `boolean`,\n    },\n    {\n      name: '__IS_OPERA__',\n      value: config.browser === 'opera',\n      type: `boolean`,\n    },\n    {\n      name: '__COMMAND__',\n      value: config.command,\n      type: `\"build\" | \"serve\"`,\n    },\n  ];\n}\n", "import { relative, resolve } from 'path';\nimport {\n  BackgroundEntrypoint,\n  BackgroundScriptDefintition,\n  ContentScriptDefinition,\n  ContentScriptEntrypoint,\n  Entrypoint,\n  InternalConfig,\n  OptionsEntrypoint,\n  PopupEntrypoint,\n} from '../types';\nimport fs from 'fs-extra';\nimport picomatch from 'picomatch';\nimport { parseHTML } from 'linkedom';\nimport JSON5 from 'json5';\nimport { importTsFile } from '../utils/importTsFile';\nimport glob from 'fast-glob';\nimport { getEntrypointName } from '../utils/entrypoints';\n\n/**\n * Return entrypoints and their configuration by looking through the\n */\nexport async function findEntrypoints(\n  config: FindEntrypointsConfig,\n): Promise<Entrypoint[]> {\n  const relativePaths = await glob('**/*', {\n    cwd: config.entrypointsDir,\n  });\n  // Ensure consistent output\n  relativePaths.sort();\n\n  const pathGlobs = Object.keys(PATH_GLOB_TO_TYPE_MAP);\n  const existingNames: Record<string, Entrypoint | undefined> = {};\n\n  const entrypoints: Entrypoint[] = [];\n  await Promise.all(\n    relativePaths.map(async (relativePath) => {\n      const path = resolve(config.entrypointsDir, relativePath);\n      const matchingGlob = pathGlobs.find((glob) =>\n        picomatch.isMatch(relativePath, glob),\n      );\n\n      if (matchingGlob == null) {\n        return config.logger.warn(\n          `${relativePath} does not match any known entrypoint. Known entrypoints:\\n${JSON.stringify(\n            PATH_GLOB_TO_TYPE_MAP,\n            null,\n            2,\n          )}`,\n        );\n      }\n\n      const type = PATH_GLOB_TO_TYPE_MAP[matchingGlob];\n      if (type === 'ignored') return;\n\n      let entrypoint: Entrypoint;\n      switch (type) {\n        case 'popup':\n          entrypoint = await getPopupEntrypoint(config, path);\n          break;\n        case 'options':\n          entrypoint = await getOptionsEntrypoint(config, path);\n          break;\n        case 'background':\n          entrypoint = await getBackgroundEntrypoint(config, path);\n          break;\n        case 'content-script':\n          entrypoint = await getContentScriptEntrypoint(\n            config,\n            relativePath.split('.', 2)[0],\n            path,\n          );\n          break;\n        default:\n          entrypoint = {\n            type,\n            name: getEntrypointName(config.entrypointsDir, path),\n            inputPath: path,\n            outputDir: config.outDir,\n          };\n      }\n\n      const withSameName = existingNames[entrypoint.name];\n      if (withSameName) {\n        throw Error(\n          `Multiple entrypoints with the name \"${\n            entrypoint.name\n          }\" detected, but only one is allowed: ${[\n            relative(config.root, withSameName.inputPath),\n            relative(config.root, entrypoint.inputPath),\n          ].join(', ')}`,\n        );\n      }\n      entrypoints.push(entrypoint);\n      existingNames[entrypoint.name] = entrypoint;\n    }),\n  );\n  return entrypoints;\n}\n\n/**\n * @param path Absolute path to the popup HTML file.\n * @param content String contents of the file at the path.\n */\nasync function getPopupEntrypoint(\n  config: FindEntrypointsConfig,\n  path: string,\n): Promise<PopupEntrypoint> {\n  const options: PopupEntrypoint['options'] = {};\n\n  const content = await fs.readFile(path, 'utf-8');\n  const { document } = parseHTML(content);\n\n  const title = document.querySelector('title');\n  if (title != null) options.defaultTitle = title.textContent ?? undefined;\n\n  const defaultIconContent = document\n    .querySelector(\"meta[name='manifest.default_icon']\")\n    ?.getAttribute('content');\n  if (defaultIconContent) {\n    try {\n      options.defaultIcon = JSON5.parse(defaultIconContent);\n    } catch (err) {\n      config.logger.fatal(\n        `Failed to parse default_icon meta tag content as JSON5. content=${defaultIconContent}`,\n        err,\n      );\n    }\n  }\n\n  const mv2KeyContent = document\n    .querySelector(\"meta[name='manifest.type']\")\n    ?.getAttribute('content');\n  if (mv2KeyContent) {\n    options.mv2Key =\n      mv2KeyContent === 'page_action' ? 'page_action' : 'browser_action';\n  }\n\n  return {\n    type: 'popup',\n    name: 'popup',\n    options,\n    inputPath: path,\n    outputDir: config.outDir,\n  };\n}\n\n/**\n * @param path Absolute path to the options HTML file.\n * @param content String contents of the file at the path.\n */\nasync function getOptionsEntrypoint(\n  config: FindEntrypointsConfig,\n  path: string,\n): Promise<OptionsEntrypoint> {\n  const options: OptionsEntrypoint['options'] = {};\n\n  const content = await fs.readFile(path, 'utf-8');\n  const { document } = parseHTML(content);\n\n  const openInTabContent = document\n    .querySelector(\"meta[name='manifest.open_in_tab']\")\n    ?.getAttribute('content');\n  if (openInTabContent) {\n    options.openInTab = Boolean(openInTabContent);\n  }\n\n  const chromeStyleContent = document\n    .querySelector(\"meta[name='manifest.chrome_style']\")\n    ?.getAttribute('content');\n  if (chromeStyleContent) {\n    options.chromeStyle = Boolean(chromeStyleContent);\n  }\n\n  const browserStyleContent = document\n    .querySelector(\"meta[name='manifest.browser_style']\")\n    ?.getAttribute('content');\n  if (browserStyleContent) {\n    options.browserStyle = Boolean(browserStyleContent);\n  }\n\n  return {\n    type: 'options',\n    name: 'options',\n    options,\n    inputPath: path,\n    outputDir: config.outDir,\n  };\n}\n\n/**\n * @param path Absolute path to the background's TS file.\n */\nasync function getBackgroundEntrypoint(\n  config: FindEntrypointsConfig,\n  path: string,\n): Promise<BackgroundEntrypoint> {\n  const { main: _, ...options } =\n    await importTsFile<BackgroundScriptDefintition>(config.root, path);\n  if (options == null) {\n    throw Error('Background script does not have a default export');\n  }\n  return {\n    type: 'background',\n    name: 'background',\n    inputPath: path,\n    outputDir: config.outDir,\n    options: options,\n  };\n}\n\n/**\n * @param path Absolute path to the content script's TS file.\n */\nasync function getContentScriptEntrypoint(\n  config: FindEntrypointsConfig,\n  name: string,\n  path: string,\n): Promise<ContentScriptEntrypoint> {\n  const { main: _, ...options } = await importTsFile<ContentScriptDefinition>(\n    config.root,\n    path,\n  );\n  if (options == null) {\n    throw Error(`Content script ${name} does not have a default export`);\n  }\n  return {\n    type: 'content-script',\n    name: getEntrypointName(config.entrypointsDir, path),\n    inputPath: path,\n    outputDir: resolve(config.outDir, 'content-scripts'),\n    options,\n  };\n}\n\nconst PATH_GLOB_TO_TYPE_MAP: Record<string, Entrypoint['type'] | 'ignored'> = {\n  'sandbox.html': 'sandbox',\n  'sandbox/index.html': 'sandbox',\n  '*.sandbox.html': 'sandbox',\n  '*.sandbox/index.html': 'sandbox',\n\n  'bookmarks.html': 'bookmarks',\n  'bookmarks/index.html': 'bookmarks',\n\n  'history.html': 'history',\n  'history/index.html': 'history',\n\n  'newtab.html': 'newtab',\n  'newtab/index.html': 'newtab',\n\n  'sidepanel.html': 'sidepanel',\n  'sidepanel/index.html': 'sidepanel',\n  '*.sidepanel.html': 'sidepanel',\n  '*.sidepanel/index.html': 'sidepanel',\n\n  'devtools.html': 'devtools',\n  'devtools/index.html': 'devtools',\n\n  'background.ts': 'background',\n\n  '*.content.ts?(x)': 'content-script',\n  '*.content/index.ts?(x)': 'content-script',\n\n  'popup.html': 'popup',\n  'popup/index.html': 'popup',\n\n  'options.html': 'options',\n  'options/index.html': 'options',\n\n  '*.html': 'unlisted-page',\n  '*/index.html': 'unlisted-page',\n  '*.ts': 'unlisted-script',\n\n  // Don't warn about any files in subdirectories, like CSS or JS entrypoints for HTML files\n  '*/*': 'ignored',\n};\n\nexport type FindEntrypointsConfig = Pick<\n  InternalConfig,\n  'root' | 'entrypointsDir' | 'outDir' | 'logger' | 'mode' | 'command'\n>;\n", "import * as vite from 'vite';\nimport {\n  BuildOutput,\n  BuildStepOutput,\n  Entrypoint,\n  EntrypointGroup,\n  InternalConfig,\n} from '../types';\nimport * as plugins from '../vite-plugins';\nimport { removeEmptyDirs } from '../utils/removeEmptyDirs';\nimport { getEntrypointBundlePath } from '../utils/entrypoints';\nimport glob from 'fast-glob';\nimport fs from 'fs-extra';\nimport { dirname, resolve } from 'path';\n\nexport async function buildEntrypoints(\n  groups: EntrypointGroup[],\n  config: InternalConfig,\n): Promise<Omit<BuildOutput, 'manifest'>> {\n  const steps: BuildStepOutput[] = [];\n  for (const group of groups) {\n    const step = Array.isArray(group)\n      ? await buildMultipleEntrypoints(group, config)\n      : await buildSingleEntrypoint(group, config);\n    steps.push(step);\n  }\n  const publicAssets = await copyPublicDirectory(config);\n\n  // Remove any empty directories from moving outputs around\n  await removeEmptyDirs(config.outDir);\n\n  return { publicAssets, steps };\n}\n\n/**\n * Use Vite's lib mode + IIFE format to bundle the entrypoint to a single file.\n */\nasync function buildSingleEntrypoint(\n  entrypoint: Entrypoint,\n  config: InternalConfig,\n): Promise<BuildStepOutput> {\n  // Should this entrypoint be wrapped by the vite-plugins/virtualEntrypoint plugin?\n  const isVirtual = ['background', 'content-script'].includes(entrypoint.type);\n  const entry = isVirtual\n    ? `virtual:wxt-${entrypoint.type}?${entrypoint.inputPath}`\n    : entrypoint.inputPath;\n\n  const libMode: vite.InlineConfig = {\n    build: {\n      lib: {\n        entry,\n        formats: ['iife'],\n        name: entrypoint.name,\n        fileName: entrypoint.name,\n      },\n      rollupOptions: {\n        output: {\n          // There's only a single output for this build, so we use the desired bundle path for the\n          // entry output (like \"content-scripts/overlay.js\")\n          entryFileNames: getEntrypointBundlePath(\n            entrypoint,\n            config.outDir,\n            '.js',\n          ),\n          // Output content script CSS to assets/ with a hash to prevent conflicts. Defaults to\n          // \"[name].[ext]\" in lib mode, which usually results in \"style.css\". That means multiple\n          // content scripts with styles would overwrite each other if it weren't changed below.\n          assetFileNames: `assets/${entrypoint.name}.[ext]`,\n        },\n      },\n    },\n  };\n  const entryConfig = vite.mergeConfig(\n    libMode,\n    config.vite,\n  ) as vite.InlineConfig;\n\n  const result = await vite.build(entryConfig);\n  return {\n    entrypoints: entrypoint,\n    chunks: getBuildOutputChunks(result),\n  };\n}\n\n/**\n * Use Vite's multipage build to bundle all the entrypoints in a single step.\n */\nasync function buildMultipleEntrypoints(\n  entrypoints: Entrypoint[],\n  config: InternalConfig,\n): Promise<BuildStepOutput> {\n  const multiPage: vite.InlineConfig = {\n    plugins: [plugins.multipageMove(entrypoints, config)],\n    build: {\n      rollupOptions: {\n        input: entrypoints.reduce<Record<string, string>>((input, entry) => {\n          input[entry.name] = entry.inputPath;\n          return input;\n        }, {}),\n        output: {\n          // Include a hash to prevent conflicts\n          chunkFileNames: 'chunks/[name]-[hash].js',\n          // Include a hash to prevent conflicts\n          entryFileNames: 'chunks/[name]-[hash].js',\n          // We can't control the \"name\", so we need a hash to prevent conflicts\n          assetFileNames: 'assets/[name]-[hash].[ext]',\n        },\n      },\n    },\n  };\n\n  const entryConfig = vite.mergeConfig(\n    multiPage,\n    config.vite,\n  ) as vite.InlineConfig;\n\n  const result = await vite.build(entryConfig);\n  return {\n    entrypoints,\n    chunks: getBuildOutputChunks(result),\n  };\n}\n\nfunction getBuildOutputChunks(\n  result: Awaited<ReturnType<typeof vite.build>>,\n): BuildStepOutput['chunks'] {\n  if ('on' in result) throw Error('wxt does not support vite watch mode.');\n  if (Array.isArray(result)) return result.flatMap(({ output }) => output);\n  return result.output;\n}\n\nasync function copyPublicDirectory(\n  config: InternalConfig,\n): Promise<BuildOutput['publicAssets']> {\n  const publicAssets: BuildOutput['publicAssets'] = [];\n  if (!(await fs.exists(config.publicDir))) return publicAssets;\n\n  const files = await glob('**/*', { cwd: config.publicDir });\n\n  for (const file of files) {\n    const srcPath = resolve(config.publicDir, file);\n    const outPath = resolve(config.outDir, file);\n\n    await fs.ensureDir(dirname(outPath));\n    await fs.copyFile(srcPath, outPath);\n    publicAssets.push({\n      type: 'asset',\n      fileName: file,\n      name: file,\n      needsCodeReference: false,\n      source: await fs.readFile(srcPath),\n    });\n  }\n\n  return publicAssets;\n}\n", "import fs from 'fs-extra';\nimport path from 'path';\n\nexport async function removeEmptyDirs(dir: string): Promise<void> {\n  const files = await fs.readdir(dir);\n  for (const file of files) {\n    const filePath = path.join(dir, file);\n    const stats = await fs.stat(filePath);\n    if (stats.isDirectory()) {\n      await removeEmptyDirs(filePath);\n    }\n  }\n\n  try {\n    await fs.rmdir(dir);\n  } catch {\n    // noop on failure - this means the directory was not empty.\n  }\n}\n", "import { Entrypoint } from '../..';\nimport { Manifest } from 'webextension-polyfill';\nimport {\n  BackgroundEntrypoint,\n  BuildOutput,\n  ContentScriptEntrypoint,\n  InternalConfig,\n  OptionsEntrypoint,\n  PopupEntrypoint,\n} from '../types';\nimport fs from 'fs-extra';\nimport { resolve } from 'path';\nimport { getEntrypointBundlePath } from './entrypoints';\nimport { ContentSecurityPolicy } from './ContentSecurityPolicy';\n\n/**\n * Writes the manifest to the output directory and the build output.\n */\nexport async function writeManifest(\n  manifest: Manifest.WebExtensionManifest,\n  output: BuildOutput,\n  config: InternalConfig,\n): Promise<void> {\n  const str =\n    config.mode === 'production'\n      ? JSON.stringify(manifest)\n      : JSON.stringify(manifest, null, 2);\n\n  await fs.ensureDir(config.outDir);\n  await fs.writeFile(resolve(config.outDir, 'manifest.json'), str, 'utf-8');\n\n  output.publicAssets.unshift({\n    type: 'asset',\n    fileName: 'manifest.json',\n    name: 'manifest',\n    needsCodeReference: false,\n    source: str,\n  });\n}\n\n/**\n * Generates the manifest based on the config and entrypoints.\n */\nexport async function generateMainfest(\n  entrypoints: Entrypoint[],\n  buildOutput: Omit<BuildOutput, 'manifest'>,\n  config: InternalConfig,\n): Promise<Manifest.WebExtensionManifest> {\n  const pkg = await getPackageJson(config);\n  if (pkg.version == null)\n    throw Error('package.json does not include a version');\n  if (pkg.name == null) throw Error('package.json does not include a name');\n  if (pkg.description == null)\n    throw Error('package.json does not include a description');\n\n  const manifest: Manifest.WebExtensionManifest = {\n    manifest_version: config.manifestVersion,\n    name: pkg.name,\n    short_name: pkg.shortName,\n    version: simplifyVersion(pkg.version),\n    version_name: config.browser === 'firefox' ? undefined : pkg.version,\n    ...config.manifest,\n  };\n\n  addEntrypoints(manifest, entrypoints, buildOutput, config);\n\n  if (config.command === 'serve') addDevModeCsp(manifest, config);\n\n  return manifest;\n}\n\n/**\n * Read the package.json from the current directory.\n *\n * TODO: look in root and up directories until it's found\n */\nasync function getPackageJson(config: InternalConfig): Promise<any> {\n  return await fs.readJson(resolve(config.root, 'package.json'));\n}\n\n/**\n * Removes suffixes from the version, like X.Y.Z-alpha1 (which brosers don't allow), so it's a\n * simple version number, like X or X.Y or X.Y.Z, which browsers allow.\n */\nfunction simplifyVersion(versionName: string): string {\n  // Regex adapted from here: https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/version#version_format\n\n  const version = /^((0|[1-9][0-9]{0,8})([.](0|[1-9][0-9]{0,8})){0,3}).*$/.exec(\n    versionName,\n  )?.[1];\n\n  if (version == null)\n    throw Error(\n      `Cannot simplify package.json version \"${versionName}\" to a valid extension version, \"X.Y.Z\"`,\n    );\n\n  return version;\n}\n\nfunction addEntrypoints(\n  manifest: Manifest.WebExtensionManifest,\n  entrypoints: Entrypoint[],\n  buildOutput: Omit<BuildOutput, 'manifest'>,\n  config: InternalConfig,\n): void {\n  const entriesByType = entrypoints.reduce<\n    Partial<Record<Entrypoint['type'], Entrypoint[]>>\n  >((map, entrypoint) => {\n    map[entrypoint.type] ??= [];\n    map[entrypoint.type]?.push(entrypoint);\n    return map;\n  }, {});\n\n  const background = entriesByType['background']?.[0] as\n    | BackgroundEntrypoint\n    | undefined;\n  const bookmarks = entriesByType['bookmarks']?.[0];\n  const contentScripts = entriesByType['content-script'] as\n    | ContentScriptEntrypoint[]\n    | undefined;\n  const devtools = entriesByType['devtools']?.[0];\n  const history = entriesByType['history']?.[0];\n  const newtab = entriesByType['newtab']?.[0];\n  const options = entriesByType['options']?.[0] as\n    | OptionsEntrypoint\n    | undefined;\n  const popup = entriesByType['popup']?.[0] as PopupEntrypoint | undefined;\n  const sandboxes = entriesByType['sandbox'];\n  const sidepanels = entriesByType['sidepanel'];\n\n  if (background) {\n    const script = getEntrypointBundlePath(background, config.outDir, '.js');\n    if (manifest.manifest_version === 3) {\n      manifest.background = {\n        type: background.options.type,\n        service_worker: script,\n      };\n    } else {\n      manifest.background = {\n        persistent: background.options.persistent,\n        scripts: [script],\n      };\n    }\n  }\n\n  if (bookmarks) {\n    if (config.browser === 'firefox') {\n      config.logger.warn(\n        'Bookmarks are not supported by Firefox. chrome_url_overrides.bookmarks was not added to the manifest',\n      );\n    } else {\n      manifest.chrome_url_overrides ??= {};\n      // @ts-expect-error: bookmarks is untyped in webextension-polyfill, but supported by chrome\n      manifest.chrome_url_overrides.bookmarks = getEntrypointBundlePath(\n        bookmarks,\n        config.outDir,\n        '.html',\n      );\n    }\n  }\n\n  if (history) {\n    if (config.browser === 'firefox') {\n      config.logger.warn(\n        'Bookmarks are not supported by Firefox. chrome_url_overrides.history was not added to the manifest',\n      );\n    } else {\n      manifest.chrome_url_overrides ??= {};\n      // @ts-expect-error: history is untyped in webextension-polyfill, but supported by chrome\n      manifest.chrome_url_overrides.history = getEntrypointBundlePath(\n        history,\n        config.outDir,\n        '.html',\n      );\n    }\n  }\n\n  if (newtab) {\n    manifest.chrome_url_overrides ??= {};\n    manifest.chrome_url_overrides.newtab = getEntrypointBundlePath(\n      newtab,\n      config.outDir,\n      '.html',\n    );\n  }\n\n  if (popup) {\n    const default_popup = getEntrypointBundlePath(\n      popup,\n      config.outDir,\n      '.html',\n    );\n    const options: Manifest.ActionManifest = {\n      default_icon: popup.options.defaultIcon,\n      default_title: popup.options.defaultTitle,\n    };\n    if (manifest.manifest_version === 3) {\n      manifest.action = {\n        ...options,\n        default_popup,\n      };\n    } else {\n      manifest[popup.options.mv2Key ?? 'browser_action'] = {\n        ...options,\n        default_popup,\n      };\n    }\n  }\n\n  if (devtools) {\n    manifest.devtools_page = getEntrypointBundlePath(\n      devtools,\n      config.outDir,\n      '.html',\n    );\n  }\n\n  if (options) {\n    const page = getEntrypointBundlePath(options, config.outDir, '.html');\n    manifest.options_ui = {\n      open_in_tab: options.options.openInTab,\n      browser_style:\n        config.browser === 'firefox' ? options.options.browserStyle : undefined,\n      chrome_style:\n        config.browser !== 'firefox' ? options.options.chromeStyle : undefined,\n      page,\n    };\n  }\n\n  if (sandboxes?.length) {\n    if (config.browser === 'firefox') {\n      config.logger.warn(\n        'Sandboxed pages not supported by Firefox. sandbox.pages was not added to the manifest',\n      );\n    } else {\n      // @ts-expect-error: sandbox not typed\n      manifest.sandbox = {\n        pages: sandboxes.map((entry) =>\n          getEntrypointBundlePath(entry, config.outDir, '.html'),\n        ),\n      };\n    }\n  }\n\n  if (sidepanels?.length) {\n    const defaultSidepanel =\n      sidepanels.find((entry) => entry.name === 'sidepanel') ?? sidepanels[0];\n    const page = getEntrypointBundlePath(\n      defaultSidepanel,\n      config.outDir,\n      '.html',\n    );\n\n    if (config.browser === 'firefox') {\n      manifest.sidebar_action = {\n        // TODO: Add options to side panel\n        // ...defaultSidepanel.options,\n        default_panel: page,\n      };\n    } else if (config.manifestVersion === 3) {\n      // @ts-expect-error: Untyped\n      manifest.side_panel = {\n        default_path: page,\n      };\n    } else {\n      config.logger.warn(\n        'Side panel not supported by Chromium using MV2. side_panel.default_path was not added to the manifest',\n      );\n    }\n  }\n\n  if (contentScripts?.length) {\n    if (config.command === 'serve') {\n      const permissionsKey =\n        config.manifestVersion === 2 ? 'permissions' : 'host_permissions';\n      const hostPermissions = new Set<string>(manifest[permissionsKey] ?? []);\n      contentScripts.forEach((script) => {\n        script.options.matches.forEach((matchPattern) => {\n          hostPermissions.add(matchPattern);\n        });\n      });\n      manifest[permissionsKey] = Array.from(hostPermissions).sort();\n    } else {\n      const hashToEntrypointsMap = contentScripts.reduce((map, script) => {\n        const hash = JSON.stringify(script.options);\n        if (!map.has(hash)) {\n          map.set(hash, [script]);\n        } else {\n          map.get(hash)?.push(script);\n        }\n        return map;\n      }, new Map<string, ContentScriptEntrypoint[]>());\n\n      manifest.content_scripts = Array.from(hashToEntrypointsMap.entries()).map(\n        ([, scripts]) => ({\n          ...scripts[0].options,\n          // TOOD: Sorting css and js arrays here so we get consistent test results... but we\n          // shouldn't have to. Where is the inconsistency coming from?\n          css: getContentScriptCssFiles(scripts, buildOutput)?.sort(),\n          js: scripts\n            .map((entry) =>\n              getEntrypointBundlePath(entry, config.outDir, '.js'),\n            )\n            .sort(),\n        }),\n      );\n    }\n  }\n}\n\nfunction addDevModeCsp(\n  manifest: Manifest.WebExtensionManifest,\n  config: InternalConfig,\n): void {\n  const permission = `http://${config.server?.hostname ?? ''}/*`;\n  const allowedCsp = config.server?.origin ?? 'http://localhost:*';\n\n  if (manifest.manifest_version === 3) {\n    manifest.host_permissions ??= [];\n    if (!manifest.host_permissions.includes(permission))\n      manifest.host_permissions.push(permission);\n  } else {\n    manifest.permissions ??= [];\n    if (!manifest.permissions.includes(permission))\n      manifest.permissions.push(permission);\n  }\n\n  const csp = new ContentSecurityPolicy(\n    manifest.manifest_version === 3\n      ? // @ts-expect-error: extension_pages is not typed\n        manifest.content_security_policy?.extension_pages ??\n        \"script-src 'self' 'wasm-unsafe-eval'; object-src 'self';\" // default CSP for MV3\n      : manifest.content_security_policy ??\n        \"script-src 'self'; object-src 'self';\", // default CSP for MV2\n  );\n\n  if (config.server) csp.add('script-src', allowedCsp);\n\n  if (manifest.manifest_version === 3) {\n    manifest.content_security_policy ??= {};\n    // @ts-expect-error: extension_pages is not typed\n    manifest.content_security_policy.extension_pages = csp.toString();\n  } else {\n    manifest.content_security_policy = csp.toString();\n  }\n}\n\n/**\n * Returns the bundle paths to CSS files associated with a list of content scripts, or undefined if\n * there is no associated CSS.\n */\nfunction getContentScriptCssFiles(\n  contentScripts: ContentScriptEntrypoint[],\n  buildOutput: Omit<BuildOutput, 'manifest'>,\n): string[] | undefined {\n  const css: string[] = [];\n\n  const allChunks = buildOutput.steps.flatMap((step) => step.chunks);\n\n  contentScripts.forEach((script) => {\n    // TODO: optimize and remove loop with a map\n    const relatedCss = allChunks.find(\n      (chunk) => chunk.fileName === `assets/${script.name}.css`,\n    );\n    if (relatedCss) css.push(relatedCss.fileName);\n  });\n\n  if (css.length > 0) return css;\n  return undefined;\n}\n", "/**\n * Directive names that make up CSPs. There are more, this is all I need for the plugin.\n */\nexport type CspDirective = 'default-src' | 'script-src' | 'object-src';\n\nexport class ContentSecurityPolicy {\n  private static DIRECTIVE_ORDER: Record<string, number | undefined> = {\n    'default-src': 0,\n    'script-src': 1,\n    'object-src': 2,\n  };\n\n  data: Record<string, string[]>;\n\n  constructor(csp?: string) {\n    if (csp) {\n      const sections = csp.split(';').map((section) => section.trim());\n      this.data = sections.reduce<Record<string, string[]>>((data, section) => {\n        const [key, ...values] = section.split(' ').map((item) => item.trim());\n        if (key) data[key] = values;\n        return data;\n      }, {});\n    } else {\n      this.data = {};\n    }\n  }\n\n  /**\n   * Ensure a set of values are listed under a directive.\n   */\n  add(directive: CspDirective, ...newValues: string[]): ContentSecurityPolicy {\n    const values = this.data[directive] ?? [];\n    newValues.forEach((newValue) => {\n      if (!values.includes(newValue)) values.push(newValue);\n    });\n    this.data[directive] = values;\n    return this;\n  }\n\n  toString(): string {\n    const directives = Object.entries(this.data).sort(([l], [r]) => {\n      const lo = ContentSecurityPolicy.DIRECTIVE_ORDER[l] ?? 2;\n      const ro = ContentSecurityPolicy.DIRECTIVE_ORDER[r] ?? 2;\n      return lo - ro;\n    });\n    return directives.map((entry) => entry.flat().join(' ')).join('; ') + ';';\n  }\n}\n", "import path, { extname, relative, resolve } from 'path';\nimport { BuildOutput, InternalConfig } from '../types';\nimport { printTable } from './printTable';\nimport pc from 'picocolors';\nimport fs from 'fs-extra';\nimport { filesize } from 'filesize';\n\nexport async function printBuildSummary(\n  output: BuildOutput,\n  config: InternalConfig,\n) {\n  const chunks = [\n    ...output.steps.flatMap((step) => step.chunks),\n    ...output.publicAssets,\n  ].sort((l, r) => {\n    const lWeight =\n      CHUNK_SORT_WEIGHTS[l.fileName] ??\n      CHUNK_SORT_WEIGHTS[extname(l.fileName)] ??\n      DEFAULT_SORT_WEIGHT;\n    const rWeight =\n      CHUNK_SORT_WEIGHTS[r.fileName] ??\n      CHUNK_SORT_WEIGHTS[extname(r.fileName)] ??\n      DEFAULT_SORT_WEIGHT;\n    const diff = lWeight - rWeight;\n    if (diff !== 0) return diff;\n    return l.fileName.localeCompare(r.fileName);\n  });\n\n  let totalSize = 0;\n\n  const chunkRows: string[][] = await Promise.all(\n    chunks.map(async (chunk, i) => {\n      const file = [\n        relative(process.cwd(), config.outDir) + path.sep,\n        chunk.fileName,\n      ];\n      const ext = extname(chunk.fileName);\n      const prefix = i === chunks.length - 1 ? '  \u2514\u2500' : '  \u251C\u2500';\n      const color = CHUNK_COLORS[ext] ?? DEFAULT_COLOR;\n      const stats = await fs.lstat(resolve(config.outDir, chunk.fileName));\n      totalSize += stats.size;\n      const size = String(filesize(stats.size));\n      return [\n        `${pc.gray(prefix)} ${pc.dim(file[0])}${color(file[1])}`,\n        pc.dim(size),\n      ];\n    }),\n  );\n\n  printTable(config.logger.log, chunkRows);\n\n  config.logger.log(\n    `${pc.cyan('\u03A3 Total size:')} ${String(filesize(totalSize))}`,\n  );\n}\n\nconst DEFAULT_SORT_WEIGHT = 100;\nconst CHUNK_SORT_WEIGHTS: Record<string, number> = {\n  'manifest.json': 0,\n  '.html': 1,\n  '.js': 2,\n  '.css': 3,\n};\n\nconst DEFAULT_COLOR = pc.blue;\nconst CHUNK_COLORS: Record<string, (text: string) => string> = {\n  '.html': pc.green,\n  '.css': pc.magenta,\n  '.js': pc.cyan,\n};\n", "export function printTable(\n  log: (message: string) => void,\n  rows: string[][],\n  gap = 2,\n): void {\n  if (rows.length === 0) return;\n\n  const columnWidths = rows.reduce(\n    (widths, row) => {\n      for (let i = 0; i < Math.max(widths.length, row.length); i++) {\n        widths[i] = Math.max(row[i]?.length ?? 0, widths[i] ?? 0);\n      }\n      return widths;\n    },\n    rows[0].map((column) => column.length),\n  );\n\n  let str = '';\n  rows.forEach((row, i) => {\n    row.forEach((col, j) => {\n      str += col.padEnd(columnWidths[j], ' ');\n      if (j !== row.length - 1) str += ''.padEnd(gap, ' ');\n    });\n    if (i !== rows.length - 1) str += '\\n';\n  });\n\n  log(str);\n}\n", "import {\n  BuildOutput,\n  WxtDevServer,\n  InlineConfig,\n  InternalConfig,\n  EntrypointGroup,\n} from './core/types';\nimport { getInternalConfig } from './core/utils/getInternalConfig';\nimport { findEntrypoints } from './core/build/findEntrypoints';\nimport { buildEntrypoints } from './core/build/buildEntrypoints';\nimport { generateMainfest, writeManifest } from './core/utils/manifest';\nimport { printBuildSummary } from './core/log/printBuildSummary';\nimport fs from 'fs-extra';\nimport { generateTypesDir } from './core/build/generateTypesDir';\nimport pc from 'picocolors';\nimport * as vite from 'vite';\nimport { findOpenPort } from './core/utils/findOpenPort';\nimport { formatDuration } from './core/utils/formatDuration';\nimport { createWebExtRunner } from './core/runners/createWebExtRunner';\nimport { groupEntrypoints } from './core/utils/groupEntrypoints';\nimport { Manifest } from 'webextension-polyfill';\nimport { detectDevChanges } from './core/utils/detectDevChanges';\nimport { Mutex } from 'async-mutex';\nimport { consola } from 'consola';\nimport { relative } from 'node:path';\nimport {\n  getEntrypointBundlePath,\n  getEntrypointOutputFile,\n} from './core/utils/entrypoints';\n\nexport { version } from '../package.json';\nexport * from './core/types/external';\nexport * from './core/utils/defineConfig';\nexport * from './core/utils/defineRunnerConfig';\n\n/**\n * Bundles the extension for production. Returns a promise of the build result.\n */\nexport async function build(config: InlineConfig): Promise<BuildOutput> {\n  const internalConfig = await getInternalConfig(config, 'build');\n  return await buildInternal(internalConfig);\n}\n\nexport async function createServer(\n  config?: InlineConfig,\n): Promise<WxtDevServer> {\n  const port = await findOpenPort(3000, 3010);\n  const hostname = 'localhost';\n  const origin = `http://${hostname}:${port}`;\n  const serverConfig: vite.InlineConfig = {\n    server: {\n      origin,\n    },\n  };\n  let internalConfig = await getInternalConfig(\n    vite.mergeConfig(serverConfig, config ?? {}),\n    'serve',\n  );\n  const runner = createWebExtRunner();\n\n  let hasBuiltOnce = false;\n  let currentOutput: BuildOutput | undefined;\n  const fileChangedMutex = new Mutex();\n  const changeQueue: Array<[string, string]> = [];\n\n  const viteServer = await vite.createServer(internalConfig.vite);\n  viteServer.watcher.on('all', async (event, path, stats) => {\n    if (!hasBuiltOnce || path.startsWith(internalConfig.outBaseDir)) return;\n    changeQueue.push([event, path]);\n\n    await fileChangedMutex.runExclusive(async () => {\n      const fileChanges = changeQueue.splice(0, changeQueue.length);\n      const changes = detectDevChanges(fileChanges, currentOutput);\n\n      if (changes.type === 'no-change') return;\n\n      // Log the entrypoints that were effected\n      consola.info(\n        `Changed: ${Array.from(new Set(fileChanges.map((change) => change[1])))\n          .map((file) => pc.dim(relative(internalConfig.root, file)))\n          .join(', ')}`,\n      );\n      const rebuiltNames = changes.rebuildGroups\n        .flat()\n        .map((entry) => {\n          return pc.cyan(\n            relative(internalConfig.outDir, getEntrypointOutputFile(entry, '')),\n          );\n        })\n        .join(pc.dim(', '));\n\n      // Get latest config and Rebuild groups with changes\n      internalConfig = await getInternalConfig(\n        vite.mergeConfig(serverConfig, config ?? {}),\n        'serve',\n      );\n      internalConfig.server = server;\n      const { output: newOutput } = await rebuild(\n        internalConfig,\n        // TODO: this excludes new entrypoints, so they're not built until the dev command is restarted\n        changes.rebuildGroups,\n        changes.cachedOutput,\n      );\n      currentOutput = newOutput;\n\n      // Perform reloads\n      switch (changes.type) {\n        case 'extension-reload':\n          server.reloadExtension();\n          consola.success(`Reloaded extension: ${rebuiltNames}`);\n          break;\n        case 'html-reload':\n          changes.rebuildGroups.flat().forEach((entry) => {\n            const path = getEntrypointBundlePath(\n              entry,\n              internalConfig.outDir,\n              '.html',\n            );\n            server.reloadPage(path);\n          });\n          consola.success(`Reloaded pages: ${rebuiltNames}`);\n          break;\n      }\n    });\n  });\n  const server: WxtDevServer = {\n    ...viteServer,\n    async listen(port, isRestart) {\n      const res = await viteServer.listen(port, isRestart);\n\n      if (!isRestart) {\n        internalConfig.logger.success(`Started dev server @ ${origin}`);\n\n        internalConfig.logger.info('Opening browser...');\n        await runner.openBrowser(internalConfig);\n        internalConfig.logger.success('Opened!');\n      }\n\n      return res;\n    },\n    port,\n    hostname,\n    origin,\n    reloadExtension: () => {\n      server.ws.send('wxt:reload-extension');\n    },\n    reloadPage: (path) => {\n      // Can't use Vite's built-in \"full-reload\" event because it doesn't like our paths, it expects\n      // paths ending in \"/index.html\"\n      server.ws.send('wxt:reload-page', path);\n    },\n  };\n  internalConfig.logger.info('Created dev server');\n\n  internalConfig.server = server;\n  currentOutput = await buildInternal(internalConfig);\n  hasBuiltOnce = true;\n\n  return server;\n}\n\nasync function buildInternal(config: InternalConfig): Promise<BuildOutput> {\n  const verb = config.command === 'serve' ? 'Pre-rendering' : 'Building';\n  const target = `${config.browser}-mv${config.manifestVersion}`;\n  config.logger.info(\n    `${verb} ${pc.cyan(target)} for ${pc.cyan(config.mode)} with ${pc.green(\n      `Vite ${vite.version}`,\n    )}`,\n  );\n  const startTime = Date.now();\n\n  // Cleanup\n  await fs.rm(config.outDir, { recursive: true, force: true });\n  await fs.ensureDir(config.outDir);\n\n  const entrypoints = await findEntrypoints(config);\n  const groups = groupEntrypoints(entrypoints);\n  const { output } = await rebuild(config, groups);\n\n  // Post-build\n  config.logger.success(\n    `Built extension in ${formatDuration(Date.now() - startTime)}`,\n  );\n  await printBuildSummary(output, config);\n\n  return output;\n}\n\nexport async function rebuild(\n  config: InternalConfig,\n  entrypointGroups: EntrypointGroup[],\n  existingOutput: Omit<BuildOutput, 'manifest'> = {\n    steps: [],\n    publicAssets: [],\n  },\n): Promise<{ output: BuildOutput; manifest: Manifest.WebExtensionManifest }> {\n  // Build\n  const allEntrypoints = await findEntrypoints(config);\n  await generateTypesDir(allEntrypoints, config);\n  const buildOutput = await buildEntrypoints(entrypointGroups, config);\n\n  const manifest = await generateMainfest(allEntrypoints, buildOutput, config);\n  const output: BuildOutput = {\n    manifest,\n    ...buildOutput,\n  };\n\n  // Write manifest\n  await writeManifest(manifest, output, config);\n\n  return {\n    output: {\n      manifest,\n      steps: [...existingOutput.steps, ...output.steps],\n      publicAssets: [...existingOutput.publicAssets, ...output.publicAssets],\n    },\n    manifest,\n  };\n}\n", "import { createUnimport } from 'unimport';\nimport { Entrypoint, InternalConfig } from '../types';\nimport fs from 'fs-extra';\nimport { relative, resolve } from 'path';\nimport { getEntrypointBundlePath } from '../utils/entrypoints';\nimport { getUnimportOptions } from '../utils/auto-imports';\nimport { getGlobals } from '../utils/globals';\n\n/**\n * Generate and write all the files inside the `InternalConfig.typesDir` directory.\n */\nexport async function generateTypesDir(\n  entrypoints: Entrypoint[],\n  config: InternalConfig,\n): Promise<void> {\n  await fs.ensureDir(config.typesDir);\n\n  const references: string[] = [];\n  references.push(await writeImportsDeclarationFile(config));\n  references.push(await writePathsDeclarationFile(entrypoints, config));\n  references.push(await writeGlobalsDeclarationFile(config));\n\n  const mainReference = await writeMainDeclarationFile(references, config);\n  await writeTsConfigFile(mainReference, config);\n}\n\nasync function writeImportsDeclarationFile(\n  config: InternalConfig,\n): Promise<string> {\n  const filePath = resolve(config.typesDir, 'imports.d.ts');\n  const unimport = createUnimport(getUnimportOptions(config));\n\n  // Load project imports into unimport memory so they are output via generateTypeDeclarations\n  await unimport.scanImportsFromDir(undefined, { cwd: config.srcDir });\n\n  await fs.writeFile(\n    filePath,\n    ['// Generated by wxt', await unimport.generateTypeDeclarations()].join(\n      '\\n',\n    ) + '\\n',\n  );\n\n  return filePath;\n}\n\nasync function writePathsDeclarationFile(\n  entrypoints: Entrypoint[],\n  config: InternalConfig,\n): Promise<string> {\n  const filePath = resolve(config.typesDir, 'paths.d.ts');\n\n  await fs.writeFile(\n    filePath,\n    [\n      '// Generated by wxt',\n      'type EntrypointPath =',\n      ...entrypoints\n        .map((entry) => {\n          const path = getEntrypointBundlePath(\n            entry,\n            config.outDir,\n            entry.inputPath.endsWith('.html') ? '.html' : '.js',\n          );\n          return `  | \"/${path}\"`;\n        })\n        .sort(),\n    ].join('\\n') + '\\n',\n  );\n\n  return filePath;\n}\n\nasync function writeGlobalsDeclarationFile(\n  config: InternalConfig,\n): Promise<string> {\n  const filePath = resolve(config.typesDir, 'globals.d.ts');\n  const globals = getGlobals(config);\n  await fs.writeFile(\n    filePath,\n    [\n      '// Generated by wxt',\n      'export {}',\n      'declare global {',\n      ...globals.map((global) => `  const ${global.name}: ${global.type};`),\n      '}',\n    ].join('\\n') + '\\n',\n    'utf-8',\n  );\n  return filePath;\n}\n\nasync function writeMainDeclarationFile(\n  references: string[],\n  config: InternalConfig,\n): Promise<string> {\n  const dir = config.wxtDir;\n  const filePath = resolve(dir, 'wxt.d.ts');\n  await fs.writeFile(\n    filePath,\n    [\n      '// Generated by wxt',\n      ...references.map(\n        (ref) => `/// <reference types=\"./${relative(dir, ref)}\" />`,\n      ),\n    ].join('\\n') + '\\n',\n  );\n  return filePath;\n}\n\nasync function writeTsConfigFile(\n  mainReference: string,\n  config: InternalConfig,\n) {\n  const dir = config.wxtDir;\n  await fs.writeFile(\n    resolve(dir, 'tsconfig.json'),\n    `{\n  \"compilerOptions\": {\n    \"target\": \"ESNext\",\n    \"module\": \"ESNext\",\n    \"moduleResolution\": \"Bundler\",\n    \"noEmit\": true,\n    \"esModuleInterop\": true,\n    \"forceConsistentCasingInFileNames\": true,\n    \"resolveJsonModule\": true,\n\n    /* Type Checking */\n    \"strict\": true,\n\n    /* Completeness */\n    \"skipLibCheck\": true\n  },\n  \"include\": [\n    \"${relative(dir, config.root)}/**/*\",\n    \"./${relative(dir, mainReference)}\"\n  ],\n  \"exclude\": [\"${relative(dir, config.outBaseDir)}\"]\n}`,\n  );\n}\n", "import net from 'node:net';\n\n/**\n * Finds the first open port in a range of ports.\n */\nexport function findOpenPort(\n  startPort: number,\n  endPort: number,\n): Promise<number> {\n  return findOpenPortRecursive(startPort, startPort, endPort);\n}\n\nfunction findOpenPortRecursive(\n  port: number,\n  startPort: number,\n  endPort: number,\n): Promise<number> {\n  return new Promise((resolve, reject) => {\n    if (port > endPort)\n      return reject(\n        Error(`Could not find open port between ${startPort}-${endPort}`),\n      );\n    const server = net.createServer();\n\n    server.listen(port, () => {\n      server.once('close', () => resolve(port));\n      server.close();\n    });\n    server.on('error', () =>\n      resolve(findOpenPortRecursive(port + 1, startPort, endPort)),\n    );\n  });\n}\n", "export function formatDuration(duration: number): string {\n  if (duration < 1e3) return `${duration} ms`;\n  if (duration < 10e3) return `${(duration / 1e3).toFixed(3)} s`;\n  if (duration < 60e3) return `${(duration / 1e3).toFixed(1)} s`;\n  return `${(duration / 1e3).toFixed(0)} s`;\n}\n", "import type { WebExtRunInstance } from 'web-ext';\nimport { ExtensionRunner } from './ExtensionRunner';\n\n/**\n * Create an `ExtensionRunner` backed by `web-ext`.\n */\nexport function createWebExtRunner(): ExtensionRunner {\n  let runner: WebExtRunInstance | undefined;\n\n  return {\n    async openBrowser(config) {\n      if (config.browser === 'safari') {\n        config.logger.warn('Cannot open safari automatically.');\n        return;\n      }\n\n      // Use the plugin's logger instead of web-ext's built-in one.\n      const webExtLogger = await import('web-ext/util/logger');\n      webExtLogger.consoleStream.write = ({ level, msg, name }) => {\n        if (level >= ERROR_LOG_LEVEL) config.logger.error(name, msg);\n        if (level >= WARN_LOG_LEVEL) config.logger.warn(msg);\n      };\n\n      const wxtUserConfig = config.runnerConfig.config;\n      const userConfig = {\n        console: wxtUserConfig?.openConsole,\n        devtools: wxtUserConfig?.openDevtools,\n        startUrl: wxtUserConfig?.startUrls,\n        ...(config.browser === 'firefox'\n          ? {\n              firefox: wxtUserConfig?.binaries?.firefox,\n              firefoxProfile: wxtUserConfig?.firefoxProfile,\n              prefs: wxtUserConfig?.firefoxPrefs,\n              args: wxtUserConfig?.firefoxArgs,\n            }\n          : {\n              chromiumBinary: wxtUserConfig?.binaries?.[config.browser],\n              chromiumProfile: wxtUserConfig?.chromiumProfile,\n              args: wxtUserConfig?.chromiumArgs,\n            }),\n      };\n\n      const finalConfig = {\n        ...userConfig,\n        target: config.browser === 'firefox' ? 'firefox-desktop' : 'chromium',\n        sourceDir: config.outDir,\n        // WXT handles reloads, so disable auto-reload behaviors in web-ext\n        noReload: true,\n        noInput: true,\n      };\n      const options = {\n        // Don't call `process.exit(0)` after starting web-ext\n        shouldExitProgram: false,\n      };\n      config.logger.debug('web-ext config:', finalConfig);\n      config.logger.debug('web-ext options:', options);\n\n      const webExt = await import('web-ext');\n      runner = await webExt.default.cmd.run(finalConfig, options);\n    },\n\n    async closeBrowser() {\n      return await runner?.exit();\n    },\n  };\n}\n\n// https://github.com/mozilla/web-ext/blob/e37e60a2738478f512f1255c537133321f301771/src/util/logger.js#L12\nconst WARN_LOG_LEVEL = 40;\nconst ERROR_LOG_LEVEL = 50;\n", "import { Entrypoint } from '../..';\nimport { EntrypointGroup } from '../types';\n\n/**\n * Entrypoints can be build in groups. HTML pages can all be built together in a single step, while\n * content scripts must be build individually.\n *\n * This function returns the entrypoints put into these types of groups.\n */\nexport function groupEntrypoints(entrypoints: Entrypoint[]): EntrypointGroup[] {\n  const groupIndexMap: Partial<Record<Group, number>> = {};\n  const groups: EntrypointGroup[] = [];\n\n  for (const entry of entrypoints) {\n    const group = ENTRY_TYPE_TO_GROUP_MAP[entry.type];\n    if (group === 'no-group') {\n      groups.push(entry);\n    } else {\n      let groupIndex = groupIndexMap[group];\n      if (groupIndex == null) {\n        groupIndex = groups.push([]) - 1;\n        groupIndexMap[group] = groupIndex;\n      }\n      (groups[groupIndex] as Entrypoint[]).push(entry);\n    }\n  }\n\n  return groups;\n}\n\nconst ENTRY_TYPE_TO_GROUP_MAP: Record<Entrypoint['type'], Group> = {\n  sandbox: 'sandbox-page',\n\n  popup: 'extension-page',\n  newtab: 'extension-page',\n  history: 'extension-page',\n  options: 'extension-page',\n  devtools: 'extension-page',\n  bookmarks: 'extension-page',\n  sidepanel: 'extension-page',\n  'unlisted-page': 'extension-page',\n\n  background: 'no-group',\n  'content-script': 'no-group',\n  'unlisted-script': 'no-group',\n};\n\ntype Group = 'extension-page' | 'sandbox-page' | 'no-group';\n", "import { BuildOutput, BuildStepOutput, EntrypointGroup } from '../types';\nimport * as vite from 'vite';\n\n/**\n * Compare the changed files vs the build output and determine what kind of reload needs to happen:\n *\n * - Do nothing\n *   - CSS or JS file associated with an HTML page is changed - this is handled automatically by the\n *     dev server\n *   - Change isn't used by any of the entrypoints\n * - Reload Content script\n *   - CSS or JS file associated with a content script\n *   - Background script will be told to reload the content script\n * - Reload HTML file\n *   - HTML file itself is saved - HMR doesn't handle this because the HTML pages are pre-rendered\n *   - Chrome is OK reloading the page when the HTML file is changed without reloading the whole\n *     extension. Not sure about firefox, this might need to change to an extension reload\n * - Reload extension\n *   - Background script is changed\n *   - Manifest is different\n * - Restart browser\n *   - Config file changed (wxt.config.ts, .env, web-ext.config.ts, etc)\n */\nexport function detectDevChanges(\n  changedFiles: [event: string, path: string][],\n  currentOutput: BuildOutput | undefined,\n): DevModeChange {\n  if (currentOutput == null) return { type: 'no-change' };\n\n  const changedSteps = new Set(\n    changedFiles.flatMap((changedFile) =>\n      findEffectedSteps(changedFile, currentOutput),\n    ),\n  );\n  if (changedSteps.size === 0) return { type: 'no-change' };\n\n  const unchangedOutput: BuildOutput = {\n    manifest: currentOutput.manifest,\n    steps: [],\n    publicAssets: [],\n  };\n  const changedOutput: BuildOutput = {\n    manifest: currentOutput.manifest,\n    steps: [],\n    publicAssets: [],\n  };\n\n  for (const step of currentOutput.steps) {\n    if (changedSteps.has(step)) {\n      changedOutput.steps.push(step);\n    } else {\n      unchangedOutput.steps.push(step);\n    }\n  }\n  for (const asset of currentOutput.publicAssets) {\n    if (changedSteps.has(asset)) {\n      changedOutput.publicAssets.push(asset);\n    } else {\n      unchangedOutput.publicAssets.push(asset);\n    }\n  }\n\n  const isOnlyHtmlChanges = !changedFiles.find(\n    ([_, file]) => !file.endsWith('.html'),\n  );\n  if (isOnlyHtmlChanges) {\n    return {\n      type: 'html-reload',\n      cachedOutput: unchangedOutput,\n      rebuildGroups: changedOutput.steps.map((step) => step.entrypoints),\n    };\n  }\n\n  return {\n    type: 'extension-reload',\n    cachedOutput: unchangedOutput,\n    rebuildGroups: changedOutput.steps.map((step) => step.entrypoints),\n  };\n}\n\n/**\n * For a single change, return all the step of the build output that were effected by it.\n */\nfunction findEffectedSteps(\n  changedFile: [event: string, path: string],\n  currentOutput: BuildOutput,\n): DetectedChange[] {\n  const changes: DetectedChange[] = [];\n  const changedPath = changedFile[1];\n\n  const isChunkEffected = (\n    chunk: vite.Rollup.OutputChunk | vite.Rollup.OutputAsset,\n  ): boolean =>\n    // If it's an HTML file with the same path, is is effected because HTML files need to be pre-rendered\n    // TODO: use bundle path to support `<name>/index.html`?\n    (chunk.type === 'asset' && changedPath.endsWith(chunk.fileName)) ||\n    // If it's a chunk that depends on the changed file, it is effected\n    (chunk.type === 'chunk' && chunk.moduleIds.includes(changedPath));\n\n  for (const step of currentOutput.steps) {\n    const effectedChunk = step.chunks.find((chunk) => isChunkEffected(chunk));\n    if (effectedChunk) changes.push(step);\n  }\n\n  const effectedAsset = currentOutput.publicAssets.find((chunk) =>\n    isChunkEffected(chunk),\n  );\n  if (effectedAsset) changes.push(effectedAsset);\n\n  return changes;\n}\n\n/**\n * Contains information about what files changed, what needs rebuilt, and the type of reload that is\n * required.\n */\nexport type DevModeChange = NoChange | HtmlReload | ExtensionReload;\n// | BrowserRestart\n// | ContentScriptReload\n\ninterface NoChange {\n  type: 'no-change';\n}\n\ninterface RebuildChange {\n  /**\n   * The list of entrypoints that need rebuilt.\n   */\n  rebuildGroups: EntrypointGroup[];\n  /**\n   * The previous output stripped of any files are going to change.\n   */\n  cachedOutput: BuildOutput;\n}\n\ninterface HtmlReload extends RebuildChange {\n  type: 'html-reload';\n}\n\ninterface ExtensionReload extends RebuildChange {\n  type: 'extension-reload';\n}\n\n// interface BrowserRestart extends RebuildChange {\n//   type: 'browser-restart';\n// }\n\n// interface ContentScriptReload extends RebuildChange {\n//   type: 'content-script-reload';\n// }\n\n/**\n * When figuring out what needs reloaded, this stores the step that was changed, or the public\n * directory asset that was changed. It doesn't know what type of change is required yet. Just an\n * intermediate type.\n */\ntype DetectedChange = BuildStepOutput | vite.Rollup.OutputAsset;\n", "import { consola } from 'consola';\nimport { printHeader } from '../../core/log/printHeader';\nimport { formatDuration } from '../../core/utils/formatDuration';\n\nexport function defineCommand<TArgs extends any[]>(\n  cb: (...args: TArgs) => void | boolean | Promise<void | boolean>,\n) {\n  return async (...args: TArgs) => {\n    const startTime = Date.now();\n    try {\n      printHeader();\n\n      const ongoing = await cb(...args);\n\n      if (!ongoing)\n        consola.success(\n          `Finished in ${formatDuration(Date.now() - startTime)}`,\n        );\n    } catch (err) {\n      consola.fail(\n        `Command failed after ${formatDuration(Date.now() - startTime)}`,\n      );\n      consola.error(err);\n      process.exit(1);\n    }\n  };\n}\n", "import pc from 'picocolors';\nimport { version } from '../..';\nimport { consola } from 'consola';\n\nexport function printHeader() {\n  console.log();\n  consola.log(`${pc.gray('WXT')} ${pc.gray(pc.bold(version))}`);\n}\n", "import * as wxt from '../..';\nimport { defineCommand } from '../utils/defineCommand';\n\nexport const build = defineCommand<\n  [\n    root: string | undefined,\n    flags: {\n      mode?: string;\n      config?: string;\n      browser?: wxt.TargetBrowser;\n      mv3?: boolean;\n      mv2?: boolean;\n    },\n  ]\n>(async (root, flags) => {\n  const mode = flags.mode ?? 'production';\n  const cliConfig: wxt.InlineConfig = {\n    root,\n    mode,\n    browser: flags.browser,\n    manifestVersion: flags.mv3 ? 3 : flags.mv2 ? 2 : undefined,\n    configFile: flags.config,\n  };\n\n  await wxt.build(cliConfig);\n});\n", "import * as wxt from '../..';\nimport { defineCommand } from '../utils/defineCommand';\n\nexport const dev = defineCommand<\n  [\n    root: string | undefined,\n    flags: {\n      mode?: string;\n      config?: string;\n      browser?: wxt.TargetBrowser;\n      mv3?: boolean;\n      mv2?: boolean;\n    },\n  ]\n>(async (root, flags) => {\n  const mode = flags.mode ?? 'development';\n  const cliConfig: wxt.InlineConfig = {\n    root,\n    mode,\n    browser: flags.browser,\n    manifestVersion: flags.mv3 ? 3 : flags.mv2 ? 2 : undefined,\n    configFile: flags.config,\n  };\n\n  const server = await wxt.createServer(cliConfig);\n  await server.listen(server.port);\n\n  return true;\n});\n", "import { consola } from 'consola';\nimport { defineCommand } from '../utils/defineCommand';\n\nexport const init = defineCommand<[directory?: string]>(async (directory) => {\n  consola.warn('wxt init: Not implemented');\n});\n", "import { getInternalConfig } from '../../core/utils/getInternalConfig';\nimport { findEntrypoints } from '../../core/build/findEntrypoints';\nimport { generateTypesDir } from '../../core/build/generateTypesDir';\nimport { defineCommand } from '../utils/defineCommand';\nimport * as wxt from '../..';\n\nexport const prepare = defineCommand<\n  [\n    root: string | undefined,\n    flags: {\n      config?: string;\n    },\n  ]\n>(async (root, flags) => {\n  const cliConfig: wxt.InlineConfig = {\n    root,\n    configFile: flags.config,\n  };\n  const config = await getInternalConfig(cliConfig, 'build');\n\n  config.logger.info('Generating types...');\n\n  const entrypoints = await findEntrypoints(config);\n  await generateTypesDir(entrypoints, config);\n});\n", "import { consola } from 'consola';\nimport { defineCommand } from '../utils/defineCommand';\n\nexport const publish = defineCommand(\n  async (root: any, { config: configFile }: any) => {\n    consola.warn('wxt publish: Not implemented');\n  },\n);\n"],
  "mappings": "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",
  "names": ["import_node_path", "vite", "import_consola", "path", "createJITI", "transform", "path", "import_path", "isOffline", "dns", "import_node_path", "fs", "import_unimport", "unimport", "import_fs_extra", "import_path", "fs", "import_fs_extra", "import_path", "path", "fs", "path", "import_path", "import_fs_extra", "import_linkedom", "glob", "path", "picomatch", "fs", "JSON5", "vite", "import_fs_extra", "import_path", "fs", "path", "import_fast_glob", "import_fs_extra", "import_path", "fs", "glob", "import_fs_extra", "import_path", "fs", "version", "options", "import_path", "import_fs_extra", "path", "fs", "pc", "import_fs_extra", "import_unimport", "import_fs_extra", "import_path", "fs", "unimport", "path", "import_picocolors", "vite", "resolve", "net", "import_consola", "import_node_path", "build", "createServer", "path", "pc", "port", "fs", "import_consola", "import_picocolors", "import_consola", "pc", "build", "createServer", "import_consola", "import_consola", "cac", "build"]
}
