@projectwallace/css-analyzer 9.3.0 → 9.5.0

package/dist/index.js

@@ -0,0 +1,1010 @@
+import { n as isSupportsBrowserhack, t as isMediaBrowserhack } from "./atrules-CskmpIdJ.js";
+import { n as unquote, r as KeywordSet, t as endsWith } from "./string-utils-olNNcOlY.js";
+import { a as getComplexity, i as getCombinators, n as calculateForAST, o as isAccessibility, s as isPrefixed, t as calculate } from "./specificity-svLpcKkT.js";
+import { a as colorKeywords, i as colorFunctions, n as isValueReset, o as namedColors, r as keywords, s as systemColors, t as isIe9Hack } from "./browserhacks-eP_e1D5u.js";
+import { ATTRIBUTE_SELECTOR, AT_RULE, BLOCK, CONTAINER_QUERY, DECLARATION, DIMENSION, FUNCTION, HASH, IDENTIFIER, LAYER_NAME, MEDIA_FEATURE, 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_starts_with, walk } from "@projectwallace/css-parser";
+//#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/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
+* @deprecated this one is the inverse of the one exported in /selectors/index.ts; wille be removed in next major version
+* @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 };