wxt 0.20.13 → 0.20.14

package/dist/core/utils/minimatch-multiple.mjs

@@ -1,17 +1,28 @@
 import { minimatch } from "minimatch";
-export function minimatchMultiple(search, patterns, options) {
-  if (patterns == null) return false;
-  const negatePatterns = [];
-  const positivePatterns = [];
-  for (const pattern of patterns) {
-    if (pattern[0] === "!") negatePatterns.push(pattern.slice(1));
-    else positivePatterns.push(pattern);
-  }
-  if (negatePatterns.some(
-    (negatePattern) => minimatch(search, negatePattern, options)
-  ))
-    return false;
-  return positivePatterns.some(
-    (positivePattern) => minimatch(search, positivePattern, options)
-  );
+
+//#region src/core/utils/minimatch-multiple.ts
+/**
+* Run [`minimatch`](https://npmjs.com/package/minimatch) against multiple
+* patterns.
+*
+* Supports negated patterns, the order does not matter. If your `search` string
+* matches any of the negative patterns, it will return `false`.
+*
+* @example
+* ```ts
+* minimatchMultiple('a.json', ['*.json', '!b.json']); // => true
+* minimatchMultiple('b.json', ['*.json', '!b.json']); // => false
+* ```
+*/
+function minimatchMultiple(search, patterns, options) {
+	if (patterns == null) return false;
+	const negatePatterns = [];
+	const positivePatterns = [];
+	for (const pattern of patterns) if (pattern[0] === "!") negatePatterns.push(pattern.slice(1));
+	else positivePatterns.push(pattern);
+	if (negatePatterns.some((negatePattern) => minimatch(search, negatePattern, options))) return false;
+	return positivePatterns.some((positivePattern) => minimatch(search, positivePattern, options));
 }
+
+//#endregion
+export { minimatchMultiple };

package/dist/core/utils/network.mjs

@@ -1,38 +1,35 @@
-import dns from "node:dns";
 import { withTimeout } from "./time.mjs";
+import dns from "node:dns";
+
+//#region src/core/utils/network.ts
 function isOffline() {
-  const isOffline2 = new Promise((res) => {
-    dns.resolve("google.com", (err) => {
-      if (err == null) {
-        res(false);
-      } else {
-        res(true);
-      }
-    });
-  });
-  return withTimeout(isOffline2, 1e3).catch(() => true);
+	return withTimeout(new Promise((res) => {
+		dns.resolve("google.com", (err) => {
+			if (err == null) res(false);
+			else res(true);
+		});
+	}), 1e3).catch(() => true);
 }
-export async function isOnline() {
-  const offline = await isOffline();
-  return !offline;
+async function isOnline() {
+	return !await isOffline();
 }
-export async function fetchCached(url, config) {
-  let content = "";
-  if (await isOnline()) {
-    const res = await fetch(url);
-    if (res.status < 300) {
-      content = await res.text();
-      await config.fsCache.set(url, content);
-    } else {
-      config.logger.debug(
-        `Failed to download "${url}", falling back to cache...`
-      );
-    }
-  }
-  if (!content) content = await config.fsCache.get(url) ?? "";
-  if (!content)
-    throw Error(
-      `Offline and "${url}" has not been cached. Try again when online.`
-    );
-  return content;
+/**
+* Fetches a URL with a simple GET request. Grabs it from cache if it doesn't exist, or throws an
+* error if it can't be resolved via the network or cache.
+*/
+async function fetchCached(url, config) {
+	let content = "";
+	if (await isOnline()) {
+		const res = await fetch(url);
+		if (res.status < 300) {
+			content = await res.text();
+			await config.fsCache.set(url, content);
+		} else config.logger.debug(`Failed to download "${url}", falling back to cache...`);
+	}
+	if (!content) content = await config.fsCache.get(url) ?? "";
+	if (!content) throw Error(`Offline and "${url}" has not been cached. Try again when online.`);
+	return content;
 }
+
+//#endregion
+export { fetchCached };

package/dist/core/utils/number.mjs

@@ -1,4 +1,8 @@
-export function safeStringToNumber(str) {
-  const num = Number(str);
-  return isNaN(num) ? null : num;
+//#region src/core/utils/number.ts
+function safeStringToNumber(str) {
+	const num = Number(str);
+	return isNaN(num) ? null : num;
 }
+
+//#endregion
+export { safeStringToNumber };

package/dist/core/utils/package.mjs

@@ -1,15 +1,22 @@
-import { resolve } from "node:path";
-import fs from "fs-extra";
 import { wxt } from "../wxt.mjs";
-export async function getPackageJson() {
-  const file = resolve(wxt.config.root, "package.json");
-  try {
-    return await fs.readJson(file);
-  } catch (err) {
-    wxt.logger.debug(
-      `Failed to read package.json at: ${file}. Returning undefined.`,
-      err
-    );
-    return {};
-  }
+import fs from "fs-extra";
+import { resolve } from "node:path";
+
+//#region src/core/utils/package.ts
+/**
+* Read the project's package.json.
+*
+* TODO: look in root and up directories until it's found
+*/
+async function getPackageJson() {
+	const file = resolve(wxt.config.root, "package.json");
+	try {
+		return await fs.readJson(file);
+	} catch (err) {
+		wxt.logger.debug(`Failed to read package.json at: ${file}. Returning undefined.`, err);
+		return {};
+	}
 }
+
+//#endregion
+export { getPackageJson };

package/dist/core/utils/paths.mjs

@@ -1,10 +1,29 @@
-import systemPath from "node:path";
+import path from "node:path";
 import normalize from "normalize-path";
-export function normalizePath(path) {
-  return normalize(path);
+
+//#region src/core/utils/paths.ts
+/**
+* Converts system paths to normalized bundler path. On windows and unix, this returns paths with /
+* instead of \.
+*/
+function normalizePath(path) {
+	return normalize(path);
 }
-export function unnormalizePath(path) {
-  return systemPath.normalize(path);
+/**
+* Given a normalized path, convert it to the system path style. On Windows, switch to \, otherwise use /.
+*/
+function unnormalizePath(path$1) {
+	return path.normalize(path$1);
 }
-export const CSS_EXTENSIONS = ["css", "scss", "sass", "less", "styl", "stylus"];
-export const CSS_EXTENSIONS_PATTERN = `+(${CSS_EXTENSIONS.join("|")})`;
+const CSS_EXTENSIONS = [
+	"css",
+	"scss",
+	"sass",
+	"less",
+	"styl",
+	"stylus"
+];
+const CSS_EXTENSIONS_PATTERN = `+(${CSS_EXTENSIONS.join("|")})`;
+
+//#endregion
+export { CSS_EXTENSIONS_PATTERN, normalizePath, unnormalizePath };

package/dist/core/utils/strings.mjs

@@ -1,18 +1,23 @@
 import { camelCase } from "scule";
-export function kebabCaseAlphanumeric(str) {
-  return str.toLowerCase().replace(/[^a-z0-9-\s]/g, "").replace(/\s+/g, "-");
+
+//#region src/core/utils/strings.ts
+function kebabCaseAlphanumeric(str) {
+	return str.toLowerCase().replace(/[^a-z0-9-\s]/g, "").replace(/\s+/g, "-");
 }
-export function safeVarName(str) {
-  const name = camelCase(kebabCaseAlphanumeric(str));
-  if (name.match(/^[a-z]/)) return name;
-  return "_" + name;
+/**
+* Return a safe variable name for a given string.
+*/
+function safeVarName(str) {
+	const name = camelCase(kebabCaseAlphanumeric(str));
+	if (name.match(/^[a-z]/)) return name;
+	return "_" + name;
 }
-export function safeFilename(str) {
-  return kebabCaseAlphanumeric(str);
-}
-export function removeImportStatements(text) {
-  return text.replace(
-    /(import\s?[\s\S]*?from\s?["'][\s\S]*?["'];?|import\s?["'][\s\S]*?["'];?)/gm,
-    ""
-  );
+/**
+* Converts a string to a valid filename (NOT path), stripping out invalid characters.
+*/
+function safeFilename(str) {
+	return kebabCaseAlphanumeric(str);
 }
+
+//#endregion
+export { safeFilename, safeVarName };

package/dist/core/utils/syntax-errors.mjs

@@ -1,20 +1,18 @@
+import { wxt } from "../wxt.mjs";
 import { relative } from "node:path";
 import pc from "picocolors";
-import { wxt } from "../wxt.mjs";
-export function isBabelSyntaxError(error) {
-  return error instanceof SyntaxError && error.code === "BABEL_PARSER_SYNTAX_ERROR";
+
+//#region src/core/utils/syntax-errors.ts
+function isBabelSyntaxError(error) {
+	return error instanceof SyntaxError && error.code === "BABEL_PARSER_SYNTAX_ERROR";
 }
-export function logBabelSyntaxError(error) {
-  let filename = relative(wxt.config.root, error.id);
-  if (filename.startsWith("..")) {
-    filename = error.id;
-  }
-  let message = error.message.replace(
-    /\(\d+:\d+\)$/,
-    `(${filename}:${error.loc.line}:${error.loc.column + 1})`
-  );
-  if (error.frame) {
-    message += "\n\n" + pc.red(error.frame);
-  }
-  wxt.logger.error(message);
+function logBabelSyntaxError(error) {
+	let filename = relative(wxt.config.root, error.id);
+	if (filename.startsWith("..")) filename = error.id;
+	let message = error.message.replace(/\(\d+:\d+\)$/, `(${filename}:${error.loc.line}:${error.loc.column + 1})`);
+	if (error.frame) message += "\n\n" + pc.red(error.frame);
+	wxt.logger.error(message);
 }
+
+//#endregion
+export { isBabelSyntaxError, logBabelSyntaxError };

package/dist/core/utils/time.mjs

@@ -1,17 +1,21 @@
-export 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`;
+//#region src/core/utils/time.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`;
 }
-export function withTimeout(promise, duration) {
-  return new Promise((res, rej) => {
-    const timeout = setTimeout(() => {
-      rej(`Promise timed out after ${duration}ms`);
-    }, duration);
-    promise.then(res).catch(rej).finally(() => clearTimeout(timeout));
-  });
-}
-export function sleep(ms) {
-  return new Promise((res) => setTimeout(res, ms));
+/**
+* Add a timeout to a promise.
+*/
+function withTimeout(promise, duration) {
+	return new Promise((res, rej) => {
+		const timeout = setTimeout(() => {
+			rej(`Promise timed out after ${duration}ms`);
+		}, duration);
+		promise.then(res).catch(rej).finally(() => clearTimeout(timeout));
+	});
 }
+
+//#endregion
+export { formatDuration, withTimeout };

package/dist/core/utils/transform.mjs

@@ -1,178 +1,147 @@
 import { parseModule } from "magicast";
-export function removeMainFunctionCode(code) {
-  const mod = parseModule(code);
-  emptyMainFunction(mod);
-  let removedCount = 0;
-  let depth = 0;
-  const maxDepth = 10;
-  do {
-    removedCount = 0;
-    removedCount += removeUnusedTopLevelVariables(mod);
-    removedCount += removeUnusedTopLevelFunctions(mod);
-    removedCount += removeUnusedImports(mod);
-  } while (removedCount > 0 && depth++ <= maxDepth);
-  removeSideEffectImports(mod);
-  return mod.generate();
+
+//#region src/core/utils/transform.ts
+/**
+* Removes any code used at runtime related to an entrypoint's main function.
+* 1. Removes or clears out `main` function from returned object
+* 2. Removes any unused functions/variables outside the definition that aren't being called/used
+* 3. Removes unused imports
+* 3. Removes value-less, side-effect only imports (like `import "./styles.css"` or `import "polyfill"`)
+*/
+function removeMainFunctionCode(code) {
+	const mod = parseModule(code);
+	emptyMainFunction(mod);
+	let removedCount = 0;
+	let depth = 0;
+	const maxDepth = 10;
+	do {
+		removedCount = 0;
+		removedCount += removeUnusedTopLevelVariables(mod);
+		removedCount += removeUnusedTopLevelFunctions(mod);
+		removedCount += removeUnusedImports(mod);
+	} while (removedCount > 0 && depth++ <= maxDepth);
+	removeSideEffectImports(mod);
+	return mod.generate();
 }
 function emptyMainFunction(mod) {
-  if (mod.exports?.default?.$type === "function-call") {
-    if (mod.exports.default.$ast?.arguments?.[0]?.body) {
-      delete mod.exports.default.$ast.arguments[0];
-    } else if (mod.exports.default.$ast?.arguments?.[0]?.properties) {
-      mod.exports.default.$ast.arguments[0].properties = mod.exports.default.$ast.arguments[0].properties.filter(
-        (prop) => prop.key.name !== "main"
-      );
-    }
-  }
+	if (mod.exports?.default?.$type === "function-call") {
+		if (mod.exports.default.$ast?.arguments?.[0]?.body) delete mod.exports.default.$ast.arguments[0];
+		else if (mod.exports.default.$ast?.arguments?.[0]?.properties) mod.exports.default.$ast.arguments[0].properties = mod.exports.default.$ast.arguments[0].properties.filter((prop) => prop.key.name !== "main");
+	}
 }
 function removeUnusedTopLevelVariables(mod) {
-  const simpleAst = getSimpleAstJson(mod.$ast);
-  const usedMap = findUsedIdentifiers(simpleAst);
-  let deletedCount = 0;
-  const ast = mod.$ast;
-  const isUsed = (id) => {
-    return id?.type === "Identifier" && usedMap.get(id.name);
-  };
-  const cleanArrayPattern = (pattern) => {
-    const elements = pattern.elements;
-    for (let i = elements.length - 1; i >= 0; i--) {
-      const el = elements[i];
-      if (el?.type === "Identifier" && !isUsed(el)) {
-        elements.splice(i, 1);
-        deletedCount++;
-      }
-    }
-    return elements.length === 0;
-  };
-  const cleanObjectPattern = (pattern) => {
-    const properties = pattern.properties;
-    for (let i = properties.length - 1; i >= 0; i--) {
-      const prop = properties[i];
-      if (prop.type === "Property") {
-        const value = prop.value;
-        if (value.type === "ObjectPattern") {
-          const isEmpty = cleanObjectPattern(value);
-          if (isEmpty) {
-            properties.splice(i, 1);
-          }
-        } else if (value.type === "ArrayPattern") {
-          const isEmpty = cleanArrayPattern(value);
-          if (isEmpty) {
-            properties.splice(i, 1);
-          }
-        } else if (value.type === "Identifier" && !isUsed(value)) {
-          properties.splice(i, 1);
-          deletedCount++;
-        }
-      } else if (prop.type === "RestElement") {
-        const arg = prop.argument;
-        if (arg.type === "Identifier" && !isUsed(arg)) {
-          properties.splice(i, 1);
-          deletedCount++;
-        }
-      }
-    }
-    return properties.length === 0;
-  };
-  for (let i = ast.body.length - 1; i >= 0; i--) {
-    if (ast.body[i].type !== "VariableDeclaration") continue;
-    for (let j = ast.body[i].declarations.length - 1; j >= 0; j--) {
-      const id = ast.body[i].declarations[j].id;
-      let shouldRemove = false;
-      if (id.type === "Identifier") {
-        shouldRemove = !isUsed(id);
-        if (shouldRemove) deletedCount++;
-      } else if (id.type === "ArrayPattern") {
-        shouldRemove = cleanArrayPattern(id);
-      } else if (id.type === "ObjectPattern") {
-        shouldRemove = cleanObjectPattern(id);
-      }
-      if (shouldRemove) {
-        ast.body[i].declarations.splice(j, 1);
-      }
-    }
-    if (ast.body[i].declarations.length === 0) {
-      ast.body.splice(i, 1);
-    }
-  }
-  return deletedCount;
+	const usedMap = findUsedIdentifiers(getSimpleAstJson(mod.$ast));
+	let deletedCount = 0;
+	const ast = mod.$ast;
+	const isUsed = (id) => {
+		return id?.type === "Identifier" && usedMap.get(id.name);
+	};
+	const cleanArrayPattern = (pattern) => {
+		const elements = pattern.elements;
+		for (let i = elements.length - 1; i >= 0; i--) {
+			const el = elements[i];
+			if (el?.type === "Identifier" && !isUsed(el)) {
+				elements.splice(i, 1);
+				deletedCount++;
+			}
+		}
+		return elements.length === 0;
+	};
+	const cleanObjectPattern = (pattern) => {
+		const properties = pattern.properties;
+		for (let i = properties.length - 1; i >= 0; i--) {
+			const prop = properties[i];
+			if (prop.type === "Property") {
+				const value = prop.value;
+				if (value.type === "ObjectPattern") {
+					if (cleanObjectPattern(value)) properties.splice(i, 1);
+				} else if (value.type === "ArrayPattern") {
+					if (cleanArrayPattern(value)) properties.splice(i, 1);
+				} else if (value.type === "Identifier" && !isUsed(value)) {
+					properties.splice(i, 1);
+					deletedCount++;
+				}
+			} else if (prop.type === "RestElement") {
+				const arg = prop.argument;
+				if (arg.type === "Identifier" && !isUsed(arg)) {
+					properties.splice(i, 1);
+					deletedCount++;
+				}
+			}
+		}
+		return properties.length === 0;
+	};
+	for (let i = ast.body.length - 1; i >= 0; i--) {
+		if (ast.body[i].type !== "VariableDeclaration") continue;
+		for (let j = ast.body[i].declarations.length - 1; j >= 0; j--) {
+			const id = ast.body[i].declarations[j].id;
+			let shouldRemove = false;
+			if (id.type === "Identifier") {
+				shouldRemove = !isUsed(id);
+				if (shouldRemove) deletedCount++;
+			} else if (id.type === "ArrayPattern") shouldRemove = cleanArrayPattern(id);
+			else if (id.type === "ObjectPattern") shouldRemove = cleanObjectPattern(id);
+			if (shouldRemove) ast.body[i].declarations.splice(j, 1);
+		}
+		if (ast.body[i].declarations.length === 0) ast.body.splice(i, 1);
+	}
+	return deletedCount;
 }
 function removeUnusedTopLevelFunctions(mod) {
-  const simpleAst = getSimpleAstJson(mod.$ast);
-  const usedMap = findUsedIdentifiers(simpleAst);
-  let deletedCount = 0;
-  const ast = mod.$ast;
-  for (let i = ast.body.length - 1; i >= 0; i--) {
-    if (ast.body[i].type === "FunctionDeclaration" && !usedMap.get(ast.body[i].id.name)) {
-      ast.body.splice(i, 1);
-      deletedCount++;
-    }
-  }
-  return deletedCount;
+	const usedMap = findUsedIdentifiers(getSimpleAstJson(mod.$ast));
+	let deletedCount = 0;
+	const ast = mod.$ast;
+	for (let i = ast.body.length - 1; i >= 0; i--) if (ast.body[i].type === "FunctionDeclaration" && !usedMap.get(ast.body[i].id.name)) {
+		ast.body.splice(i, 1);
+		deletedCount++;
+	}
+	return deletedCount;
 }
 function removeUnusedImports(mod) {
-  const simpleAst = getSimpleAstJson(mod.$ast);
-  const usedMap = findUsedIdentifiers(simpleAst);
-  const importSymbols = Object.keys(mod.imports);
-  let deletedCount = 0;
-  importSymbols.forEach((name) => {
-    if (usedMap.get(name)) return;
-    delete mod.imports[name];
-    deletedCount++;
-  });
-  return deletedCount;
+	const usedMap = findUsedIdentifiers(getSimpleAstJson(mod.$ast));
+	const importSymbols = Object.keys(mod.imports);
+	let deletedCount = 0;
+	importSymbols.forEach((name) => {
+		if (usedMap.get(name)) return;
+		delete mod.imports[name];
+		deletedCount++;
+	});
+	return deletedCount;
 }
 function findUsedIdentifiers(simpleAst) {
-  const usedMap = /* @__PURE__ */ new Map();
-  const queue = [simpleAst];
-  for (const item of queue) {
-    if (!item) {
-    } else if (Array.isArray(item)) {
-      queue.push(...item);
-    } else if (item.type === "ImportDeclaration") {
-      continue;
-    } else if (item.type === "Identifier") {
-      usedMap.set(item.name, true);
-    } else if (typeof item === "object") {
-      const filterFns = {
-        // Ignore the function declaration's name
-        FunctionDeclaration: ([key]) => key !== "id",
-        // Ignore object property names
-        ObjectProperty: ([key]) => key !== "key",
-        // Ignore variable declaration's name
-        VariableDeclarator: ([key]) => key !== "id"
-      };
-      queue.push(
-        Object.entries(item).filter(filterFns[item.type] ?? (() => true)).map(([_, value]) => value)
-      );
-    }
-  }
-  return usedMap;
+	const usedMap = /* @__PURE__ */ new Map();
+	const queue = [simpleAst];
+	for (const item of queue) if (!item) {} else if (Array.isArray(item)) queue.push(...item);
+	else if (item.type === "ImportDeclaration") continue;
+	else if (item.type === "Identifier") usedMap.set(item.name, true);
+	else if (typeof item === "object") queue.push(Object.entries(item).filter({
+		FunctionDeclaration: ([key]) => key !== "id",
+		ObjectProperty: ([key]) => key !== "key",
+		VariableDeclarator: ([key]) => key !== "id"
+	}[item.type] ?? (() => true)).map(([_, value]) => value));
+	return usedMap;
 }
 function deleteImportAst(mod, shouldDelete) {
-  const importIndexesToDelete = [];
-  mod.$ast.body.forEach((node, index) => {
-    if (node.type === "ImportDeclaration" && shouldDelete(node)) {
-      importIndexesToDelete.push(index);
-    }
-  });
-  importIndexesToDelete.reverse().forEach((i) => {
-    delete mod.$ast.body[i];
-  });
+	const importIndexesToDelete = [];
+	mod.$ast.body.forEach((node, index) => {
+		if (node.type === "ImportDeclaration" && shouldDelete(node)) importIndexesToDelete.push(index);
+	});
+	importIndexesToDelete.reverse().forEach((i) => {
+		delete mod.$ast.body[i];
+	});
 }
 function removeSideEffectImports(mod) {
-  deleteImportAst(mod, (node) => node.specifiers.length === 0);
+	deleteImportAst(mod, (node) => node.specifiers.length === 0);
 }
+/**
+* Util to get the AST as a simple JSON object, stripping out large objects and file locations to keep it readible
+*/
 function getSimpleAstJson(ast) {
-  if (!ast) {
-    return ast;
-  } else if (Array.isArray(ast)) {
-    return ast.map(getSimpleAstJson);
-  } else if (typeof ast === "object") {
-    return Object.fromEntries(
-      Object.entries(ast).filter(([key]) => key !== "loc" && key !== "start" && key !== "end").map(([key, value]) => [key, getSimpleAstJson(value)])
-    );
-  } else {
-    return ast;
-  }
+	if (!ast) return ast;
+	else if (Array.isArray(ast)) return ast.map(getSimpleAstJson);
+	else if (typeof ast === "object") return Object.fromEntries(Object.entries(ast).filter(([key]) => key !== "loc" && key !== "start" && key !== "end").map(([key, value]) => [key, getSimpleAstJson(value)]));
+	else return ast;
 }
+
+//#endregion
+export { removeMainFunctionCode };

package/dist/core/utils/types.d.mts

@@ -0,0 +1,6 @@
+import { Browser } from "@wxt-dev/browser";
+
+//#region src/core/utils/types.d.ts
+type ManifestContentScript = NonNullable<Browser.runtime.Manifest['content_scripts']>[number];
+//#endregion
+export { ManifestContentScript };