wxt 0.16.8 → 0.16.10

package/dist/{index-TYmXqKVq.d.ts → index-v_64CCcw.d.ts}

@@ -97,29 +97,35 @@ interface WxtContentScriptEventMap extends WindowEventMap {
 }
 
 type TargetBrowser = string;
-type ContentScriptDefinition = ContentScriptIsolatedWorldDefinition | ContentScriptMainWorldDefinition;
-interface ContentScriptIsolatedWorldDefinition extends ContentScriptBaseDefinition {
+interface BaseEntrypointOptions {
     /**
-     * See https://developer.chrome.com/docs/extensions/develop/concepts/content-scripts#isolated_world
-     * @default "ISOLATED"
+     * List of target browsers to include this entrypoint in. Defaults to being included in all
+     * builds. Cannot be used with `exclude`. You must choose one of the two options.
+     *
+     * @default undefined
      */
-    world?: 'ISOLATED';
+    include?: TargetBrowser[];
     /**
-     * Main function executed when the content script is loaded.
+     * List of target browsers to exclude this entrypoint from. Cannot be used with `include`. You
+     * must choose one of the two options.
+     *
+     * @default undefined
      */
-    main(ctx: ContentScriptContext): void | Promise<void>;
+    exclude?: TargetBrowser[];
 }
-interface ContentScriptMainWorldDefinition extends ContentScriptBaseDefinition {
-    /**
-     * See https://developer.chrome.com/docs/extensions/develop/concepts/content-scripts#isolated_world
-     */
-    world: 'MAIN';
+interface BackgroundEntrypointOptions extends BaseEntrypointOptions {
+    persistent?: PerBrowserOption<boolean>;
     /**
-     * Main function executed when the content script is loaded.
+     * Set to `"module"` to output the background entrypoint as ESM. ESM outputs can share chunks and
+     * reduce the overall size of the bundled extension.
+     *
+     * When `undefined`, the background is bundled individually into an IIFE format.
+     *
+     * @default undefined
      */
-    main(): void | Promise<void>;
+    type?: PerBrowserOption<'module'>;
 }
-interface ContentScriptBaseDefinition extends ExcludableEntrypoint {
+interface BaseContentScriptEntrypointOptions extends BaseEntrypointOptions {
     matches: PerBrowserOption<Manifest.ContentScript['matches']>;
     /**
      * See https://developer.chrome.com/docs/extensions/mv3/content_scripts/
@@ -165,41 +171,68 @@ interface ContentScriptBaseDefinition extends ExcludableEntrypoint {
      *   onto the page. Use `browser.runtime.getURL("content-scripts/<name>.css")` to get the file's
      *   URL
      * - `"ui"` - Exclude the CSS from the manifest. CSS will be automatically added to your UI when
-     *   calling `createContentScriptUi`
+     *   calling `createShadowRootUi`
      *
      * @default "manifest"
      */
     cssInjectionMode?: PerBrowserOption<'manifest' | 'manual' | 'ui'>;
+    /**
+     * Specify how the content script is registered.
+     *
+     * - `"manifest"`: The content script will be added to the `content_scripts` entry in the
+     *   manifest. This is the normal and most well known way of registering a content script.
+     * - `"runtime"`: The content script's `matches` is added to `host_permissions` and you are
+     *   responsible for using the scripting API to register the content script dynamically at
+     *   runtime.
+     *
+     * @default "manifest"
+     */
+    registration?: PerBrowserOption<'manifest' | 'runtime'>;
 }
-interface BackgroundDefinition extends ExcludableEntrypoint {
-    type?: PerBrowserOption<'module'>;
-    persistent?: PerBrowserOption<boolean>;
-    main(): void;
+interface MainWorldContentScriptEntrypointOptions extends BaseContentScriptEntrypointOptions {
+    /**
+     * See https://developer.chrome.com/docs/extensions/develop/concepts/content-scripts#isolated_world
+     */
+    world: 'MAIN';
 }
-interface UnlistedScriptDefinition extends ExcludableEntrypoint {
+interface IsolatedWorldContentScriptEntrypointOptions extends BaseContentScriptEntrypointOptions {
     /**
-     * Main function executed when the unlisted script is ran.
+     * See https://developer.chrome.com/docs/extensions/develop/concepts/content-scripts#isolated_world
+     * @default "ISOLATED"
+     */
+    world?: 'ISOLATED';
+}
+interface IsolatedWorldContentScriptDefinition extends IsolatedWorldContentScriptEntrypointOptions {
+    /**
+     * Main function executed when the content script is loaded.
+     */
+    main(ctx: ContentScriptContext): void | Promise<void>;
+}
+interface MainWorldContentScriptDefinition extends MainWorldContentScriptEntrypointOptions {
+    /**
+     * Main function executed when the content script is loaded.
      */
     main(): void | Promise<void>;
 }
-type PerBrowserOption<T> = T | {
-    [browser: TargetBrowser]: T;
-};
-interface ExcludableEntrypoint {
+type ContentScriptDefinition = IsolatedWorldContentScriptDefinition | MainWorldContentScriptDefinition;
+interface BackgroundDefinition extends BackgroundEntrypointOptions {
     /**
-     * List of target browsers to include this entrypoint in. Defaults to being included in all
-     * builds. Cannot be used with `exclude`. You must choose one of the two options.
-     *
-     * @default undefined
+     * Main function executed when the background script is started. Cannot be async.
      */
-    include?: TargetBrowser[];
+    main(): void;
+}
+interface UnlistedScriptDefinition extends BaseEntrypointOptions {
     /**
-     * List of target browsers to exclude this entrypoint from. Cannot be used with `include`. You
-     * must choose one of the two options.
-     *
-     * @default undefined
+     * Main function executed when the unlisted script is ran.
      */
-    exclude?: TargetBrowser[];
+    main(): void | Promise<void>;
 }
+/**
+ * Either a single value or a map of different browsers to the value for that browser.
+ */
+type PerBrowserOption<T> = T | PerBrowserMap<T>;
+type PerBrowserMap<T> = {
+    [browser: TargetBrowser]: T;
+};
 
 export { type BackgroundDefinition as B, type ContentScriptDefinition as C, type UnlistedScriptDefinition as U, ContentScriptContext as a };

package/dist/index.cjs

@@ -2652,6 +2652,14 @@ function resolvePerBrowserOption(option, browser) {
     return option[browser];
   return option;
 }
+function resolvePerBrowserOptions(options, browser) {
+  return Object.fromEntries(
+    Object.entries(options).map(([key, value]) => [
+      key,
+      key === "defaultIcon" ? value : resolvePerBrowserOption(value, browser)
+    ])
+  );
+}
 
 // src/core/utils/constants.ts
 var VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";
@@ -2690,6 +2698,8 @@ async function findEntrypoints() {
       switch (type) {
         case "popup":
           return await getPopupEntrypoint(info);
+        case "sidepanel":
+          return await getSidepanelEntrypoint(info);
         case "options":
           return await getOptionsEntrypoint(info);
         case "background":
@@ -2800,100 +2810,66 @@ function preventNoEntrypoints(files) {
     throw Error(`No entrypoints found in ${wxt.config.entrypointsDir}`);
   }
 }
-function getHtmlBaseOptions(document) {
-  const options = {};
-  const includeContent = document.querySelector("meta[name='manifest.include']")?.getAttribute("content");
-  if (includeContent) {
-    options.include = import_json5.default.parse(includeContent);
-  }
-  const excludeContent = document.querySelector("meta[name='manifest.exclude']")?.getAttribute("content");
-  if (excludeContent) {
-    options.exclude = import_json5.default.parse(excludeContent);
-  }
-  return options;
-}
-async function getPopupEntrypoint({
-  inputPath,
-  name,
-  skipped
-}) {
-  const content = await import_fs_extra3.default.readFile(inputPath, "utf-8");
-  const { document } = (0, import_linkedom.parseHTML)(content);
-  const options = getHtmlBaseOptions(document);
-  const title = document.querySelector("title");
-  if (title != null)
-    options.defaultTitle = title.textContent ?? void 0;
-  const defaultIconContent = document.querySelector("meta[name='manifest.default_icon']")?.getAttribute("content");
-  if (defaultIconContent) {
-    try {
-      options.defaultIcon = import_json5.default.parse(defaultIconContent);
-    } catch (err) {
-      wxt.logger.fatal(
-        `Failed to parse default_icon meta tag content as JSON5. content=${defaultIconContent}`,
-        err
-      );
+async function getPopupEntrypoint(info) {
+  const options = await getHtmlEntrypointOptions(
+    info,
+    {
+      browserStyle: "browse_style",
+      exclude: "exclude",
+      include: "include",
+      defaultIcon: "default_icon",
+      defaultTitle: "default_title",
+      mv2Key: "type"
+    },
+    {
+      defaultTitle: (document) => document.querySelector("title")?.textContent || void 0
+    },
+    {
+      defaultTitle: (content) => content,
+      mv2Key: (content) => content === "page_action" ? "page_action" : "browser_action"
     }
-  }
-  const mv2TypeContent = document.querySelector("meta[name='manifest.type']")?.getAttribute("content");
-  if (mv2TypeContent) {
-    options.mv2Key = mv2TypeContent === "page_action" ? "page_action" : "browser_action";
-  }
-  const browserStyleContent = document.querySelector("meta[name='manifest.browser_style']")?.getAttribute("content");
-  if (browserStyleContent) {
-    options.browserStyle = browserStyleContent === "true";
-  }
+  );
   return {
     type: "popup",
     name: "popup",
-    options,
-    inputPath,
+    options: resolvePerBrowserOptions(options, wxt.config.browser),
+    inputPath: info.inputPath,
     outputDir: wxt.config.outDir,
-    skipped
+    skipped: info.skipped
   };
 }
-async function getOptionsEntrypoint({
-  inputPath,
-  name,
-  skipped
-}) {
-  const content = await import_fs_extra3.default.readFile(inputPath, "utf-8");
-  const { document } = (0, import_linkedom.parseHTML)(content);
-  const options = getHtmlBaseOptions(document);
-  const openInTabContent = document.querySelector("meta[name='manifest.open_in_tab']")?.getAttribute("content");
-  if (openInTabContent) {
-    options.openInTab = openInTabContent === "true";
-  }
-  const chromeStyleContent = document.querySelector("meta[name='manifest.chrome_style']")?.getAttribute("content");
-  if (chromeStyleContent) {
-    options.chromeStyle = chromeStyleContent === "true";
-  }
-  const browserStyleContent = document.querySelector("meta[name='manifest.browser_style']")?.getAttribute("content");
-  if (browserStyleContent) {
-    options.browserStyle = browserStyleContent === "true";
-  }
+async function getOptionsEntrypoint(info) {
+  const options = await getHtmlEntrypointOptions(
+    info,
+    {
+      browserStyle: "browse_style",
+      chromeStyle: "chrome_style",
+      exclude: "exclude",
+      include: "include",
+      openInTab: "open_in_tab"
+    }
+  );
   return {
     type: "options",
     name: "options",
-    options,
-    inputPath,
+    options: resolvePerBrowserOptions(options, wxt.config.browser),
+    inputPath: info.inputPath,
     outputDir: wxt.config.outDir,
-    skipped
+    skipped: info.skipped
   };
 }
-async function getUnlistedPageEntrypoint({
-  inputPath,
-  name,
-  skipped
-}) {
-  const content = await import_fs_extra3.default.readFile(inputPath, "utf-8");
-  const { document } = (0, import_linkedom.parseHTML)(content);
+async function getUnlistedPageEntrypoint(info) {
+  const options = await getHtmlEntrypointOptions(info, {
+    exclude: "exclude",
+    include: "include"
+  });
   return {
     type: "unlisted-page",
-    name: getEntrypointName(wxt.config.entrypointsDir, inputPath),
-    inputPath,
+    name: info.name,
+    inputPath: info.inputPath,
     outputDir: wxt.config.outDir,
-    options: getHtmlBaseOptions(document),
-    skipped
+    options,
+    skipped: info.skipped
   };
 }
 async function getUnlistedScriptEntrypoint({
@@ -2907,14 +2883,13 @@ async function getUnlistedScriptEntrypoint({
       `${name}: Default export not found, did you forget to call "export default defineUnlistedScript(...)"?`
     );
   }
-  const { main: _, ...moduleOptions } = defaultExport;
-  const options = moduleOptions;
+  const { main: _, ...options } = defaultExport;
   return {
     type: "unlisted-script",
     name,
     inputPath,
     outputDir: wxt.config.outDir,
-    options,
+    options: resolvePerBrowserOptions(options, wxt.config.browser),
     skipped
   };
 }
@@ -2942,14 +2917,7 @@ async function getBackgroundEntrypoint({
     name,
     inputPath,
     outputDir: wxt.config.outDir,
-    options: {
-      ...options,
-      type: resolvePerBrowserOption(options.type, wxt.config.browser),
-      persistent: resolvePerBrowserOption(
-        options.persistent,
-        wxt.config.browser
-      )
-    },
+    options: resolvePerBrowserOptions(options, wxt.config.browser),
     skipped
   };
 }
@@ -2969,10 +2937,58 @@ async function getContentScriptEntrypoint({
     name,
     inputPath,
     outputDir: (0, import_path2.resolve)(wxt.config.outDir, CONTENT_SCRIPT_OUT_DIR),
-    options,
+    options: resolvePerBrowserOptions(options, wxt.config.browser),
     skipped
   };
 }
+async function getSidepanelEntrypoint(info) {
+  const options = await getHtmlEntrypointOptions(
+    info,
+    {
+      browserStyle: "browse_style",
+      exclude: "exclude",
+      include: "include",
+      defaultIcon: "default_icon",
+      defaultTitle: "default_title",
+      openAtInstall: "open_at_install"
+    },
+    {
+      defaultTitle: (document) => document.querySelector("title")?.textContent || void 0
+    },
+    {
+      defaultTitle: (content) => content
+    }
+  );
+  return {
+    type: "sidepanel",
+    name: info.name,
+    options: resolvePerBrowserOptions(options, wxt.config.browser),
+    inputPath: info.inputPath,
+    outputDir: wxt.config.outDir,
+    skipped: info.skipped
+  };
+}
+async function getHtmlEntrypointOptions(info, keyMap, queries, parsers) {
+  const content = await import_fs_extra3.default.readFile(info.inputPath, "utf-8");
+  const { document } = (0, import_linkedom.parseHTML)(content);
+  const options = {};
+  const defaultQuery = (manifestKey) => document.querySelector(`meta[name='manifest.${manifestKey}']`)?.getAttribute("content");
+  Object.entries(keyMap).forEach(([_key, manifestKey]) => {
+    const key = _key;
+    const content2 = queries?.[key] ? queries[key](document, manifestKey) : defaultQuery(manifestKey);
+    if (content2) {
+      try {
+        options[key] = (parsers?.[key] ?? import_json5.default.parse)(content2);
+      } catch (err) {
+        wxt.logger.fatal(
+          `Failed to parse meta tag content. Usually this means you have invalid JSON5 content (content=${content2})`,
+          err
+        );
+      }
+    }
+  });
+  return options;
+}
 var PATH_GLOB_TO_TYPE_MAP = {
   "sandbox.html": "sandbox",
   "sandbox/index.html": "sandbox",
@@ -4081,6 +4097,7 @@ async function resolveConfig(inlineConfig, command, server) {
   let userConfigMetadata;
   if (inlineConfig.configFile !== false) {
     const { config: loadedConfig, ...metadata } = await (0, import_c12.loadConfig)({
+      configFile: inlineConfig.configFile,
       name: "wxt",
       cwd: inlineConfig.root ?? process.cwd(),
       rcFile: false,
@@ -4460,7 +4477,12 @@ function getEsbuildOptions(opts) {
   return {
     format: "cjs",
     loader: isJsx ? "tsx" : "ts",
-    jsx: isJsx ? "automatic" : void 0
+    ...isJsx ? {
+      // `h` and `Fragment` are undefined, but that's OK because JSX is never evaluated while
+      // grabbing the entrypoint's options.
+      jsxFactory: "h",
+      jsxFragment: "Fragment"
+    } : void 0
   };
 }
 
@@ -4579,7 +4601,7 @@ function getChunkSortWeight(filename) {
 var import_picocolors4 = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "0.16.8";
+var version = "0.16.10";
 
 // src/core/utils/log/printHeader.ts
 var import_consola2 = require("consola");
@@ -4636,7 +4658,11 @@ var ContentSecurityPolicy = class _ContentSecurityPolicy {
 
 // src/core/utils/content-scripts.ts
 function hashContentScriptOptions(options) {
-  const simplifiedOptions = mapWxtOptionsToContentScript(options);
+  const simplifiedOptions = mapWxtOptionsToContentScript(
+    options,
+    void 0,
+    void 0
+  );
   Object.keys(simplifiedOptions).forEach((key) => {
     if (simplifiedOptions[key] == null)
       delete simplifiedOptions[key];
@@ -4662,32 +4688,31 @@ function hashContentScriptOptions(options) {
     }).sort((l, r) => l[0].localeCompare(r[0]))
   );
 }
-function mapWxtOptionsToContentScript(options) {
+function mapWxtOptionsToContentScript(options, js, css) {
   return {
-    matches: resolvePerBrowserOption(options.matches, wxt.config.browser),
-    all_frames: resolvePerBrowserOption(options.allFrames, wxt.config.browser),
-    match_about_blank: resolvePerBrowserOption(
-      options.matchAboutBlank,
-      wxt.config.browser
-    ),
-    exclude_globs: resolvePerBrowserOption(
-      options.excludeGlobs,
-      wxt.config.browser
-    ),
-    exclude_matches: resolvePerBrowserOption(
-      options.excludeMatches,
-      wxt.config.browser
-    ),
-    include_globs: resolvePerBrowserOption(
-      options.includeGlobs,
-      wxt.config.browser
-    ),
-    run_at: resolvePerBrowserOption(options.runAt, wxt.config.browser),
+    matches: options.matches,
+    all_frames: options.allFrames,
+    match_about_blank: options.matchAboutBlank,
+    exclude_globs: options.excludeGlobs,
+    exclude_matches: options.excludeMatches,
+    include_globs: options.includeGlobs,
+    run_at: options.runAt,
+    css,
+    js,
     // @ts-expect-error: untyped chrome options
-    match_origin_as_fallback: resolvePerBrowserOption(
-      options.matchOriginAsFallback,
-      wxt.config.browser
-    ),
+    match_origin_as_fallback: options.matchOriginAsFallback,
+    world: options.world
+  };
+}
+function mapWxtOptionsToRegisteredContentScript(options, js, css) {
+  return {
+    allFrames: options.allFrames,
+    excludeMatches: options.excludeMatches,
+    matches: options.matches,
+    runAt: options.runAt,
+    js,
+    css,
+    // @ts-expect-error: Chrome accepts this, not typed in webextension-polyfill (https://developer.chrome.com/docs/extensions/reference/scripting/#type-RegisteredContentScript)
     world: options.world
   };
 }
@@ -4922,9 +4947,11 @@ function addEntrypoints(manifest, entrypoints, buildOutput) {
     );
     if (wxt.config.browser === "firefox") {
       manifest.sidebar_action = {
-        // TODO: Add options to side panel
-        // ...defaultSidepanel.options,
-        default_panel: page
+        default_panel: page,
+        browser_style: defaultSidepanel.options.browserStyle,
+        default_icon: defaultSidepanel.options.defaultIcon,
+        default_title: defaultSidepanel.options.defaultTitle,
+        open_at_install: defaultSidepanel.options.openAtInstall
       };
     } else if (wxt.config.manifestVersion === 3) {
       manifest.side_panel = {
@@ -4939,21 +4966,13 @@ function addEntrypoints(manifest, entrypoints, buildOutput) {
   if (contentScripts?.length) {
     const cssMap = getContentScriptsCssMap(buildOutput, contentScripts);
     if (wxt.config.command === "serve" && wxt.config.manifestVersion === 3) {
-      const hostPermissions = new Set(manifest.host_permissions ?? []);
       contentScripts.forEach((script) => {
-        const matches = resolvePerBrowserOption(
-          script.options.matches,
-          wxt.config.browser
-        );
-        matches.forEach((matchPattern) => {
-          hostPermissions.add(matchPattern);
+        script.options.matches.forEach((matchPattern) => {
+          addHostPermission(manifest, matchPattern);
         });
       });
-      hostPermissions.forEach(
-        (permission) => addHostPermission(manifest, permission)
-      );
     } else {
-      const hashToEntrypointsMap = contentScripts.reduce((map, script) => {
+      const hashToEntrypointsMap = contentScripts.filter((cs) => cs.options.registration !== "runtime").reduce((map, script) => {
         const hash = hashContentScriptOptions(script.options);
         if (map.has(hash))
           map.get(hash)?.push(script);
@@ -4961,19 +4980,34 @@ function addEntrypoints(manifest, entrypoints, buildOutput) {
           map.set(hash, [script]);
         return map;
       }, /* @__PURE__ */ new Map());
-      const newContentScripts = Array.from(hashToEntrypointsMap.entries()).map(
-        ([, scripts]) => ({
-          ...mapWxtOptionsToContentScript(scripts[0].options),
-          css: getContentScriptCssFiles(scripts, cssMap),
-          js: scripts.map(
+      const manifestContentScripts = Array.from(
+        hashToEntrypointsMap.values()
+      ).map(
+        (scripts) => mapWxtOptionsToContentScript(
+          scripts[0].options,
+          scripts.map(
             (entry) => getEntrypointBundlePath(entry, wxt.config.outDir, ".js")
-          )
-        })
+          ),
+          getContentScriptCssFiles(scripts, cssMap)
+        )
       );
-      if (newContentScripts.length >= 0) {
+      if (manifestContentScripts.length >= 0) {
         manifest.content_scripts ??= [];
-        manifest.content_scripts.push(...newContentScripts);
+        manifest.content_scripts.push(...manifestContentScripts);
       }
+      const runtimeContentScripts = contentScripts.filter(
+        (cs) => cs.options.registration === "runtime"
+      );
+      if (runtimeContentScripts.length > 0 && wxt.config.manifestVersion === 2) {
+        throw Error(
+          'Cannot use `registration: "runtime"` with MV2 content scripts, it is a MV3-only feature.'
+        );
+      }
+      runtimeContentScripts.forEach((script) => {
+        script.options.matches.forEach((matchPattern) => {
+          addHostPermission(manifest, matchPattern);
+        });
+      });
     }
     const contentScriptCssResources = getContentScriptCssWebAccessibleResources(
       contentScripts,
@@ -5072,10 +5106,9 @@ function getContentScriptCssWebAccessibleResources(contentScripts, contentScript
       return;
     resources.push({
       resources: [cssFile],
-      matches: resolvePerBrowserOption(
-        script.options.matches,
-        wxt.config.browser
-      ).map((matchPattern) => stripPathFromMatchPattern(matchPattern))
+      matches: script.options.matches.map(
+        (matchPattern) => stripPathFromMatchPattern(matchPattern)
+      )
     });
   });
   return resources;
@@ -5699,25 +5732,9 @@ function reloadContentScripts(steps, server) {
       const js = [getEntrypointBundlePath(entry, wxt.config.outDir, ".js")];
       const cssMap = getContentScriptsCssMap(server.currentOutput, [entry]);
       const css = getContentScriptCssFiles([entry], cssMap);
-      server.reloadContentScript({
-        allFrames: resolvePerBrowserOption(
-          entry.options.allFrames,
-          wxt.config.browser
-        ),
-        excludeMatches: resolvePerBrowserOption(
-          entry.options.excludeMatches,
-          wxt.config.browser
-        ),
-        matches: resolvePerBrowserOption(
-          entry.options.matches,
-          wxt.config.browser
-        ),
-        runAt: resolvePerBrowserOption(entry.options.runAt, wxt.config.browser),
-        // @ts-expect-error: Chrome accepts this, not typed in webextension-polyfill (https://developer.chrome.com/docs/extensions/reference/scripting/#type-RegisteredContentScript)
-        world: resolvePerBrowserOption(entry.options.world, wxt.config.browser),
-        js,
-        css
-      });
+      server.reloadContentScript(
+        mapWxtOptionsToRegisteredContentScript(entry.options, js, css)
+      );
     });
   } else {
     server.reloadExtension();

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { I as InlineConfig, B as BuildOutput, U as UserConfig, E as ExtensionRunnerConfig, W as WxtDevServer } from './index-sl22zA2Z.cjs';
-export { q as BackgroundDefinition, h as BackgroundEntrypoint, g as BaseEntrypoint, f as BaseEntrypointOptions, d as BuildStepOutput, w as ConfigEnv, p as ContentScriptBaseDefinition, m as ContentScriptDefinition, C as ContentScriptEntrypoint, n as ContentScriptIsolatedWorldDefinition, o as ContentScriptMainWorldDefinition, j as Entrypoint, k as EntrypointGroup, J as EslintGlobalsPropValue, K as Eslintrc, t as ExcludableEntrypoint, D as ExtensionRunner, F as FsCache, G as GenericEntrypoint, H as HookResult, L as Logger, l as OnContentScriptStopped, i as OptionsEntrypoint, c as OutputAsset, b as OutputChunk, O as OutputFile, s as PerBrowserOption, P as PopupEntrypoint, R as ResolvedConfig, M as ResolvedEslintrc, S as ServerInfo, T as TargetBrowser, e as TargetManifestVersion, r as UnlistedScriptDefinition, u as UserManifest, v as UserManifestFn, V as VirtualEntrypointType, A as Wxt, x as WxtBuilder, y as WxtBuilderServer, z as WxtHooks, Q as WxtResolvedUnimportOptions, N as WxtUnimportOptions, a as WxtViteConfig } from './index-sl22zA2Z.cjs';
+import { I as InlineConfig, B as BuildOutput, U as UserConfig, E as ExtensionRunnerConfig, W as WxtDevServer } from './index-h54vKikt.cjs';
+export { v as BackgroundDefinition, l as BackgroundEntrypoint, g as BackgroundEntrypointOptions, h as BaseContentScriptEntrypointOptions, k as BaseEntrypoint, f as BaseEntrypointOptions, d as BuildStepOutput, D as ConfigEnv, u as ContentScriptDefinition, C as ContentScriptEntrypoint, p as Entrypoint, q as EntrypointGroup, _ as EslintGlobalsPropValue, $ as Eslintrc, Y as ExtensionRunner, X as FsCache, G as GenericEntrypoint, K as HookResult, s as IsolatedWorldContentScriptDefinition, i as IsolatedWorldContentScriptEntrypointOptions, L as Logger, t as MainWorldContentScriptDefinition, M as MainWorldContentScriptEntrypointOptions, r as OnContentScriptStopped, n as OptionsEntrypoint, j as OptionsEntrypointOptions, c as OutputAsset, b as OutputChunk, O as OutputFile, y as PerBrowserMap, x as PerBrowserOption, m as PopupEntrypoint, P as PopupEntrypointOptions, V as ResolvedConfig, a0 as ResolvedEslintrc, R as ResolvedPerBrowserOptions, J as ServerInfo, o as SidepanelEntrypoint, S as SidepanelEntrypointOptions, T as TargetBrowser, e as TargetManifestVersion, w as UnlistedScriptDefinition, z as UserManifest, A as UserManifestFn, Z as VirtualEntrypointType, Q as Wxt, F as WxtBuilder, H as WxtBuilderServer, N as WxtHooks, a2 as WxtResolvedUnimportOptions, a1 as WxtUnimportOptions, a as WxtViteConfig } from './index-h54vKikt.cjs';
 import 'vite';
 import 'webextension-polyfill';
 import 'unimport';
@@ -64,6 +64,6 @@ declare function prepare(config: InlineConfig): Promise<void>;
  */
 declare function zip(config?: InlineConfig): Promise<string[]>;
 
-var version = "0.16.8";
+var version = "0.16.10";
 
 export { BuildOutput, ExtensionRunnerConfig, InlineConfig, UserConfig, WxtDevServer, build, clean, createServer, defineConfig, defineRunnerConfig, initialize, prepare, version, zip };