wxt 0.0.2 → 0.1.1-alpha1

package/dist/cli.cjs

@@ -27,7 +27,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var import_cac = __toESM(require("cac"), 1);
 
 // package.json
-var version = "0.0.2";
+var version = "0.1.1-alpha1";
 
 // src/core/utils/getInternalConfig.ts
 var import_node_path3 = __toESM(require("path"), 1);
@@ -40,24 +40,26 @@ 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");
+var import_fs_extra = __toESM(require("fs-extra"), 1);
 async function importTsFile(root, path5) {
-  const clientImports = await (0, import_unimport.scanExports)(
+  const unimport2 = (0, import_unimport.createUnimport)({});
+  await unimport2.scanImportsFromFile(
     (0, import_path.resolve)(root, "node_modules/wxt/dist/client.js")
   );
+  const text = await import_fs_extra.default.readFile(path5, "utf-8");
+  const res = await unimport2.injectImports(text, path5);
+  const transformedText = res.code;
   const jiti = (0, import_jiti.default)(__filename, {
     cache: false,
     esmResolve: true,
     interopDefault: true,
+    alias: {
+      "webextension-polyfill": "wxt"
+    },
     transform(opts) {
+      if (opts.filename === path5)
+        opts.source = transformedText;
       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);
     }
   });
@@ -240,7 +242,7 @@ function download(config) {
 
 // src/core/vite-plugins/multipageMove.ts
 var import_node_path2 = require("path");
-var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_fs_extra2 = __toESM(require("fs-extra"), 1);
 function multipageMove(entrypoints, config) {
   return {
     name: "wxt:multipage-move",
@@ -267,8 +269,8 @@ function multipageMove(entrypoints, config) {
         }
         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 });
+        await (0, import_fs_extra2.ensureDir)((0, import_node_path2.dirname)(newAbsPath));
+        await import_fs_extra2.default.move(oldAbsPath, newAbsPath, { overwrite: true });
         const renamedChunk = {
           ...bundle[oldBundlePath],
           fileName: newBundlePath
@@ -318,7 +320,7 @@ function unimport(config) {
 }
 
 // src/core/vite-plugins/virtualEntrypoint.ts
-var import_fs_extra2 = __toESM(require("fs-extra"), 1);
+var import_fs_extra3 = __toESM(require("fs-extra"), 1);
 var import_path3 = require("path");
 function virtualEntrypoin(type, config) {
   const virtualId = `virtual:wxt-${type}?`;
@@ -336,7 +338,7 @@ function virtualEntrypoin(type, config) {
       if (!id.startsWith(resolvedVirtualId))
         return;
       const inputPath = id.replace(resolvedVirtualId, "");
-      const template = await import_fs_extra2.default.readFile(
+      const template = await import_fs_extra3.default.readFile(
         (0, import_path3.resolve)(
           config.root,
           `node_modules/wxt/dist/virtual-modules/${type}-entrypoint.js`
@@ -349,20 +351,20 @@ function virtualEntrypoin(type, config) {
 }
 
 // src/core/utils/createFsCache.ts
-var import_fs_extra3 = __toESM(require("fs-extra"), 1);
+var import_fs_extra4 = __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");
+      await (0, import_fs_extra4.ensureDir)((0, import_path4.dirname)(path5));
+      await import_fs_extra4.default.writeFile(path5, value, "utf-8");
     },
     async get(key) {
       const path5 = getPath(key);
       try {
-        return await import_fs_extra3.default.readFile(path5, "utf-8");
+        return await import_fs_extra4.default.readFile(path5, "utf-8");
       } catch {
         return void 0;
       }
@@ -501,15 +503,246 @@ async function getInternalConfig(config, command) {
   return finalConfig;
 }
 
+// src/index.ts
+var import_picocolors3 = __toESM(require("picocolors"), 1);
+var vite6 = __toESM(require("vite"), 1);
+
+// src/core/utils/arrays.ts
+function every(array, predicate) {
+  for (let i = 0; i < array.length; i++)
+    if (!predicate(array[i], i))
+      return false;
+  return true;
+}
+
+// src/core/utils/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.length > 0 && every(changedFiles, ([_, file]) => file.endsWith(".html"));
+  if (isOnlyHtmlChanges) {
+    return {
+      type: "html-reload",
+      cachedOutput: unchangedOutput,
+      rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
+    };
+  }
+  const isOnlyContentScripts = changedOutput.steps.length > 0 && every(
+    changedOutput.steps.flatMap((step) => step.entrypoints),
+    (entry) => entry.type === "content-script"
+  );
+  if (isOnlyContentScripts) {
+    return {
+      type: "content-script-reload",
+      cachedOutput: unchangedOutput,
+      changedSteps: changedOutput.steps,
+      rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
+    };
+  }
+  return {
+    type: "extension-reload",
+    cachedOutput: unchangedOutput,
+    rebuildGroups: changedOutput.steps.map((step) => step.entrypoints)
+  };
+}
+function findEffectedSteps(changedFile, currentOutput) {
+  const changes = [];
+  const changedPath = 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");
+
+// 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_path5 = __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_path5.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_glob = __toESM(require("fast-glob"), 1);
+var import_fs_extra6 = __toESM(require("fs-extra"), 1);
+var import_path6 = 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_glob.default)("**/*", { cwd: config.publicDir });
+  for (const file of files) {
+    const srcPath = (0, import_path6.resolve)(config.publicDir, file);
+    const outPath = (0, import_path6.resolve)(config.outDir, file);
+    await import_fs_extra6.default.ensureDir((0, import_path6.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/build/findEntrypoints.ts
-var import_path5 = require("path");
-var import_fs_extra4 = __toESM(require("fs-extra"), 1);
+var import_path7 = require("path");
+var import_fs_extra7 = __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);
+var import_fast_glob2 = __toESM(require("fast-glob"), 1);
 async function findEntrypoints(config) {
-  const relativePaths = await (0, import_fast_glob.default)("**/*", {
+  const relativePaths = await (0, import_fast_glob2.default)("**/*", {
     cwd: config.entrypointsDir
   });
   relativePaths.sort();
@@ -518,7 +751,7 @@ async function findEntrypoints(config) {
   const entrypoints = [];
   await Promise.all(
     relativePaths.map(async (relativePath) => {
-      const path5 = (0, import_path5.resolve)(config.entrypointsDir, relativePath);
+      const path5 = (0, import_path7.resolve)(config.entrypointsDir, relativePath);
       const matchingGlob = pathGlobs.find(
         (glob3) => import_picomatch.default.isMatch(relativePath, glob3)
       );
@@ -565,8 +798,8 @@ ${JSON.stringify(
       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)
+            (0, import_path7.relative)(config.root, withSameName.inputPath),
+            (0, import_path7.relative)(config.root, entrypoint.inputPath)
           ].join(", ")}`
         );
       }
@@ -578,7 +811,7 @@ ${JSON.stringify(
 }
 async function getPopupEntrypoint(config, path5) {
   const options = {};
-  const content = await import_fs_extra4.default.readFile(path5, "utf-8");
+  const content = await import_fs_extra7.default.readFile(path5, "utf-8");
   const { document } = (0, import_linkedom2.parseHTML)(content);
   const title = document.querySelector("title");
   if (title != null)
@@ -608,7 +841,7 @@ async function getPopupEntrypoint(config, path5) {
 }
 async function getOptionsEntrypoint(config, path5) {
   const options = {};
-  const content = await import_fs_extra4.default.readFile(path5, "utf-8");
+  const content = await import_fs_extra7.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) {
@@ -655,7 +888,7 @@ async function getContentScriptEntrypoint(config, name, path5) {
     type: "content-script",
     name: getEntrypointName(config.entrypointsDir, path5),
     inputPath: path5,
-    outputDir: (0, import_path5.resolve)(config.outDir, "content-scripts"),
+    outputDir: (0, import_path7.resolve)(config.outDir, "content-scripts"),
     options
   };
 }
@@ -690,140 +923,112 @@ var PATH_GLOB_TO_TYPE_MAP = {
   "*/*": "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/generateTypesDir.ts
+var import_unimport3 = require("unimport");
+var import_fs_extra8 = __toESM(require("fs-extra"), 1);
+var import_path8 = require("path");
+async function generateTypesDir(entrypoints, config) {
+  await import_fs_extra8.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);
 }
-
-// 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 writeImportsDeclarationFile(config) {
+  const filePath = (0, import_path8.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_extra8.default.writeFile(
+    filePath,
+    ["// Generated by wxt", await unimport2.generateTypeDeclarations()].join(
+      "\n"
+    ) + "\n"
+  );
+  return filePath;
 }
-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
+async function writePathsDeclarationFile(entrypoints, config) {
+  const filePath = (0, import_path8.resolve)(config.typesDir, "paths.d.ts");
+  await import_fs_extra8.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"
   );
-  const result = await vite3.build(entryConfig);
-  return {
-    entrypoints: entrypoint,
-    chunks: getBuildOutputChunks(result)
-  };
+  return filePath;
 }
-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
+async function writeGlobalsDeclarationFile(config) {
+  const filePath = (0, import_path8.resolve)(config.typesDir, "globals.d.ts");
+  const globals = getGlobals(config);
+  await import_fs_extra8.default.writeFile(
+    filePath,
+    [
+      "// Generated by wxt",
+      "export {}",
+      "declare global {",
+      ...globals.map((global) => `  const ${global.name}: ${global.type};`),
+      "}"
+    ].join("\n") + "\n",
+    "utf-8"
   );
-  const result = await vite3.build(entryConfig);
-  return {
-    entrypoints,
-    chunks: getBuildOutputChunks(result)
-  };
+  return filePath;
 }
-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 writeMainDeclarationFile(references, config) {
+  const dir = config.wxtDir;
+  const filePath = (0, import_path8.resolve)(dir, "wxt.d.ts");
+  await import_fs_extra8.default.writeFile(
+    filePath,
+    [
+      "// Generated by wxt",
+      ...references.map(
+        (ref) => `/// <reference types="./${(0, import_path8.relative)(dir, ref)}" />`
+      )
+    ].join("\n") + "\n"
+  );
+  return filePath;
 }
-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;
+async function writeTsConfigFile(mainReference, config) {
+  const dir = config.wxtDir;
+  await import_fs_extra8.default.writeFile(
+    (0, import_path8.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_path8.relative)(dir, config.root)}/**/*",
+    "./${(0, import_path8.relative)(dir, mainReference)}"
+  ],
+  "exclude": ["${(0, import_path8.relative)(dir, config.outBaseDir)}"]
+}`
+  );
 }
 
 // src/core/utils/manifest.ts
-var import_fs_extra7 = __toESM(require("fs-extra"), 1);
-var import_path8 = require("path");
+var import_fs_extra9 = __toESM(require("fs-extra"), 1);
+var import_path9 = require("path");
 
 // src/core/utils/ContentSecurityPolicy.ts
 var ContentSecurityPolicy = class _ContentSecurityPolicy {
@@ -871,8 +1076,8 @@ var ContentSecurityPolicy = class _ContentSecurityPolicy {
 // 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");
+  await import_fs_extra9.default.ensureDir(config.outDir);
+  await import_fs_extra9.default.writeFile((0, import_path9.resolve)(config.outDir, "manifest.json"), str, "utf-8");
   output.publicAssets.unshift({
     type: "asset",
     fileName: "manifest.json",
@@ -900,10 +1105,12 @@ async function generateMainfest(entrypoints, buildOutput, config) {
   addEntrypoints(manifest, entrypoints, buildOutput, config);
   if (config.command === "serve")
     addDevModeCsp(manifest, config);
+  if (config.command === "serve")
+    addDevModePermissions(manifest, config);
   return manifest;
 }
 async function getPackageJson(config) {
-  return await import_fs_extra7.default.readJson((0, import_path8.resolve)(config.root, "package.json"));
+  return await import_fs_extra9.default.readJson((0, import_path9.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(
@@ -1056,23 +1263,23 @@ function addEntrypoints(manifest, entrypoints, buildOutput, config) {
     }
   }
   if (contentScripts?.length) {
-    if (config.command === "serve") {
-      const permissionsKey = config.manifestVersion === 2 ? "permissions" : "host_permissions";
-      const hostPermissions = new Set(manifest[permissionsKey] ?? []);
+    if (config.command === "serve" && config.manifestVersion === 3) {
+      const hostPermissions = new Set(manifest.host_permissions ?? []);
       contentScripts.forEach((script) => {
         script.options.matches.forEach((matchPattern) => {
           hostPermissions.add(matchPattern);
         });
       });
-      manifest[permissionsKey] = Array.from(hostPermissions).sort();
+      hostPermissions.forEach(
+        (permission) => addHostPermission(manifest, permission)
+      );
     } else {
       const hashToEntrypointsMap = contentScripts.reduce((map, script) => {
         const hash = JSON.stringify(script.options);
-        if (!map.has(hash)) {
-          map.set(hash, [script]);
-        } else {
+        if (map.has(hash))
           map.get(hash)?.push(script);
-        }
+        else
+          map.set(hash, [script]);
         return map;
       }, /* @__PURE__ */ new Map());
       manifest.content_scripts = Array.from(hashToEntrypointsMap.entries()).map(
@@ -1093,13 +1300,9 @@ 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);
+    addHostPermission(manifest, permission);
   } else {
-    manifest.permissions ??= [];
-    if (!manifest.permissions.includes(permission))
-      manifest.permissions.push(permission);
+    addPermission(manifest, permission);
   }
   const csp = new ContentSecurityPolicy(
     manifest.manifest_version === 3 ? (
@@ -1117,6 +1320,11 @@ function addDevModeCsp(manifest, config) {
     manifest.content_security_policy = csp.toString();
   }
 }
+function addDevModePermissions(manifest, config) {
+  addPermission(manifest, "tabs");
+  if (config.manifestVersion === 3)
+    addPermission(manifest, "scripting");
+}
 function getContentScriptCssFiles(contentScripts, buildOutput) {
   const css = [];
   const allChunks = buildOutput.steps.flatMap((step) => step.chunks);
@@ -1131,9 +1339,71 @@ function getContentScriptCssFiles(contentScripts, buildOutput) {
     return css;
   return void 0;
 }
+function addPermission(manifest, permission) {
+  manifest.permissions ??= [];
+  if (manifest.permissions.includes(permission))
+    return;
+  manifest.permissions.push(permission);
+}
+function addHostPermission(manifest, hostPermission) {
+  manifest.host_permissions ??= [];
+  if (manifest.host_permissions.includes(hostPermission))
+    return;
+  manifest.host_permissions.push(hostPermission);
+}
+
+// src/core/build.ts
+var import_picocolors2 = __toESM(require("picocolors"), 1);
+var vite4 = __toESM(require("vite"), 1);
+var import_fs_extra11 = __toESM(require("fs-extra"), 1);
+
+// src/core/utils/groupEntrypoints.ts
+function groupEntrypoints(entrypoints) {
+  const groupIndexMap = {};
+  const groups = [];
+  for (const entry of entrypoints) {
+    const group = ENTRY_TYPE_TO_GROUP_MAP[entry.type];
+    if (group === "no-group") {
+      groups.push(entry);
+    } else {
+      let groupIndex = groupIndexMap[group];
+      if (groupIndex == null) {
+        groupIndex = groups.push([]) - 1;
+        groupIndexMap[group] = groupIndex;
+      }
+      groups[groupIndex].push(entry);
+    }
+  }
+  return groups;
+}
+var ENTRY_TYPE_TO_GROUP_MAP = {
+  sandbox: "sandbox-page",
+  popup: "extension-page",
+  newtab: "extension-page",
+  history: "extension-page",
+  options: "extension-page",
+  devtools: "extension-page",
+  bookmarks: "extension-page",
+  sidepanel: "extension-page",
+  "unlisted-page": "extension-page",
+  background: "no-group",
+  "content-script": "no-group",
+  "unlisted-script": "no-group"
+};
+
+// src/core/utils/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/log/printBuildSummary.ts
-var import_path9 = __toESM(require("path"), 1);
+var import_path10 = __toESM(require("path"), 1);
 
 // src/core/log/printTable.ts
 function printTable(log, rows, gap = 2) {
@@ -1163,15 +1433,15 @@ function printTable(log, rows, gap = 2) {
 
 // src/core/log/printBuildSummary.ts
 var import_picocolors = __toESM(require("picocolors"), 1);
-var import_fs_extra8 = __toESM(require("fs-extra"), 1);
+var import_fs_extra10 = __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 lWeight = CHUNK_SORT_WEIGHTS[l.fileName] ?? CHUNK_SORT_WEIGHTS[(0, import_path10.extname)(l.fileName)] ?? DEFAULT_SORT_WEIGHT;
+    const rWeight = CHUNK_SORT_WEIGHTS[r.fileName] ?? CHUNK_SORT_WEIGHTS[(0, import_path10.extname)(r.fileName)] ?? DEFAULT_SORT_WEIGHT;
     const diff = lWeight - rWeight;
     if (diff !== 0)
       return diff;
@@ -1181,13 +1451,13 @@ async function printBuildSummary(output, config) {
   const chunkRows = await Promise.all(
     chunks.map(async (chunk, i) => {
       const file = [
-        (0, import_path9.relative)(process.cwd(), config.outDir) + import_path9.default.sep,
+        (0, import_path10.relative)(process.cwd(), config.outDir) + import_path10.default.sep,
         chunk.fileName
       ];
-      const ext = (0, import_path9.extname)(chunk.fileName);
+      const ext = (0, import_path10.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));
+      const stats = await import_fs_extra10.default.lstat((0, import_path10.resolve)(config.outDir, chunk.fileName));
       totalSize += stats.size;
       const size = String((0, import_filesize.filesize)(stats.size));
       return [
@@ -1215,115 +1485,63 @@ var CHUNK_COLORS = {
   ".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"
+// src/core/build.ts
+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}`
+    )}`
   );
-  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"
+  const startTime = Date.now();
+  await import_fs_extra11.default.rm(config.outDir, { recursive: true, force: true });
+  await import_fs_extra11.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)}`
   );
-  return filePath;
+  await printBuildSummary(output, config);
+  return output;
 }
-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)}"]
-}`
+async function rebuild(config, entrypointGroups, existingOutput = {
+  steps: [],
+  publicAssets: []
+}) {
+  const allEntrypoints = await findEntrypoints(config);
+  await generateTypesDir(allEntrypoints, config);
+  const newOutput = await buildEntrypoints(entrypointGroups, config);
+  const mergedOutput = {
+    steps: [...existingOutput.steps, ...newOutput.steps],
+    publicAssets: [...existingOutput.publicAssets, ...newOutput.publicAssets]
+  };
+  const newManifest = await generateMainfest(
+    allEntrypoints,
+    mergedOutput,
+    config
   );
+  const finalOutput = {
+    manifest: newManifest,
+    ...newOutput
+  };
+  await writeManifest(newManifest, finalOutput, config);
+  return {
+    output: {
+      manifest: newManifest,
+      steps: [...existingOutput.steps, ...finalOutput.steps],
+      publicAssets: [
+        ...existingOutput.publicAssets,
+        ...finalOutput.publicAssets
+      ]
+    },
+    manifest: newManifest
+  };
 }
 
-// src/index.ts
-var import_picocolors2 = __toESM(require("picocolors"), 1);
-var vite4 = __toESM(require("vite"), 1);
+// src/core/server.ts
+var vite5 = __toESM(require("vite"), 1);
 
 // src/core/utils/findOpenPort.ts
 var import_node_net = __toESM(require("net"), 1);
@@ -1348,17 +1566,6 @@ function findOpenPortRecursive(port, 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;
@@ -1416,161 +1623,131 @@ function createWebExtRunner() {
 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);
+// src/core/server.ts
+async function getServerInfo() {
+  const port = await findOpenPort(3e3, 3010);
+  const hostname = "localhost";
+  const origin = `http://${hostname}:${port}`;
+  const serverConfig = {
+    server: {
+      origin
     }
-  }
-  return groups;
+  };
+  return {
+    port,
+    hostname,
+    origin,
+    viteServerConfig: serverConfig
+  };
 }
-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)
-    )
+async function setupServer(serverInfo, config) {
+  const runner = createWebExtRunner();
+  const viteServer = await vite5.createServer(
+    vite5.mergeConfig(serverInfo, config.vite)
   );
-  if (changedSteps.size === 0)
-    return { type: "no-change" };
-  const unchangedOutput = {
-    manifest: currentOutput.manifest,
-    steps: [],
-    publicAssets: []
+  const start = async () => {
+    await viteServer.listen(server.port);
+    config.logger.success(`Started dev server @ ${serverInfo.origin}`);
+    server.currentOutput = await buildInternal(config);
+    config.logger.info("Opening browser...");
+    await runner.openBrowser(config);
+    config.logger.success("Opened!");
   };
-  const changedOutput = {
-    manifest: currentOutput.manifest,
-    steps: [],
-    publicAssets: []
+  const reloadExtension = () => {
+    viteServer.ws.send("wxt:reload-extension");
   };
-  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)
+  const reloadPage = (path5) => {
+    viteServer.ws.send("wxt:reload-page", path5);
+  };
+  const reloadContentScript = (contentScript) => {
+    viteServer.ws.send("wxt:reload-content-script", contentScript);
+  };
+  const server = {
+    ...viteServer,
+    start,
+    currentOutput: {
+      manifest: {
+        manifest_version: 3,
+        name: "",
+        version: ""
+      },
+      publicAssets: [],
+      steps: []
+    },
+    port: serverInfo.port,
+    hostname: serverInfo.hostname,
+    origin: serverInfo.origin,
+    reloadExtension,
+    reloadPage,
+    reloadContentScript
   };
+  return server;
 }
-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);
+function reloadContentScripts(steps, config, server) {
+  if (config.manifestVersion === 3) {
+    steps.forEach((step) => {
+      const entry = step.entrypoints;
+      if (Array.isArray(entry) || entry.type !== "content-script")
+        return;
+      const js = [getEntrypointBundlePath(entry, config.outDir, ".js")];
+      const css = getContentScriptCssFiles([entry], server.currentOutput);
+      server.reloadContentScript({
+        js,
+        css,
+        ...entry.options
+      });
+    });
+  } else {
+    server.reloadExtension();
   }
-  const effectedAsset = currentOutput.publicAssets.find(
-    (chunk) => isChunkEffected(chunk)
-  );
-  if (effectedAsset)
-    changes.push(effectedAsset);
-  return changes;
+}
+function reloadHtmlPages(groups, server, config) {
+  groups.flat().forEach((entry) => {
+    const path5 = getEntrypointBundlePath(entry, config.outDir, ".html");
+    server.reloadPage(path5);
+  });
 }
 
 // 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
-    }
+  const serverInfo = await getServerInfo();
+  const getLatestInternalConfig = () => {
+    const viteConfig = vite6.mergeConfig(
+      serverInfo.viteServerConfig,
+      config?.vite ?? {}
+    );
+    return getInternalConfig({ ...config, vite: viteConfig }, "serve");
   };
-  let internalConfig = await getInternalConfig(
-    vite4.mergeConfig(serverConfig, config ?? {}),
-    "serve"
-  );
-  const runner = createWebExtRunner();
-  let hasBuiltOnce = false;
-  let currentOutput;
+  let internalConfig = await getLatestInternalConfig();
+  const server = await setupServer(serverInfo, internalConfig);
+  internalConfig.server = server;
   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))
+  server.ws.on("wxt:background-initialized", () => {
+    reloadContentScripts(server.currentOutput.steps, internalConfig, server);
+  });
+  server.watcher.on("all", async (event, path5, _stats) => {
+    if (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);
+      const changes = detectDevChanges(fileChanges, server.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(", ")}`
+        `Changed: ${Array.from(new Set(fileChanges.map((change) => change[1]))).map((file) => import_picocolors3.default.dim((0, import_node_path4.relative)(internalConfig.root, file))).join(", ")}`
       );
       const rebuiltNames = changes.rebuildGroups.flat().map((entry) => {
-        return import_picocolors2.default.cyan(
+        return import_picocolors3.default.cyan(
           (0, import_node_path4.relative)(internalConfig.outDir, getEntrypointOutputFile(entry, ""))
         );
-      }).join(import_picocolors2.default.dim(", "));
-      internalConfig = await getInternalConfig(
-        vite4.mergeConfig(serverConfig, config ?? {}),
-        "serve"
-      );
+      }).join(import_picocolors3.default.dim(", "));
+      internalConfig = await getLatestInternalConfig();
       internalConfig.server = server;
       const { output: newOutput } = await rebuild(
         internalConfig,
@@ -1578,106 +1755,33 @@ async function createServer2(config) {
         changes.rebuildGroups,
         changes.cachedOutput
       );
-      currentOutput = newOutput;
+      server.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}`);
+          reloadHtmlPages(changes.rebuildGroups, server, internalConfig);
+          break;
+        case "content-script-reload":
+          reloadContentScripts(changes.changedSteps, internalConfig, server);
           break;
       }
+      import_consola3.consola.success(`Reloaded: ${rebuiltNames}`);
     });
   });
-  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_picocolors4 = __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))}`);
+  import_consola4.consola.log(`${import_picocolors4.default.gray("WXT")} ${import_picocolors4.default.gray(import_picocolors4.default.bold(version))}`);
 }
 
 // src/cli/utils/defineCommand.ts
@@ -1725,7 +1829,7 @@ var dev = defineCommand(async (root, flags) => {
     configFile: flags.config
   };
   const server = await createServer2(cliConfig);
-  await server.listen(server.port);
+  await server.start();
   return true;
 });
 
@@ -1765,4 +1869,4 @@ cli.command("prepare [root]", "prepare").option("-c, --config <file>", "use spec
 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": ";;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,iBAAgB;;;ACCd,cAAW;;;ACGb,IAAAA,oBAA8B;AAC9B,IAAAC,QAAsB;AACtB,IAAAC,kBAAwB;;;ACRxB,qBAAwB;AACxB,kBAAuB;AACvB,mBAAsB;AACtB,kBAAwB;AACxB,sBAA4B;AAE5B,eAAsB,aAAgB,MAAcC,OAA0B;AAC5E,QAAM,gBAAgB,UAAM;AAAA,QAC1B,qBAAQ,MAAM,iCAAiC;AAAA,EACjD;AACA,QAAM,WAAO,YAAAC,SAAW,YAAY;AAAA,IAClC,OAAO;AAAA,IACP,YAAY;AAAA,IACZ,gBAAgB;AAAA,IAEhB,UAAU,MAAM;AAEd,WAAK,SAAS,KAAK,OAAO,QAAQ,gCAAgC,EAAE;AACpE,WAAK,SAAS,KAAK,OAAO;AAAA,QACxB;AAAA,QACA;AAAA,MACF;AAGA,UAAI,KAAK,aAAaD,OAAM;AAE1B,cAAM,UACJ,cACG,IAAI,CAAC,MAAM,YAAY,EAAE,gBAAgB,EAAE,QAAQ,EACnD,KAAK,IAAI,IAAI;AAClB,aAAK,SAAS,UAAU,KAAK;AAAA,MAC/B;AAGA,iBAAO,aAAAE,SAAU,IAAI;AAAA,IACvB;AAAA,EACF,CAAC;AACD,MAAI;AACF,WAAO,MAAM,KAAKF,KAAI;AAAA,EACxB,SAAS,KAAP;AACA,2BAAQ,MAAM,0BAA0BA,OAAM;AAC9C,UAAM;AAAA,EACR;AACF;;;AC3CA,WAAsB;;;ACCtB,uBAAwC;AAEjC,SAAS,kBACd,gBACA,WAEQ;AACR,QAAM,eAAe,iBAAAG,QAAK,SAAS,gBAAgB,SAAS;AAE5D,QAAM,OAAO,aAAa,MAAM,UAAU,CAAC,EAAE,CAAC;AAE9C,SAAO;AACT;AAEO,SAAS,wBACd,YACA,KACQ;AACR,aAAO,0BAAQ,WAAW,WAAW,GAAG,WAAW,OAAO,KAAK;AACjE;AAMO,SAAS,wBACd,YACA,QACA,KACQ;AACR,aAAO,2BAAS,QAAQ,wBAAwB,YAAY,GAAG,CAAC;AAClE;;;AD7BA,sBAA0B;AAC1B,IAAAC,eAAuD;AAKhD,SAAS,iBAAiB,QAAqC;AACpE,SAAO;AAAA,IACL,OAAO;AAAA,IACP,MAAM;AAAA,IACN,OAAO,YAAY;AACjB,aAAY;AAAA,QACV;AAAA,UACE,SAAS;AAAA,YACP,OAAO;AAAA,cACL,wBAAoB;AAAA,gBAClB,OAAO;AAAA,gBACP;AAAA,cACF;AAAA,YACF;AAAA,UACF;AAAA,QACF;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA,IACA,MAAM,UAAU,MAAM,IAAI;AACxB,YAAM,SAAS,OAAO;AACtB,UAAI,OAAO,YAAY,WAAW,UAAU,QAAQ,CAAC,GAAG,SAAS,OAAO;AACtE;AAEF,YAAM,cAAc,GAAG,OAAO,SAAS;AACvC,YAAM,OAAO,kBAAkB,OAAO,gBAAgB,EAAE;AACxD,YAAM,MAAM,GAAG,OAAO,UAAU;AAChC,YAAM,aAAa,MAAM,OAAO;AAAA,QAC9B;AAAA,QACA;AAAA,QACA;AAAA,MACF;AACA,YAAM,EAAE,SAAS,QAAI,2BAAU,UAAU;AAEzC,YAAM,mBAAmB,CAAC,eAAuB,SAAuB;AACtE,iBAAS,iBAAiB,aAAa,EAAE,QAAQ,CAAC,YAAY;AAC5D,gBAAM,MAAM,QAAQ,aAAa,IAAI;AACrC,cAAI,CAAC;AAAK;AAEV,kBAAI,yBAAW,GAAG,GAAG;AACnB,oBAAQ,aAAa,MAAM,OAAO,SAAS,GAAG;AAAA,UAChD,WAAW,IAAI,WAAW,GAAG,GAAG;AAC9B,kBAAM,UAAM,0BAAQ,sBAAQ,EAAE,GAAG,GAAG;AACpC,kBAAM,eAAW,uBAAS,OAAO,MAAM,GAAG;AAC1C,oBAAQ,aAAa,MAAM,GAAG,OAAO,UAAU,UAAU;AAAA,UAC3D;AAAA,QACF,CAAC;AAAA,MACH;AACA,uBAAiB,uBAAuB,KAAK;AAC7C,uBAAiB,wBAAwB,MAAM;AAG/C,YAAM,WAAW,SAAS,cAAc,QAAQ;AAChD,eAAS,MAAM;AACf,eAAS,OAAO;AAChB,eAAS,KAAK,YAAY,QAAQ;AAElC,YAAM,UAAU,SAAS,SAAS;AAClC,aAAO,OAAO,MAAM,iBAAiB,EAAE;AACvC,aAAO,OAAO,MAAM,gBAAgB,IAAI;AACxC,aAAO,OAAO,MAAM,gBAAgB,OAAO;AAC3C,aAAO;AAAA,IACT;AAAA,EACF;AACF;;;AEnEO,SAAS,iBAAiB,gBAAwC;AACvE,SAAO;AAAA,IACL,MAAM;AAAA,IACN,OAAO,QAAQ;AACb,UAAI,eAAe,UAAU,QAAQ,eAAe,WAAW;AAC7D;AAEF,aAAO,WAAW,CAAC;AACnB,aAAO,OAAO,0BAA0B,KAAK,UAAU,KAAK;AAC5D,aAAO,OAAO,0BAA0B,KAAK;AAAA,QAC3C,eAAe,OAAO;AAAA,MACxB;AACA,aAAO,OAAO,sBAAsB,KAAK;AAAA,QACvC,eAAe,OAAO;AAAA,MACxB;AAAA,IACF;AAAA,EACF;AACF;;;ACvBA,sBAAgB;;;ACGT,SAAS,YACd,SACA,UACY;AACZ,SAAO,IAAI,QAAQ,CAAC,KAAK,QAAQ;AAC/B,UAAM,UAAU,WAAW,MAAM;AAC/B,UAAI,2BAA2B,YAAY;AAAA,IAC7C,GAAG,QAAQ;AACX,YACG,KAAK,GAAG,EACR,MAAM,GAAG,EACT,QAAQ,MAAM,aAAa,OAAO,CAAC;AAAA,EACxC,CAAC;AACH;;;ADZA,SAAS,YAA8B;AACrC,QAAMC,aAAY,IAAI,QAAiB,CAAC,QAAQ;AAC9C,oBAAAC,QAAI,QAAQ,cAAc,CAAC,QAAQ;AACjC,UAAI,OAAO,MAAM;AACf,YAAI,KAAK;AAAA,MACX,OAAO;AACL,YAAI,IAAI;AAAA,MACV;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AACD,SAAO,YAAYD,YAAW,GAAG,EAAE,MAAM,MAAM,IAAI;AACrD;AAEA,eAAsB,WAA6B;AACjD,QAAM,UAAU,MAAM,UAAU;AAChC,SAAO,CAAC;AACV;AAMA,eAAsB,YACpB,KACA,QACiB;AACjB,MAAI,UAAkB;AAEtB,MAAI,MAAM,SAAS,GAAG;AACpB,UAAM,MAAM,MAAM,MAAM,GAAG;AAC3B,QAAI,IAAI,SAAS,KAAK;AACpB,gBAAU,MAAM,IAAI,KAAK;AACzB,YAAM,OAAO,QAAQ,IAAI,KAAK,OAAO;AAAA,IACvC,OAAO;AACL,aAAO,OAAO;AAAA,QACZ,uBAAuB;AAAA,MACzB;AAAA,IACF;AAAA,EACF;AAEA,MAAI,CAAC;AAAS,cAAW,MAAM,OAAO,QAAQ,IAAI,GAAG,KAAM;AAC3D,MAAI,CAAC;AACH,UAAM;AAAA,MACJ,gBAAgB;AAAA,IAClB;AAEF,SAAO;AACT;;;AExCO,SAAS,SAAS,QAAgC;AACvD,SAAO;AAAA,IACL,MAAM;AAAA,IACN,UAAU,IAAI;AACZ,UAAI,GAAG,WAAW,MAAM;AAAG,eAAO,OAAO;AAAA,IAC3C;AAAA,IACA,MAAM,KAAK,IAAI;AACb,UAAI,CAAC,GAAG,WAAW,QAAQ;AAAG;AAG9B,YAAM,MAAM,GAAG,QAAQ,UAAU,EAAE;AACnC,aAAO,MAAM,YAAY,KAAK,MAAM;AAAA,IACtC;AAAA,EACF;AACF;;;ACvBA,IAAAE,oBAA0C;AAE1C,sBAA8B;AAavB,SAAS,cACd,aACA,QACa;AACb,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM,YAAY,GAAG,QAAQ;AAC3B,iBAAW,iBAAiB,QAAQ;AAIlC,cAAM,aAAa,YAAY;AAAA,UAC7B,CAAC,UAAU,CAAC,CAAC,MAAM,UAAU,SAAS,aAAa;AAAA,QACrD;AACA,YAAI,cAAc,MAAM;AACtB,iBAAO,OAAO,MAAM,2BAA2B,aAAa;AAC5D;AAAA,QACF;AAGA,cAAM,gBAAgB;AAAA,UACpB;AAAA,UACA,OAAO;AAAA,cACP,2BAAQ,aAAa;AAAA,QACvB;AACA,YAAI,kBAAkB,eAAe;AACnC,iBAAO,OAAO;AAAA,YACZ;AAAA,YACA;AAAA,UACF;AACA;AAAA,QACF;AAIA,cAAM,iBAAa,2BAAQ,OAAO,QAAQ,aAAa;AACvD,cAAM,iBAAa,2BAAQ,OAAO,QAAQ,aAAa;AACvD,kBAAM,+BAAU,2BAAQ,UAAU,CAAC;AACnC,cAAM,gBAAAC,QAAG,KAAK,YAAY,YAAY,EAAE,WAAW,KAAK,CAAC;AAEzD,cAAM,eAAe;AAAA,UACnB,GAAG,OAAO,aAAa;AAAA,UACvB,UAAU;AAAA,QACZ;AACA,eAAO,OAAO,aAAa;AAC3B,eAAO,aAAa,IAAI;AAAA,MAC1B;AAAA,IACF;AAAA,EACF;AACF;;;AClEA,IAAAC,mBAA+B;;;ACE/B,kBAA4B;AAErB,SAAS,mBACd,QAC0B;AAC1B,QAAM,iBAA2C;AAAA,IAC/C,UAAU,OAAO,OAAO;AAAA,IACxB,SAAS;AAAA,MACP,EAAE,MAAM,KAAK,IAAI,WAAW,MAAM,wBAAwB;AAAA,MAC1D,EAAE,MAAM,gBAAgB,MAAM,MAAM;AAAA,IACtC;AAAA,IACA,SAAS,CAAC,EAAE,SAAS,aAAa,CAAC;AAAA,IACnC,MAAM,OAAO,OAAO;AAAA,IACpB,MAAM,CAAC,cAAc,eAAe,SAAS,OAAO;AAAA,EACtD;AAEA,aAAO;AAAA,IACL;AAAA,IACA,OAAO;AAAA,EACT;AACF;;;ADdO,SAAS,SAAS,QAAgC;AACvD,QAAM,UAAU,mBAAmB,MAAM;AACzC,QAAMC,gBAAW,iCAAe,OAAO;AAEvC,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM,SAAS;AACb,YAAMA,UAAS,mBAAmB,QAAW,EAAE,KAAK,OAAO,OAAO,CAAC;AAAA,IACrE;AAAA,IACA,MAAM,UAAU,MAAM,IAAI;AACxB,aAAOA,UAAS,cAAc,MAAM,EAAE;AAAA,IACxC;AAAA,EACF;AACF;;;AEnBA,IAAAC,mBAAe;AACf,IAAAC,eAAwB;AAKjB,SAAS,iBACd,MACA,QACQ;AACR,QAAM,YAAY,eAAe;AACjC,QAAM,oBAAoB,KAAK;AAE/B,SAAO;AAAA,IACL,MAAM;AAAA,IACN,UAAU,IAAI;AAGZ,YAAM,QAAQ,GAAG,QAAQ,SAAS;AAClC,UAAI,UAAU;AAAI;AAElB,YAAM,YAAY,GAAG,UAAU,QAAQ,UAAU,MAAM;AACvD,aAAO,oBAAoB;AAAA,IAC7B;AAAA,IACA,MAAM,KAAK,IAAI;AACb,UAAI,CAAC,GAAG,WAAW,iBAAiB;AAAG;AAEvC,YAAM,YAAY,GAAG,QAAQ,mBAAmB,EAAE;AAClD,YAAM,WAAW,MAAM,iBAAAC,QAAG;AAAA,YACxB;AAAA,UACE,OAAO;AAAA,UACP,yCAAyC;AAAA,QAC3C;AAAA,QACA;AAAA,MACF;AACA,aAAO,SAAS,QAAQ,gBAAgB,QAAQ,SAAS;AAAA,IAC3D;AAAA,EACF;AACF;;;ACxCA,IAAAC,mBAA8B;AAE9B,IAAAC,eAAiC;AAQ1B,SAAS,cAAc,QAAyB;AACrD,QAAM,UAAU,CAAC,YACf,sBAAQ,QAAQ,SAAS,mBAAmB,GAAG,CAAC;AAElD,SAAO;AAAA,IACL,MAAM,IAAI,KAAa,OAA8B;AACnD,YAAMC,QAAO,QAAQ,GAAG;AACxB,gBAAM,gCAAU,sBAAQA,KAAI,CAAC;AAC7B,YAAM,iBAAAC,QAAG,UAAUD,OAAM,OAAO,OAAO;AAAA,IACzC;AAAA,IACA,MAAM,IAAI,KAA0C;AAClD,YAAMA,QAAO,QAAQ,GAAG;AACxB,UAAI;AACF,eAAO,MAAM,iBAAAC,QAAG,SAASD,OAAM,OAAO;AAAA,MACxC,QAAE;AACA,eAAO;AAAA,MACT;AAAA,IACF;AAAA,EACF;AACF;;;AC3BO,SAAS,WACd,QACmD;AACnD,SAAO;AAAA,IACL;AAAA,MACE,MAAM;AAAA,MACN,OAAO,OAAO;AAAA,MACd,MAAM;AAAA,IACR;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,OAAO,OAAO;AAAA,MACd,MAAM;AAAA,IACR;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,OAAO,OAAO,YAAY;AAAA,MAC1B,MAAM;AAAA,IACR;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,OAAO,OAAO,YAAY;AAAA,MAC1B,MAAM;AAAA,IACR;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,OAAO,OAAO,YAAY;AAAA,MAC1B,MAAM;AAAA,IACR;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,OAAO,OAAO,YAAY;AAAA,MAC1B,MAAM;AAAA,IACR;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,OAAO,OAAO,YAAY;AAAA,MAC1B,MAAM;AAAA,IACR;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,OAAO,OAAO;AAAA,MACd,MAAM;AAAA,IACR;AAAA,EACF;AACF;;;AblCA,iBAA2B;AAM3B,eAAsB,kBACpB,QACA,SACyB;AAEzB,QAAM,OAAO,OAAO,OAAO,kBAAAE,QAAK,QAAQ,OAAO,IAAI,IAAI,QAAQ,IAAI;AACnE,QAAM,OACJ,OAAO,SAAS,YAAY,UAAU,eAAe;AACvD,QAAM,UAAU,OAAO,WAAW;AAClC,QAAM,kBACJ,OAAO,oBAAoB,WAAW,YAAY,IAAI;AACxD,QAAM,aAAa,kBAAAA,QAAK,QAAQ,MAAM,SAAS;AAC/C,QAAM,SAAS,kBAAAA,QAAK,QAAQ,YAAY,GAAG,aAAa,iBAAiB;AACzE,QAAM,SAAS,OAAO,UAAU;AAEhC,QAAM,aAAuC;AAAA,IAC3C;AAAA,IACA;AAAA,IACA;AAAA,IACA,UAAU,OAAO,YAAY,CAAC;AAAA,IAC9B;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,MAAM,OAAO,QAAQ,CAAC;AAAA,IACtB,UAAU,OAAO,YAAY,CAAC;AAAA,IAC9B,SAAS,OAAO,WAAW,CAAC;AAAA,IAC5B,cAAc,UAAM,uBAAkC;AAAA,MACpD,MAAM;AAAA,MACN,KAAK;AAAA,MACL,UAAU;AAAA,MACV,QAAQ;AAAA,MACR,WAAW,OAAO;AAAA,IACpB,CAAC;AAAA,EACH;AAGA,MAAI,aAAyB;AAAA,IAC3B;AAAA,EACF;AACA,MAAI,OAAO,eAAe,OAAO;AAC/B,iBAAa,MAAM;AAAA,MACjB;AAAA,MACA,kBAAAA,QAAK,QAAQ,MAAM,OAAO,cAAc,eAAe;AAAA,IACzD;AAAA,EACF;AAGA,QAAM,SAAc;AAAA,IAClB;AAAA,IACA;AAAA,EACF;AAGA,QAAM,SAAS,WAAW,aAAS,2BAAQ,MAAM,WAAW,MAAM,IAAI;AACtE,QAAM,qBAAiB;AAAA,IACrB;AAAA,IACA,WAAW,kBAAkB;AAAA,EAC/B;AACA,QAAM,gBAAY,2BAAQ,QAAQ,WAAW,aAAa,QAAQ;AAClE,QAAM,aAAS,2BAAQ,QAAQ,MAAM;AACrC,QAAM,eAAW,2BAAQ,QAAQ,OAAO;AAExC,QAAM,cAA8B;AAAA,IAClC,GAAG;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,SAAS,cAAc,MAAM;AAAA,EAC/B;AAGA,cAAY,KAAK,OAAO;AACxB,cAAY,KAAK,aAAa;AAC9B,cAAY,KAAK,WAAW;AAE5B,cAAY,KAAK,UAAU,CAAC;AAC5B,cAAY,KAAK,MAAM,SAAS;AAChC,cAAY,KAAK,MAAM,cAAc;AAErC,cAAY,KAAK,YAAY,CAAC;AAC9B,cAAY,KAAK,QAAQ,KAAa,SAAS,WAAW,CAAC;AAC3D,cAAY,KAAK,QAAQ,KAAa,iBAAiB,WAAW,CAAC;AACnE,cAAY,KAAK,QAAQ,KAAa,SAAS,WAAW,CAAC;AAC3D,cAAY,KAAK,QAAQ;AAAA,IACf,iBAAiB,cAAc,WAAW;AAAA,EACpD;AACA,cAAY,KAAK,QAAQ;AAAA,IACf,iBAAiB,kBAAkB,WAAW;AAAA,EACxD;AACA,cAAY,KAAK,QAAQ,KAAa,iBAAiB,WAAW,CAAC;AAEnE,cAAY,KAAK,WAAW,CAAC;AAC7B,aAAW,WAAW,EAAE,QAAQ,CAAC,WAAW;AAC1C,gBAAY,KAAK,OAAQ,OAAO,IAAI,IAAI,KAAK,UAAU,OAAO,KAAK;AAAA,EACrE,CAAC;AAED,SAAO;AACT;;;AcxHA,IAAAC,eAAkC;AAWlC,IAAAC,mBAAe;AACf,uBAAsB;AACtB,IAAAC,mBAA0B;AAC1B,mBAAkB;AAElB,uBAAiB;AAMjB,eAAsB,gBACpB,QACuB;AACvB,QAAM,gBAAgB,UAAM,iBAAAC,SAAK,QAAQ;AAAA,IACvC,KAAK,OAAO;AAAA,EACd,CAAC;AAED,gBAAc,KAAK;AAEnB,QAAM,YAAY,OAAO,KAAK,qBAAqB;AACnD,QAAM,gBAAwD,CAAC;AAE/D,QAAM,cAA4B,CAAC;AACnC,QAAM,QAAQ;AAAA,IACZ,cAAc,IAAI,OAAO,iBAAiB;AACxC,YAAMC,YAAO,sBAAQ,OAAO,gBAAgB,YAAY;AACxD,YAAM,eAAe,UAAU;AAAA,QAAK,CAACD,UACnC,iBAAAE,QAAU,QAAQ,cAAcF,KAAI;AAAA,MACtC;AAEA,UAAI,gBAAgB,MAAM;AACxB,eAAO,OAAO,OAAO;AAAA,UACnB,GAAG;AAAA,EAAyE,KAAK;AAAA,YAC/E;AAAA,YACA;AAAA,YACA;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAEA,YAAM,OAAO,sBAAsB,YAAY;AAC/C,UAAI,SAAS;AAAW;AAExB,UAAI;AACJ,cAAQ,MAAM;AAAA,QACZ,KAAK;AACH,uBAAa,MAAM,mBAAmB,QAAQC,KAAI;AAClD;AAAA,QACF,KAAK;AACH,uBAAa,MAAM,qBAAqB,QAAQA,KAAI;AACpD;AAAA,QACF,KAAK;AACH,uBAAa,MAAM,wBAAwB,QAAQA,KAAI;AACvD;AAAA,QACF,KAAK;AACH,uBAAa,MAAM;AAAA,YACjB;AAAA,YACA,aAAa,MAAM,KAAK,CAAC,EAAE,CAAC;AAAA,YAC5BA;AAAA,UACF;AACA;AAAA,QACF;AACE,uBAAa;AAAA,YACX;AAAA,YACA,MAAM,kBAAkB,OAAO,gBAAgBA,KAAI;AAAA,YACnD,WAAWA;AAAA,YACX,WAAW,OAAO;AAAA,UACpB;AAAA,MACJ;AAEA,YAAM,eAAe,cAAc,WAAW,IAAI;AAClD,UAAI,cAAc;AAChB,cAAM;AAAA,UACJ,uCACE,WAAW,4CAC2B;AAAA,gBACtC,uBAAS,OAAO,MAAM,aAAa,SAAS;AAAA,gBAC5C,uBAAS,OAAO,MAAM,WAAW,SAAS;AAAA,UAC5C,EAAE,KAAK,IAAI;AAAA,QACb;AAAA,MACF;AACA,kBAAY,KAAK,UAAU;AAC3B,oBAAc,WAAW,IAAI,IAAI;AAAA,IACnC,CAAC;AAAA,EACH;AACA,SAAO;AACT;AAMA,eAAe,mBACb,QACAA,OAC0B;AAC1B,QAAM,UAAsC,CAAC;AAE7C,QAAM,UAAU,MAAM,iBAAAE,QAAG,SAASF,OAAM,OAAO;AAC/C,QAAM,EAAE,SAAS,QAAI,4BAAU,OAAO;AAEtC,QAAM,QAAQ,SAAS,cAAc,OAAO;AAC5C,MAAI,SAAS;AAAM,YAAQ,eAAe,MAAM,eAAe;AAE/D,QAAM,qBAAqB,SACxB,cAAc,oCAAoC,GACjD,aAAa,SAAS;AAC1B,MAAI,oBAAoB;AACtB,QAAI;AACF,cAAQ,cAAc,aAAAG,QAAM,MAAM,kBAAkB;AAAA,IACtD,SAAS,KAAP;AACA,aAAO,OAAO;AAAA,QACZ,mEAAmE;AAAA,QACnE;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,QAAM,gBAAgB,SACnB,cAAc,4BAA4B,GACzC,aAAa,SAAS;AAC1B,MAAI,eAAe;AACjB,YAAQ,SACN,kBAAkB,gBAAgB,gBAAgB;AAAA,EACtD;AAEA,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM;AAAA,IACN;AAAA,IACA,WAAWH;AAAA,IACX,WAAW,OAAO;AAAA,EACpB;AACF;AAMA,eAAe,qBACb,QACAA,OAC4B;AAC5B,QAAM,UAAwC,CAAC;AAE/C,QAAM,UAAU,MAAM,iBAAAE,QAAG,SAASF,OAAM,OAAO;AAC/C,QAAM,EAAE,SAAS,QAAI,4BAAU,OAAO;AAEtC,QAAM,mBAAmB,SACtB,cAAc,mCAAmC,GAChD,aAAa,SAAS;AAC1B,MAAI,kBAAkB;AACpB,YAAQ,YAAY,QAAQ,gBAAgB;AAAA,EAC9C;AAEA,QAAM,qBAAqB,SACxB,cAAc,oCAAoC,GACjD,aAAa,SAAS;AAC1B,MAAI,oBAAoB;AACtB,YAAQ,cAAc,QAAQ,kBAAkB;AAAA,EAClD;AAEA,QAAM,sBAAsB,SACzB,cAAc,qCAAqC,GAClD,aAAa,SAAS;AAC1B,MAAI,qBAAqB;AACvB,YAAQ,eAAe,QAAQ,mBAAmB;AAAA,EACpD;AAEA,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM;AAAA,IACN;AAAA,IACA,WAAWA;AAAA,IACX,WAAW,OAAO;AAAA,EACpB;AACF;AAKA,eAAe,wBACb,QACAA,OAC+B;AAC/B,QAAM,EAAE,MAAM,GAAG,GAAG,QAAQ,IAC1B,MAAM,aAA0C,OAAO,MAAMA,KAAI;AACnE,MAAI,WAAW,MAAM;AACnB,UAAM,MAAM,kDAAkD;AAAA,EAChE;AACA,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM;AAAA,IACN,WAAWA;AAAA,IACX,WAAW,OAAO;AAAA,IAClB;AAAA,EACF;AACF;AAKA,eAAe,2BACb,QACA,MACAA,OACkC;AAClC,QAAM,EAAE,MAAM,GAAG,GAAG,QAAQ,IAAI,MAAM;AAAA,IACpC,OAAO;AAAA,IACPA;AAAA,EACF;AACA,MAAI,WAAW,MAAM;AACnB,UAAM,MAAM,kBAAkB,qCAAqC;AAAA,EACrE;AACA,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM,kBAAkB,OAAO,gBAAgBA,KAAI;AAAA,IACnD,WAAWA;AAAA,IACX,eAAW,sBAAQ,OAAO,QAAQ,iBAAiB;AAAA,IACnD;AAAA,EACF;AACF;AAEA,IAAM,wBAAwE;AAAA,EAC5E,gBAAgB;AAAA,EAChB,sBAAsB;AAAA,EACtB,kBAAkB;AAAA,EAClB,wBAAwB;AAAA,EAExB,kBAAkB;AAAA,EAClB,wBAAwB;AAAA,EAExB,gBAAgB;AAAA,EAChB,sBAAsB;AAAA,EAEtB,eAAe;AAAA,EACf,qBAAqB;AAAA,EAErB,kBAAkB;AAAA,EAClB,wBAAwB;AAAA,EACxB,oBAAoB;AAAA,EACpB,0BAA0B;AAAA,EAE1B,iBAAiB;AAAA,EACjB,uBAAuB;AAAA,EAEvB,iBAAiB;AAAA,EAEjB,oBAAoB;AAAA,EACpB,0BAA0B;AAAA,EAE1B,cAAc;AAAA,EACd,oBAAoB;AAAA,EAEpB,gBAAgB;AAAA,EAChB,sBAAsB;AAAA,EAEtB,UAAU;AAAA,EACV,gBAAgB;AAAA,EAChB,QAAQ;AAAA;AAAA,EAGR,OAAO;AACT;;;ACnRA,IAAAI,QAAsB;;;ACAtB,IAAAC,mBAAe;AACf,IAAAC,eAAiB;AAEjB,eAAsB,gBAAgB,KAA4B;AAChE,QAAM,QAAQ,MAAM,iBAAAC,QAAG,QAAQ,GAAG;AAClC,aAAW,QAAQ,OAAO;AACxB,UAAM,WAAW,aAAAC,QAAK,KAAK,KAAK,IAAI;AACpC,UAAM,QAAQ,MAAM,iBAAAD,QAAG,KAAK,QAAQ;AACpC,QAAI,MAAM,YAAY,GAAG;AACvB,YAAM,gBAAgB,QAAQ;AAAA,IAChC;AAAA,EACF;AAEA,MAAI;AACF,UAAM,iBAAAA,QAAG,MAAM,GAAG;AAAA,EACpB,QAAE;AAAA,EAEF;AACF;;;ADPA,IAAAE,oBAAiB;AACjB,IAAAC,mBAAe;AACf,IAAAC,eAAiC;AAEjC,eAAsB,iBACpB,QACA,QACwC;AACxC,QAAM,QAA2B,CAAC;AAClC,aAAW,SAAS,QAAQ;AAC1B,UAAM,OAAO,MAAM,QAAQ,KAAK,IAC5B,MAAM,yBAAyB,OAAO,MAAM,IAC5C,MAAM,sBAAsB,OAAO,MAAM;AAC7C,UAAM,KAAK,IAAI;AAAA,EACjB;AACA,QAAM,eAAe,MAAM,oBAAoB,MAAM;AAGrD,QAAM,gBAAgB,OAAO,MAAM;AAEnC,SAAO,EAAE,cAAc,MAAM;AAC/B;AAKA,eAAe,sBACb,YACA,QAC0B;AAE1B,QAAM,YAAY,CAAC,cAAc,gBAAgB,EAAE,SAAS,WAAW,IAAI;AAC3E,QAAM,QAAQ,YACV,eAAe,WAAW,QAAQ,WAAW,cAC7C,WAAW;AAEf,QAAM,UAA6B;AAAA,IACjC,OAAO;AAAA,MACL,KAAK;AAAA,QACH;AAAA,QACA,SAAS,CAAC,MAAM;AAAA,QAChB,MAAM,WAAW;AAAA,QACjB,UAAU,WAAW;AAAA,MACvB;AAAA,MACA,eAAe;AAAA,QACb,QAAQ;AAAA;AAAA;AAAA,UAGN,gBAAgB;AAAA,YACd;AAAA,YACA,OAAO;AAAA,YACP;AAAA,UACF;AAAA;AAAA;AAAA;AAAA,UAIA,gBAAgB,UAAU,WAAW;AAAA,QACvC;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACA,QAAM,cAAmB;AAAA,IACvB;AAAA,IACA,OAAO;AAAA,EACT;AAEA,QAAM,SAAS,MAAW,YAAM,WAAW;AAC3C,SAAO;AAAA,IACL,aAAa;AAAA,IACb,QAAQ,qBAAqB,MAAM;AAAA,EACrC;AACF;AAKA,eAAe,yBACb,aACA,QAC0B;AAC1B,QAAM,YAA+B;AAAA,IACnC,SAAS,CAAS,cAAc,aAAa,MAAM,CAAC;AAAA,IACpD,OAAO;AAAA,MACL,eAAe;AAAA,QACb,OAAO,YAAY,OAA+B,CAAC,OAAO,UAAU;AAClE,gBAAM,MAAM,IAAI,IAAI,MAAM;AAC1B,iBAAO;AAAA,QACT,GAAG,CAAC,CAAC;AAAA,QACL,QAAQ;AAAA;AAAA,UAEN,gBAAgB;AAAA;AAAA,UAEhB,gBAAgB;AAAA;AAAA,UAEhB,gBAAgB;AAAA,QAClB;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,QAAM,cAAmB;AAAA,IACvB;AAAA,IACA,OAAO;AAAA,EACT;AAEA,QAAM,SAAS,MAAW,YAAM,WAAW;AAC3C,SAAO;AAAA,IACL;AAAA,IACA,QAAQ,qBAAqB,MAAM;AAAA,EACrC;AACF;AAEA,SAAS,qBACP,QAC2B;AAC3B,MAAI,QAAQ;AAAQ,UAAM,MAAM,uCAAuC;AACvE,MAAI,MAAM,QAAQ,MAAM;AAAG,WAAO,OAAO,QAAQ,CAAC,EAAE,OAAO,MAAM,MAAM;AACvE,SAAO,OAAO;AAChB;AAEA,eAAe,oBACb,QACsC;AACtC,QAAM,eAA4C,CAAC;AACnD,MAAI,CAAE,MAAM,iBAAAC,QAAG,OAAO,OAAO,SAAS;AAAI,WAAO;AAEjD,QAAM,QAAQ,UAAM,kBAAAC,SAAK,QAAQ,EAAE,KAAK,OAAO,UAAU,CAAC;AAE1D,aAAW,QAAQ,OAAO;AACxB,UAAM,cAAU,sBAAQ,OAAO,WAAW,IAAI;AAC9C,UAAM,cAAU,sBAAQ,OAAO,QAAQ,IAAI;AAE3C,UAAM,iBAAAD,QAAG,cAAU,sBAAQ,OAAO,CAAC;AACnC,UAAM,iBAAAA,QAAG,SAAS,SAAS,OAAO;AAClC,iBAAa,KAAK;AAAA,MAChB,MAAM;AAAA,MACN,UAAU;AAAA,MACV,MAAM;AAAA,MACN,oBAAoB;AAAA,MACpB,QAAQ,MAAM,iBAAAA,QAAG,SAAS,OAAO;AAAA,IACnC,CAAC;AAAA,EACH;AAEA,SAAO;AACT;;;AEjJA,IAAAE,mBAAe;AACf,IAAAC,eAAwB;;;ACNjB,IAAM,wBAAN,MAAM,uBAAsB;AAAA,EACjC,OAAe,kBAAsD;AAAA,IACnE,eAAe;AAAA,IACf,cAAc;AAAA,IACd,cAAc;AAAA,EAChB;AAAA,EAEA;AAAA,EAEA,YAAY,KAAc;AACxB,QAAI,KAAK;AACP,YAAM,WAAW,IAAI,MAAM,GAAG,EAAE,IAAI,CAAC,YAAY,QAAQ,KAAK,CAAC;AAC/D,WAAK,OAAO,SAAS,OAAiC,CAAC,MAAM,YAAY;AACvE,cAAM,CAAC,KAAK,GAAG,MAAM,IAAI,QAAQ,MAAM,GAAG,EAAE,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC;AACrE,YAAI;AAAK,eAAK,GAAG,IAAI;AACrB,eAAO;AAAA,MACT,GAAG,CAAC,CAAC;AAAA,IACP,OAAO;AACL,WAAK,OAAO,CAAC;AAAA,IACf;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,cAA4B,WAA4C;AAC1E,UAAM,SAAS,KAAK,KAAK,SAAS,KAAK,CAAC;AACxC,cAAU,QAAQ,CAAC,aAAa;AAC9B,UAAI,CAAC,OAAO,SAAS,QAAQ;AAAG,eAAO,KAAK,QAAQ;AAAA,IACtD,CAAC;AACD,SAAK,KAAK,SAAS,IAAI;AACvB,WAAO;AAAA,EACT;AAAA,EAEA,WAAmB;AACjB,UAAM,aAAa,OAAO,QAAQ,KAAK,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM;AAC9D,YAAM,KAAK,uBAAsB,gBAAgB,CAAC,KAAK;AACvD,YAAM,KAAK,uBAAsB,gBAAgB,CAAC,KAAK;AACvD,aAAO,KAAK;AAAA,IACd,CAAC;AACD,WAAO,WAAW,IAAI,CAAC,UAAU,MAAM,KAAK,EAAE,KAAK,GAAG,CAAC,EAAE,KAAK,IAAI,IAAI;AAAA,EACxE;AACF;;;AD7BA,eAAsB,cACpB,UACA,QACA,QACe;AACf,QAAM,MACJ,OAAO,SAAS,eACZ,KAAK,UAAU,QAAQ,IACvB,KAAK,UAAU,UAAU,MAAM,CAAC;AAEtC,QAAM,iBAAAC,QAAG,UAAU,OAAO,MAAM;AAChC,QAAM,iBAAAA,QAAG,cAAU,sBAAQ,OAAO,QAAQ,eAAe,GAAG,KAAK,OAAO;AAExE,SAAO,aAAa,QAAQ;AAAA,IAC1B,MAAM;AAAA,IACN,UAAU;AAAA,IACV,MAAM;AAAA,IACN,oBAAoB;AAAA,IACpB,QAAQ;AAAA,EACV,CAAC;AACH;AAKA,eAAsB,iBACpB,aACA,aACA,QACwC;AACxC,QAAM,MAAM,MAAM,eAAe,MAAM;AACvC,MAAI,IAAI,WAAW;AACjB,UAAM,MAAM,yCAAyC;AACvD,MAAI,IAAI,QAAQ;AAAM,UAAM,MAAM,sCAAsC;AACxE,MAAI,IAAI,eAAe;AACrB,UAAM,MAAM,6CAA6C;AAE3D,QAAM,WAA0C;AAAA,IAC9C,kBAAkB,OAAO;AAAA,IACzB,MAAM,IAAI;AAAA,IACV,YAAY,IAAI;AAAA,IAChB,SAAS,gBAAgB,IAAI,OAAO;AAAA,IACpC,cAAc,OAAO,YAAY,YAAY,SAAY,IAAI;AAAA,IAC7D,GAAG,OAAO;AAAA,EACZ;AAEA,iBAAe,UAAU,aAAa,aAAa,MAAM;AAEzD,MAAI,OAAO,YAAY;AAAS,kBAAc,UAAU,MAAM;AAE9D,SAAO;AACT;AAOA,eAAe,eAAe,QAAsC;AAClE,SAAO,MAAM,iBAAAA,QAAG,aAAS,sBAAQ,OAAO,MAAM,cAAc,CAAC;AAC/D;AAMA,SAAS,gBAAgB,aAA6B;AAGpD,QAAMC,WAAU,yDAAyD;AAAA,IACvE;AAAA,EACF,IAAI,CAAC;AAEL,MAAIA,YAAW;AACb,UAAM;AAAA,MACJ,yCAAyC;AAAA,IAC3C;AAEF,SAAOA;AACT;AAEA,SAAS,eACP,UACA,aACA,aACA,QACM;AACN,QAAM,gBAAgB,YAAY,OAEhC,CAAC,KAAK,eAAe;AACrB,QAAI,WAAW,IAAI,MAAM,CAAC;AAC1B,QAAI,WAAW,IAAI,GAAG,KAAK,UAAU;AACrC,WAAO;AAAA,EACT,GAAG,CAAC,CAAC;AAEL,QAAM,aAAa,cAAc,YAAY,IAAI,CAAC;AAGlD,QAAM,YAAY,cAAc,WAAW,IAAI,CAAC;AAChD,QAAM,iBAAiB,cAAc,gBAAgB;AAGrD,QAAM,WAAW,cAAc,UAAU,IAAI,CAAC;AAC9C,QAAM,UAAU,cAAc,SAAS,IAAI,CAAC;AAC5C,QAAM,SAAS,cAAc,QAAQ,IAAI,CAAC;AAC1C,QAAM,UAAU,cAAc,SAAS,IAAI,CAAC;AAG5C,QAAM,QAAQ,cAAc,OAAO,IAAI,CAAC;AACxC,QAAM,YAAY,cAAc,SAAS;AACzC,QAAM,aAAa,cAAc,WAAW;AAE5C,MAAI,YAAY;AACd,UAAM,SAAS,wBAAwB,YAAY,OAAO,QAAQ,KAAK;AACvE,QAAI,SAAS,qBAAqB,GAAG;AACnC,eAAS,aAAa;AAAA,QACpB,MAAM,WAAW,QAAQ;AAAA,QACzB,gBAAgB;AAAA,MAClB;AAAA,IACF,OAAO;AACL,eAAS,aAAa;AAAA,QACpB,YAAY,WAAW,QAAQ;AAAA,QAC/B,SAAS,CAAC,MAAM;AAAA,MAClB;AAAA,IACF;AAAA,EACF;AAEA,MAAI,WAAW;AACb,QAAI,OAAO,YAAY,WAAW;AAChC,aAAO,OAAO;AAAA,QACZ;AAAA,MACF;AAAA,IACF,OAAO;AACL,eAAS,yBAAyB,CAAC;AAEnC,eAAS,qBAAqB,YAAY;AAAA,QACxC;AAAA,QACA,OAAO;AAAA,QACP;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,MAAI,SAAS;AACX,QAAI,OAAO,YAAY,WAAW;AAChC,aAAO,OAAO;AAAA,QACZ;AAAA,MACF;AAAA,IACF,OAAO;AACL,eAAS,yBAAyB,CAAC;AAEnC,eAAS,qBAAqB,UAAU;AAAA,QACtC;AAAA,QACA,OAAO;AAAA,QACP;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,MAAI,QAAQ;AACV,aAAS,yBAAyB,CAAC;AACnC,aAAS,qBAAqB,SAAS;AAAA,MACrC;AAAA,MACA,OAAO;AAAA,MACP;AAAA,IACF;AAAA,EACF;AAEA,MAAI,OAAO;AACT,UAAM,gBAAgB;AAAA,MACpB;AAAA,MACA,OAAO;AAAA,MACP;AAAA,IACF;AACA,UAAMC,WAAmC;AAAA,MACvC,cAAc,MAAM,QAAQ;AAAA,MAC5B,eAAe,MAAM,QAAQ;AAAA,IAC/B;AACA,QAAI,SAAS,qBAAqB,GAAG;AACnC,eAAS,SAAS;AAAA,QAChB,GAAGA;AAAA,QACH;AAAA,MACF;AAAA,IACF,OAAO;AACL,eAAS,MAAM,QAAQ,UAAU,gBAAgB,IAAI;AAAA,QACnD,GAAGA;AAAA,QACH;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,MAAI,UAAU;AACZ,aAAS,gBAAgB;AAAA,MACvB;AAAA,MACA,OAAO;AAAA,MACP;AAAA,IACF;AAAA,EACF;AAEA,MAAI,SAAS;AACX,UAAM,OAAO,wBAAwB,SAAS,OAAO,QAAQ,OAAO;AACpE,aAAS,aAAa;AAAA,MACpB,aAAa,QAAQ,QAAQ;AAAA,MAC7B,eACE,OAAO,YAAY,YAAY,QAAQ,QAAQ,eAAe;AAAA,MAChE,cACE,OAAO,YAAY,YAAY,QAAQ,QAAQ,cAAc;AAAA,MAC/D;AAAA,IACF;AAAA,EACF;AAEA,MAAI,WAAW,QAAQ;AACrB,QAAI,OAAO,YAAY,WAAW;AAChC,aAAO,OAAO;AAAA,QACZ;AAAA,MACF;AAAA,IACF,OAAO;AAEL,eAAS,UAAU;AAAA,QACjB,OAAO,UAAU;AAAA,UAAI,CAAC,UACpB,wBAAwB,OAAO,OAAO,QAAQ,OAAO;AAAA,QACvD;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,MAAI,YAAY,QAAQ;AACtB,UAAM,mBACJ,WAAW,KAAK,CAAC,UAAU,MAAM,SAAS,WAAW,KAAK,WAAW,CAAC;AACxE,UAAM,OAAO;AAAA,MACX;AAAA,MACA,OAAO;AAAA,MACP;AAAA,IACF;AAEA,QAAI,OAAO,YAAY,WAAW;AAChC,eAAS,iBAAiB;AAAA;AAAA;AAAA,QAGxB,eAAe;AAAA,MACjB;AAAA,IACF,WAAW,OAAO,oBAAoB,GAAG;AAEvC,eAAS,aAAa;AAAA,QACpB,cAAc;AAAA,MAChB;AAAA,IACF,OAAO;AACL,aAAO,OAAO;AAAA,QACZ;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,MAAI,gBAAgB,QAAQ;AAC1B,QAAI,OAAO,YAAY,SAAS;AAC9B,YAAM,iBACJ,OAAO,oBAAoB,IAAI,gBAAgB;AACjD,YAAM,kBAAkB,IAAI,IAAY,SAAS,cAAc,KAAK,CAAC,CAAC;AACtE,qBAAe,QAAQ,CAAC,WAAW;AACjC,eAAO,QAAQ,QAAQ,QAAQ,CAAC,iBAAiB;AAC/C,0BAAgB,IAAI,YAAY;AAAA,QAClC,CAAC;AAAA,MACH,CAAC;AACD,eAAS,cAAc,IAAI,MAAM,KAAK,eAAe,EAAE,KAAK;AAAA,IAC9D,OAAO;AACL,YAAM,uBAAuB,eAAe,OAAO,CAAC,KAAK,WAAW;AAClE,cAAM,OAAO,KAAK,UAAU,OAAO,OAAO;AAC1C,YAAI,CAAC,IAAI,IAAI,IAAI,GAAG;AAClB,cAAI,IAAI,MAAM,CAAC,MAAM,CAAC;AAAA,QACxB,OAAO;AACL,cAAI,IAAI,IAAI,GAAG,KAAK,MAAM;AAAA,QAC5B;AACA,eAAO;AAAA,MACT,GAAG,oBAAI,IAAuC,CAAC;AAE/C,eAAS,kBAAkB,MAAM,KAAK,qBAAqB,QAAQ,CAAC,EAAE;AAAA,QACpE,CAAC,CAAC,EAAE,OAAO,OAAO;AAAA,UAChB,GAAG,QAAQ,CAAC,EAAE;AAAA;AAAA;AAAA,UAGd,KAAK,yBAAyB,SAAS,WAAW,GAAG,KAAK;AAAA,UAC1D,IAAI,QACD;AAAA,YAAI,CAAC,UACJ,wBAAwB,OAAO,OAAO,QAAQ,KAAK;AAAA,UACrD,EACC,KAAK;AAAA,QACV;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAEA,SAAS,cACP,UACA,QACM;AACN,QAAM,aAAa,UAAU,OAAO,QAAQ,YAAY;AACxD,QAAM,aAAa,OAAO,QAAQ,UAAU;AAE5C,MAAI,SAAS,qBAAqB,GAAG;AACnC,aAAS,qBAAqB,CAAC;AAC/B,QAAI,CAAC,SAAS,iBAAiB,SAAS,UAAU;AAChD,eAAS,iBAAiB,KAAK,UAAU;AAAA,EAC7C,OAAO;AACL,aAAS,gBAAgB,CAAC;AAC1B,QAAI,CAAC,SAAS,YAAY,SAAS,UAAU;AAC3C,eAAS,YAAY,KAAK,UAAU;AAAA,EACxC;AAEA,QAAM,MAAM,IAAI;AAAA,IACd,SAAS,qBAAqB;AAAA;AAAA,MAE1B,SAAS,yBAAyB,mBAClC;AAAA,QACA,SAAS,2BACT;AAAA;AAAA,EACN;AAEA,MAAI,OAAO;AAAQ,QAAI,IAAI,cAAc,UAAU;AAEnD,MAAI,SAAS,qBAAqB,GAAG;AACnC,aAAS,4BAA4B,CAAC;AAEtC,aAAS,wBAAwB,kBAAkB,IAAI,SAAS;AAAA,EAClE,OAAO;AACL,aAAS,0BAA0B,IAAI,SAAS;AAAA,EAClD;AACF;AAMA,SAAS,yBACP,gBACA,aACsB;AACtB,QAAM,MAAgB,CAAC;AAEvB,QAAM,YAAY,YAAY,MAAM,QAAQ,CAAC,SAAS,KAAK,MAAM;AAEjE,iBAAe,QAAQ,CAAC,WAAW;AAEjC,UAAM,aAAa,UAAU;AAAA,MAC3B,CAAC,UAAU,MAAM,aAAa,UAAU,OAAO;AAAA,IACjD;AACA,QAAI;AAAY,UAAI,KAAK,WAAW,QAAQ;AAAA,EAC9C,CAAC;AAED,MAAI,IAAI,SAAS;AAAG,WAAO;AAC3B,SAAO;AACT;;;AEjXA,IAAAC,eAAiD;;;ACA1C,SAAS,WACd,KACA,MACA,MAAM,GACA;AACN,MAAI,KAAK,WAAW;AAAG;AAEvB,QAAM,eAAe,KAAK;AAAA,IACxB,CAAC,QAAQ,QAAQ;AACf,eAAS,IAAI,GAAG,IAAI,KAAK,IAAI,OAAO,QAAQ,IAAI,MAAM,GAAG,KAAK;AAC5D,eAAO,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,GAAG,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC;AAAA,MAC1D;AACA,aAAO;AAAA,IACT;AAAA,IACA,KAAK,CAAC,EAAE,IAAI,CAAC,WAAW,OAAO,MAAM;AAAA,EACvC;AAEA,MAAI,MAAM;AACV,OAAK,QAAQ,CAAC,KAAK,MAAM;AACvB,QAAI,QAAQ,CAAC,KAAK,MAAM;AACtB,aAAO,IAAI,OAAO,aAAa,CAAC,GAAG,GAAG;AACtC,UAAI,MAAM,IAAI,SAAS;AAAG,eAAO,GAAG,OAAO,KAAK,GAAG;AAAA,IACrD,CAAC;AACD,QAAI,MAAM,KAAK,SAAS;AAAG,aAAO;AAAA,EACpC,CAAC;AAED,MAAI,GAAG;AACT;;;ADxBA,wBAAe;AACf,IAAAC,mBAAe;AACf,sBAAyB;AAEzB,eAAsB,kBACpB,QACA,QACA;AACA,QAAM,SAAS;AAAA,IACb,GAAG,OAAO,MAAM,QAAQ,CAAC,SAAS,KAAK,MAAM;AAAA,IAC7C,GAAG,OAAO;AAAA,EACZ,EAAE,KAAK,CAAC,GAAG,MAAM;AACf,UAAM,UACJ,mBAAmB,EAAE,QAAQ,KAC7B,uBAAmB,sBAAQ,EAAE,QAAQ,CAAC,KACtC;AACF,UAAM,UACJ,mBAAmB,EAAE,QAAQ,KAC7B,uBAAmB,sBAAQ,EAAE,QAAQ,CAAC,KACtC;AACF,UAAM,OAAO,UAAU;AACvB,QAAI,SAAS;AAAG,aAAO;AACvB,WAAO,EAAE,SAAS,cAAc,EAAE,QAAQ;AAAA,EAC5C,CAAC;AAED,MAAI,YAAY;AAEhB,QAAM,YAAwB,MAAM,QAAQ;AAAA,IAC1C,OAAO,IAAI,OAAO,OAAO,MAAM;AAC7B,YAAM,OAAO;AAAA,YACX,uBAAS,QAAQ,IAAI,GAAG,OAAO,MAAM,IAAI,aAAAC,QAAK;AAAA,QAC9C,MAAM;AAAA,MACR;AACA,YAAM,UAAM,sBAAQ,MAAM,QAAQ;AAClC,YAAM,SAAS,MAAM,OAAO,SAAS,IAAI,mBAAS;AAClD,YAAM,QAAQ,aAAa,GAAG,KAAK;AACnC,YAAM,QAAQ,MAAM,iBAAAC,QAAG,UAAM,sBAAQ,OAAO,QAAQ,MAAM,QAAQ,CAAC;AACnE,mBAAa,MAAM;AACnB,YAAM,OAAO,WAAO,0BAAS,MAAM,IAAI,CAAC;AACxC,aAAO;AAAA,QACL,GAAG,kBAAAC,QAAG,KAAK,MAAM,KAAK,kBAAAA,QAAG,IAAI,KAAK,CAAC,CAAC,IAAI,MAAM,KAAK,CAAC,CAAC;AAAA,QACrD,kBAAAA,QAAG,IAAI,IAAI;AAAA,MACb;AAAA,IACF,CAAC;AAAA,EACH;AAEA,aAAW,OAAO,OAAO,KAAK,SAAS;AAEvC,SAAO,OAAO;AAAA,IACZ,GAAG,kBAAAA,QAAG,KAAK,oBAAe,KAAK,WAAO,0BAAS,SAAS,CAAC;AAAA,EAC3D;AACF;AAEA,IAAM,sBAAsB;AAC5B,IAAM,qBAA6C;AAAA,EACjD,iBAAiB;AAAA,EACjB,SAAS;AAAA,EACT,OAAO;AAAA,EACP,QAAQ;AACV;AAEA,IAAM,gBAAgB,kBAAAA,QAAG;AACzB,IAAM,eAAyD;AAAA,EAC7D,SAAS,kBAAAA,QAAG;AAAA,EACZ,QAAQ,kBAAAA,QAAG;AAAA,EACX,OAAO,kBAAAA,QAAG;AACZ;;;AEzDA,IAAAC,oBAAe;;;ACZf,IAAAC,mBAA+B;AAE/B,IAAAC,mBAAe;AACf,IAAAC,gBAAkC;AAQlC,eAAsB,iBACpB,aACA,QACe;AACf,QAAM,iBAAAC,QAAG,UAAU,OAAO,QAAQ;AAElC,QAAM,aAAuB,CAAC;AAC9B,aAAW,KAAK,MAAM,4BAA4B,MAAM,CAAC;AACzD,aAAW,KAAK,MAAM,0BAA0B,aAAa,MAAM,CAAC;AACpE,aAAW,KAAK,MAAM,4BAA4B,MAAM,CAAC;AAEzD,QAAM,gBAAgB,MAAM,yBAAyB,YAAY,MAAM;AACvE,QAAM,kBAAkB,eAAe,MAAM;AAC/C;AAEA,eAAe,4BACb,QACiB;AACjB,QAAM,eAAW,uBAAQ,OAAO,UAAU,cAAc;AACxD,QAAMC,gBAAW,iCAAe,mBAAmB,MAAM,CAAC;AAG1D,QAAMA,UAAS,mBAAmB,QAAW,EAAE,KAAK,OAAO,OAAO,CAAC;AAEnE,QAAM,iBAAAD,QAAG;AAAA,IACP;AAAA,IACA,CAAC,uBAAuB,MAAMC,UAAS,yBAAyB,CAAC,EAAE;AAAA,MACjE;AAAA,IACF,IAAI;AAAA,EACN;AAEA,SAAO;AACT;AAEA,eAAe,0BACb,aACA,QACiB;AACjB,QAAM,eAAW,uBAAQ,OAAO,UAAU,YAAY;AAEtD,QAAM,iBAAAD,QAAG;AAAA,IACP;AAAA,IACA;AAAA,MACE;AAAA,MACA;AAAA,MACA,GAAG,YACA,IAAI,CAAC,UAAU;AACd,cAAME,QAAO;AAAA,UACX;AAAA,UACA,OAAO;AAAA,UACP,MAAM,UAAU,SAAS,OAAO,IAAI,UAAU;AAAA,QAChD;AACA,eAAO,SAASA;AAAA,MAClB,CAAC,EACA,KAAK;AAAA,IACV,EAAE,KAAK,IAAI,IAAI;AAAA,EACjB;AAEA,SAAO;AACT;AAEA,eAAe,4BACb,QACiB;AACjB,QAAM,eAAW,uBAAQ,OAAO,UAAU,cAAc;AACxD,QAAM,UAAU,WAAW,MAAM;AACjC,QAAM,iBAAAF,QAAG;AAAA,IACP;AAAA,IACA;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,MACA,GAAG,QAAQ,IAAI,CAAC,WAAW,WAAW,OAAO,SAAS,OAAO,OAAO;AAAA,MACpE;AAAA,IACF,EAAE,KAAK,IAAI,IAAI;AAAA,IACf;AAAA,EACF;AACA,SAAO;AACT;AAEA,eAAe,yBACb,YACA,QACiB;AACjB,QAAM,MAAM,OAAO;AACnB,QAAM,eAAW,uBAAQ,KAAK,UAAU;AACxC,QAAM,iBAAAA,QAAG;AAAA,IACP;AAAA,IACA;AAAA,MACE;AAAA,MACA,GAAG,WAAW;AAAA,QACZ,CAAC,QAAQ,+BAA2B,wBAAS,KAAK,GAAG;AAAA,MACvD;AAAA,IACF,EAAE,KAAK,IAAI,IAAI;AAAA,EACjB;AACA,SAAO;AACT;AAEA,eAAe,kBACb,eACA,QACA;AACA,QAAM,MAAM,OAAO;AACnB,QAAM,iBAAAA,QAAG;AAAA,QACP,uBAAQ,KAAK,eAAe;AAAA,IAC5B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,WAiBG,wBAAS,KAAK,OAAO,IAAI;AAAA,aACvB,wBAAS,KAAK,aAAa;AAAA;AAAA,qBAEnB,wBAAS,KAAK,OAAO,UAAU;AAAA;AAAA,EAE9C;AACF;;;AD7HA,IAAAG,qBAAe;AACf,IAAAC,QAAsB;;;AEftB,sBAAgB;AAKT,SAAS,aACd,WACA,SACiB;AACjB,SAAO,sBAAsB,WAAW,WAAW,OAAO;AAC5D;AAEA,SAAS,sBACP,MACA,WACA,SACiB;AACjB,SAAO,IAAI,QAAQ,CAACC,WAAS,WAAW;AACtC,QAAI,OAAO;AACT,aAAO;AAAA,QACL,MAAM,oCAAoC,aAAa,SAAS;AAAA,MAClE;AACF,UAAM,SAAS,gBAAAC,QAAI,aAAa;AAEhC,WAAO,OAAO,MAAM,MAAM;AACxB,aAAO,KAAK,SAAS,MAAMD,UAAQ,IAAI,CAAC;AACxC,aAAO,MAAM;AAAA,IACf,CAAC;AACD,WAAO;AAAA,MAAG;AAAA,MAAS,MACjBA,UAAQ,sBAAsB,OAAO,GAAG,WAAW,OAAO,CAAC;AAAA,IAC7D;AAAA,EACF,CAAC;AACH;;;AChCO,SAAS,eAAe,UAA0B;AACvD,MAAI,WAAW;AAAK,WAAO,GAAG;AAC9B,MAAI,WAAW;AAAM,WAAO,IAAI,WAAW,KAAK,QAAQ,CAAC;AACzD,MAAI,WAAW;AAAM,WAAO,IAAI,WAAW,KAAK,QAAQ,CAAC;AACzD,SAAO,IAAI,WAAW,KAAK,QAAQ,CAAC;AACtC;;;ACCO,SAAS,qBAAsC;AACpD,MAAI;AAEJ,SAAO;AAAA,IACL,MAAM,YAAY,QAAQ;AACxB,UAAI,OAAO,YAAY,UAAU;AAC/B,eAAO,OAAO,KAAK,mCAAmC;AACtD;AAAA,MACF;AAGA,YAAM,eAAe,MAAM,OAAO,qBAAqB;AACvD,mBAAa,cAAc,QAAQ,CAAC,EAAE,OAAO,KAAK,KAAK,MAAM;AAC3D,YAAI,SAAS;AAAiB,iBAAO,OAAO,MAAM,MAAM,GAAG;AAC3D,YAAI,SAAS;AAAgB,iBAAO,OAAO,KAAK,GAAG;AAAA,MACrD;AAEA,YAAM,gBAAgB,OAAO,aAAa;AAC1C,YAAM,aAAa;AAAA,QACjB,SAAS,eAAe;AAAA,QACxB,UAAU,eAAe;AAAA,QACzB,UAAU,eAAe;AAAA,QACzB,GAAI,OAAO,YAAY,YACnB;AAAA,UACE,SAAS,eAAe,UAAU;AAAA,UAClC,gBAAgB,eAAe;AAAA,UAC/B,OAAO,eAAe;AAAA,UACtB,MAAM,eAAe;AAAA,QACvB,IACA;AAAA,UACE,gBAAgB,eAAe,WAAW,OAAO,OAAO;AAAA,UACxD,iBAAiB,eAAe;AAAA,UAChC,MAAM,eAAe;AAAA,QACvB;AAAA,MACN;AAEA,YAAM,cAAc;AAAA,QAClB,GAAG;AAAA,QACH,QAAQ,OAAO,YAAY,YAAY,oBAAoB;AAAA,QAC3D,WAAW,OAAO;AAAA;AAAA,QAElB,UAAU;AAAA,QACV,SAAS;AAAA,MACX;AACA,YAAM,UAAU;AAAA;AAAA,QAEd,mBAAmB;AAAA,MACrB;AACA,aAAO,OAAO,MAAM,mBAAmB,WAAW;AAClD,aAAO,OAAO,MAAM,oBAAoB,OAAO;AAE/C,YAAM,SAAS,MAAM,OAAO,SAAS;AACrC,eAAS,MAAM,OAAO,QAAQ,IAAI,IAAI,aAAa,OAAO;AAAA,IAC5D;AAAA,IAEA,MAAM,eAAe;AACnB,aAAO,MAAM,QAAQ,KAAK;AAAA,IAC5B;AAAA,EACF;AACF;AAGA,IAAM,iBAAiB;AACvB,IAAM,kBAAkB;;;AC5DjB,SAAS,iBAAiB,aAA8C;AAC7E,QAAM,gBAAgD,CAAC;AACvD,QAAM,SAA4B,CAAC;AAEnC,aAAW,SAAS,aAAa;AAC/B,UAAM,QAAQ,wBAAwB,MAAM,IAAI;AAChD,QAAI,UAAU,YAAY;AACxB,aAAO,KAAK,KAAK;AAAA,IACnB,OAAO;AACL,UAAI,aAAa,cAAc,KAAK;AACpC,UAAI,cAAc,MAAM;AACtB,qBAAa,OAAO,KAAK,CAAC,CAAC,IAAI;AAC/B,sBAAc,KAAK,IAAI;AAAA,MACzB;AACA,MAAC,OAAO,UAAU,EAAmB,KAAK,KAAK;AAAA,IACjD;AAAA,EACF;AAEA,SAAO;AACT;AAEA,IAAM,0BAA6D;AAAA,EACjE,SAAS;AAAA,EAET,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,SAAS;AAAA,EACT,UAAU;AAAA,EACV,WAAW;AAAA,EACX,WAAW;AAAA,EACX,iBAAiB;AAAA,EAEjB,YAAY;AAAA,EACZ,kBAAkB;AAAA,EAClB,mBAAmB;AACrB;;;ACtBO,SAAS,iBACd,cACA,eACe;AACf,MAAI,iBAAiB;AAAM,WAAO,EAAE,MAAM,YAAY;AAEtD,QAAM,eAAe,IAAI;AAAA,IACvB,aAAa;AAAA,MAAQ,CAAC,gBACpB,kBAAkB,aAAa,aAAa;AAAA,IAC9C;AAAA,EACF;AACA,MAAI,aAAa,SAAS;AAAG,WAAO,EAAE,MAAM,YAAY;AAExD,QAAM,kBAA+B;AAAA,IACnC,UAAU,cAAc;AAAA,IACxB,OAAO,CAAC;AAAA,IACR,cAAc,CAAC;AAAA,EACjB;AACA,QAAM,gBAA6B;AAAA,IACjC,UAAU,cAAc;AAAA,IACxB,OAAO,CAAC;AAAA,IACR,cAAc,CAAC;AAAA,EACjB;AAEA,aAAW,QAAQ,cAAc,OAAO;AACtC,QAAI,aAAa,IAAI,IAAI,GAAG;AAC1B,oBAAc,MAAM,KAAK,IAAI;AAAA,IAC/B,OAAO;AACL,sBAAgB,MAAM,KAAK,IAAI;AAAA,IACjC;AAAA,EACF;AACA,aAAW,SAAS,cAAc,cAAc;AAC9C,QAAI,aAAa,IAAI,KAAK,GAAG;AAC3B,oBAAc,aAAa,KAAK,KAAK;AAAA,IACvC,OAAO;AACL,sBAAgB,aAAa,KAAK,KAAK;AAAA,IACzC;AAAA,EACF;AAEA,QAAM,oBAAoB,CAAC,aAAa;AAAA,IACtC,CAAC,CAAC,GAAG,IAAI,MAAM,CAAC,KAAK,SAAS,OAAO;AAAA,EACvC;AACA,MAAI,mBAAmB;AACrB,WAAO;AAAA,MACL,MAAM;AAAA,MACN,cAAc;AAAA,MACd,eAAe,cAAc,MAAM,IAAI,CAAC,SAAS,KAAK,WAAW;AAAA,IACnE;AAAA,EACF;AAEA,SAAO;AAAA,IACL,MAAM;AAAA,IACN,cAAc;AAAA,IACd,eAAe,cAAc,MAAM,IAAI,CAAC,SAAS,KAAK,WAAW;AAAA,EACnE;AACF;AAKA,SAAS,kBACP,aACA,eACkB;AAClB,QAAM,UAA4B,CAAC;AACnC,QAAM,cAAc,YAAY,CAAC;AAEjC,QAAM,kBAAkB,CACtB;AAAA;AAAA;AAAA,IAIC,MAAM,SAAS,WAAW,YAAY,SAAS,MAAM,QAAQ;AAAA,IAE7D,MAAM,SAAS,WAAW,MAAM,UAAU,SAAS,WAAW;AAAA;AAEjE,aAAW,QAAQ,cAAc,OAAO;AACtC,UAAM,gBAAgB,KAAK,OAAO,KAAK,CAAC,UAAU,gBAAgB,KAAK,CAAC;AACxE,QAAI;AAAe,cAAQ,KAAK,IAAI;AAAA,EACtC;AAEA,QAAM,gBAAgB,cAAc,aAAa;AAAA,IAAK,CAAC,UACrD,gBAAgB,KAAK;AAAA,EACvB;AACA,MAAI;AAAe,YAAQ,KAAK,aAAa;AAE7C,SAAO;AACT;;;ANxFA,yBAAsB;AACtB,IAAAE,kBAAwB;AACxB,IAAAC,oBAAyB;AAczB,eAAsBC,OAAM,QAA4C;AACtE,QAAM,iBAAiB,MAAM,kBAAkB,QAAQ,OAAO;AAC9D,SAAO,MAAM,cAAc,cAAc;AAC3C;AAEA,eAAsBC,cACpB,QACuB;AACvB,QAAM,OAAO,MAAM,aAAa,KAAM,IAAI;AAC1C,QAAM,WAAW;AACjB,QAAM,SAAS,UAAU,YAAY;AACrC,QAAM,eAAkC;AAAA,IACtC,QAAQ;AAAA,MACN;AAAA,IACF;AAAA,EACF;AACA,MAAI,iBAAiB,MAAM;AAAA,IACpB,kBAAY,cAAc,UAAU,CAAC,CAAC;AAAA,IAC3C;AAAA,EACF;AACA,QAAM,SAAS,mBAAmB;AAElC,MAAI,eAAe;AACnB,MAAI;AACJ,QAAM,mBAAmB,IAAI,yBAAM;AACnC,QAAM,cAAuC,CAAC;AAE9C,QAAM,aAAa,MAAW,mBAAa,eAAe,IAAI;AAC9D,aAAW,QAAQ,GAAG,OAAO,OAAO,OAAOC,OAAM,UAAU;AACzD,QAAI,CAAC,gBAAgBA,MAAK,WAAW,eAAe,UAAU;AAAG;AACjE,gBAAY,KAAK,CAAC,OAAOA,KAAI,CAAC;AAE9B,UAAM,iBAAiB,aAAa,YAAY;AAC9C,YAAM,cAAc,YAAY,OAAO,GAAG,YAAY,MAAM;AAC5D,YAAM,UAAU,iBAAiB,aAAa,aAAa;AAE3D,UAAI,QAAQ,SAAS;AAAa;AAGlC,8BAAQ;AAAA,QACN,YAAY,MAAM,KAAK,IAAI,IAAI,YAAY,IAAI,CAAC,WAAW,OAAO,CAAC,CAAC,CAAC,CAAC,EACnE,IAAI,CAAC,SAAS,mBAAAC,QAAG,QAAI,4BAAS,eAAe,MAAM,IAAI,CAAC,CAAC,EACzD,KAAK,IAAI;AAAA,MACd;AACA,YAAM,eAAe,QAAQ,cAC1B,KAAK,EACL,IAAI,CAAC,UAAU;AACd,eAAO,mBAAAA,QAAG;AAAA,cACR,4BAAS,eAAe,QAAQ,wBAAwB,OAAO,EAAE,CAAC;AAAA,QACpE;AAAA,MACF,CAAC,EACA,KAAK,mBAAAA,QAAG,IAAI,IAAI,CAAC;AAGpB,uBAAiB,MAAM;AAAA,QAChB,kBAAY,cAAc,UAAU,CAAC,CAAC;AAAA,QAC3C;AAAA,MACF;AACA,qBAAe,SAAS;AACxB,YAAM,EAAE,QAAQ,UAAU,IAAI,MAAM;AAAA,QAClC;AAAA;AAAA,QAEA,QAAQ;AAAA,QACR,QAAQ;AAAA,MACV;AACA,sBAAgB;AAGhB,cAAQ,QAAQ,MAAM;AAAA,QACpB,KAAK;AACH,iBAAO,gBAAgB;AACvB,kCAAQ,QAAQ,uBAAuB,cAAc;AACrD;AAAA,QACF,KAAK;AACH,kBAAQ,cAAc,KAAK,EAAE,QAAQ,CAAC,UAAU;AAC9C,kBAAMD,QAAO;AAAA,cACX;AAAA,cACA,eAAe;AAAA,cACf;AAAA,YACF;AACA,mBAAO,WAAWA,KAAI;AAAA,UACxB,CAAC;AACD,kCAAQ,QAAQ,mBAAmB,cAAc;AACjD;AAAA,MACJ;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AACD,QAAM,SAAuB;AAAA,IAC3B,GAAG;AAAA,IACH,MAAM,OAAOE,OAAM,WAAW;AAC5B,YAAM,MAAM,MAAM,WAAW,OAAOA,OAAM,SAAS;AAEnD,UAAI,CAAC,WAAW;AACd,uBAAe,OAAO,QAAQ,wBAAwB,QAAQ;AAE9D,uBAAe,OAAO,KAAK,oBAAoB;AAC/C,cAAM,OAAO,YAAY,cAAc;AACvC,uBAAe,OAAO,QAAQ,SAAS;AAAA,MACzC;AAEA,aAAO;AAAA,IACT;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,iBAAiB,MAAM;AACrB,aAAO,GAAG,KAAK,sBAAsB;AAAA,IACvC;AAAA,IACA,YAAY,CAACF,UAAS;AAGpB,aAAO,GAAG,KAAK,mBAAmBA,KAAI;AAAA,IACxC;AAAA,EACF;AACA,iBAAe,OAAO,KAAK,oBAAoB;AAE/C,iBAAe,SAAS;AACxB,kBAAgB,MAAM,cAAc,cAAc;AAClD,iBAAe;AAEf,SAAO;AACT;AAEA,eAAe,cAAc,QAA8C;AACzE,QAAM,OAAO,OAAO,YAAY,UAAU,kBAAkB;AAC5D,QAAM,SAAS,GAAG,OAAO,aAAa,OAAO;AAC7C,SAAO,OAAO;AAAA,IACZ,GAAG,QAAQ,mBAAAC,QAAG,KAAK,MAAM,SAAS,mBAAAA,QAAG,KAAK,OAAO,IAAI,UAAU,mBAAAA,QAAG;AAAA,MAChE,QAAa;AAAA,IACf;AAAA,EACF;AACA,QAAM,YAAY,KAAK,IAAI;AAG3B,QAAM,kBAAAE,QAAG,GAAG,OAAO,QAAQ,EAAE,WAAW,MAAM,OAAO,KAAK,CAAC;AAC3D,QAAM,kBAAAA,QAAG,UAAU,OAAO,MAAM;AAEhC,QAAM,cAAc,MAAM,gBAAgB,MAAM;AAChD,QAAM,SAAS,iBAAiB,WAAW;AAC3C,QAAM,EAAE,OAAO,IAAI,MAAM,QAAQ,QAAQ,MAAM;AAG/C,SAAO,OAAO;AAAA,IACZ,sBAAsB,eAAe,KAAK,IAAI,IAAI,SAAS;AAAA,EAC7D;AACA,QAAM,kBAAkB,QAAQ,MAAM;AAEtC,SAAO;AACT;AAEA,eAAsB,QACpB,QACA,kBACA,iBAAgD;AAAA,EAC9C,OAAO,CAAC;AAAA,EACR,cAAc,CAAC;AACjB,GAC2E;AAE3E,QAAM,iBAAiB,MAAM,gBAAgB,MAAM;AACnD,QAAM,iBAAiB,gBAAgB,MAAM;AAC7C,QAAM,cAAc,MAAM,iBAAiB,kBAAkB,MAAM;AAEnE,QAAM,WAAW,MAAM,iBAAiB,gBAAgB,aAAa,MAAM;AAC3E,QAAM,SAAsB;AAAA,IAC1B;AAAA,IACA,GAAG;AAAA,EACL;AAGA,QAAM,cAAc,UAAU,QAAQ,MAAM;AAE5C,SAAO;AAAA,IACL,QAAQ;AAAA,MACN;AAAA,MACA,OAAO,CAAC,GAAG,eAAe,OAAO,GAAG,OAAO,KAAK;AAAA,MAChD,cAAc,CAAC,GAAG,eAAe,cAAc,GAAG,OAAO,YAAY;AAAA,IACvE;AAAA,IACA;AAAA,EACF;AACF;;;AO1NA,IAAAC,kBAAwB;;;ACAxB,IAAAC,qBAAe;AAEf,IAAAC,kBAAwB;AAEjB,SAAS,cAAc;AAC5B,UAAQ,IAAI;AACZ,0BAAQ,IAAI,GAAG,mBAAAC,QAAG,KAAK,KAAK,KAAK,mBAAAA,QAAG,KAAK,mBAAAA,QAAG,KAAK,OAAO,CAAC,GAAG;AAC9D;;;ADHO,SAAS,cACd,IACA;AACA,SAAO,UAAU,SAAgB;AAC/B,UAAM,YAAY,KAAK,IAAI;AAC3B,QAAI;AACF,kBAAY;AAEZ,YAAM,UAAU,MAAM,GAAG,GAAG,IAAI;AAEhC,UAAI,CAAC;AACH,gCAAQ;AAAA,UACN,eAAe,eAAe,KAAK,IAAI,IAAI,SAAS;AAAA,QACtD;AAAA,IACJ,SAAS,KAAP;AACA,8BAAQ;AAAA,QACN,wBAAwB,eAAe,KAAK,IAAI,IAAI,SAAS;AAAA,MAC/D;AACA,8BAAQ,MAAM,GAAG;AACjB,cAAQ,KAAK,CAAC;AAAA,IAChB;AAAA,EACF;AACF;;;AEvBO,IAAMC,SAAQ,cAWnB,OAAO,MAAM,UAAU;AACvB,QAAM,OAAO,MAAM,QAAQ;AAC3B,QAAM,YAA8B;AAAA,IAClC;AAAA,IACA;AAAA,IACA,SAAS,MAAM;AAAA,IACf,iBAAiB,MAAM,MAAM,IAAI,MAAM,MAAM,IAAI;AAAA,IACjD,YAAY,MAAM;AAAA,EACpB;AAEA,QAAUA,OAAM,SAAS;AAC3B,CAAC;;;ACtBM,IAAM,MAAM,cAWjB,OAAO,MAAM,UAAU;AACvB,QAAM,OAAO,MAAM,QAAQ;AAC3B,QAAM,YAA8B;AAAA,IAClC;AAAA,IACA;AAAA,IACA,SAAS,MAAM;AAAA,IACf,iBAAiB,MAAM,MAAM,IAAI,MAAM,MAAM,IAAI;AAAA,IACjD,YAAY,MAAM;AAAA,EACpB;AAEA,QAAM,SAAS,MAAUC,cAAa,SAAS;AAC/C,QAAM,OAAO,OAAO,OAAO,IAAI;AAE/B,SAAO;AACT,CAAC;;;AC5BD,IAAAC,kBAAwB;AAGjB,IAAM,OAAO,cAAoC,OAAO,cAAc;AAC3E,0BAAQ,KAAK,2BAA2B;AAC1C,CAAC;;;ACCM,IAAM,UAAU,cAOrB,OAAO,MAAM,UAAU;AACvB,QAAM,YAA8B;AAAA,IAClC;AAAA,IACA,YAAY,MAAM;AAAA,EACpB;AACA,QAAM,SAAS,MAAM,kBAAkB,WAAW,OAAO;AAEzD,SAAO,OAAO,KAAK,qBAAqB;AAExC,QAAM,cAAc,MAAM,gBAAgB,MAAM;AAChD,QAAM,iBAAiB,aAAa,MAAM;AAC5C,CAAC;;;ACxBD,IAAAC,kBAAwB;AAGjB,IAAM,UAAU;AAAA,EACrB,OAAO,MAAW,EAAE,QAAQ,WAAW,MAAW;AAChD,4BAAQ,KAAK,8BAA8B;AAAA,EAC7C;AACF;;;ApCDA,IAAM,UAAM,WAAAC,SAAI,KAAK;AACrB,IAAI,KAAK;AACT,IAAI,QAAQ,OAAO;AAGnB,IACG,QAAQ,UAAU,kBAAkB,EACpC,OAAO,uBAAuB,2BAA2B,EACzD,OAAO,qBAAqB,cAAc,EAC1C,OAAO,2BAA2B,mBAAmB,EACrD,OAAO,SAAS,oBAAoB,EACpC,OAAO,SAAS,oBAAoB,EACpC,OAAgB,GAAG;AAGtB,IACG,QAAQ,gBAAgB,sBAAsB,EAC9C,OAAO,uBAAuB,2BAA2B,EACzD,OAAO,qBAAqB,cAAc,EAC1C,OAAO,2BAA2B,mBAAmB,EACrD,OAAO,SAAS,oBAAoB,EACpC,OAAO,SAAS,oBAAoB,EACpC,OAAgBC,MAAK;AAGxB,IACG,QAAQ,kBAAkB,SAAS,EACnC,OAAO,uBAAuB,2BAA2B,EACzD,OAAgB,OAAO;AAG1B,IAAI,QAAQ,kBAAkB,mBAAmB,EAAE,OAAgB,OAAO;AAG1E,IACG,QAAQ,oBAAoB,0BAA0B,EACtD,OAAgB,IAAI;AAEvB,IAAI,MAAM;",
  "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"]
}

+//# 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/index.ts", "../src/core/utils/arrays.ts", "../src/core/utils/detectDevChanges.ts", "../src/core/build/buildEntrypoints.ts", "../src/core/utils/removeEmptyDirs.ts", "../src/core/build/findEntrypoints.ts", "../src/core/build/generateTypesDir.ts", "../src/core/utils/manifest.ts", "../src/core/utils/ContentSecurityPolicy.ts", "../src/core/build.ts", "../src/core/utils/groupEntrypoints.ts", "../src/core/utils/formatDuration.ts", "../src/core/log/printBuildSummary.ts", "../src/core/log/printTable.ts", "../src/core/server.ts", "../src/core/utils/findOpenPort.ts", "../src/core/runners/createWebExtRunner.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.1.1-alpha1\",\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    \"@webext-core/match-patterns\": \"^1.0.1\",\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.4\",\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 { createUnimport } from 'unimport';\nimport fs from 'fs-extra';\n\nexport async function importTsFile<T>(root: string, path: string): Promise<T> {\n  const unimport = createUnimport({});\n  await unimport.scanImportsFromFile(\n    resolve(root, 'node_modules/wxt/dist/client.js'),\n  );\n  const text = await fs.readFile(path, 'utf-8');\n  const res = await unimport.injectImports(text, path);\n  const transformedText = res.code;\n\n  const jiti = createJITI(__filename, {\n    cache: false,\n    esmResolve: true,\n    interopDefault: true,\n    alias: {\n      'webextension-polyfill': 'wxt',\n    },\n\n    transform(opts) {\n      if (opts.filename === path) opts.source = transformedText;\n\n      // Remove CSS imports from the source code - Jiti can't handle them.\n      opts.source = opts.source.replace(/^import ['\"].*\\.css['\"];?$/gm, '');\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 { BuildOutput, WxtDevServer, InlineConfig } from './core/types';\nimport { getInternalConfig } from './core/utils/getInternalConfig';\nimport pc from 'picocolors';\nimport * as vite from 'vite';\nimport { detectDevChanges } from './core/utils/detectDevChanges';\nimport { Mutex } from 'async-mutex';\nimport { consola } from 'consola';\nimport { relative } from 'node:path';\nimport { getEntrypointOutputFile } from './core/utils/entrypoints';\nimport { buildInternal, rebuild } from './core/build';\nimport {\n  getServerInfo,\n  reloadContentScripts,\n  reloadHtmlPages,\n  setupServer,\n} from './core/server';\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 serverInfo = await getServerInfo();\n\n  const getLatestInternalConfig = () => {\n    const viteConfig: vite.InlineConfig = vite.mergeConfig(\n      serverInfo.viteServerConfig,\n      config?.vite ?? {},\n    );\n    return getInternalConfig({ ...config, vite: viteConfig }, 'serve');\n  };\n\n  let internalConfig = await getLatestInternalConfig();\n  const server = await setupServer(serverInfo, internalConfig);\n  internalConfig.server = server;\n\n  const fileChangedMutex = new Mutex();\n  const changeQueue: Array<[string, string]> = [];\n\n  server.ws.on('wxt:background-initialized', () => {\n    // Register content scripts for the first time since they're not listed in the manifest\n    reloadContentScripts(server.currentOutput.steps, internalConfig, server);\n  });\n\n  server.watcher.on('all', async (event, path, _stats) => {\n    if (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, server.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 getLatestInternalConfig();\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      server.currentOutput = newOutput;\n\n      // Perform reloads\n      switch (changes.type) {\n        case 'extension-reload':\n          server.reloadExtension();\n          break;\n        case 'html-reload':\n          reloadHtmlPages(changes.rebuildGroups, server, internalConfig);\n          break;\n        case 'content-script-reload':\n          reloadContentScripts(changes.changedSteps, internalConfig, server);\n          break;\n      }\n      consola.success(`Reloaded: ${rebuiltNames}`);\n    });\n  });\n\n  return server;\n}\n", "/**\n * Checks if `predicate` returns truthy for all elements of the array.\n */\nexport function every<T>(\n  array: T[],\n  predicate: (item: T, index: number) => boolean,\n): boolean {\n  for (let i = 0; i < array.length; i++)\n    if (!predicate(array[i], i)) return false;\n  return true;\n}\n", "import { BuildOutput, BuildStepOutput, EntrypointGroup } from '../types';\nimport * as vite from 'vite';\nimport { every } from './arrays';\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 =\n    changedFiles.length > 0 &&\n    every(changedFiles, ([_, file]) => file.endsWith('.html'));\n  if (isOnlyHtmlChanges) {\n    return {\n      type: 'html-reload',\n      cachedOutput: unchangedOutput,\n      rebuildGroups: changedOutput.steps.map((step) => step.entrypoints),\n    };\n  }\n\n  const isOnlyContentScripts =\n    changedOutput.steps.length > 0 &&\n    every(\n      changedOutput.steps.flatMap((step) => step.entrypoints),\n      (entry) => entry.type === 'content-script',\n    );\n  if (isOnlyContentScripts) {\n    return {\n      type: 'content-script-reload',\n      cachedOutput: unchangedOutput,\n      changedSteps: changedOutput.steps,\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 =\n  | NoChange\n  | HtmlReload\n  | ExtensionReload\n  | ContentScriptReload;\n// | BrowserRestart\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\ninterface ContentScriptReload extends RebuildChange {\n  type: 'content-script-reload';\n  changedSteps: BuildStepOutput[];\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 * 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 { 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 { 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 { 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  if (config.command === 'serve') addDevModePermissions(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    // Don't add content scripts to the manifest in dev mode for MV3 - they're managed and reloaded\n    // at runtime\n    if (config.command === 'serve' && config.manifestVersion === 3) {\n      const hostPermissions = new Set<string>(manifest.host_permissions ?? []);\n      contentScripts.forEach((script) => {\n        script.options.matches.forEach((matchPattern) => {\n          hostPermissions.add(matchPattern);\n        });\n      });\n      hostPermissions.forEach((permission) =>\n        addHostPermission(manifest, permission),\n      );\n    } else {\n      const hashToEntrypointsMap = contentScripts.reduce((map, script) => {\n        const hash = JSON.stringify(script.options);\n        if (map.has(hash)) map.get(hash)?.push(script);\n        else map.set(hash, [script]);\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    addHostPermission(manifest, permission);\n  } else {\n    addPermission(manifest, 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\nfunction addDevModePermissions(\n  manifest: Manifest.WebExtensionManifest,\n  config: InternalConfig,\n) {\n  // For reloading the page\n  addPermission(manifest, 'tabs');\n\n  // For registering content scripts\n  if (config.manifestVersion === 3) addPermission(manifest, 'scripting');\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 */\nexport function 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\nfunction addPermission(\n  manifest: Manifest.WebExtensionManifest,\n  permission: string,\n): void {\n  manifest.permissions ??= [];\n  if (manifest.permissions.includes(permission)) return;\n  manifest.permissions.push(permission);\n}\n\nfunction addHostPermission(\n  manifest: Manifest.WebExtensionManifest,\n  hostPermission: string,\n): void {\n  manifest.host_permissions ??= [];\n  if (manifest.host_permissions.includes(hostPermission)) return;\n  manifest.host_permissions.push(hostPermission);\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 { Manifest } from 'webextension-polyfill';\nimport { BuildOutput } from './types';\nimport { buildEntrypoints } from './build/buildEntrypoints';\nimport { findEntrypoints } from './build/findEntrypoints';\nimport { generateTypesDir } from './build/generateTypesDir';\nimport { InternalConfig, EntrypointGroup } from './types';\nimport { generateMainfest, writeManifest } from './utils/manifest';\nimport pc from 'picocolors';\nimport * as vite from 'vite';\nimport fs from 'fs-extra';\nimport { groupEntrypoints } from './utils/groupEntrypoints';\nimport { formatDuration } from './utils/formatDuration';\nimport { printBuildSummary } from './log/printBuildSummary';\n\n/**\n * Builds the extension based on an internal config.\n *\n * This function:\n * 1. Cleans the output directory\n * 2. Executes the rebuild function with a blank previous output so everything is built (see\n *    `rebuild` for more details)\n * 3. Prints the summary\n */\nexport async function buildInternal(\n  config: InternalConfig,\n): 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\n/**\n * Given a configuration, list of entrypoints, and an existing, partial output, build the\n * entrypoints and merge the new output with the existing output.\n *\n * This function will:\n * 1. Generate the .wxt directory's types\n * 2. Build the `entrypointGroups` (and copies public files)\n * 3. Generate the latest manifest for all entrypoints\n * 4. Write the new manifest to the file system\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  // Update types directory with new files and types\n  const allEntrypoints = await findEntrypoints(config);\n  await generateTypesDir(allEntrypoints, config);\n\n  // Build and merge the outputs\n  const newOutput = await buildEntrypoints(entrypointGroups, config);\n  const mergedOutput: Omit<BuildOutput, 'manifest'> = {\n    steps: [...existingOutput.steps, ...newOutput.steps],\n    publicAssets: [...existingOutput.publicAssets, ...newOutput.publicAssets],\n  };\n\n  const newManifest = await generateMainfest(\n    allEntrypoints,\n    mergedOutput,\n    config,\n  );\n  const finalOutput: BuildOutput = {\n    manifest: newManifest,\n    ...newOutput,\n  };\n\n  // Write manifest\n  await writeManifest(newManifest, finalOutput, config);\n\n  return {\n    output: {\n      manifest: newManifest,\n      steps: [...existingOutput.steps, ...finalOutput.steps],\n      publicAssets: [\n        ...existingOutput.publicAssets,\n        ...finalOutput.publicAssets,\n      ],\n    },\n    manifest: newManifest,\n  };\n}\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", "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 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  BuildStepOutput,\n  EntrypointGroup,\n  InternalConfig,\n  WxtDevServer,\n} from './types';\nimport * as vite from 'vite';\nimport { findOpenPort } from './utils/findOpenPort';\nimport { Manifest } from 'webextension-polyfill';\nimport { getEntrypointBundlePath } from './utils/entrypoints';\nimport { getContentScriptCssFiles } from './utils/manifest';\nimport { createWebExtRunner } from './runners/createWebExtRunner';\nimport { buildInternal } from './build';\n\nexport async function getServerInfo(): Promise<ServerInfo> {\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\n  return {\n    port,\n    hostname,\n    origin,\n    viteServerConfig: serverConfig,\n  };\n}\n\nexport async function setupServer(\n  serverInfo: ServerInfo,\n  config: InternalConfig,\n): Promise<WxtDevServer> {\n  const runner = createWebExtRunner();\n\n  const viteServer = await vite.createServer(\n    vite.mergeConfig(serverInfo, config.vite),\n  );\n\n  const start = async () => {\n    await viteServer.listen(server.port);\n    config.logger.success(`Started dev server @ ${serverInfo.origin}`);\n\n    server.currentOutput = await buildInternal(config);\n    config.logger.info('Opening browser...');\n    await runner.openBrowser(config);\n    config.logger.success('Opened!');\n  };\n\n  const reloadExtension = () => {\n    viteServer.ws.send('wxt:reload-extension');\n  };\n  const reloadPage = (path: string) => {\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    viteServer.ws.send('wxt:reload-page', path);\n  };\n  const reloadContentScript = (contentScript: Manifest.ContentScript) => {\n    viteServer.ws.send('wxt:reload-content-script', contentScript);\n  };\n\n  const server: WxtDevServer = {\n    ...viteServer,\n    start,\n    currentOutput: {\n      manifest: {\n        manifest_version: 3,\n        name: '',\n        version: '',\n      },\n      publicAssets: [],\n      steps: [],\n    },\n    port: serverInfo.port,\n    hostname: serverInfo.hostname,\n    origin: serverInfo.origin,\n    reloadExtension,\n    reloadPage,\n    reloadContentScript,\n  };\n\n  return server;\n}\n\n/**\n * From the server, tell the client to reload content scripts from the provided build step outputs.\n */\nexport function reloadContentScripts(\n  steps: BuildStepOutput[],\n  config: InternalConfig,\n  server: WxtDevServer,\n) {\n  if (config.manifestVersion === 3) {\n    steps.forEach((step) => {\n      const entry = step.entrypoints;\n      if (Array.isArray(entry) || entry.type !== 'content-script') return;\n\n      const js = [getEntrypointBundlePath(entry, config.outDir, '.js')];\n      const css = getContentScriptCssFiles([entry], server.currentOutput);\n\n      server.reloadContentScript({\n        js,\n        css,\n        ...entry.options,\n      });\n    });\n  } else {\n    server.reloadExtension();\n  }\n}\n\nexport function reloadHtmlPages(\n  groups: EntrypointGroup[],\n  server: WxtDevServer,\n  config: InternalConfig,\n) {\n  groups.flat().forEach((entry) => {\n    const path = getEntrypointBundlePath(entry, config.outDir, '.html');\n    server.reloadPage(path);\n  });\n}\n\ninterface ServerInfo {\n  port: number;\n  hostname: string;\n  origin: string;\n  viteServerConfig: vite.InlineConfig;\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", "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 { 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.start();\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", "unimport", "fs", "createJITI", "transform", "path", "import_path", "isOffline", "dns", "import_node_path", "import_fs_extra", "fs", "import_unimport", "unimport", "import_fs_extra", "import_path", "fs", "import_fs_extra", "import_path", "path", "fs", "path", "import_picocolors", "vite", "import_consola", "import_node_path", "vite", "import_fs_extra", "import_path", "fs", "path", "import_fs_extra", "import_path", "fs", "glob", "import_path", "import_fs_extra", "import_linkedom", "import_fast_glob", "glob", "path", "picomatch", "fs", "JSON5", "import_unimport", "import_fs_extra", "import_path", "fs", "unimport", "path", "import_fs_extra", "import_path", "fs", "version", "options", "import_picocolors", "vite", "import_fs_extra", "import_path", "import_fs_extra", "path", "fs", "pc", "pc", "fs", "vite", "resolve", "net", "path", "build", "createServer", "path", "pc", "import_consola", "import_picocolors", "import_consola", "pc", "build", "createServer", "import_consola", "import_consola", "cac", "build"]
}
