wxt 0.20.13 → 0.20.15

package/dist/core/utils/building/group-entrypoints.mjs

@@ -1,38 +1,45 @@
-export function groupEntrypoints(entrypoints) {
-  const groupIndexMap = {};
-  const groups = [];
-  for (const entry of entrypoints) {
-    if (entry.skipped) continue;
-    let group = ENTRY_TYPE_TO_GROUP_MAP[entry.type];
-    if (entry.type === "background" && entry.options.type === "module") {
-      group = "esm";
-    }
-    if (group === "individual") {
-      groups.push(entry);
-    } else {
-      let groupIndex = groupIndexMap[group];
-      if (groupIndex == null) {
-        groupIndex = groups.push([]) - 1;
-        groupIndexMap[group] = groupIndex;
-      }
-      groups[groupIndex].push(entry);
-    }
-  }
-  return groups;
+//#region src/core/utils/building/group-entrypoints.ts
+/**
+* Entrypoints are built in groups. HTML pages can all be built together in a single step,
+* content scripts must be build individually, etc.
+*
+* This function returns the entrypoints put into these types of groups.
+*/
+function groupEntrypoints(entrypoints) {
+	const groupIndexMap = {};
+	const groups = [];
+	for (const entry of entrypoints) {
+		if (entry.skipped) continue;
+		let group = ENTRY_TYPE_TO_GROUP_MAP[entry.type];
+		if (entry.type === "background" && entry.options.type === "module") group = "esm";
+		if (group === "individual") groups.push(entry);
+		else {
+			let groupIndex = groupIndexMap[group];
+			if (groupIndex == null) {
+				groupIndex = groups.push([]) - 1;
+				groupIndexMap[group] = groupIndex;
+			}
+			groups[groupIndex].push(entry);
+		}
+	}
+	return groups;
 }
 const ENTRY_TYPE_TO_GROUP_MAP = {
-  sandbox: "sandboxed-esm",
-  popup: "esm",
-  newtab: "esm",
-  history: "esm",
-  options: "esm",
-  devtools: "esm",
-  bookmarks: "esm",
-  sidepanel: "esm",
-  "unlisted-page": "esm",
-  background: "individual",
-  "content-script": "individual",
-  "unlisted-script": "individual",
-  "unlisted-style": "individual",
-  "content-script-style": "individual"
+	sandbox: "sandboxed-esm",
+	popup: "esm",
+	newtab: "esm",
+	history: "esm",
+	options: "esm",
+	devtools: "esm",
+	bookmarks: "esm",
+	sidepanel: "esm",
+	"unlisted-page": "esm",
+	background: "individual",
+	"content-script": "individual",
+	"unlisted-script": "individual",
+	"unlisted-style": "individual",
+	"content-script-style": "individual"
 };
+
+//#endregion
+export { groupEntrypoints };

package/dist/core/utils/building/index.mjs

@@ -1,6 +1,8 @@
-export * from "./build-entrypoints.mjs";
-export * from "./detect-dev-changes.mjs";
-export * from "./find-entrypoints.mjs";
-export * from "./group-entrypoints.mjs";
-export * from "./internal-build.mjs";
-export * from "./rebuild.mjs";
+import { buildEntrypoints } from "./build-entrypoints.mjs";
+import { detectDevChanges } from "./detect-dev-changes.mjs";
+import { findEntrypoints } from "./find-entrypoints.mjs";
+import { groupEntrypoints } from "./group-entrypoints.mjs";
+import { rebuild } from "./rebuild.mjs";
+import { internalBuild } from "./internal-build.mjs";
+
+export {  };

package/dist/core/utils/building/internal-build.mjs

@@ -1,112 +1,96 @@
+import { unnormalizePath } from "../paths.mjs";
+import { formatDuration } from "../time.mjs";
+import { wxt } from "../../wxt.mjs";
 import { findEntrypoints } from "./find-entrypoints.mjs";
-import pc from "picocolors";
-import fs from "fs-extra";
 import { groupEntrypoints } from "./group-entrypoints.mjs";
-import { formatDuration } from "../../utils/time.mjs";
-import { printBuildSummary } from "../../utils/log/index.mjs";
-import glob from "fast-glob";
-import { unnormalizePath } from "../../utils/paths.mjs";
+import { printBuildSummary } from "../log/printBuildSummary.mjs";
+import "../log/index.mjs";
 import { rebuild } from "./rebuild.mjs";
+import { ValidationError, validateEntrypoints } from "../validation.mjs";
+import fs from "fs-extra";
+import glob from "fast-glob";
 import { relative } from "node:path";
-import {
-  ValidationError,
-  validateEntrypoints
-} from "../validation.mjs";
-import { wxt } from "../../wxt.mjs";
 import { mergeJsonOutputs } from "@aklinker1/rollup-plugin-visualizer";
+import pc from "picocolors";
 import { isCI } from "ci-info";
-export async function internalBuild() {
-  await wxt.hooks.callHook("build:before", wxt);
-  const verb = wxt.config.command === "serve" ? "Pre-rendering" : "Building";
-  const target = `${wxt.config.browser}-mv${wxt.config.manifestVersion}`;
-  wxt.logger.info(
-    `${verb} ${pc.cyan(target)} for ${pc.cyan(wxt.config.mode)} with ${pc.green(
-      `${wxt.builder.name} ${wxt.builder.version}`
-    )}`
-  );
-  const startTime = Date.now();
-  await fs.rm(wxt.config.outDir, { recursive: true, force: true });
-  await fs.ensureDir(wxt.config.outDir);
-  const entrypoints = await findEntrypoints();
-  wxt.logger.debug("Detected entrypoints:", entrypoints);
-  const validationResults = validateEntrypoints(entrypoints);
-  if (validationResults.errorCount + validationResults.warningCount > 0) {
-    printValidationResults(validationResults);
-  }
-  if (validationResults.errorCount > 0) {
-    throw new ValidationError(`Entrypoint validation failed`, {
-      cause: validationResults
-    });
-  }
-  const groups = groupEntrypoints(entrypoints);
-  await wxt.hooks.callHook("entrypoints:grouped", wxt, groups);
-  const { output, warnings } = await rebuild(entrypoints, groups, void 0);
-  await wxt.hooks.callHook("build:done", wxt, output);
-  await printBuildSummary(
-    wxt.logger.success,
-    `Built extension in ${formatDuration(Date.now() - startTime)}`,
-    output
-  );
-  for (const warning of warnings) {
-    wxt.logger.warn(...warning);
-  }
-  if (wxt.config.analysis.enabled) {
-    await combineAnalysisStats();
-    const statsPath = relative(wxt.config.root, wxt.config.analysis.outputFile);
-    wxt.logger.info(
-      `Analysis complete:
-  ${pc.gray("\u2514\u2500")} ${pc.yellow(statsPath)}`
-    );
-    if (wxt.config.analysis.open) {
-      if (isCI) {
-        wxt.logger.debug(`Skipped opening ${pc.yellow(statsPath)} in CI`);
-      } else {
-        wxt.logger.info(`Opening ${pc.yellow(statsPath)} in browser...`);
-        const { default: open } = await import("open");
-        open(wxt.config.analysis.outputFile);
-      }
-    }
-  }
-  return output;
+
+//#region src/core/utils/building/internal-build.ts
+/**
+* Builds the extension based on an internal config. No more config discovery is performed, the
+* build is based on exactly what is passed in.
+*
+* This function:
+* 1. Cleans the output directory
+* 2. Executes the rebuild function with a blank previous output so everything is built (see
+*    `rebuild` for more details)
+* 3. Prints the summary
+*/
+async function internalBuild() {
+	await wxt.hooks.callHook("build:before", wxt);
+	const verb = wxt.config.command === "serve" ? "Pre-rendering" : "Building";
+	const target = `${wxt.config.browser}-mv${wxt.config.manifestVersion}`;
+	wxt.logger.info(`${verb} ${pc.cyan(target)} for ${pc.cyan(wxt.config.mode)} with ${pc.green(`${wxt.builder.name} ${wxt.builder.version}`)}`);
+	const startTime = Date.now();
+	await fs.rm(wxt.config.outDir, {
+		recursive: true,
+		force: true
+	});
+	await fs.ensureDir(wxt.config.outDir);
+	const entrypoints = await findEntrypoints();
+	wxt.logger.debug("Detected entrypoints:", entrypoints);
+	const validationResults = validateEntrypoints(entrypoints);
+	if (validationResults.errorCount + validationResults.warningCount > 0) printValidationResults(validationResults);
+	if (validationResults.errorCount > 0) throw new ValidationError(`Entrypoint validation failed`, { cause: validationResults });
+	const groups = groupEntrypoints(entrypoints);
+	await wxt.hooks.callHook("entrypoints:grouped", wxt, groups);
+	const { output, warnings } = await rebuild(entrypoints, groups, void 0);
+	await wxt.hooks.callHook("build:done", wxt, output);
+	await printBuildSummary(wxt.logger.success, `Built extension in ${formatDuration(Date.now() - startTime)}`, output);
+	for (const warning of warnings) wxt.logger.warn(...warning);
+	if (wxt.config.analysis.enabled) {
+		await combineAnalysisStats();
+		const statsPath = relative(wxt.config.root, wxt.config.analysis.outputFile);
+		wxt.logger.info(`Analysis complete:\n  ${pc.gray("└─")} ${pc.yellow(statsPath)}`);
+		if (wxt.config.analysis.open) if (isCI) wxt.logger.debug(`Skipped opening ${pc.yellow(statsPath)} in CI`);
+		else {
+			wxt.logger.info(`Opening ${pc.yellow(statsPath)} in browser...`);
+			const { default: open } = await import("open");
+			await open(wxt.config.analysis.outputFile);
+		}
+	}
+	return output;
 }
 async function combineAnalysisStats() {
-  const unixFiles = await glob(`${wxt.config.analysis.outputName}-*.json`, {
-    cwd: wxt.config.analysis.outputDir,
-    absolute: true
-  });
-  const absolutePaths = unixFiles.map(unnormalizePath);
-  await mergeJsonOutputs({
-    inputs: absolutePaths,
-    template: wxt.config.analysis.template,
-    filename: wxt.config.analysis.outputFile
-  });
-  if (!wxt.config.analysis.keepArtifacts) {
-    await Promise.all(absolutePaths.map((statsFile) => fs.remove(statsFile)));
-  }
+	const absolutePaths = (await glob(`${wxt.config.analysis.outputName}-*.json`, {
+		cwd: wxt.config.analysis.outputDir,
+		absolute: true
+	})).map(unnormalizePath);
+	await mergeJsonOutputs({
+		inputs: absolutePaths,
+		template: wxt.config.analysis.template,
+		filename: wxt.config.analysis.outputFile
+	});
+	if (!wxt.config.analysis.keepArtifacts) await Promise.all(absolutePaths.map((statsFile) => fs.remove(statsFile)));
 }
-function printValidationResults({
-  errorCount,
-  errors,
-  warningCount
-}) {
-  (errorCount > 0 ? wxt.logger.error : wxt.logger.warn)(
-    `Entrypoint validation failed: ${errorCount} error${errorCount === 1 ? "" : "s"}, ${warningCount} warning${warningCount === 1 ? "" : "s"}`
-  );
-  const cwd = process.cwd();
-  const entrypointErrors = errors.reduce((map, error) => {
-    const entryErrors = map.get(error.entrypoint) ?? [];
-    entryErrors.push(error);
-    map.set(error.entrypoint, entryErrors);
-    return map;
-  }, /* @__PURE__ */ new Map());
-  Array.from(entrypointErrors.entries()).forEach(([entrypoint, errors2]) => {
-    wxt.logger.log(relative(cwd, entrypoint.inputPath));
-    console.log();
-    errors2.forEach((err) => {
-      const type = err.type === "error" ? pc.red("ERROR") : pc.yellow("WARN");
-      const recieved = pc.dim(`(recieved: ${JSON.stringify(err.value)})`);
-      wxt.logger.log(`  - ${type} ${err.message} ${recieved}`);
-    });
-    console.log();
-  });
+function printValidationResults({ errorCount, errors, warningCount }) {
+	(errorCount > 0 ? wxt.logger.error : wxt.logger.warn)(`Entrypoint validation failed: ${errorCount} error${errorCount === 1 ? "" : "s"}, ${warningCount} warning${warningCount === 1 ? "" : "s"}`);
+	const cwd = process.cwd();
+	const entrypointErrors = errors.reduce((map, error) => {
+		const entryErrors = map.get(error.entrypoint) ?? [];
+		entryErrors.push(error);
+		map.set(error.entrypoint, entryErrors);
+		return map;
+	}, /* @__PURE__ */ new Map());
+	Array.from(entrypointErrors.entries()).forEach(([entrypoint, errors]) => {
+		wxt.logger.log(relative(cwd, entrypoint.inputPath) + "\n");
+		errors.forEach((err) => {
+			const type = err.type === "error" ? pc.red("ERROR") : pc.yellow("WARN");
+			const received = pc.dim(`(received: ${JSON.stringify(err.value)})`);
+			wxt.logger.log(`  - ${type} ${err.message} ${received}`);
+		});
+		console.log();
+	});
 }
+
+//#endregion
+export { internalBuild };

package/dist/core/utils/building/rebuild.mjs

@@ -1,33 +1,53 @@
-import { generateWxtDir } from "../../generate-wxt-dir.mjs";
-import { buildEntrypoints } from "./build-entrypoints.mjs";
-import { generateManifest, writeManifest } from "../../utils/manifest.mjs";
 import { wxt } from "../../wxt.mjs";
-export async function rebuild(allEntrypoints, entrypointGroups, existingOutput = {
-  steps: [],
-  publicAssets: []
+import { buildEntrypoints } from "./build-entrypoints.mjs";
+import { generateWxtDir } from "../../generate-wxt-dir.mjs";
+import { generateManifest, writeManifest } from "../manifest.mjs";
+
+//#region src/core/utils/building/rebuild.ts
+/**
+* Given a configuration, list of entrypoints, and an existing, partial output, build the
+* entrypoints and merge the new output with the existing output.
+*
+* This function will:
+* 1. Generate the .wxt directory's types
+* 2. Build the `entrypointGroups` (and copies public files)
+* 3. Generate the latest manifest for all entrypoints
+* 4. Write the new manifest to the file system
+*
+* @param config Internal config containing all the project information.
+* @param allEntrypoints List of entrypoints used to generate the types inside .wxt directory.
+* @param entrypointGroups The list of entrypoint groups to build.
+* @param existingOutput The previous output to combine the rebuild results into. An emptry array if
+*                       this is the first build.
+*/
+async function rebuild(allEntrypoints, entrypointGroups, existingOutput = {
+	steps: [],
+	publicAssets: []
 }) {
-  const { default: ora } = await import("ora");
-  const spinner = ora(`Preparing...`).start();
-  await generateWxtDir(allEntrypoints).catch((err) => {
-    wxt.logger.warn("Failed to update .wxt directory:", err);
-    if (wxt.config.command === "build") throw err;
-  });
-  const newOutput = await buildEntrypoints(entrypointGroups, spinner);
-  const mergedOutput = {
-    steps: [...existingOutput.steps, ...newOutput.steps],
-    // Do not merge existing because all publicAssets copied everytime
-    publicAssets: newOutput.publicAssets
-  };
-  const { manifest: newManifest, warnings: manifestWarnings } = await generateManifest(allEntrypoints, mergedOutput);
-  const finalOutput = {
-    manifest: newManifest,
-    ...mergedOutput
-  };
-  await writeManifest(newManifest, finalOutput);
-  spinner.clear().stop();
-  return {
-    output: finalOutput,
-    manifest: newManifest,
-    warnings: manifestWarnings
-  };
+	const { default: ora } = await import("ora");
+	const spinner = ora(`Preparing...`).start();
+	await generateWxtDir(allEntrypoints).catch((err) => {
+		wxt.logger.warn("Failed to update .wxt directory:", err);
+		if (wxt.config.command === "build") throw err;
+	});
+	const newOutput = await buildEntrypoints(entrypointGroups, spinner);
+	const mergedOutput = {
+		steps: [...existingOutput.steps, ...newOutput.steps],
+		publicAssets: newOutput.publicAssets
+	};
+	const { manifest: newManifest, warnings: manifestWarnings } = await generateManifest(allEntrypoints, mergedOutput);
+	const finalOutput = {
+		manifest: newManifest,
+		...mergedOutput
+	};
+	await writeManifest(newManifest, finalOutput);
+	spinner.clear().stop();
+	return {
+		output: finalOutput,
+		manifest: newManifest,
+		warnings: manifestWarnings
+	};
 }
+
+//#endregion
+export { rebuild };

package/dist/core/utils/cache.mjs

@@ -1,21 +1,32 @@
+import { writeFileIfDifferent } from "./fs.mjs";
 import fs, { ensureDir } from "fs-extra";
 import { dirname, resolve } from "path";
-import { writeFileIfDifferent } from "./fs.mjs";
-export function createFsCache(wxtDir) {
-  const getPath = (key) => resolve(wxtDir, "cache", encodeURIComponent(key));
-  return {
-    async set(key, value) {
-      const path = getPath(key);
-      await ensureDir(dirname(path));
-      await writeFileIfDifferent(path, value);
-    },
-    async get(key) {
-      const path = getPath(key);
-      try {
-        return await fs.readFile(path, "utf-8");
-      } catch {
-        return void 0;
-      }
-    }
-  };
+
+//#region src/core/utils/cache.ts
+/**
+* A basic file system cache stored at `<srcDir>/.wxt/cache/<key>`. Just caches a string in a
+* file for the given key.
+*
+* @param srcDir Absolute path to source directory. See `InternalConfig.srcDir`
+*/
+function createFsCache(wxtDir) {
+	const getPath = (key) => resolve(wxtDir, "cache", encodeURIComponent(key));
+	return {
+		async set(key, value) {
+			const path = getPath(key);
+			await ensureDir(dirname(path));
+			await writeFileIfDifferent(path, value);
+		},
+		async get(key) {
+			const path = getPath(key);
+			try {
+				return await fs.readFile(path, "utf-8");
+			} catch {
+				return;
+			}
+		}
+	};
 }
+
+//#endregion
+export { createFsCache };

package/dist/core/utils/constants.mjs

@@ -1 +1,9 @@
-export const VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";
+//#region src/core/utils/constants.ts
+/**
+* Module ID used to build the background in dev mode if the extension doesn't include a background
+* script/service worker.
+*/
+const VIRTUAL_NOOP_BACKGROUND_MODULE_ID = "virtual:user-background";
+
+//#endregion
+export { VIRTUAL_NOOP_BACKGROUND_MODULE_ID };

package/dist/core/utils/content-scripts.mjs

@@ -1,59 +1,61 @@
 import { getEntrypointBundlePath } from "./entrypoints.mjs";
-export function hashContentScriptOptions(options) {
-  const simplifiedOptions = mapWxtOptionsToContentScript(
-    options,
-    void 0,
-    void 0
-  );
-  Object.keys(simplifiedOptions).forEach((key) => {
-    if (simplifiedOptions[key] == null) delete simplifiedOptions[key];
-  });
-  const withDefaults = {
-    exclude_globs: [],
-    exclude_matches: [],
-    include_globs: [],
-    match_about_blank: false,
-    run_at: "document_idle",
-    all_frames: false,
-    // @ts-expect-error: Untyped
-    match_origin_as_fallback: false,
-    world: "ISOLATED",
-    ...simplifiedOptions
-  };
-  return JSON.stringify(
-    Object.entries(withDefaults).map(([key, value]) => {
-      if (Array.isArray(value)) return [key, value.sort()];
-      else return [key, value];
-    }).sort((l, r) => l[0].localeCompare(r[0]))
-  );
+
+//#region src/core/utils/content-scripts.ts
+/**
+* Returns a unique and consistent string hash based on a content scripts options.
+*
+* It is able to recognize default values,
+*/
+function hashContentScriptOptions(options) {
+	const simplifiedOptions = mapWxtOptionsToContentScript(options, void 0, void 0);
+	Object.keys(simplifiedOptions).forEach((key) => {
+		if (simplifiedOptions[key] == null) delete simplifiedOptions[key];
+	});
+	const withDefaults = {
+		exclude_globs: [],
+		exclude_matches: [],
+		include_globs: [],
+		match_about_blank: false,
+		run_at: "document_idle",
+		all_frames: false,
+		match_origin_as_fallback: false,
+		world: "ISOLATED",
+		...simplifiedOptions
+	};
+	return JSON.stringify(Object.entries(withDefaults).map(([key, value]) => {
+		if (Array.isArray(value)) return [key, value.sort()];
+		else return [key, value];
+	}).sort((l, r) => l[0].localeCompare(r[0])));
 }
-export function mapWxtOptionsToContentScript(options, js, css) {
-  return {
-    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
-    match_origin_as_fallback: options.matchOriginAsFallback,
-    world: options.world
-  };
+function mapWxtOptionsToContentScript(options, js, css) {
+	return {
+		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,
+		match_origin_as_fallback: options.matchOriginAsFallback,
+		world: options.world
+	};
 }
-export function mapWxtOptionsToRegisteredContentScript(options, js, css) {
-  return {
-    allFrames: options.allFrames,
-    excludeMatches: options.excludeMatches,
-    matches: options.matches,
-    runAt: options.runAt,
-    js,
-    css,
-    world: options.world
-  };
+function mapWxtOptionsToRegisteredContentScript(options, js, css) {
+	return {
+		allFrames: options.allFrames,
+		excludeMatches: options.excludeMatches,
+		matches: options.matches,
+		runAt: options.runAt,
+		js,
+		css,
+		world: options.world
+	};
 }
-export function getContentScriptJs(config, entrypoint) {
-  return [getEntrypointBundlePath(entrypoint, config.outDir, ".js")];
+function getContentScriptJs(config, entrypoint) {
+	return [getEntrypointBundlePath(entrypoint, config.outDir, ".js")];
 }
+
+//#endregion
+export { getContentScriptJs, hashContentScriptOptions, mapWxtOptionsToContentScript, mapWxtOptionsToRegisteredContentScript };

package/dist/core/utils/content-security-policy.mjs

@@ -1,39 +1,36 @@
-export class ContentSecurityPolicy {
-  static DIRECTIVE_ORDER = {
-    "default-src": 0,
-    "script-src": 1,
-    "object-src": 2
-  };
-  data;
-  constructor(csp) {
-    if (csp) {
-      const sections = csp.split(";").map((section) => section.trim());
-      this.data = sections.reduce((data, section) => {
-        const [key, ...values] = section.split(" ").map((item) => item.trim());
-        if (key) data[key] = values;
-        return data;
-      }, {});
-    } else {
-      this.data = {};
-    }
-  }
-  /**
-   * Ensure a set of values are listed under a directive.
-   */
-  add(directive, ...newValues) {
-    const values = this.data[directive] ?? [];
-    newValues.forEach((newValue) => {
-      if (!values.includes(newValue)) values.push(newValue);
-    });
-    this.data[directive] = values;
-    return this;
-  }
-  toString() {
-    const directives = Object.entries(this.data).sort(([l], [r]) => {
-      const lo = ContentSecurityPolicy.DIRECTIVE_ORDER[l] ?? 2;
-      const ro = ContentSecurityPolicy.DIRECTIVE_ORDER[r] ?? 2;
-      return lo - ro;
-    });
-    return directives.map((entry) => entry.flat().join(" ")).join("; ") + ";";
-  }
-}
+//#region src/core/utils/content-security-policy.ts
+var ContentSecurityPolicy = class ContentSecurityPolicy {
+	static DIRECTIVE_ORDER = {
+		"default-src": 0,
+		"script-src": 1,
+		"object-src": 2
+	};
+	data;
+	constructor(csp) {
+		if (csp) this.data = csp.split(";").map((section) => section.trim()).reduce((data, section) => {
+			const [key, ...values] = section.split(" ").map((item) => item.trim());
+			if (key) data[key] = values;
+			return data;
+		}, {});
+		else this.data = {};
+	}
+	/**
+	* Ensure a set of values are listed under a directive.
+	*/
+	add(directive, ...newValues) {
+		const values = this.data[directive] ?? [];
+		newValues.forEach((newValue) => {
+			if (!values.includes(newValue)) values.push(newValue);
+		});
+		this.data[directive] = values;
+		return this;
+	}
+	toString() {
+		return Object.entries(this.data).sort(([l], [r]) => {
+			return (ContentSecurityPolicy.DIRECTIVE_ORDER[l] ?? 2) - (ContentSecurityPolicy.DIRECTIVE_ORDER[r] ?? 2);
+		}).map((entry) => entry.flat().join(" ")).join("; ") + ";";
+	}
+};
+
+//#endregion
+export { ContentSecurityPolicy };