@projectwallace/css-analyzer 9.2.1 → 9.4.0

package/dist/index.js

@@ -0,0 +1,1606 @@
+import { ATTRIBUTE_SELECTOR, AT_RULE, BLOCK, BREAK, CLASS_SELECTOR, COMBINATOR, CONTAINER_QUERY, DECLARATION, DIMENSION, FUNCTION, HASH, IDENTIFIER, ID_SELECTOR, LAYER_NAME, MEDIA_FEATURE, MEDIA_TYPE, NTH_OF_SELECTOR, NTH_SELECTOR, NUMBER, OPERATOR, PSEUDO_CLASS_SELECTOR, PSEUDO_ELEMENT_SELECTOR, SELECTOR, SELECTOR_LIST, SKIP, STYLE_RULE, SUPPORTS_QUERY, TYPE_SELECTOR, URL, is_custom, is_vendor_prefixed, parse, str_equals, str_starts_with, walk } from "@projectwallace/css-parser";
+import { parse_selector } from "@projectwallace/css-parser/parse-selector";
+//#region src/atrules/atrules.ts
+/**
+* Check if an @supports atRule is a browserhack (Wallace parser version)
+* @param node - The Atrule CSSNode from Wallace parser
+*/
+function isSupportsBrowserhack(node, on_hack) {
+	walk(node, function(n) {
+		if (n.type === SUPPORTS_QUERY) {
+			const normalizedPrelude = (n.prelude || n.value || "").toString().toLowerCase().replaceAll(/\s+/g, "");
+			if (normalizedPrelude.includes("-webkit-appearance:none")) {
+				on_hack("-webkit-appearance: none");
+				return BREAK;
+			}
+			if (normalizedPrelude.includes("-moz-appearance:meterbar")) {
+				on_hack("-moz-appearance: meterbar");
+				return BREAK;
+			}
+		}
+	});
+}
+/**
+* Check if a @media atRule is a browserhack (Wallace parser version)
+* @param node - The Atrule CSSNode from Wallace parser
+* @returns true if the atrule is a browserhack
+*/
+function isMediaBrowserhack(node, on_hack) {
+	walk(node, function(n) {
+		if (n.type === MEDIA_TYPE) {
+			const text = n.text || "";
+			if (text.startsWith("\\0")) {
+				on_hack("\\0");
+				return BREAK;
+			}
+			if (text.includes("\\9")) {
+				on_hack("\\9");
+				return BREAK;
+			}
+		}
+		if (n.type === MEDIA_FEATURE) {
+			const name = n.property || "";
+			if (str_equals("-moz-images-in-menus", name)) {
+				on_hack("-moz-images-in-menus");
+				return BREAK;
+			}
+			if (str_equals("min--moz-device-pixel-ratio", name)) {
+				on_hack("min--moz-device-pixel-ratio");
+				return BREAK;
+			}
+			if (str_equals("-ms-high-contrast", name)) {
+				on_hack("-ms-high-contrast");
+				return BREAK;
+			}
+			if (str_equals("min-resolution", name) && n.has_children) {
+				for (const child of n) if (child.type === DIMENSION && child.value === .001 && str_equals("dpcm", child.unit || "")) {
+					on_hack("min-resolution: .001dpcm");
+					return BREAK;
+				}
+			}
+			if (str_equals("-webkit-min-device-pixel-ratio", name) && n.has_children) {
+				for (const child of n) if (child.type === NUMBER && (child.value === 0 || child.value === 1e4)) {
+					on_hack("-webkit-min-device-pixel-ratio");
+					return BREAK;
+				}
+			}
+			if (n.has_children) {
+				for (const child of n) if (child.type === IDENTIFIER && child.text === "\\0") {
+					on_hack("\\0");
+					return BREAK;
+				}
+			}
+		}
+	});
+}
+//#endregion
+//#region src/keyword-set.ts
+/**
+* @description A Set-like construct to search CSS keywords in a case-insensitive way
+*/
+var KeywordSet = class {
+	set;
+	constructor(items) {
+		/** @type {Set<string>} */
+		this.set = new Set(items);
+	}
+	has(item) {
+		return this.set.has(item.toLowerCase());
+	}
+};
+//#endregion
+//#region src/string-utils.ts
+function unquote(str) {
+	return str.replaceAll(/(?:^['"])|(?:['"]$)/g, "");
+}
+/**
+* Case-insensitive compare two character codes
+* @see https://github.com/csstree/csstree/blob/41f276e8862d8223eeaa01a3d113ab70bb13d2d9/lib/tokenizer/utils.js#L22
+*/
+function compareChar(referenceCode, testCode) {
+	if (testCode >= 65 && testCode <= 90) testCode = testCode | 32;
+	return referenceCode === testCode;
+}
+/**
+* Case-insensitive testing whether a string ends with a given substring
+*
+* @example
+* endsWith('test', 'my-test') // true
+* endsWith('test', 'est') // false
+*
+* @param base e.g. '-webkit-transform'
+* @param maybe e.g. 'transform'
+* @returns true if `test` ends with `base`, false otherwise
+*/
+function endsWith(base, maybe) {
+	if (base === maybe) return true;
+	let len = maybe.length;
+	let offset = len - base.length;
+	if (offset < 0) return false;
+	for (let i = len - 1; i >= offset; i--) if (compareChar(base.charCodeAt(i - offset), maybe.charCodeAt(i)) === false) return false;
+	return true;
+}
+//#endregion
+//#region src/selectors/utils.ts
+const PSEUDO_FUNCTIONS = new KeywordSet([
+	"nth-child",
+	"where",
+	"not",
+	"is",
+	"has",
+	"nth-last-child",
+	"matches",
+	"-webkit-any",
+	"-moz-any"
+]);
+function isPrefixed(selector, on_selector) {
+	walk(selector, function(node) {
+		if (node.type === PSEUDO_ELEMENT_SELECTOR || node.type === PSEUDO_CLASS_SELECTOR || node.type === TYPE_SELECTOR) {
+			if (node.is_vendor_prefixed) {
+				let prefix = "";
+				if (node.type === PSEUDO_CLASS_SELECTOR) prefix = ":";
+				else if (node.type === PSEUDO_ELEMENT_SELECTOR) prefix = "::";
+				on_selector(prefix + (node.name || node.text));
+			}
+		}
+	});
+}
+/**
+* Check if a Wallace selector is an accessibility selector (has aria-* or role attribute)
+*/
+function isAccessibility(selector, on_selector) {
+	function normalize(node) {
+		let clone = node.clone();
+		if (clone.value) return "[" + clone.name?.toLowerCase() + clone.attr_operator + "\"" + unquote(clone.value.toString()) + "\"]";
+		return "[" + clone.name?.toLowerCase() + "]";
+	}
+	walk(selector, function(node) {
+		if (node.type === ATTRIBUTE_SELECTOR) {
+			const name = node.name || "";
+			if (str_equals("role", name) || str_starts_with(name, "aria-")) on_selector(normalize(node));
+		}
+	});
+}
+/**
+* Get the Complexity for a Wallace Selector Node
+* @param selector - Wallace CSSNode for a Selector
+* @return The numeric complexity of the Selector
+*/
+function getComplexity(selector) {
+	let complexity = 0;
+	function findSelectors(node, complexities) {
+		walk(node, function(n) {
+			if (n.type === SELECTOR) complexities.push(getComplexity(n));
+		});
+	}
+	walk(selector, function(node) {
+		const type = node.type;
+		if (type === SELECTOR) return;
+		if (type === NTH_SELECTOR) {
+			if (node.text && node.text.trim()) complexity++;
+			return;
+		}
+		complexity++;
+		if (type === PSEUDO_ELEMENT_SELECTOR || type === TYPE_SELECTOR || type === PSEUDO_CLASS_SELECTOR) {
+			if (node.is_vendor_prefixed) complexity++;
+		}
+		if (type === ATTRIBUTE_SELECTOR) {
+			if (node.value) complexity++;
+			return SKIP;
+		}
+		if (type === PSEUDO_CLASS_SELECTOR) {
+			const name = node.name || "";
+			if (PSEUDO_FUNCTIONS.has(name.toLowerCase())) {
+				const childComplexities = [];
+				if (node.has_children) for (const child of node) if (child.type === SELECTOR) childComplexities.push(getComplexity(child));
+				else findSelectors(child, childComplexities);
+				if (childComplexities.length > 0) {
+					for (const c of childComplexities) complexity += c;
+					return SKIP;
+				}
+			}
+		}
+	});
+	return complexity;
+}
+/**
+* Walk a selector node and trigger a callback every time a Combinator was found
+*/
+function getCombinators(selector, onMatch) {
+	walk(selector, function(node) {
+		if (node.type === COMBINATOR) onMatch({
+			name: node.name?.trim() === "" ? " " : node.name,
+			loc: {
+				offset: node.start,
+				line: node.line,
+				column: node.column,
+				length: 1
+			}
+		});
+	});
+}
+//#endregion
+//#region src/selectors/specificity.ts
+function compare(s1, s2) {
+	if (s1[0] === s2[0]) {
+		if (s1[1] === s2[1]) return s1[2] - s2[2];
+		return s1[1] - s2[1];
+	}
+	return s1[0] - s2[0];
+}
+function max(list) {
+	return list.sort(compare).at(-1);
+}
+const calculateForAST = (selectorAST) => {
+	let a = 0;
+	let b = 0;
+	let c = 0;
+	let current = selectorAST.first_child;
+	while (current) {
+		switch (current.type) {
+			case ID_SELECTOR:
+				a += 1;
+				break;
+			case ATTRIBUTE_SELECTOR:
+			case CLASS_SELECTOR:
+				b += 1;
+				break;
+			case PSEUDO_CLASS_SELECTOR:
+				switch (current.name?.toLowerCase()) {
+					case "where": break;
+					case "-webkit-any":
+					case "any":
+						if (current.first_child) b += 1;
+						break;
+					case "-moz-any":
+					case "is":
+					case "matches":
+					case "not":
+					case "has":
+						if (current.has_children) {
+							const childSelectorList = current.first_child;
+							if (childSelectorList?.type === SELECTOR_LIST) {
+								const max1 = max(calculate(childSelectorList));
+								a += max1[0];
+								b += max1[1];
+								c += max1[2];
+							}
+						}
+						break;
+					case "nth-child":
+					case "nth-last-child":
+						b += 1;
+						const nthOf = current.first_child;
+						if (nthOf?.type === NTH_OF_SELECTOR && nthOf.selector) {
+							const max2 = max(calculate(nthOf.selector));
+							a += max2[0];
+							b += max2[1];
+							c += max2[2];
+						}
+						break;
+					case "host-context":
+					case "host":
+						b += 1;
+						const childSelector = current.first_child?.first_child;
+						if (childSelector?.type === SELECTOR) {
+							let childPart = childSelector.first_child;
+							while (childPart) {
+								if (childPart.type === COMBINATOR) break;
+								const partSpecificity = calculateForAST({
+									type_name: "Selector",
+									first_child: childPart,
+									has_children: true
+								});
+								a += partSpecificity[0] ?? 0;
+								b += partSpecificity[1] ?? 0;
+								c += partSpecificity[2] ?? 0;
+								childPart = childPart.next_sibling;
+							}
+						}
+						break;
+					case "after":
+					case "before":
+					case "first-letter":
+					case "first-line":
+						c += 1;
+						break;
+					default:
+						b += 1;
+						break;
+				}
+				break;
+			case PSEUDO_ELEMENT_SELECTOR:
+				switch (current.name?.toLowerCase()) {
+					case "slotted":
+						c += 1;
+						const childSelector = current.first_child?.first_child;
+						if (childSelector?.type === SELECTOR) {
+							let childPart = childSelector.first_child;
+							while (childPart) {
+								if (childPart.type === COMBINATOR) break;
+								const partSpecificity = calculateForAST({
+									type_name: "Selector",
+									first_child: childPart,
+									has_children: true
+								});
+								a += partSpecificity[0] ?? 0;
+								b += partSpecificity[1] ?? 0;
+								c += partSpecificity[2] ?? 0;
+								childPart = childPart.next_sibling;
+							}
+						}
+						break;
+					case "view-transition-group":
+					case "view-transition-image-pair":
+					case "view-transition-old":
+					case "view-transition-new":
+						if (current.first_child?.text === "*") break;
+						c += 1;
+						break;
+					default:
+						c += 1;
+						break;
+				}
+				break;
+			case TYPE_SELECTOR:
+				let typeSelector = current.name ?? "";
+				if (typeSelector.includes("|")) typeSelector = typeSelector.split("|")[1] ?? "";
+				if (typeSelector !== "*") c += 1;
+				break;
+			default: break;
+		}
+		current = current.next_sibling;
+	}
+	return [
+		a,
+		b,
+		c
+	];
+};
+const convertToAST = (source) => {
+	if (typeof source === "string") try {
+		return parse_selector(source);
+	} catch (e) {
+		const message = e instanceof Error ? e.message : String(e);
+		throw new TypeError(`Could not convert passed in source '${source}' to SelectorList: ${message}`);
+	}
+	if (source instanceof Object) {
+		if (source.type === SELECTOR_LIST) return source;
+		throw new TypeError(`Passed in source is an Object but no AST / AST of the type SelectorList`);
+	}
+	throw new TypeError(`Passed in source is not a String nor an Object. I don't know what to do with it.`);
+};
+const calculate = (selector) => {
+	if (!selector) return [];
+	const ast = convertToAST(selector);
+	const specificities = [];
+	let selectorNode = ast.first_child;
+	while (selectorNode) {
+		specificities.push(calculateForAST(selectorNode));
+		selectorNode = selectorNode.next_sibling;
+	}
+	return specificities;
+};
+//#endregion
+//#region src/values/colors.ts
+const namedColors = new KeywordSet([
+	"white",
+	"black",
+	"red",
+	"gray",
+	"silver",
+	"grey",
+	"green",
+	"orange",
+	"blue",
+	"dimgray",
+	"whitesmoke",
+	"lightgray",
+	"lightgrey",
+	"yellow",
+	"gold",
+	"pink",
+	"gainsboro",
+	"magenta",
+	"purple",
+	"darkgray",
+	"navy",
+	"darkred",
+	"teal",
+	"maroon",
+	"darkgrey",
+	"tomato",
+	"darkorange",
+	"brown",
+	"crimson",
+	"lightyellow",
+	"slategray",
+	"salmon",
+	"lightgreen",
+	"lightblue",
+	"orangered",
+	"aliceblue",
+	"dodgerblue",
+	"lime",
+	"darkblue",
+	"darkgoldenrod",
+	"skyblue",
+	"royalblue",
+	"darkgreen",
+	"ivory",
+	"olive",
+	"aqua",
+	"turquoise",
+	"cyan",
+	"khaki",
+	"beige",
+	"snow",
+	"ghostwhite",
+	"limegreen",
+	"coral",
+	"dimgrey",
+	"hotpink",
+	"midnightblue",
+	"firebrick",
+	"indigo",
+	"wheat",
+	"mediumblue",
+	"lightpink",
+	"plum",
+	"azure",
+	"violet",
+	"lavender",
+	"deepskyblue",
+	"darkslategrey",
+	"goldenrod",
+	"cornflowerblue",
+	"lightskyblue",
+	"indianred",
+	"yellowgreen",
+	"saddlebrown",
+	"palegreen",
+	"bisque",
+	"tan",
+	"antiquewhite",
+	"steelblue",
+	"forestgreen",
+	"fuchsia",
+	"mediumaquamarine",
+	"seagreen",
+	"sienna",
+	"deeppink",
+	"mediumseagreen",
+	"peru",
+	"greenyellow",
+	"lightgoldenrodyellow",
+	"orchid",
+	"cadetblue",
+	"navajowhite",
+	"lightsteelblue",
+	"slategrey",
+	"linen",
+	"lightseagreen",
+	"darkcyan",
+	"lightcoral",
+	"aquamarine",
+	"blueviolet",
+	"cornsilk",
+	"lightsalmon",
+	"chocolate",
+	"lightslategray",
+	"floralwhite",
+	"darkturquoise",
+	"darkslategray",
+	"rebeccapurple",
+	"burlywood",
+	"chartreuse",
+	"lightcyan",
+	"lemonchiffon",
+	"palevioletred",
+	"darkslateblue",
+	"mediumpurple",
+	"lawngreen",
+	"slateblue",
+	"darkseagreen",
+	"blanchedalmond",
+	"mistyrose",
+	"darkolivegreen",
+	"seashell",
+	"olivedrab",
+	"peachpuff",
+	"darkviolet",
+	"powderblue",
+	"darkmagenta",
+	"lightslategrey",
+	"honeydew",
+	"palegoldenrod",
+	"darkkhaki",
+	"oldlace",
+	"mintcream",
+	"sandybrown",
+	"mediumturquoise",
+	"papayawhip",
+	"paleturquoise",
+	"mediumvioletred",
+	"thistle",
+	"springgreen",
+	"moccasin",
+	"rosybrown",
+	"lavenderblush",
+	"mediumslateblue",
+	"darkorchid",
+	"mediumorchid",
+	"darksalmon",
+	"mediumspringgreen"
+]);
+const systemColors = new KeywordSet([
+	"accentcolor",
+	"accentcolortext",
+	"activetext",
+	"buttonborder",
+	"buttonface",
+	"buttontext",
+	"canvas",
+	"canvastext",
+	"field",
+	"fieldtext",
+	"graytext",
+	"highlight",
+	"highlighttext",
+	"linktext",
+	"mark",
+	"marktext",
+	"selecteditem",
+	"selecteditemtext",
+	"visitedtext"
+]);
+const colorFunctions = new KeywordSet([
+	"rgba",
+	"rgb",
+	"hsla",
+	"hsl",
+	"oklch",
+	"color",
+	"hwb",
+	"lch",
+	"lab",
+	"oklab"
+]);
+const colorKeywords = new KeywordSet(["transparent", "currentcolor"]);
+//#endregion
+//#region src/values/values.ts
+const keywords = new KeywordSet([
+	"auto",
+	"none",
+	"inherit",
+	"initial",
+	"unset",
+	"revert",
+	"revert-layer"
+]);
+/**
+* Test whether a value is a reset (0, 0px, -0.0e0 etc.)
+*/
+function isValueReset(node) {
+	for (let child of node.children) {
+		if (child.type === NUMBER && child.value === 0) continue;
+		if (child.type === DIMENSION && child.value === 0) continue;
+		return false;
+	}
+	return true;
+}
+//#endregion
+//#region src/values/destructure-font-shorthand.ts
+const SYSTEM_FONTS = new KeywordSet([
+	"caption",
+	"icon",
+	"menu",
+	"message-box",
+	"small-caption",
+	"status-bar"
+]);
+const SIZE_KEYWORDS = new KeywordSet([
+	"xx-small",
+	"x-small",
+	"small",
+	"medium",
+	"large",
+	"x-large",
+	"xx-large",
+	"xxx-large",
+	"smaller",
+	"larger"
+]);
+const COMMA = 44;
+const SLASH = 47;
+function destructure(value, cb) {
+	let font_family = [void 0, void 0];
+	let font_size;
+	let line_height;
+	if (value.first_child.type === FUNCTION && value.first_child.name?.toLowerCase() === "var") return null;
+	let prev;
+	for (let node of value.children) {
+		let next = node.next_sibling;
+		if (node.type === IDENTIFIER && keywords.has(node.name)) cb({
+			type: "keyword",
+			value: node.name
+		});
+		if (next && next.type === OPERATOR && next.text.charCodeAt(0) === SLASH) {
+			font_size = node.text;
+			prev = node;
+			continue;
+		}
+		if (prev?.type === OPERATOR && prev.text.charCodeAt(0) === SLASH) {
+			line_height = node.text;
+			prev = node;
+			continue;
+		}
+		if (next?.type === OPERATOR && next.text.charCodeAt(0) === COMMA && !font_family[0]) {
+			font_family[0] = node;
+			if (!font_size && prev) font_size = prev.text;
+			prev = node;
+			continue;
+		}
+		if (node.next_sibling === null) {
+			font_family[1] = node;
+			if (!font_size && !font_family[0] && prev) font_size = prev.text;
+			prev = node;
+			continue;
+		}
+		if (node.type === NUMBER) {
+			prev = node;
+			continue;
+		}
+		if (node.type === IDENTIFIER) {
+			let name = node.name;
+			if (name && SIZE_KEYWORDS.has(name)) {
+				font_size = name;
+				prev = node;
+				continue;
+			}
+		}
+		prev = node;
+	}
+	let family = font_family[0] || font_family[1] ? value.text.substring((font_family?.[0] || font_family?.[1] || { start: value.start }).start - value.start, font_family[1] ? font_family[1].end - value.start : value.text.length) : null;
+	return {
+		font_size,
+		line_height,
+		font_family: family
+	};
+}
+//#endregion
+//#region src/values/animations.ts
+const TIMING_KEYWORDS = new KeywordSet([
+	"linear",
+	"ease",
+	"ease-in",
+	"ease-out",
+	"ease-in-out",
+	"step-start",
+	"step-end"
+]);
+const TIMING_FUNCTION_VALUES = new KeywordSet(["cubic-bezier", "steps"]);
+function analyzeAnimation(children, cb) {
+	let durationFound = false;
+	for (let child of children) {
+		let type = child.type;
+		let name = child.name;
+		if (type === OPERATOR) durationFound = false;
+		else if (type === DIMENSION && durationFound === false) {
+			durationFound = true;
+			cb({
+				type: "duration",
+				value: child
+			});
+		} else if (type === IDENTIFIER && name) {
+			if (TIMING_KEYWORDS.has(name)) cb({
+				type: "fn",
+				value: child
+			});
+			else if (keywords.has(name)) cb({
+				type: "keyword",
+				value: child
+			});
+		} else if (type === FUNCTION && name && TIMING_FUNCTION_VALUES.has(name)) cb({
+			type: "fn",
+			value: child
+		});
+	}
+}
+//#endregion
+//#region src/values/vendor-prefix.ts
+function isValuePrefixed(node, on_value) {
+	walk(node, function(child) {
+		if (child.is_vendor_prefixed) on_value(child.name || child.text);
+	});
+}
+//#endregion
+//#region src/collection.ts
+var Collection = class {
+	#items;
+	#total;
+	#nodes = [];
+	#useLocations;
+	constructor(useLocations = false) {
+		this.#items = /* @__PURE__ */ new Map();
+		this.#total = 0;
+		if (useLocations) this.#nodes = [];
+		this.#useLocations = useLocations;
+	}
+	p(item, node_location) {
+		let index = this.#total;
+		if (this.#useLocations) {
+			let position = index * 4;
+			this.#nodes[position] = node_location.line;
+			this.#nodes[position + 1] = node_location.column;
+			this.#nodes[position + 2] = node_location.offset;
+			this.#nodes[position + 3] = node_location.length;
+		}
+		if (this.#items.has(item)) {
+			this.#items.get(item).push(index);
+			this.#total++;
+			return;
+		}
+		this.#items.set(item, [index]);
+		this.#total++;
+	}
+	size() {
+		return this.#total;
+	}
+	c() {
+		let uniqueWithLocations = /* @__PURE__ */ new Map();
+		let unique = {};
+		let useLocations = this.#useLocations;
+		let items = this.#items;
+		let _nodes = this.#nodes;
+		let size = items.size;
+		items.forEach((list, key) => {
+			if (useLocations) {
+				let nodes = list.map(function(index) {
+					let position = index * 4;
+					return {
+						line: _nodes[position],
+						column: _nodes[position + 1],
+						offset: _nodes[position + 2],
+						length: _nodes[position + 3]
+					};
+				});
+				uniqueWithLocations.set(key, nodes);
+			} else unique[key] = list.length;
+		});
+		let total = this.#total;
+		if (useLocations) return {
+			total,
+			totalUnique: size,
+			unique,
+			uniquenessRatio: total === 0 ? 0 : size / total,
+			uniqueWithLocations: Object.fromEntries(uniqueWithLocations)
+		};
+		return {
+			total,
+			totalUnique: size,
+			unique,
+			uniquenessRatio: total === 0 ? 0 : size / total,
+			uniqueWithLocations: void 0
+		};
+	}
+};
+//#endregion
+//#region src/context-collection.ts
+var ContextCollection = class {
+	#list;
+	#contexts;
+	#useLocations;
+	constructor(useLocations) {
+		this.#list = new Collection(useLocations);
+		this.#contexts = /* @__PURE__ */ new Map();
+		this.#useLocations = useLocations;
+	}
+	/**
+	* Add an item to this #list's context
+	* @param item Item to push
+	* @param context Context to push Item to
+	* @param node_location
+	*/
+	push(item, context, node_location) {
+		this.#list.p(item, node_location);
+		if (!this.#contexts.has(context)) this.#contexts.set(context, new Collection(this.#useLocations));
+		this.#contexts.get(context).p(item, node_location);
+	}
+	count() {
+		let itemsPerContext = /* @__PURE__ */ new Map();
+		for (let [context, value] of this.#contexts.entries()) itemsPerContext.set(context, value.c());
+		return Object.assign(this.#list.c(), { itemsPerContext: Object.fromEntries(itemsPerContext) });
+	}
+};
+//#endregion
+//#region src/aggregate-collection.ts
+/**
+* Find the mode (most occurring value) in an array of Numbers
+* Takes the mean/average of multiple values if multiple values occur the same amount of times.
+*
+* @see https://github.com/angus-c/just/blob/684af9ca0c7808bc78543ec89379b1fdfce502b1/packages/array-mode/index.js
+* @param arr - Array to find the mode value for
+* @returns mode - The `mode` value of `arr`
+*/
+function Mode(arr) {
+	let frequencies = /* @__PURE__ */ new Map();
+	let maxOccurrences = -1;
+	let maxOccurenceCount = 0;
+	let sum = 0;
+	let len = arr.length;
+	for (let i = 0; i < len; i++) {
+		let element = arr[i];
+		let updatedCount = (frequencies.get(element) || 0) + 1;
+		frequencies.set(element, updatedCount);
+		if (updatedCount > maxOccurrences) {
+			maxOccurrences = updatedCount;
+			maxOccurenceCount = 0;
+			sum = 0;
+		}
+		if (updatedCount >= maxOccurrences) {
+			maxOccurenceCount++;
+			sum += element;
+		}
+	}
+	return sum / maxOccurenceCount;
+}
+var AggregateCollection = class {
+	#items;
+	#sum;
+	constructor() {
+		this.#items = [];
+		this.#sum = 0;
+	}
+	/**
+	* Add a new Integer at the end of this AggregateCollection
+	* @param item - The item to add
+	*/
+	push(item) {
+		this.#items.push(item);
+		this.#sum += item;
+	}
+	size() {
+		return this.#items.length;
+	}
+	aggregate() {
+		let len = this.#items.length;
+		if (len === 0) return {
+			min: 0,
+			max: 0,
+			mean: 0,
+			mode: 0,
+			range: 0,
+			sum: 0
+		};
+		let sorted = this.#items.slice().sort((a, b) => a - b);
+		let min = sorted[0];
+		let max = sorted[len - 1];
+		let mode = Mode(sorted);
+		let sum = this.#sum;
+		return {
+			min,
+			max,
+			mean: sum / len,
+			mode,
+			range: max - min,
+			sum
+		};
+	}
+	toArray() {
+		return this.#items;
+	}
+};
+//#endregion
+//#region src/stylesheet/stylesheet.ts
+function getEmbedType(embed) {
+	let start = 5;
+	let semicolon = embed.indexOf(";");
+	let comma = embed.indexOf(",");
+	if (semicolon === -1) return embed.substring(start, comma);
+	if (comma !== -1 && comma < semicolon) return embed.substring(start, comma);
+	return embed.substring(start, semicolon);
+}
+//#endregion
+//#region src/values/browserhacks.ts
+function isIe9Hack(node) {
+	let children = node.children;
+	if (children) {
+		let last = children.at(-1);
+		return last && last.type === IDENTIFIER && endsWith("\\9", last.text) ? true : false;
+	}
+	return false;
+}
+//#endregion
+//#region src/properties/property-utils.ts
+const SPACING_RESET_PROPERTIES = new Set([
+	"margin",
+	"margin-block",
+	"margin-inline",
+	"margin-top",
+	"margin-block-start",
+	"margin-block-end",
+	"margin-inline-end",
+	"margin-inline-end",
+	"margin-right",
+	"margin-bottom",
+	"margin-left",
+	"padding",
+	"padding-block",
+	"padding-inline",
+	"padding-top",
+	"padding-right",
+	"padding-bottom",
+	"padding-left",
+	"padding-block-start",
+	"padding-block-end",
+	"padding-inline-start",
+	"padding-inline-end"
+]);
+const border_radius_properties = new KeywordSet([
+	"border-radius",
+	"border-top-left-radius",
+	"border-top-right-radius",
+	"border-bottom-right-radius",
+	"border-bottom-left-radius",
+	"border-start-start-radius",
+	"border-start-end-radius",
+	"border-end-end-radius",
+	"border-end-start-radius"
+]);
+/**
+* @see https://github.com/csstree/csstree/blob/master/lib/utils/names.js#L69
+*/
+function isHack(property) {
+	if (is_custom(property) || is_vendor_prefixed(property)) return false;
+	let code = property.charCodeAt(0);
+	return code === 47 || code === 42 || code === 95 || code === 43 || code === 38 || code === 36 || code === 35;
+}
+/**
+* Get the normalized basename for a property with a vendor prefix
+* @returns The property name without vendor prefix
+*/
+function basename(property) {
+	if (is_custom(property)) return property;
+	if (is_vendor_prefixed(property)) return property.slice(property.indexOf("-", 2) + 1).toLowerCase();
+	if (isHack(property)) return property.slice(1).toLowerCase();
+	return property.toLowerCase();
+}
+//#endregion
+//#region src/vendor-prefix.ts
+/** Kept for backwards compatibility */
+function hasVendorPrefix(keyword) {
+	return is_vendor_prefixed(keyword);
+}
+//#endregion
+//#region src/index.ts
+function ratio(part, total) {
+	if (total === 0) return 0;
+	return part / total;
+}
+function analyze(css, options = {}) {
+	if (options.useLocations === true) return analyzeInternal(css, options, true);
+	return analyzeInternal(css, options, false);
+}
+function analyzeInternal(css, options, useLocations) {
+	let start = Date.now();
+	let linesOfCode = (css.match(/\n/g) || []).length + 1;
+	let totalComments = 0;
+	let commentsSize = 0;
+	let embedSize = 0;
+	let embedTypes = {
+		total: 0,
+		unique: /* @__PURE__ */ new Map()
+	};
+	let startParse = Date.now();
+	let ast = parse(css, { on_comment({ length }) {
+		totalComments++;
+		commentsSize += length;
+	} });
+	let startAnalysis = Date.now();
+	let atrules = new Collection(useLocations);
+	let atRuleComplexities = new AggregateCollection();
+	/** @type {Record<string, string>[]} */
+	let fontfaces = [];
+	let fontfaces_with_loc = new Collection(useLocations);
+	let layers = new Collection(useLocations);
+	let imports = new Collection(useLocations);
+	let medias = new Collection(useLocations);
+	let mediaBrowserhacks = new Collection(useLocations);
+	let mediaFeatures = new Collection(useLocations);
+	let charsets = new Collection(useLocations);
+	let supports = new Collection(useLocations);
+	let supportsBrowserhacks = new Collection(useLocations);
+	let keyframes = new Collection(useLocations);
+	let prefixedKeyframes = new Collection(useLocations);
+	let containers = new Collection(useLocations);
+	let containerNames = new Collection(useLocations);
+	let registeredProperties = new Collection(useLocations);
+	let functions = new Collection(useLocations);
+	let scopes = new Collection(useLocations);
+	let atruleNesting = new AggregateCollection();
+	let uniqueAtruleNesting = new Collection(useLocations);
+	let totalRules = 0;
+	let emptyRules = 0;
+	let ruleSizes = new AggregateCollection();
+	let selectorsPerRule = new AggregateCollection();
+	let declarationsPerRule = new AggregateCollection();
+	let uniqueRuleSize = new Collection(useLocations);
+	let uniqueSelectorsPerRule = new Collection(useLocations);
+	let uniqueDeclarationsPerRule = new Collection(useLocations);
+	let ruleNesting = new AggregateCollection();
+	let uniqueRuleNesting = new Collection(useLocations);
+	let keyframeSelectors = new Collection(useLocations);
+	let uniqueSelectors = /* @__PURE__ */ new Set();
+	let prefixedSelectors = new Collection(useLocations);
+	let maxSpecificity;
+	let minSpecificity;
+	let specificityA = new AggregateCollection();
+	let specificityB = new AggregateCollection();
+	let specificityC = new AggregateCollection();
+	let uniqueSpecificities = new Collection(useLocations);
+	let selectorComplexities = new AggregateCollection();
+	let uniqueSelectorComplexities = new Collection(useLocations);
+	let specificities = [];
+	let ids = new Collection(useLocations);
+	let a11y = new Collection(useLocations);
+	let pseudoClasses = new Collection(useLocations);
+	let pseudoElements = new Collection(useLocations);
+	let attributeSelectors = new Collection(useLocations);
+	let customElementSelectors = new Collection(useLocations);
+	let combinators = new Collection(useLocations);
+	let selectorNesting = new AggregateCollection();
+	let uniqueSelectorNesting = new Collection(useLocations);
+	let uniqueDeclarations = /* @__PURE__ */ new Set();
+	let totalDeclarations = 0;
+	let declarationComplexities = new AggregateCollection();
+	let importantDeclarations = 0;
+	let importantsInKeyframes = 0;
+	let importantCustomProperties = new Collection(useLocations);
+	let declarationNesting = new AggregateCollection();
+	let uniqueDeclarationNesting = new Collection(useLocations);
+	let properties = new Collection(useLocations);
+	let propertyHacks = new Collection(useLocations);
+	let propertyVendorPrefixes = new Collection(useLocations);
+	let customProperties = new Collection(useLocations);
+	let propertyComplexities = new AggregateCollection();
+	let valueComplexities = new AggregateCollection();
+	let vendorPrefixedValues = new Collection(useLocations);
+	let valueBrowserhacks = new Collection(useLocations);
+	let displays = new Collection(useLocations);
+	let zindex = new Collection(useLocations);
+	let textShadows = new Collection(useLocations);
+	let boxShadows = new Collection(useLocations);
+	let fontFamilies = new Collection(useLocations);
+	let fontSizes = new Collection(useLocations);
+	let lineHeights = new Collection(useLocations);
+	let timingFunctions = new Collection(useLocations);
+	let durations = new Collection(useLocations);
+	let colors = new ContextCollection(useLocations);
+	let colorFormats = new Collection(useLocations);
+	let units = new ContextCollection(useLocations);
+	let gradients = new Collection(useLocations);
+	let valueKeywords = new Collection(useLocations);
+	let borderRadiuses = new ContextCollection(useLocations);
+	let resets = new Collection(useLocations);
+	function toLoc(node) {
+		return {
+			line: node.line,
+			column: node.column,
+			offset: node.start,
+			length: node.length
+		};
+	}
+	let keyframesDepth = -1;
+	walk(ast, (node, depth) => {
+		if (keyframesDepth >= 0 && depth <= keyframesDepth) keyframesDepth = -1;
+		let inKeyframes = keyframesDepth >= 0 && depth > keyframesDepth;
+		if (node.type === AT_RULE) {
+			let atruleLoc = toLoc(node);
+			atruleNesting.push(depth);
+			uniqueAtruleNesting.p(depth, atruleLoc);
+			let normalized_name = basename(node.name ?? "");
+			atrules.p(normalized_name, atruleLoc);
+			if (normalized_name === "font-face") {
+				let descriptors = Object.create(null);
+				if (useLocations) fontfaces_with_loc.p(node.start, toLoc(node));
+				let block = node.children.find((child) => child.type === BLOCK);
+				for (let descriptor of block?.children || []) if (descriptor.type === DECLARATION && descriptor.value) descriptors[descriptor.property] = descriptor.value.text;
+				atRuleComplexities.push(1);
+				fontfaces.push(descriptors);
+			}
+			if (node.prelude === null || node.prelude === void 0) {
+				if (normalized_name === "layer") {
+					layers.p("<anonymous>", toLoc(node));
+					atRuleComplexities.push(2);
+				}
+			} else {
+				let complexity = 1;
+				if (normalized_name === "media") {
+					medias.p(node.prelude.text, toLoc(node));
+					isMediaBrowserhack(node.prelude, (hack) => {
+						mediaBrowserhacks.p(hack, toLoc(node));
+						complexity++;
+					});
+				} else if (normalized_name === "supports") {
+					supports.p(node.prelude.text, toLoc(node));
+					isSupportsBrowserhack(node.prelude, (hack) => {
+						supportsBrowserhacks.p(hack, toLoc(node));
+						complexity++;
+					});
+				} else if (normalized_name.endsWith("keyframes")) {
+					let prelude = node.prelude.text;
+					keyframes.p(prelude, toLoc(node));
+					if (node.is_vendor_prefixed) {
+						prefixedKeyframes.p(`@${node.name?.toLowerCase()} ${node.prelude.text}`, toLoc(node));
+						complexity++;
+					}
+					keyframesDepth = depth;
+				} else if (normalized_name === "layer") for (let layer of node.prelude.text.split(",").map((s) => s.trim())) layers.p(layer, toLoc(node));
+				else if (normalized_name === "import") {
+					imports.p(node.prelude.text, toLoc(node));
+					if (node.prelude.has_children) {
+						for (let child of node.prelude) if (child.type === SUPPORTS_QUERY && typeof child.value === "string") supports.p(child.value, toLoc(child));
+						else if (child.type === LAYER_NAME && typeof child.value === "string") layers.p(child.value, toLoc(child));
+					}
+				} else if (normalized_name === "container") {
+					containers.p(node.prelude.text, toLoc(node));
+					if (node.prelude.first_child?.type === CONTAINER_QUERY) {
+						if (node.prelude.first_child.first_child?.type === IDENTIFIER) containerNames.p(node.prelude.first_child.first_child.text, toLoc(node));
+					}
+				} else if (normalized_name === "property") registeredProperties.p(node.prelude.text, toLoc(node));
+				else if (normalized_name === "function") {
+					let prelude = node.prelude.text;
+					let name = prelude.includes("(") ? prelude.slice(0, prelude.indexOf("(")).trim() : prelude.trim();
+					functions.p(name, toLoc(node));
+				} else if (normalized_name === "charset") charsets.p(node.prelude.text.toLowerCase(), toLoc(node));
+				else if (normalized_name === "scope") scopes.p(node.prelude.text, toLoc(node));
+				atRuleComplexities.push(complexity);
+			}
+		} else if (node.type === STYLE_RULE) if (inKeyframes && node.prelude) {
+			if (node.prelude.type === SELECTOR_LIST && node.prelude.children.length > 0) for (let keyframe_selector of node.prelude.children) keyframeSelectors.p(keyframe_selector.text, toLoc(keyframe_selector));
+		} else {
+			totalRules++;
+			if (node.block?.is_empty) emptyRules++;
+			let numSelectors = 0;
+			let numDeclarations = 0;
+			let loc = toLoc(node);
+			if (node.prelude) {
+				for (const selector of node.prelude.children) if (selector.type === SELECTOR) numSelectors++;
+			}
+			if (node.block) {
+				for (const declaration of node.block.children) if (declaration.type === DECLARATION) numDeclarations++;
+			}
+			ruleSizes.push(numSelectors + numDeclarations);
+			uniqueRuleSize.p(numSelectors + numDeclarations, loc);
+			selectorsPerRule.push(numSelectors);
+			uniqueSelectorsPerRule.p(numSelectors, loc);
+			declarationsPerRule.push(numDeclarations);
+			uniqueDeclarationsPerRule.p(numDeclarations, loc);
+			ruleNesting.push(depth);
+			uniqueRuleNesting.p(depth, loc);
+		}
+		else if (node.type === SELECTOR) {
+			if (inKeyframes) return SKIP;
+			let loc = toLoc(node);
+			selectorNesting.push(depth > 0 ? depth - 1 : 0);
+			uniqueSelectorNesting.p(depth > 0 ? depth - 1 : 0, loc);
+			uniqueSelectors.add(node.text);
+			let complexity = getComplexity(node);
+			selectorComplexities.push(complexity);
+			uniqueSelectorComplexities.p(complexity, loc);
+			isPrefixed(node, (prefix) => {
+				prefixedSelectors.p(prefix.toLowerCase(), loc);
+			});
+			isAccessibility(node, (a11y_selector) => {
+				a11y.p(a11y_selector, loc);
+			});
+			walk(node, (child) => {
+				if (child.type === ATTRIBUTE_SELECTOR) attributeSelectors.p(child.name?.toLowerCase() ?? "", loc);
+				else if (child.type === TYPE_SELECTOR && child.name?.includes("-")) customElementSelectors.p(child.name.toLowerCase(), loc);
+				else if (child.type === PSEUDO_CLASS_SELECTOR) pseudoClasses.p(child.name?.toLowerCase() ?? "", loc);
+				else if (child.type === PSEUDO_ELEMENT_SELECTOR) pseudoElements.p(child.name?.toLowerCase() ?? "", loc);
+			});
+			getCombinators(node, (combinator) => {
+				let name = combinator.name.trim() === "" ? " " : combinator.name;
+				combinators.p(name, combinator.loc);
+			});
+			let specificity = calculateForAST(node);
+			let [sa, sb, sc] = specificity;
+			uniqueSpecificities.p(specificity.toString(), loc);
+			specificityA.push(sa);
+			specificityB.push(sb);
+			specificityC.push(sc);
+			if (maxSpecificity === void 0) maxSpecificity = specificity;
+			if (minSpecificity === void 0) minSpecificity = specificity;
+			if (minSpecificity !== void 0 && compareSpecificity(minSpecificity, specificity) < 0) minSpecificity = specificity;
+			if (maxSpecificity !== void 0 && compareSpecificity(maxSpecificity, specificity) > 0) maxSpecificity = specificity;
+			specificities.push(specificity);
+			if (sa > 0) ids.p(node.text, loc);
+			return SKIP;
+		} else if (node.type === DECLARATION) {
+			totalDeclarations++;
+			uniqueDeclarations.add(node.text);
+			let loc = toLoc(node);
+			let declarationDepth = depth > 0 ? depth - 1 : 0;
+			declarationNesting.push(declarationDepth);
+			uniqueDeclarationNesting.p(declarationDepth, loc);
+			let complexity = 1;
+			if (node.is_important) {
+				complexity++;
+				if (!node.text.toLowerCase().includes("!important")) valueBrowserhacks.p("!ie", toLoc(node.value));
+				if (inKeyframes) {
+					importantsInKeyframes++;
+					complexity++;
+				}
+			}
+			declarationComplexities.push(complexity);
+			let { is_important, property, is_browserhack, is_vendor_prefixed } = node;
+			if (!property) return;
+			let propertyLoc = toLoc(node);
+			propertyLoc.length = property.length;
+			let normalizedProperty = basename(property);
+			properties.p(normalizedProperty, propertyLoc);
+			if (is_important) importantDeclarations++;
+			if (is_vendor_prefixed) {
+				propertyComplexities.push(2);
+				propertyVendorPrefixes.p(property, propertyLoc);
+			} else if (is_custom(property)) {
+				customProperties.p(property, propertyLoc);
+				propertyComplexities.push(is_important ? 3 : 2);
+				if (is_important) importantCustomProperties.p(property, propertyLoc);
+			} else if (is_browserhack) {
+				propertyHacks.p(property.charAt(0), propertyLoc);
+				propertyComplexities.push(2);
+			} else propertyComplexities.push(1);
+			{
+				let value = node.value;
+				let { text } = value;
+				let valueLoc = toLoc(value);
+				let complexity = 1;
+				if (keywords.has(text)) {
+					valueKeywords.p(text.toLowerCase(), valueLoc);
+					valueComplexities.push(complexity);
+					if (normalizedProperty === "display") displays.p(text.toLowerCase(), valueLoc);
+					return;
+				}
+				isValuePrefixed(value, (prefixed) => {
+					vendorPrefixedValues.p(prefixed.toLowerCase(), valueLoc);
+					complexity++;
+				});
+				if (isIe9Hack(value)) {
+					valueBrowserhacks.p("\\9", valueLoc);
+					text = text.slice(0, -2);
+					complexity++;
+				}
+				valueComplexities.push(complexity);
+				if (SPACING_RESET_PROPERTIES.has(normalizedProperty)) {
+					if (isValueReset(value)) resets.p(normalizedProperty, valueLoc);
+				} else if (normalizedProperty === "display") if (/var\(/i.test(text)) displays.p(text, valueLoc);
+				else displays.p(text.toLowerCase(), valueLoc);
+				else if (normalizedProperty === "z-index") {
+					zindex.p(text, valueLoc);
+					return SKIP;
+				} else if (normalizedProperty === "font") {
+					if (!SYSTEM_FONTS.has(text)) {
+						let result = destructure(value, function(item) {
+							if (item.type === "keyword") valueKeywords.p(item.value.toLowerCase(), valueLoc);
+						});
+						if (!result) return SKIP;
+						let { font_size, line_height, font_family } = result;
+						if (font_family) fontFamilies.p(font_family, valueLoc);
+						if (font_size) fontSizes.p(font_size.toLowerCase(), valueLoc);
+						if (line_height) lineHeights.p(line_height.toLowerCase(), valueLoc);
+					}
+				} else if (normalizedProperty === "font-size") {
+					if (!SYSTEM_FONTS.has(text)) {
+						let normalized = text.toLowerCase();
+						if (normalized.includes("var(")) fontSizes.p(text, valueLoc);
+						else fontSizes.p(normalized, valueLoc);
+					}
+				} else if (normalizedProperty === "font-family") {
+					if (!SYSTEM_FONTS.has(text)) fontFamilies.p(text, valueLoc);
+					return SKIP;
+				} else if (normalizedProperty === "line-height") {
+					let normalized = text.toLowerCase();
+					if (normalized.includes("var(")) lineHeights.p(text, valueLoc);
+					else lineHeights.p(normalized, valueLoc);
+				} else if (normalizedProperty === "transition" || normalizedProperty === "animation") {
+					analyzeAnimation(value.children, function(item) {
+						if (item.type === "fn") timingFunctions.p(item.value.text.toLowerCase(), valueLoc);
+						else if (item.type === "duration") durations.p(item.value.text.toLowerCase(), valueLoc);
+						else if (item.type === "keyword") valueKeywords.p(item.value.text.toLowerCase(), valueLoc);
+					});
+					return SKIP;
+				} else if (normalizedProperty === "animation-duration" || normalizedProperty === "transition-duration") {
+					for (let child of value.children) if (child.type !== OPERATOR) {
+						let text = child.text;
+						if (/var\(/i.test(text)) durations.p(text, valueLoc);
+						else durations.p(text.toLowerCase(), valueLoc);
+					}
+				} else if (normalizedProperty === "transition-timing-function" || normalizedProperty === "animation-timing-function") {
+					for (let child of value.children) if (child.type !== OPERATOR) timingFunctions.p(child.text, valueLoc);
+				} else if (normalizedProperty === "container-name") containerNames.p(text, valueLoc);
+				else if (normalizedProperty === "container") {
+					if (value.first_child?.type === IDENTIFIER) containerNames.p(value.first_child.text, valueLoc);
+				} else if (border_radius_properties.has(normalizedProperty)) borderRadiuses.push(text, property, valueLoc);
+				else if (normalizedProperty === "text-shadow") textShadows.p(text, valueLoc);
+				else if (normalizedProperty === "box-shadow") boxShadows.p(text, valueLoc);
+				let valueHasIe9Hack = isIe9Hack(value);
+				walk(value, (valueNode) => {
+					switch (valueNode.type) {
+						case DIMENSION: {
+							let unit = valueNode.unit?.toLowerCase() ?? "";
+							let loc = toLoc(valueNode);
+							units.push(unit, property, loc);
+							return SKIP;
+						}
+						case HASH: {
+							let hashText = valueNode.text;
+							if (!hashText || !hashText.startsWith("#")) return SKIP;
+							let hashValue = hashText.toLowerCase();
+							if (valueHasIe9Hack && !hashValue.endsWith("\\9")) hashValue = hashValue + "\\9";
+							let hexLength = hashValue.length - 1;
+							if (endsWith("\\9", hashValue)) hexLength = hexLength - 2;
+							let hashLoc = toLoc(valueNode);
+							colors.push(hashValue, property, hashLoc);
+							colorFormats.p(`hex` + hexLength, hashLoc);
+							return SKIP;
+						}
+						case IDENTIFIER: {
+							let identifierText = valueNode.text;
+							let identifierLoc = toLoc(valueNode);
+							if (normalizedProperty === "font" || normalizedProperty === "font-family") return SKIP;
+							if (keywords.has(identifierText)) valueKeywords.p(identifierText.toLowerCase(), identifierLoc);
+							let nodeLen = identifierText.length;
+							if (nodeLen > 20 || nodeLen < 3) return SKIP;
+							if (colorKeywords.has(identifierText)) {
+								let colorKeyword = identifierText.toLowerCase();
+								colors.push(colorKeyword, property, identifierLoc);
+								colorFormats.p(colorKeyword, identifierLoc);
+								return;
+							}
+							if (namedColors.has(identifierText)) {
+								colors.push(identifierText.toLowerCase(), property, identifierLoc);
+								colorFormats.p("named", identifierLoc);
+								return;
+							}
+							if (systemColors.has(identifierText)) {
+								colors.push(identifierText.toLowerCase(), property, identifierLoc);
+								colorFormats.p("system", identifierLoc);
+								return;
+							}
+							return SKIP;
+						}
+						case FUNCTION: {
+							let funcName = valueNode.name;
+							let funcLoc = toLoc(valueNode);
+							if (colorFunctions.has(funcName)) {
+								colors.push(valueNode.text, property, funcLoc);
+								colorFormats.p(funcName.toLowerCase(), funcLoc);
+								return;
+							}
+							if (endsWith("gradient", funcName)) {
+								gradients.p(valueNode.text, funcLoc);
+								return;
+							}
+						}
+					}
+				});
+			}
+		} else if (node.type === URL) {
+			let { value } = node;
+			let embed = unquote(value || "");
+			if (str_starts_with(embed, "data:")) {
+				let size = embed.length;
+				let type = getEmbedType(embed);
+				embedTypes.total++;
+				embedSize += size;
+				let loc = {
+					line: node.line,
+					column: node.column,
+					offset: node.start,
+					length: node.length
+				};
+				if (embedTypes.unique.has(type)) {
+					let item = embedTypes.unique.get(type);
+					item.count++;
+					item.size += size;
+					embedTypes.unique.set(type, item);
+					if (useLocations && item.uniqueWithLocations) item.uniqueWithLocations.push(loc);
+				} else {
+					let item = {
+						count: 1,
+						size,
+						uniqueWithLocations: useLocations ? [loc] : void 0
+					};
+					embedTypes.unique.set(type, item);
+				}
+			}
+		} else if (node.type === MEDIA_FEATURE) {
+			if (node.property) mediaFeatures.p(node.property.toLowerCase(), toLoc(node));
+			return SKIP;
+		}
+	});
+	let totalUniqueDeclarations = uniqueDeclarations.size;
+	let totalSelectors = selectorComplexities.size();
+	let specificitiesA = specificityA.aggregate();
+	let specificitiesB = specificityB.aggregate();
+	let specificitiesC = specificityC.aggregate();
+	let totalUniqueSelectors = uniqueSelectors.size;
+	let assign = Object.assign;
+	let cssLen = css.length;
+	let fontFacesCount = fontfaces.length;
+	let atRuleComplexity = atRuleComplexities.aggregate();
+	let selectorComplexity = selectorComplexities.aggregate();
+	let declarationComplexity = declarationComplexities.aggregate();
+	let propertyComplexity = propertyComplexities.aggregate();
+	let valueComplexity = valueComplexities.aggregate();
+	let atruleCount = atrules.c();
+	return {
+		stylesheet: {
+			sourceLinesOfCode: atruleCount.total + totalSelectors + totalDeclarations + keyframeSelectors.size(),
+			linesOfCode,
+			size: cssLen,
+			complexity: atRuleComplexity.sum + selectorComplexity.sum + declarationComplexity.sum + propertyComplexity.sum + valueComplexity.sum,
+			comments: {
+				total: totalComments,
+				size: commentsSize
+			},
+			embeddedContent: {
+				size: {
+					total: embedSize,
+					ratio: ratio(embedSize, cssLen)
+				},
+				types: {
+					total: embedTypes.total,
+					totalUnique: embedTypes.unique.size,
+					uniquenessRatio: ratio(embedTypes.unique.size, embedTypes.total),
+					unique: Object.fromEntries(embedTypes.unique)
+				}
+			}
+		},
+		atrules: assign(atruleCount, {
+			fontface: assign({
+				total: fontFacesCount,
+				totalUnique: fontFacesCount,
+				unique: fontfaces,
+				uniquenessRatio: fontFacesCount === 0 ? 0 : 1
+			}, useLocations ? { uniqueWithLocations: fontfaces_with_loc.c().uniqueWithLocations } : {}),
+			import: imports.c(),
+			media: assign(medias.c(), {
+				browserhacks: mediaBrowserhacks.c(),
+				features: mediaFeatures.c()
+			}),
+			charset: charsets.c(),
+			supports: assign(supports.c(), { browserhacks: supportsBrowserhacks.c() }),
+			keyframes: assign(keyframes.c(), { prefixed: assign(prefixedKeyframes.c(), { ratio: ratio(prefixedKeyframes.size(), keyframes.size()) }) }),
+			container: assign(containers.c(), { names: containerNames.c() }),
+			layer: layers.c(),
+			property: registeredProperties.c(),
+			function: functions.c(),
+			scope: scopes.c(),
+			complexity: atRuleComplexity,
+			nesting: assign(atruleNesting.aggregate(), { items: atruleNesting.toArray() }, uniqueAtruleNesting.c())
+		}),
+		rules: {
+			total: totalRules,
+			empty: {
+				total: emptyRules,
+				ratio: ratio(emptyRules, totalRules)
+			},
+			sizes: assign(ruleSizes.aggregate(), { items: ruleSizes.toArray() }, uniqueRuleSize.c()),
+			nesting: assign(ruleNesting.aggregate(), { items: ruleNesting.toArray() }, uniqueRuleNesting.c()),
+			selectors: assign(selectorsPerRule.aggregate(), { items: selectorsPerRule.toArray() }, uniqueSelectorsPerRule.c()),
+			declarations: assign(declarationsPerRule.aggregate(), { items: declarationsPerRule.toArray() }, uniqueDeclarationsPerRule.c())
+		},
+		selectors: {
+			total: totalSelectors,
+			totalUnique: totalUniqueSelectors,
+			uniquenessRatio: ratio(totalUniqueSelectors, totalSelectors),
+			specificity: assign({
+				min: minSpecificity === void 0 ? [
+					0,
+					0,
+					0
+				] : minSpecificity,
+				max: maxSpecificity === void 0 ? [
+					0,
+					0,
+					0
+				] : maxSpecificity,
+				sum: [
+					specificitiesA.sum,
+					specificitiesB.sum,
+					specificitiesC.sum
+				],
+				mean: [
+					specificitiesA.mean,
+					specificitiesB.mean,
+					specificitiesC.mean
+				],
+				mode: [
+					specificitiesA.mode,
+					specificitiesB.mode,
+					specificitiesC.mode
+				],
+				items: specificities
+			}, uniqueSpecificities.c()),
+			complexity: assign(selectorComplexity, uniqueSelectorComplexities.c(), { items: selectorComplexities.toArray() }),
+			nesting: assign(selectorNesting.aggregate(), { items: selectorNesting.toArray() }, uniqueSelectorNesting.c()),
+			id: assign(ids.c(), { ratio: ratio(ids.size(), totalSelectors) }),
+			pseudoClasses: pseudoClasses.c(),
+			pseudoElements: pseudoElements.c(),
+			accessibility: assign(a11y.c(), { ratio: ratio(a11y.size(), totalSelectors) }),
+			attributes: attributeSelectors.c(),
+			customElements: customElementSelectors.c(),
+			keyframes: keyframeSelectors.c(),
+			prefixed: assign(prefixedSelectors.c(), { ratio: ratio(prefixedSelectors.size(), totalSelectors) }),
+			combinators: combinators.c()
+		},
+		declarations: {
+			total: totalDeclarations,
+			totalUnique: totalUniqueDeclarations,
+			uniquenessRatio: ratio(totalUniqueDeclarations, totalDeclarations),
+			importants: {
+				total: importantDeclarations,
+				ratio: ratio(importantDeclarations, totalDeclarations),
+				inKeyframes: {
+					total: importantsInKeyframes,
+					ratio: ratio(importantsInKeyframes, importantDeclarations)
+				}
+			},
+			complexity: declarationComplexity,
+			nesting: assign(declarationNesting.aggregate(), { items: declarationNesting.toArray() }, uniqueDeclarationNesting.c())
+		},
+		properties: assign(properties.c(), {
+			prefixed: assign(propertyVendorPrefixes.c(), { ratio: ratio(propertyVendorPrefixes.size(), properties.size()) }),
+			custom: assign(customProperties.c(), {
+				ratio: ratio(customProperties.size(), properties.size()),
+				importants: assign(importantCustomProperties.c(), { ratio: ratio(importantCustomProperties.size(), customProperties.size()) })
+			}),
+			browserhacks: assign(propertyHacks.c(), { ratio: ratio(propertyHacks.size(), properties.size()) }),
+			complexity: propertyComplexity
+		}),
+		values: {
+			colors: assign(colors.count(), { formats: colorFormats.c() }),
+			gradients: gradients.c(),
+			fontFamilies: fontFamilies.c(),
+			fontSizes: fontSizes.c(),
+			lineHeights: lineHeights.c(),
+			zindexes: zindex.c(),
+			textShadows: textShadows.c(),
+			boxShadows: boxShadows.c(),
+			borderRadiuses: borderRadiuses.count(),
+			animations: {
+				durations: durations.c(),
+				timingFunctions: timingFunctions.c()
+			},
+			prefixes: vendorPrefixedValues.c(),
+			browserhacks: valueBrowserhacks.c(),
+			units: units.count(),
+			complexity: valueComplexity,
+			keywords: valueKeywords.c(),
+			resets: resets.c(),
+			displays: displays.c()
+		},
+		__meta__: {
+			parseTime: startAnalysis - startParse,
+			analyzeTime: Date.now() - startAnalysis,
+			total: Date.now() - start
+		}
+	};
+}
+/**
+* Compare specificity A to Specificity B
+* @returns 0 when a==b, 1 when a<b, -1 when a>b
+*/
+function compareSpecificity(a, b) {
+	if (a[0] === b[0]) {
+		if (a[1] === b[1]) return b[2] - a[2];
+		return b[1] - a[1];
+	}
+	return b[0] - a[0];
+}
+//#endregion
+export { KeywordSet, analyze, calculate as calculateSpecificity, colorFunctions, colorKeywords, compareSpecificity, keywords as cssKeywords, hasVendorPrefix, isAccessibility as isAccessibilitySelector, isMediaBrowserhack, isHack as isPropertyHack, isPrefixed as isSelectorPrefixed, isSupportsBrowserhack, isValuePrefixed, namedColors, getComplexity as selectorComplexity, systemColors };