@tailwind-merge/next 0.0.0-dev.50b1d1e9f69ac68604be38dabea94cccdc6b070a

package/dist/loader.mjs

@@ -0,0 +1,2815 @@
+import fs, { statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { readFile, readdir, realpath, stat } from "node:fs/promises";
+import { getDefaultConfig, validators } from "tailwind-merge";
+import { createClassGroupLookup, createClassGroupUtils, createParseClassName } from "tailwind-merge/unstable-do-not-import";
+import { Features, __unstable__loadDesignSystem, compile, loadModule } from "@tailwindcss/node";
+import { parse } from "postcss";
+import enhancedResolve from "enhanced-resolve";
+import { createHash } from "node:crypto";
+import { clearRequireCache } from "@tailwindcss/node/require-cache";
+//#region ../configurator/src/css-statements.ts
+/**
+* Reads active CSS statements and block headers for build-time inspection without interpreting their contents. Comments cannot introduce directives, and quoted text and function arguments cannot end a statement or open a block. Sharing this between source scanning and root discovery keeps both integrations' view of active directives consistent.
+* Unlike declaration analysis of compiled CSS, discovery must tolerate unfinished edits so generation can select the entrypoint and report its error through the normal recovery path.
+*/
+function* cssStatements(css) {
+	let statement = "";
+	let quote = "";
+	let parenDepth = 0;
+	for (let index = 0; index < css.length; index++) {
+		const character = css[index];
+		if (character === "\\") {
+			statement += css.slice(index, index + 2);
+			index += 1;
+			continue;
+		}
+		if (quote) {
+			statement += character;
+			if (character === quote) quote = "";
+			continue;
+		}
+		if (character === "/" && css[index + 1] === "*") {
+			const end = css.indexOf("*/", index + 2);
+			index = end === -1 ? css.length : end + 1;
+			statement += " ";
+			continue;
+		}
+		if (character === "\"" || character === "'") quote = character;
+		else if (character === "(") parenDepth += 1;
+		else if (character === ")") parenDepth -= 1;
+		else if (parenDepth === 0 && (character === ";" || character === "{" || character === "}")) {
+			if (statement.trim() !== "") yield statement.trim();
+			statement = "";
+			continue;
+		}
+		statement += character;
+	}
+	if (statement.trim() !== "") yield statement.trim();
+}
+/**
+* Splits at a separator that sits outside any parentheses, brackets, braces, and quotes (Tailwind's `segment`), so `a(b,c),d` splits into two parts at the top-level comma and quoted separators stay put.
+*/
+function segment(input, separator) {
+	const parts = [];
+	const stack = [];
+	let last = 0;
+	for (let index = 0; index < input.length; index++) {
+		const character = input[index];
+		if (stack.length === 0 && character === separator) {
+			parts.push(input.slice(last, index));
+			last = index + 1;
+			continue;
+		}
+		switch (character) {
+			case "\\":
+				index += 1;
+				break;
+			case "\"":
+			case "'":
+				while (++index < input.length) if (input[index] === "\\") index += 1;
+				else if (input[index] === character) break;
+				break;
+			case "(":
+				stack.push(")");
+				break;
+			case "[":
+				stack.push("]");
+				break;
+			case "{":
+				stack.push("}");
+				break;
+			case ")":
+			case "]":
+			case "}": if (stack.length > 0 && stack[stack.length - 1] === character) stack.pop();
+		}
+	}
+	parts.push(input.slice(last));
+	return parts;
+}
+//#endregion
+//#region ../configurator/src/declarations.ts
+/** Annotates compiled CSS with the target and conditions needed for coverage checks. PostCSS owns CSS syntax (including escaped identifiers, importance, and nested value blocks); this walker only interprets style scopes. `candidate` is the class the CSS was compiled for, so its own selector can be told apart from ancestor classes a variant adds (`.in-dark\:block` inside `:where(.dark *) .in-dark\:block`); without it the first class selector is taken. */
+function parseDeclarations(css, candidate) {
+	const entries = [];
+	visit(parse(css).nodes);
+	return entries;
+	function visit(nodes, frame) {
+		for (const node of nodes) if (node.type === "decl") {
+			if (frame && !frame.skip) entries.push({
+				context: frame.context,
+				conditional: frame.conditional,
+				scope: frame.scope,
+				property: node.prop,
+				important: node.important ?? false,
+				value: node.value
+			});
+		} else if (node.type === "rule" || node.type === "atrule") {
+			const header = node.type === "rule" ? node.selector : `@${node.name}${node.params ? ` ${node.params}` : ""}`;
+			visit(node.nodes ?? [], frameForHeader(header, frame, candidate));
+		}
+	}
+}
+function frameForHeader(header, parent, candidate) {
+	const parentContext = parent?.context ?? "";
+	const parentConditional = parent?.conditional ?? false;
+	const parentScope = parent?.scope ?? [];
+	const parentSkip = parent?.skip ?? false;
+	if (header.startsWith("@")) {
+		const isNonStyle = /^@(?:property|(?:-[\w]+-)?keyframes)(?:\s|$)/i.test(header);
+		return {
+			context: parentContext,
+			conditional: true,
+			scope: [...parentScope, header],
+			skip: parentSkip || isNonStyle
+		};
+	}
+	const { contextFragment, conditional, relativeSelector } = analyzeSelector(header, candidate);
+	return {
+		context: parentContext === "" || contextFragment === "" ? parentContext + contextFragment : `${parentContext} ${contextFragment}`,
+		conditional: parentConditional || conditional,
+		scope: [...parentScope, relativeSelector],
+		skip: parentSkip
+	};
+}
+/** The class selector to anchor on: the one spelling the candidate, or the first one when the candidate is unknown or absent (a selector Tailwind built without the class itself). */
+function findClassAnchor(subject, candidate) {
+	const classSelectors = [...subject.matchAll(/\.(?:[\w-]|\\(?:[\da-f]{1,6}\s?|.))+/gi)];
+	if (candidate !== void 0) {
+		const own = classSelectors.find((match) => unescapeIdentifier(match[0].slice(1)) === candidate);
+		if (own) return own;
+	}
+	return classSelectors[0] ?? null;
+}
+/** Reverses CSS identifier escaping: `\:` → `:`, `\32 xl` → `2xl`. */
+function unescapeIdentifier(identifier) {
+	return identifier.replace(/\\(?:([\da-f]{1,6})\s?|(.))/gi, (_, hex, char) => hex !== void 0 ? String.fromCodePoint(Number.parseInt(hex, 16)) : char);
+}
+/** Single-colon selectors that are pseudo-elements by CSS's legacy compatibility rule; everything else single-colon is a pseudo-class. */
+const LEGACY_PSEUDO_ELEMENTS = /* @__PURE__ */ new Set([
+	"before",
+	"after",
+	"first-line",
+	"first-letter"
+]);
+/**
+* Determines what a selector does to the render target relative to the class's base element. The subject anchor is `&` (nested rules) or the class selector itself (top-level rules, possibly wrapped in `:where(...)`). Pseudo-elements and combinator tails after the anchor change the target; pseudo-classes and ancestor prefixes only add conditions.
+*/
+function analyzeSelector(selector, candidate) {
+	let subject = segment(selector, ",")[0].trim();
+	const wrapper = /^:(?:where|is)\((.*)\)$/.exec(subject);
+	if (wrapper) subject = wrapper[1].trim();
+	const anchorMatch = /&/.exec(subject) ?? findClassAnchor(subject, candidate);
+	if (!anchorMatch) return {
+		contextFragment: subject.replace(/\s+/g, " "),
+		conditional: false,
+		relativeSelector: selector
+	};
+	let conditional = anchorMatch.index > 0 || segment(selector, ",").length > 1;
+	let contextFragment = "";
+	let rest = subject.slice(anchorMatch.index + anchorMatch[0].length);
+	while (rest !== "") {
+		const pseudo = /^::?([\w-]+)(\((?:[^()]|\([^()]*\))*\))?/.exec(rest);
+		if (pseudo) {
+			if (pseudo[0].startsWith("::") || LEGACY_PSEUDO_ELEMENTS.has(pseudo[1])) contextFragment += `::${pseudo[1]}`;
+			else conditional = true;
+			rest = rest.slice(pseudo[0].length);
+			continue;
+		}
+		const compound = /^(?:\.(?:[\w-]|\\(?:[\da-f]{1,6}\s?|.))+|\[[^\]]*\])/i.exec(rest);
+		if (compound) {
+			conditional = true;
+			rest = rest.slice(compound[0].length);
+			continue;
+		}
+		contextFragment += (contextFragment === "" ? "" : " ") + rest.trim().replace(/\s+/g, " ");
+		break;
+	}
+	return {
+		contextFragment,
+		conditional,
+		relativeSelector: selector.replace(anchorMatch[0], "&")
+	};
+}
+//#endregion
+//#region ../configurator/src/resolvers.ts
+/**
+* Resolves stylesheet requests with Tailwind's package fields and conditions after optional bundler resolution. An alias-expanded request may still need an extension or package lookup; finish that lookup here so failures report missing targets under the alias rather than the original specifier. Tracking at this boundary records the file's CSS role, including .pcss and extensionless imports, without mistaking JavaScript dependencies for stylesheets.
+* Each caller gets an uncached filesystem view so regeneration sees imports created or repaired after an earlier resolution attempt.
+* Failed resolution reports attempted missing paths separately from stylesheet roles, so integrations can watch for their creation without treating resolver metadata such as package.json as CSS.
+*/
+function createStylesheetResolver(customResolver, onStylesheet, onMissingDependency) {
+	return createResolver([{
+		extensions: [".css"],
+		mainFields: ["style"],
+		conditionNames: ["style"]
+	}], customResolver, onStylesheet, onMissingDependency);
+}
+/** Resolves JavaScript configs/plugins with Tailwind's import-then-require fallback. Report the module before loading can fail, and missing targets before rejecting, so integrations can recover from repairs and creation. An uncached filesystem also avoids retaining a missing result across the first retry. */
+function createModuleResolver(customResolver, onDependency) {
+	const extensions = [
+		".js",
+		".json",
+		".node",
+		".ts"
+	];
+	return createResolver([{
+		extensions,
+		conditionNames: ["node", "import"]
+	}, {
+		extensions,
+		conditionNames: ["node", "require"]
+	}], customResolver, onDependency, onDependency);
+}
+/**
+* Retains local transitive dependencies after module execution fails. Tailwind reports its own import walk only after a successful load, leaving a broken child (or a missing grandchild) invisible to watchers. Recognize its literal-import forms without a JavaScript parser so syntax errors cannot stop the walk. Matches only add watches: they never execute code or decide how Tailwind loads a module.
+* This recovery-only walk uses fresh resolution, reports missing alternatives, follows cycles once, and leaves the original loader responsible for errors. Bare package imports stay outside the local graph, as in Tailwind's dependency collector.
+*/
+async function trackModuleDependencies(file, onDependency) {
+	const visited = /* @__PURE__ */ new Set();
+	const jsExtensions = [
+		".js",
+		".cjs",
+		".mjs",
+		".ts",
+		".cts",
+		".mts",
+		".jsx",
+		".tsx",
+		".json",
+		".node"
+	];
+	const tsExtensions = [
+		".ts",
+		".cts",
+		".mts",
+		".tsx",
+		".js",
+		".cjs",
+		".mjs",
+		".jsx",
+		".json",
+		".node"
+	];
+	const resolveJs = createResolver([{
+		extensions: jsExtensions,
+		conditionNames: [
+			"node",
+			"import",
+			"require"
+		]
+	}], void 0, void 0, onDependency);
+	const resolveTs = createResolver([{
+		extensions: tsExtensions,
+		conditionNames: [
+			"node",
+			"import",
+			"require"
+		]
+	}], void 0, void 0, onDependency);
+	await visit(file);
+	async function visit(file) {
+		if (visited.has(file)) return;
+		visited.add(file);
+		onDependency(file);
+		const extension = path.extname(file);
+		if (extension === ".json" || extension === ".node") return;
+		const source = await readFile(file, "utf8").catch(() => null);
+		if (source === null) return;
+		const imports = /* @__PURE__ */ new Set();
+		for (const pattern of MODULE_IMPORT_PATTERNS) for (const match of source.matchAll(pattern)) if (match[1].startsWith(".")) imports.add(match[1]);
+		const resolve = [
+			".js",
+			".cjs",
+			".mjs"
+		].includes(extension) ? resolveJs : resolveTs;
+		await Promise.all([...imports].map(async (id) => {
+			const dependency = await resolve(id, path.dirname(file)).catch(() => void 0);
+			if (dependency) await visit(dependency);
+		}));
+	}
+}
+/** Shares fresh filesystem access and dependency reporting across stylesheet and module resolution. Keep failed alternatives private until every condition set fails; a successful fallback must not turn missing package metadata into watched dependencies or stylesheet inputs. */
+function createResolver(alternatives, customResolver, onResolved, onMissingDependency) {
+	const resolvers = alternatives.map((options) => enhancedResolve.ResolverFactory.createResolver({
+		...options,
+		fileSystem: fs,
+		useSyncFileSystemCalls: true,
+		modules: ["node_modules", ...process.env.NODE_PATH?.split(path.delimiter).filter(Boolean) ?? []]
+	}));
+	return async (id, base) => {
+		const request = await customResolver?.(id, base) || id;
+		const missingDependencies = onMissingDependency ? /* @__PURE__ */ new Set() : void 0;
+		let resolutionError;
+		for (const resolver of resolvers) {
+			let file;
+			try {
+				file = await new Promise((resolve, reject) => {
+					resolver.resolve({}, base, request, { missingDependencies }, (error, result) => {
+						if (error || !result) reject(error ?? /* @__PURE__ */ new Error(`Could not resolve '${id}' from '${base}'`));
+						else resolve(result);
+					});
+				});
+			} catch (error) {
+				resolutionError = error;
+				continue;
+			}
+			onResolved?.(file);
+			return file;
+		}
+		for (const file of missingDependencies ?? []) onMissingDependency?.(file);
+		if (onMissingDependency && (request.startsWith(".") || path.isAbsolute(request))) {
+			const directory = await existingParentDirectory(path.resolve(base, request));
+			if (directory) onMissingDependency(directory);
+		}
+		throw resolutionError;
+	};
+}
+/** A missing nested directory cannot be watched yet; its closest existing ancestor observes creation of the remaining path. Only failed local requests use this recovery watch, which drops out after successful resolution. */
+async function existingParentDirectory(file) {
+	let directory = path.dirname(file);
+	while (!(await stat(directory).catch(() => null))?.isDirectory()) {
+		const parent = path.dirname(directory);
+		if (parent === directory) return;
+		directory = parent;
+	}
+	return directory;
+}
+/** Recognize local static imports, re-exports, dynamic imports, and requires even in incomplete source. Do not greedily span later statements' `from` clauses; extra matches in comments or strings only broaden failure-recovery watches. */
+const MODULE_IMPORT_PATTERNS = [/\b(?:import|export)\s+(?:[^'";]*?\s+from\s*)?['"]([^'"]+)['"]/g, /\b(?:require|import)\s*\(\s*['"`]([^'"`]+)['"`]/g];
+//#endregion
+//#region ../configurator/src/design-system.ts
+/**
+* Loads project and vanilla systems through the same installed compiler and CSS-resolution base. The vanilla system is the reference for diffing and classifying theme-created classes; comparisons are only meaningful with an identical compiler.
+*/
+async function loadDesignSystems({ css, base, integration }) {
+	const project = await loadDesignSystem(css, base, integration);
+	const vanilla = await loadDesignSystem(`@import 'tailwindcss'${project.important ? " important" : ""};`, base, integration);
+	return {
+		project: memoizeClassList(project),
+		vanilla: memoizeClassList(vanilla)
+	};
+}
+/** The node wrapper currently drops resolver hooks when loading a design system. Use its own Tailwind engine with explicit loaders for bundler integrations, without changing globals or resolving a different compiler from the project. */
+async function loadDesignSystem(css, base, integration) {
+	if (!integration) return __unstable__loadDesignSystem(css, { base });
+	const engine = await (tailwindEngine ??= loadTailwindEngine());
+	const resolveStylesheet = createStylesheetResolver(integration.resolveCss, integration.onDependency, integration.onDependency);
+	const resolveModule = createModuleResolver(integration.resolveJs, integration.onDependency);
+	return engine.__unstable__loadDesignSystem(css, {
+		base,
+		async loadStylesheet(id, from) {
+			const file = await resolveStylesheet(id, from);
+			return {
+				path: file,
+				base: path.dirname(file),
+				content: await readFile(file, "utf8")
+			};
+		},
+		async loadModule(id, from) {
+			const file = await resolveModule(id, from);
+			if (integration.onDependency) await trackModuleDependencies(file, integration.onDependency);
+			return loadModule(`./${path.relative(from, file)}`, from, integration.onDependency ?? (() => {}), async () => file);
+		}
+	});
+}
+let tailwindEngine;
+/** Resolves and imports the compiler once per process. A failed load is not kept: the next generation retries, e.g. once an install has finished relinking node_modules, instead of every later generation in a dev server rethrowing the stale error. */
+function loadTailwindEngine() {
+	const engine = loadModule("tailwindcss", path.dirname(fileURLToPath(import.meta.resolve("@tailwindcss/node"))), () => {}).then(({ path: file }) => import(pathToFileURL(file).href));
+	engine.catch(() => {
+		tailwindEngine = void 0;
+	});
+	return engine;
+}
+/**
+* Caches `getClassList()` on a loaded design system. Tailwind rebuilds the list on every call, and the custom-utility, augmentation, and collision passes share it. Repeated rebuilds previously dominated generation time on themes with many custom utilities. A loaded design system never changes, so caching is safe; consumers replace the object for a new theme.
+*/
+function memoizeClassList(designSystem) {
+	const original = designSystem.getClassList.bind(designSystem);
+	let classList;
+	designSystem.getClassList = () => classList ??= original();
+	return designSystem;
+}
+/**
+* Compiles a class through Tailwind and returns its declarations, or null when the class produces no CSS. Callers pass unprefixed class names (the form `getClassList()` uses everywhere); the candidate is prefixed automatically when the theme defines a prefix, because Tailwind only compiles `tw:p-2`-style candidates there — without this, every declaration-based pass silently saw prefixed themes as producing no CSS. `@property` registrations and `@keyframes` bodies are skipped: composable utilities share the former without conflicting, and the latter describe animation frames, not what the class sets on an element. Values matter to the conflict oracle: two classes re-declaring the same property with identical text are idempotent together and carry their real state elsewhere (usually in custom properties).
+*/
+function declaredDeclarations(designSystem, className) {
+	let cache = declarationsCache.get(designSystem);
+	if (!cache) {
+		cache = /* @__PURE__ */ new Map();
+		declarationsCache.set(designSystem, cache);
+	}
+	let declarations = cache.get(className);
+	if (declarations === void 0) {
+		const candidate = toCandidate(designSystem, className);
+		const css = designSystem.candidatesToCss([candidate])[0] ?? null;
+		declarations = css === null ? null : parseDeclarations(css, candidate);
+		cache.set(className, declarations);
+	}
+	return declarations;
+}
+/**
+* The context-qualified property names of a class — the signature used for class-group classification, where values and conditions don't matter but render targets do: `color` on the element and `color` on `::before` are different things to set.
+*/
+function declaredProperties(designSystem, className) {
+	const declarations = declaredDeclarations(designSystem, className);
+	return declarations === null ? null : new Set(declarations.map((entry) => qualifiedProperty(entry)));
+}
+/** Key joining render target and property name, e.g. `'::after border-color'`; base-context entries stay the bare property name. */
+function qualifiedProperty(entry) {
+	return entry.context === "" ? entry.property : `${entry.context} ${entry.property}`;
+}
+/** Shared scaffolding must apply under the same guards on the same target; equal property/value text alone cannot prove that. Header order is kept conservatively rather than attempting CSS condition equivalence. */
+function sameDeclarationScope(first, second) {
+	return first.context === second.context && first.scope.length === second.scope.length && first.scope.every((header, index) => header === second.scope[index]);
+}
+/**
+* Whether each class name compiles to CSS, checked in one `candidatesToCss` batch — the batched boolean form of the prefix-aware compilation `declaredDeclarations` does per class. Use one of the two over raw `candidatesToCss` so the answer holds for prefixed themes.
+*/
+function classesCompile(designSystem, classNames) {
+	const candidates = classNames.map((className) => toCandidate(designSystem, className));
+	return designSystem.candidatesToCss(candidates).map((compiledCss) => compiledCss !== null);
+}
+/** The candidate string Tailwind compiles for a class name: prefixed under a theme prefix (`tw:p-2`), the name itself otherwise. Class lists and everything downstream of them stay unprefixed, so the prefix exists only at this compilation boundary. */
+function toCandidate(designSystem, className) {
+	const prefix = designSystem.theme.prefix;
+	return prefix === null ? className : `${prefix}:${className}`;
+}
+const declarationsCache = /* @__PURE__ */ new WeakMap();
+/** Proper-subset check over property names, used to recognize classes whose declarations span multiple groups' signatures. */
+function haveProperSubset(subset, superset) {
+	return subset.size < superset.size && [...subset].every((property) => superset.has(property));
+}
+/** Set equality over property names — the strict form of "these classes set the same things". */
+function havePropertiesEqual(first, second) {
+	return first.size === second.size && [...first].every((property) => second.has(property));
+}
+//#endregion
+//#region ../configurator/src/augment.ts
+/**
+* Finds new and reinterpreted project classes and determines their owning groups empirically, without a maintained namespace table.
+*
+* Mechanism: diff the project's class list against the vanilla one. Every new class is matched against candidate groups derived from its vanilla siblings (classes sharing the first name segment, e.g. `text-…`), where each candidate group is represented by the declared-property signature of one exemplar class. A unique signature match assigns the group — `text-primary` declares `color` like `text-red-500` does, not `font-size` like `text-xl` — which handles Tailwind's undocumented compat sub-namespaces (`--text-color-*`, `--background-color-*`) and namespaces tailwind-merge has no theme key for (`--z-index-*`, `--border-width-*`) with one rule. Ambiguous or unmatched classes are reported, never guessed.
+* Existing names are also checked when their group claim or membership in Tailwind's grouped suggestions changes; the deduplicated class list alone cannot reveal an added interpretation.
+*/
+function buildAugmentations({ project, vanilla, projectClassGroupId, vanillaClassGroupId, groupPrefixKeys, customGroupIds, preservedCustomClasses }) {
+	const vanillaClassNames = vanilla.getClassList().map(([className]) => className);
+	const vanillaClassNameSet = new Set(vanillaClassNames);
+	const projectClassNames = project.getClassList().map(([className]) => className);
+	const newClassNames = projectClassNames.filter((className) => !vanillaClassNameSet.has(className));
+	const projectClassNameSet = new Set(projectClassNames);
+	const exemplarsByFirstSegment = collectExemplars(vanillaClassNames, vanillaClassGroupId);
+	const changedSuggestionNames = changedUtilitySuggestions(project, vanilla);
+	const assignments = /* @__PURE__ */ new Map();
+	const collisions = [];
+	const unassigned = [];
+	const handledNames = /* @__PURE__ */ new Set();
+	for (const className of newClassNames) {
+		const registrationName = className.startsWith("-") ? className.slice(1) : className;
+		if (handledNames.has(registrationName)) continue;
+		if (preservedCustomClasses.has(registrationName)) {
+			handledNames.add(registrationName);
+			unassigned.push({
+				className: registrationName,
+				reason: "Custom utility effects cannot be distinguished safely by runtime lookup"
+			});
+			continue;
+		}
+		const claimingGroupId = projectClassGroupId(registrationName);
+		if (claimingGroupId !== void 0 && customGroupIds.has(claimingGroupId)) continue;
+		const properties = declaredProperties(project, className);
+		if (properties === null || properties.size === 0) continue;
+		handledNames.add(registrationName);
+		const targetGroupId = classifyByProperties(registrationName, properties, exemplarsByFirstSegment, vanilla);
+		if (typeof targetGroupId !== "string") {
+			if (targetGroupId.isJanus && claimingGroupId !== void 0) {
+				collisions.push({
+					className: registrationName,
+					claimingGroupId,
+					ownerGroupId: vanillaClassGroupId(registrationName) ?? claimingGroupId,
+					resolution: "neutralize"
+				});
+				continue;
+			}
+			if (claimingGroupId === void 0) unassigned.push({
+				className: registrationName,
+				reason: targetGroupId.reason
+			});
+			continue;
+		}
+		if (claimingGroupId === targetGroupId) continue;
+		if (claimingGroupId !== void 0) collisions.push({
+			className: registrationName,
+			claimingGroupId,
+			ownerGroupId: targetGroupId,
+			resolution: "restore"
+		});
+		const groupClassNames = assignments.get(targetGroupId);
+		if (groupClassNames) groupClassNames.push(registrationName);
+		else assignments.set(targetGroupId, [registrationName]);
+		for (const aliasName of aliasSpellings(registrationName, targetGroupId, groupPrefixKeys)) {
+			if (handledNames.has(aliasName) || projectClassGroupId(aliasName) === targetGroupId) continue;
+			const aliasDeclarations = declaredDeclarations(project, aliasName);
+			const classDeclarations = declaredDeclarations(project, registrationName);
+			if (aliasDeclarations !== null && classDeclarations !== null && declarationsEqual(aliasDeclarations, classDeclarations)) {
+				handledNames.add(aliasName);
+				assignments.get(targetGroupId).push(aliasName);
+			}
+		}
+	}
+	for (const className of vanillaClassNames) {
+		const registrationName = className.startsWith("-") ? className.slice(1) : className;
+		const projectGroupId = projectClassGroupId(className);
+		const vanillaGroupId = vanillaClassGroupId(className);
+		if (projectGroupId === vanillaGroupId && !changedSuggestionNames.has(registrationName) || projectGroupId === void 0 && !projectClassNameSet.has(className) || vanillaGroupId === void 0 || projectGroupId !== void 0 && customGroupIds.has(projectGroupId)) continue;
+		if (handledNames.has(registrationName)) continue;
+		const properties = declaredProperties(project, className);
+		if (properties === null || properties.size === 0) continue;
+		handledNames.add(registrationName);
+		if (projectGroupId === void 0) {
+			const targetGroupId = classifyByProperties(registrationName, properties, exemplarsByFirstSegment, vanilla);
+			if (typeof targetGroupId === "string") {
+				const groupClassNames = assignments.get(targetGroupId) ?? [];
+				groupClassNames.push(registrationName);
+				assignments.set(targetGroupId, groupClassNames);
+			} else if (!targetGroupId.isJanus) unassigned.push({
+				className: registrationName,
+				reason: targetGroupId.reason
+			});
+			continue;
+		}
+		const vanillaProperties = declaredProperties(vanilla, className);
+		if (vanillaProperties !== null && havePropertiesEqual(properties, vanillaProperties)) {
+			if (projectGroupId !== vanillaGroupId) collisions.push({
+				className: registrationName,
+				claimingGroupId: projectGroupId,
+				ownerGroupId: vanillaGroupId,
+				resolution: "restore"
+			});
+			continue;
+		}
+		const claimingSignature = exemplarsByFirstSegment.get(firstNameSegment(className))?.get(projectGroupId);
+		const claimingProperties = claimingSignature === void 0 ? null : declaredProperties(vanilla, claimingSignature);
+		if (vanillaProperties !== null && claimingProperties !== null && haveProperSubset(vanillaProperties, properties) && [...claimingProperties].every((property) => properties.has(property))) {
+			collisions.push({
+				className: registrationName,
+				claimingGroupId: projectGroupId,
+				ownerGroupId: vanillaGroupId,
+				resolution: "neutralize"
+			});
+			continue;
+		}
+		const targetGroupId = classifyByProperties(className, properties, exemplarsByFirstSegment, vanilla);
+		if (targetGroupId === projectGroupId) continue;
+		if (typeof targetGroupId !== "string" && targetGroupId.isJanus) collisions.push({
+			className: registrationName,
+			claimingGroupId: projectGroupId,
+			ownerGroupId: vanillaGroupId,
+			resolution: "neutralize"
+		});
+		else if (typeof targetGroupId === "string") {
+			if (targetGroupId !== vanillaGroupId) {
+				const groupClassNames = assignments.get(targetGroupId) ?? [];
+				groupClassNames.push(registrationName);
+				assignments.set(targetGroupId, groupClassNames);
+			}
+			collisions.push({
+				className: registrationName,
+				claimingGroupId: projectGroupId,
+				ownerGroupId: targetGroupId,
+				resolution: "restore"
+			});
+		} else unassigned.push({
+			className: registrationName,
+			reason: `classification changed but ${targetGroupId.reason}`
+		});
+	}
+	return {
+		assignments,
+		collisions,
+		unassigned
+	};
+}
+/**
+* Finds names added to or removed from each Tailwind suggestion branch, before getClassList merges duplicate names. A name can move between branches or gain a second interpretation while remaining in the final class list. Branches are compared by position within the same compiler's utility definition; a reordered branch only causes extra declaration checks. Negative forms share their positive registration path.
+*/
+function changedUtilitySuggestions(project, vanilla) {
+	const changed = /* @__PURE__ */ new Set();
+	for (const root of vanilla.utilities.keys("functional")) {
+		const before = vanilla.utilities.getCompletions(root);
+		const after = project.utilities.getCompletions(root);
+		for (let index = 0; index < Math.max(before.length, after.length); index++) {
+			const previousValues = new Set(before[index]?.values ?? []);
+			const nextValues = new Set(after[index]?.values ?? []);
+			for (const value of /* @__PURE__ */ new Set([...previousValues, ...nextValues])) if (previousValues.has(value) !== nextValues.has(value)) changed.add(value === null ? root : `${root}-${value}`);
+		}
+	}
+	return changed;
+}
+/**
+* One exemplar class per (first name segment, class group) pair, e.g. `text` → text-color: `text-red-500`. Only exemplars for segments that actually need classification get compiled later, so collecting names here is cheap.
+*/
+function collectExemplars(vanillaClassNames, vanillaClassGroupId) {
+	const exemplarsByFirstSegment = /* @__PURE__ */ new Map();
+	for (const className of vanillaClassNames) {
+		const firstSegment = firstNameSegment(className);
+		let groupExemplars = exemplarsByFirstSegment.get(firstSegment);
+		if (groupExemplars === void 0) {
+			groupExemplars = /* @__PURE__ */ new Map();
+			exemplarsByFirstSegment.set(firstSegment, groupExemplars);
+		}
+		const classGroupId = vanillaClassGroupId(className);
+		if (classGroupId !== void 0 && !groupExemplars.has(classGroupId)) groupExemplars.set(classGroupId, className);
+	}
+	return exemplarsByFirstSegment;
+}
+function classifyByProperties(className, properties, exemplarsByFirstSegment, vanilla) {
+	const groupExemplars = exemplarsByFirstSegment.get(firstNameSegment(className));
+	if (!groupExemplars || groupExemplars.size === 0) return {
+		reason: "no vanilla classes share its root",
+		isJanus: false
+	};
+	const matches = [];
+	let containedSignatures = 0;
+	for (const [classGroupId, exemplarClassName] of groupExemplars) {
+		const exemplarProperties = declaredProperties(vanilla, exemplarClassName);
+		if (exemplarProperties === null) continue;
+		if (havePropertiesEqual(properties, exemplarProperties)) matches.push(classGroupId);
+		else if (haveProperSubset(exemplarProperties, properties)) containedSignatures += 1;
+	}
+	if (matches.length === 1) return matches[0];
+	if (matches.length === 0 && containedSignatures >= 2) return {
+		reason: "resolves as multiple utilities at once",
+		isJanus: true
+	};
+	return {
+		reason: matches.length === 0 ? "no candidate group declares the same CSS properties" : `ambiguous between class groups ${matches.join(", ")}`,
+		isJanus: false
+	};
+}
+function firstNameSegment(className) {
+	const separatorIndex = className.indexOf("-");
+	return separatorIndex === -1 ? className : className.slice(0, separatorIndex);
+}
+/**
+* The same value under the target group's other class-name prefixes: `inset-s-sm` assigned to the `start` group (prefixes `inset-s` and `start`) yields the candidate `start-sm`. The longest matching prefix decides where the value part begins, so a prefix that happens to prefix another never mis-splits the name.
+*/
+function aliasSpellings(className, groupId, groupPrefixKeys) {
+	const prefixes = groupPrefixKeys.get(groupId);
+	if (!prefixes || prefixes.length < 2) return [];
+	const matchedPrefix = prefixes.filter((prefix) => className.startsWith(`${prefix}-`)).sort((first, second) => second.length - first.length)[0];
+	if (matchedPrefix === void 0) return [];
+	const value = className.slice(matchedPrefix.length + 1);
+	return prefixes.filter((prefix) => prefix !== matchedPrefix).map((prefix) => `${prefix}-${value}`);
+}
+/** Exact equality of two compiled declaration lists — the bar for treating two spellings as the same utility. */
+function declarationsEqual(first, second) {
+	return first.length === second.length && first.every((entry, index) => {
+		const other = second[index];
+		return sameDeclarationScope(entry, other) && entry.property === other.property && entry.important === other.important && entry.value === other.value;
+	});
+}
+//#endregion
+//#region ../configurator/src/compress.ts
+/**
+* Encodes a theme scale's value names into the smallest class-group representation the mode allows.
+*
+* Policy: the encoding must never fail to match a name that exists in the theme; whether it may overmatch names that don't exist is what `EncodingMode` decides. Candidates are compared by estimated emitted size:
+* - plain enumeration of all names
+* - 'compact' only: a validator covering all names, plus enumerated outliers (e.g. t-shirt sizes with a `base` outlier)
+* - families with a shared first segment collapsed into a nested entry (e.g. `{ red: [isNumber] }` for `red-50` … `red-950` — in 'exact' mode the tails enumerate instead, staying exact because only listed prefix+tail combinations match)
+*
+* The family encoding also mirrors Tailwind's own resolution order better than a flat validator: a named part match wins over sibling validators in the class map, exactly like Tailwind prefers a color namespace hit over a bare value interpretation.
+*/
+function encodeScale(names, encoding) {
+	if (names.length === 0) return {
+		items: [],
+		strategy: "empty"
+	};
+	const candidates = [
+		...encoding === "compact" ? encodeWithValidators(names) : [],
+		encodeAsFamilies(names, encoding),
+		{
+			items: names.map(literal),
+			strategy: "enumerated"
+		}
+	].filter((candidate) => candidate !== null);
+	let best = candidates[0];
+	let bestCost = estimateCost(best.items);
+	for (let index = 1; index < candidates.length; index++) {
+		const candidate = candidates[index];
+		const cost = estimateCost(candidate.items);
+		if (cost < bestCost) {
+			best = candidate;
+			bestCost = cost;
+		}
+	}
+	return best;
+}
+/**
+* Rough size in characters of the emitted representation. Only used to compare encodings of the same scale against each other, so precision doesn't matter as long as it is monotonic with real output size.
+*/
+function estimateCost(items) {
+	let cost = 0;
+	for (const item of items) if (item.kind === "class") cost += item.value.length + 4;
+	else if (item.kind === "validator") cost += item.name.length + 4;
+	else {
+		cost += 4;
+		for (const [key, entryItems] of item.entries) cost += key.length + 4 + estimateCost(entryItems);
+	}
+	return cost;
+}
+/**
+* Validators that are worth trying as whole-scale replacements. Ordered from most to least specific so that on equal cost the least overmatching candidate wins via first-strictly-smaller comparison in `encodeScale`.
+*/
+const VALIDATOR_CANDIDATES = [
+	["isTshirtSize", validators.isTshirtSize],
+	["isFraction", validators.isFraction],
+	["isNumber", validators.isNumber]
+];
+function encodeWithValidators(names) {
+	return VALIDATOR_CANDIDATES.flatMap(([name, validator]) => {
+		const outliers = names.filter((value) => !validator(value));
+		const coveredCount = names.length - outliers.length;
+		if (coveredCount < 3 || outliers.length > coveredCount) return [];
+		return [{
+			items: [...outliers.map(literal), {
+				kind: "validator",
+				name
+			}],
+			strategy: outliers.length === 0 ? `validator:${name}` : `mixed:${name}`
+		}];
+	});
+}
+/**
+* Collapses names sharing a first segment into one nested entry per family, with the tails themselves encoded recursively through `encodeScale` — so numeric shades still end in a validator (`{ red: [isNumber] }`), word tails enumerate without repeating the prefix (`{ gap: ['narrow', 'wide'] }`), and multi-segment names factor further (`{ background: [{ alternative: [isNumber] }] }`). Each family keeps the factored form only when it estimates smaller than enumerating its members, so short families don't pay the object overhead. Structural factoring measures smaller on minified AND compressed output (unlike reference-based sharing, it removes repetition without adding entropy — see EmitOptions.sharing for that contrast).
+*/
+function encodeAsFamilies(names, encoding) {
+	const families = /* @__PURE__ */ new Map();
+	for (const name of names) {
+		const separatorIndex = name.indexOf("-");
+		if (separatorIndex > 0) {
+			const familyName = name.slice(0, separatorIndex);
+			const tail = name.slice(separatorIndex + 1);
+			let family = families.get(familyName);
+			if (!family) {
+				family = {
+					tails: [],
+					enumeratedCost: 0
+				};
+				families.set(familyName, family);
+			}
+			family.tails.push(tail);
+			family.enumeratedCost += name.length + 4;
+		}
+	}
+	const factoredFamilies = /* @__PURE__ */ new Map();
+	for (const [familyName, { tails, enumeratedCost }] of families) {
+		if (tails.length < 2) continue;
+		const tailEncoding = encodeScale(tails, encoding);
+		if (familyName.length + 4 + estimateCost(tailEncoding.items) < enumeratedCost) factoredFamilies.set(familyName, tailEncoding.items);
+	}
+	if (factoredFamilies.size === 0) return null;
+	const items = [];
+	const familiesObject = {
+		kind: "object",
+		entries: []
+	};
+	const emittedFamilies = /* @__PURE__ */ new Set();
+	for (const name of names) {
+		const separatorIndex = name.indexOf("-");
+		const familyName = separatorIndex > 0 ? name.slice(0, separatorIndex) : null;
+		if (familyName === null || !factoredFamilies.has(familyName)) {
+			items.push(literal(name));
+			continue;
+		}
+		if (!emittedFamilies.has(familyName)) {
+			emittedFamilies.add(familyName);
+			if (familiesObject.entries.length === 0) items.push(familiesObject);
+			familiesObject.entries.push([familyName, factoredFamilies.get(familyName)]);
+		}
+	}
+	return {
+		items,
+		strategy: "families"
+	};
+}
+function literal(value) {
+	return {
+		kind: "class",
+		value
+	};
+}
+//#endregion
+//#region ../configurator/src/property-coverage.ts
+/**
+* Whether setting one property fully controls another, using only known CSS shorthand relationships. Name resemblance is insufficient: `font` excludes `font-synthesis`, and `border-width` excludes `border-image-width`. Unknown relationships preserve classes conservatively.
+* Logical axis coverage follows the default config's horizontal-tb policy (`padding-inline` covers left/right). Single logical sides remain unrelated to physical sides because their mapping also depends on text direction.
+*/
+function propertyCovers(property, target) {
+	if (property === target) return true;
+	const longhands = SHORTHAND_LONGHANDS.get(property);
+	if (!longhands) return false;
+	const targetLonghands = SHORTHAND_LONGHANDS.get(target);
+	return targetLonghands ? [...targetLonghands].every((longhand) => longhands.has(longhand)) : longhands.has(target);
+}
+/** Expands the known shorthand graph once, including reset-only longhands. This also handles overlapping shorthands, such as border-inline covering border-left under the horizontal-tb policy, without guessing from property names. */
+function buildShorthandLonghands() {
+	const shorthands = new Map(Object.entries({
+		animation: [
+			"animation-name",
+			"animation-duration",
+			"animation-timing-function",
+			"animation-delay",
+			"animation-iteration-count",
+			"animation-direction",
+			"animation-fill-mode",
+			"animation-play-state"
+		],
+		background: [
+			"background-image",
+			"background-position",
+			"background-size",
+			"background-repeat",
+			"background-origin",
+			"background-clip",
+			"background-attachment",
+			"background-color"
+		],
+		"background-position": ["background-position-x", "background-position-y"],
+		border: [
+			"border-width",
+			"border-style",
+			"border-color",
+			"border-image"
+		],
+		"border-image": [
+			"border-image-source",
+			"border-image-slice",
+			"border-image-width",
+			"border-image-outset",
+			"border-image-repeat"
+		],
+		"border-radius": [
+			"border-top-left-radius",
+			"border-top-right-radius",
+			"border-bottom-left-radius",
+			"border-bottom-right-radius",
+			"border-start-start-radius",
+			"border-start-end-radius",
+			"border-end-start-radius",
+			"border-end-end-radius"
+		],
+		"column-rule": [
+			"column-rule-width",
+			"column-rule-style",
+			"column-rule-color"
+		],
+		columns: ["column-width", "column-count"],
+		container: ["container-name", "container-type"],
+		flex: [
+			"flex-grow",
+			"flex-shrink",
+			"flex-basis"
+		],
+		"flex-flow": ["flex-direction", "flex-wrap"],
+		font: [
+			"font-family",
+			"font-size",
+			"font-width",
+			"font-stretch",
+			"font-style",
+			"font-weight",
+			"line-height",
+			"font-variant",
+			"font-feature-settings",
+			"font-kerning",
+			"font-language-override",
+			"font-optical-sizing",
+			"font-size-adjust",
+			"font-variation-settings"
+		],
+		"font-variant": [
+			"font-variant-alternates",
+			"font-variant-caps",
+			"font-variant-east-asian",
+			"font-variant-emoji",
+			"font-variant-ligatures",
+			"font-variant-numeric",
+			"font-variant-position"
+		],
+		"font-synthesis": [
+			"font-synthesis-weight",
+			"font-synthesis-style",
+			"font-synthesis-small-caps",
+			"font-synthesis-position"
+		],
+		gap: ["row-gap", "column-gap"],
+		grid: [
+			"grid-template",
+			"grid-auto-flow",
+			"grid-auto-rows",
+			"grid-auto-columns"
+		],
+		"grid-template": [
+			"grid-template-rows",
+			"grid-template-columns",
+			"grid-template-areas"
+		],
+		"grid-area": ["grid-row", "grid-column"],
+		"grid-row": ["grid-row-start", "grid-row-end"],
+		"grid-column": ["grid-column-start", "grid-column-end"],
+		"list-style": [
+			"list-style-image",
+			"list-style-position",
+			"list-style-type"
+		],
+		mask: [
+			"mask-image",
+			"mask-mode",
+			"mask-position",
+			"mask-size",
+			"mask-repeat",
+			"mask-origin",
+			"mask-clip",
+			"mask-composite"
+		],
+		"mask-border": [
+			"mask-border-source",
+			"mask-border-slice",
+			"mask-border-width",
+			"mask-border-outset",
+			"mask-border-repeat",
+			"mask-border-mode"
+		],
+		offset: [
+			"offset-position",
+			"offset-path",
+			"offset-distance",
+			"offset-rotate",
+			"offset-anchor"
+		],
+		outline: [
+			"outline-width",
+			"outline-style",
+			"outline-color"
+		],
+		overflow: ["overflow-x", "overflow-y"],
+		"overscroll-behavior": ["overscroll-behavior-x", "overscroll-behavior-y"],
+		"place-content": ["align-content", "justify-content"],
+		"place-items": ["align-items", "justify-items"],
+		"place-self": ["align-self", "justify-self"],
+		"text-decoration": [
+			"text-decoration-line",
+			"text-decoration-style",
+			"text-decoration-color",
+			"text-decoration-thickness"
+		],
+		"text-emphasis": ["text-emphasis-style", "text-emphasis-color"],
+		transition: [
+			"transition-property",
+			"transition-duration",
+			"transition-timing-function",
+			"transition-delay",
+			"transition-behavior"
+		],
+		"-webkit-text-stroke": ["-webkit-text-stroke-width", "-webkit-text-stroke-color"]
+	}));
+	for (const name of [
+		"margin",
+		"padding",
+		"scroll-margin",
+		"scroll-padding"
+	]) addBoxShorthand(shorthands, name, (side) => `${name}-${side}`);
+	addBoxShorthand(shorthands, "inset", (side) => side.startsWith("inline") || side.startsWith("block") ? `inset-${side}` : side);
+	const borderComponents = [
+		"width",
+		"style",
+		"color"
+	];
+	for (const component of borderComponents) addBoxShorthand(shorthands, `border-${component}`, (side) => `border-${side}-${component}`);
+	for (const side of [
+		"top",
+		"right",
+		"bottom",
+		"left",
+		"inline",
+		"block",
+		"inline-start",
+		"inline-end",
+		"block-start",
+		"block-end"
+	]) shorthands.set(`border-${side}`, borderComponents.map((part) => `border-${side}-${part}`));
+	const expanded = /* @__PURE__ */ new Map();
+	const expand = (property) => {
+		const cached = expanded.get(property);
+		if (cached) return cached;
+		const longhands = /* @__PURE__ */ new Set();
+		for (const child of shorthands.get(property)) for (const longhand of shorthands.has(child) ? expand(child) : [child]) longhands.add(longhand);
+		expanded.set(property, longhands);
+		return longhands;
+	};
+	for (const property of shorthands.keys()) expand(property);
+	return expanded;
+}
+/** Registers a known four-sided shorthand and its logical axes, retaining the library's horizontal-tb axis policy without equating individual logical and physical sides. */
+function addBoxShorthand(shorthands, name, sideProperty) {
+	shorthands.set(name, [
+		"top",
+		"right",
+		"bottom",
+		"left",
+		"inline",
+		"block"
+	].map(sideProperty));
+	for (const [axis, sides] of [["inline", ["left", "right"]], ["block", ["top", "bottom"]]]) shorthands.set(sideProperty(axis), [
+		`${axis}-start`,
+		`${axis}-end`,
+		...sides
+	].map(sideProperty));
+}
+const SHORTHAND_LONGHANDS = buildShorthandLonghands();
+//#endregion
+//#region ../configurator/src/custom-utilities.ts
+/**
+* Plans tailwind-merge support for utilities the project registers beyond the built-ins — both `@utility` definitions in CSS and utilities added by `@plugin` JS plugins land in the same registry, so one diff covers both.
+*
+* Support is empirical, derived entirely from each utility's compiled declarations, in three tiers:
+*
+* 1. A static utility whose declarations match exactly one built-in group's signature and mutually cover its effects is an alias of that group (an unconditional `color` utility behaves like `text-red-500`), so it joins the group and merges with its classes in both directions.
+* 2. Other utilities receive self-conflict groups, splitting functional values when their compiled effects differ. When a group's declarations fully cover what another group sets (`btn` with `padding` + `border-radius` covers everything `p-4` sets; see `fullyCovers` for the exact rule), an override edge is added so the utility coming later removes the covered class. The reverse direction stays out on purpose: `p-4` after `btn` only overrides part of `btn`, and removing `btn` would lose the rest of its effect — the same partial-override rule the default config applies between `px` and `p`.
+* 3. Declarations that are conditional (media queries, dark-mode guards) or target other elements (pseudo-elements, child selectors) only count as covered when they are byte-identical shared scaffolding: they overlap only sometimes or somewhere else, so a utility that merely touches them stays side by side with whatever it partially overlaps.
+*
+* Functional roots whose slash modifiers change effects without a matching full-class group remain unclassified: the runtime's fallback from an unknown full class to its base group would otherwise discard those effects.
+*
+* Roots that already exist as built-ins are skipped entirely: shadowing changes built-in behavior in ways a registry diff cannot judge. Such roots are reported so the gap is visible instead of silent.
+*/
+function buildCustomUtilityPlan({ project, vanilla, vanillaClassGroupId, encoding }) {
+	const vanillaRoots = /* @__PURE__ */ new Set([...vanilla.utilities.keys("static"), ...vanilla.utilities.keys("functional")]);
+	const functionalRoots = project.utilities.keys("functional").filter((root) => !vanillaRoots.has(root));
+	const extendedBuiltInRoots = project.utilities.keys("functional").filter((root) => vanillaRoots.has(root) && project.utilities.getCompletions(root).length > vanilla.utilities.getCompletions(root).length);
+	const staticRoots = project.utilities.keys("static").filter((root) => !vanillaRoots.has(root));
+	const staticRootSet = new Set(staticRoots);
+	const lookupRoots = [...project.utilities.keys("static"), ...project.utilities.keys("functional")].map((root) => root.startsWith("-") ? root.slice(1) : root);
+	const functionalClasses = collectFunctionalClasses(project, functionalRoots);
+	const functionalShapes = new Map([...functionalClasses].map(([root, classNames]) => [root, groupFunctionalClasses(project, root, classNames)]));
+	const preservedClasses = reconcileNegativeRoots(project, functionalShapes, staticRoots);
+	const functionalExemplars = new Map([...functionalShapes].map(([root, shapes]) => [root, shapes?.[0]?.exemplar ?? null]));
+	const groupSignatures = collectGroupSignatures(vanilla, vanillaClassGroupId);
+	const groups = /* @__PURE__ */ new Map();
+	const aliases = /* @__PURE__ */ new Map();
+	const postfixLookupClassGroups = [];
+	for (const root of staticRoots) {
+		const lookupRoot = root.startsWith("-") ? root.slice(1) : root;
+		if (preservedClasses.has(lookupRoot)) continue;
+		if (functionalClasses.has(root)) {
+			const functionalExemplar = functionalExemplars.get(root) ?? null;
+			if (functionalExemplar !== null && functionalShapes.get(root)?.length === 1 && fullyCovers(declaredDeclarations(project, root), declaredDeclarations(project, functionalExemplar)) && fullyCovers(declaredDeclarations(project, functionalExemplar), declaredDeclarations(project, root))) continue;
+			groups.set(`${customUtilityGroupId(lookupRoot)}.static`, {
+				items: [{
+					kind: "class",
+					value: lookupRoot
+				}],
+				exemplar: root
+			});
+			continue;
+		}
+		const aliasGroupId = findAliasGroup(project, root, groupSignatures);
+		if (aliasGroupId !== null) aliases.set(lookupRoot, aliasGroupId);
+		else groups.set(customUtilityGroupId(lookupRoot), {
+			items: [{
+				kind: "class",
+				value: lookupRoot
+			}],
+			exemplar: root
+		});
+	}
+	for (const root of functionalRoots) {
+		const lookupRoot = root.startsWith("-") ? root.slice(1) : root;
+		const groupId = customUtilityGroupId(lookupRoot);
+		const shapes = functionalShapes.get(root);
+		if (!shapes) {
+			for (const className of functionalClasses.get(root)) preservedClasses.add(className.startsWith("-") ? className.slice(1) : className);
+			continue;
+		}
+		if (shapes.length > 1) {
+			for (const [index, shape] of shapes.entries()) {
+				const valueItems = encodeScale(shape.classNames.map((className) => className.slice(root.length + 1)), "exact").items;
+				valueItems.push(...shape.validators.filter((name) => name !== "isInteger" || !shape.validators.includes("isNumber")).map((name) => ({
+					kind: "validator",
+					name
+				})));
+				if (valueItems.length > 0) {
+					const shapeGroupId = `${groupId}.${index}`;
+					groups.set(shapeGroupId, {
+						items: [{
+							kind: "object",
+							entries: [[lookupRoot, valueItems]]
+						}],
+						exemplar: shape.exemplar
+					});
+					postfixLookupClassGroups.push(shapeGroupId);
+				}
+			}
+			continue;
+		}
+		const items = [];
+		if (staticRootSet.has(root) && !preservedClasses.has(lookupRoot) && !groups.has(`${groupId}.static`)) items.push({
+			kind: "class",
+			value: lookupRoot
+		});
+		else if (!staticRootSet.has(root) && bareValueJoinsRoot(project, root, shapes[0])) items.push({
+			kind: "class",
+			value: lookupRoot
+		});
+		const hasDescendantRoot = lookupRoots.some((candidate) => candidate.startsWith(`${lookupRoot}-`));
+		const valueItems = encoding === "compact" && !hasDescendantRoot ? [{
+			kind: "validator",
+			name: "isAny"
+		}] : exactFunctionalValueItems(project, root, functionalClasses.get(root).map((className) => className.slice(root.length + 1)));
+		if (valueItems.length > 0) items.push({
+			kind: "object",
+			entries: [[lookupRoot, valueItems]]
+		});
+		if (items.length > 0) {
+			const existing = groups.get(groupId);
+			groups.set(groupId, {
+				items: [...existing?.items ?? [], ...items],
+				exemplar: existing?.exemplar ?? functionalExemplars.get(root) ?? null
+			});
+		}
+	}
+	return {
+		groups: new Map([...groups].map(([groupId, group]) => [groupId, group.items])),
+		aliases,
+		conflicts: inferOverrideConflicts(project, groups, groupSignatures),
+		postfixLookupClassGroups,
+		preservedClasses,
+		extendedBuiltInRoots
+	};
+}
+/** Runtime lookup removes a leading minus, so opposite static names, functional roots, and overlapping static/functional names share trie paths. Only compatible effects can share those paths. Preserve conflicting roots and their static claims together, including would-be aliases: either remaining claim could otherwise classify both signs and discard independent styles. */
+function reconcileNegativeRoots(project, shapesByRoot, staticRoots) {
+	const preservedStaticClasses = /* @__PURE__ */ new Set();
+	const staticRootSet = new Set(staticRoots);
+	for (const root of staticRoots) {
+		if (!root.startsWith("-") || !staticRootSet.has(root.slice(1))) continue;
+		const negative = declaredDeclarations(project, root);
+		const positive = declaredDeclarations(project, root.slice(1));
+		if (!fullyCovers(negative, positive) || !fullyCovers(positive, negative)) preservedStaticClasses.add(root.slice(1));
+	}
+	for (const [root, shapes] of shapesByRoot) {
+		if (!root.startsWith("-")) continue;
+		const positiveRoot = root.slice(1);
+		const positiveShapes = shapesByRoot.get(positiveRoot);
+		let compatible = shapes !== null;
+		if (positiveShapes !== void 0) {
+			if (shapes?.length === 1 && positiveShapes?.length === 1) {
+				const negative = declaredDeclarations(project, shapes[0].exemplar);
+				const positive = declaredDeclarations(project, positiveShapes[0].exemplar);
+				compatible &&= fullyCovers(negative, positive) && fullyCovers(positive, negative);
+			} else compatible = false;
+		}
+		const staticClaims = [];
+		for (const className of staticRoots) {
+			if (className !== positiveRoot && !className.startsWith(`${positiveRoot}-`)) continue;
+			const negative = declaredDeclarations(project, `-${className}`);
+			if (!negative?.length) continue;
+			staticClaims.push(className);
+			const positive = declaredDeclarations(project, className);
+			compatible &&= fullyCovers(negative, positive) && fullyCovers(positive, negative);
+		}
+		if (compatible) continue;
+		shapesByRoot.set(root, null);
+		if (shapesByRoot.has(positiveRoot)) shapesByRoot.set(positiveRoot, null);
+		for (const className of staticClaims) preservedStaticClasses.add(className);
+	}
+	return preservedStaticClasses;
+}
+/** Whether a functional root's bare class (a plugin `DEFAULT` value) compiles and covers its shape's exemplar both ways, like a static root that joins its functional group. */
+function bareValueJoinsRoot(project, root, shape) {
+	const bare = declaredDeclarations(project, root);
+	if (!bare?.length) return false;
+	const exemplar = declaredDeclarations(project, shape.exemplar);
+	return fullyCovers(bare, exemplar) && fullyCovers(exemplar, bare);
+}
+/** Group IDs get a `utility.` prefix so they cannot collide with the skeleton's group IDs and are recognizable in reports and the emitted config. */
+function customUtilityGroupId(root) {
+	return `utility.${root}`;
+}
+/**
+* Indexes suggested classes and their slash modifiers once for both encoding and conflict inference. Modifiers can enable independent declarations through --modifier(), so their complete candidates must participate in effect grouping. Bare utility names belong to their own roots; other classes belong to the longest functional root that prefixes them. Using the same ownership rule prevents a nested root such as `demo-child-*` from becoming the exemplar or a named value of `demo-*`.
+*/
+function collectFunctionalClasses(project, functionalRoots) {
+	const classesByRoot = new Map(functionalRoots.map((root) => [root, []]));
+	if (functionalRoots.length === 0) return classesByRoot;
+	const projectFunctionalRoots = project.utilities.keys("functional");
+	const bareRoots = /* @__PURE__ */ new Set([...project.utilities.keys("static"), ...projectFunctionalRoots]);
+	const longestRootsFirst = projectFunctionalRoots.sort((first, second) => second.length - first.length);
+	const seen = /* @__PURE__ */ new Set();
+	for (const [className, { modifiers }] of project.getClassList()) {
+		if (bareRoots.has(className) || !functionalRoots.some((root) => className.startsWith(`${root}-`))) continue;
+		const root = longestRootsFirst.find((candidate) => className.startsWith(`${candidate}-`));
+		const classes = root === void 0 ? void 0 : classesByRoot.get(root);
+		if (classes) {
+			for (const candidate of [className, ...modifiers.map((modifier) => `${className}/${modifier}`)]) if (!seen.has(candidate)) {
+				seen.add(candidate);
+				classes.push(candidate);
+			}
+		}
+	}
+	return classesByRoot;
+}
+/** Groups named values and numeric kinds by their compiled effects, ignoring values but preserving rule scope and importance. Probe-only shapes prevent unsafe root-wide matchers without registering probe names. Returns null when postfix effects lack a matching full-class group: the runtime falls back to a recognized base group on a full-lookup miss, so leaving only the postfix unclassified would still discard its independent styles. */
+function groupFunctionalClasses(project, root, classNames) {
+	const groups = /* @__PURE__ */ new Map();
+	const groupsByClassName = /* @__PURE__ */ new Map();
+	const namedClasses = new Set(classNames);
+	const candidates = /* @__PURE__ */ new Set([...classNames, ...FUNCTIONAL_VALUE_PROBES.map((tail) => `${root}-${tail}`)]);
+	for (const className of candidates) {
+		const declarations = declaredDeclarations(project, className);
+		if (!declarations?.length) continue;
+		const signature = functionalEffectSignature(declarations);
+		const group = groups.get(signature) ?? {
+			classNames: [],
+			exemplar: className,
+			validators: []
+		};
+		if (namedClasses.has(className)) group.classNames.push(className);
+		groups.set(signature, group);
+		groupsByClassName.set(className, group);
+	}
+	for (const [validator, sentinels] of BARE_VALUE_PROBES) {
+		const group = groupsByClassName.get(`${root}-${sentinels[0]}`);
+		if (group && sentinels.every((tail) => groupsByClassName.get(`${root}-${tail}`) === group)) group.validators.push(validator);
+	}
+	const result = [...groups.values()];
+	const integerGroup = result.find((group) => group.validators.includes("isInteger"));
+	if (integerGroup) {
+		result.splice(result.indexOf(integerGroup), 1);
+		result.unshift(integerGroup);
+	}
+	const modifiers = /* @__PURE__ */ new Set([...project.utilities.getCompletions(root).flatMap((suggestion) => suggestion.modifiers), ...MODIFIER_PROBES]);
+	for (const className of candidates) {
+		if (segment(className, "/").length > 1) continue;
+		const baseGroup = groupsByClassName.get(className);
+		for (const modifier of modifiers) {
+			const modifiedClass = `${className}/${modifier}`;
+			const declarations = declaredDeclarations(project, modifiedClass);
+			if (!declarations?.length) continue;
+			const modifiedGroup = groups.get(functionalEffectSignature(declarations));
+			if (baseGroup && modifiedGroup === baseGroup) continue;
+			const tail = modifiedClass.slice(root.length + 1);
+			const lookupGroup = namedClasses.has(modifiedClass) ? groupsByClassName.get(modifiedClass) : result.find((group) => group.validators.some((name) => validators[name](tail)));
+			if (!modifiedGroup || lookupGroup !== modifiedGroup) return null;
+		}
+	}
+	return result;
+}
+/** Values can vary within a functional group; its affected properties, targets, guards, and importance must remain the same. */
+function functionalEffectSignature(declarations) {
+	return [...new Set(declarations.map((entry) => JSON.stringify([
+		entry.context,
+		entry.scope,
+		entry.property,
+		entry.important
+	])))].sort().join("\n");
+}
+/**
+* Value kinds a functional utility can accept beyond its named values, tested with sentinel candidates: accepting the kind (`--value(number)` compiles every number) permits an open validator. The sentinels use unusual theme-token names, with two per kind to reduce the chance that named tokens impersonate open-ended support.
+*/
+const BARE_VALUE_PROBES = [
+	["isFraction", ["355/113", "19/97"]],
+	["isNumber", ["971.5", "823.25"]],
+	["isInteger", ["9713", "8231"]],
+	["isPercent", ["79%", "61%"]]
+];
+/**
+* Representatives covering Tailwind's recognized arbitrary data types for both base values and slash modifiers. Missing a type can make a root with independent branches look uniform, granting an unsafe broad matcher. Some types overlap: lengths also cover position, background size, and line width; URLs cover images; identifiers cover family names.
+*/
+const ARBITRARY_VALUE_PROBES = [
+	"[3px]",
+	"[7]",
+	"[41%]",
+	"[#650a1b]",
+	"[twm-probe]",
+	"[13/7]",
+	"[url(twm-probe.svg)]",
+	"[serif]",
+	"[medium]",
+	"[larger]",
+	"[13deg]",
+	"[1_2_3]"
+];
+const ARBITRARY_VARIABLE_PROBE = "(--twm-probe)";
+const MODIFIER_PROBES = [
+	...BARE_VALUE_PROBES.filter(([name]) => name !== "isFraction").flatMap(([, sentinels]) => sentinels),
+	...ARBITRARY_VALUE_PROBES,
+	ARBITRARY_VARIABLE_PROBE
+];
+const FUNCTIONAL_VALUE_PROBES = [
+	...BARE_VALUE_PROBES.flatMap(([, sentinels]) => sentinels),
+	...ARBITRARY_VALUE_PROBES,
+	ARBITRARY_VARIABLE_PROBE
+];
+/**
+* The exact-mode value matchers of a functional root whose compiled effects are uniform across suggestions and probes: compile-verified named values (scale-encoded, so families still factor), plus validators for accepted open-ended value kinds. Arbitrary-value matchers still approximate Tailwind's type inference: `isArbitraryValue` can match a wrong type (`ll-[red]` on a `--value([length])` utility), and representative probes do not validate every possible arbitrary value or explicit type label. Mixed-effect roots bypass this helper to avoid assigning different arbitrary branches to one group.
+*/
+function exactFunctionalValueItems(project, root, namedTails) {
+	const allTails = [...namedTails, ...FUNCTIONAL_VALUE_PROBES];
+	const compileResults = classesCompile(project, allTails.map((tail) => `${root}-${tail}`));
+	const compiledTails = new Set(allTails.filter((_, index) => compileResults[index]));
+	const items = encodeScale(namedTails.filter((tail) => compiledTails.has(tail)), "exact").items;
+	const acceptedKinds = BARE_VALUE_PROBES.filter(([, sentinels]) => sentinels.every((sentinel) => compiledTails.has(sentinel))).map(([validatorName]) => validatorName);
+	for (const validatorName of acceptedKinds) {
+		if (validatorName === "isInteger" && acceptedKinds.includes("isNumber")) continue;
+		items.push({
+			kind: "validator",
+			name: validatorName
+		});
+	}
+	if (ARBITRARY_VALUE_PROBES.some((probe) => compiledTails.has(probe))) items.push({
+		kind: "validator",
+		name: "isArbitraryValue"
+	});
+	if (compiledTails.has(ARBITRARY_VARIABLE_PROBE)) items.push({
+		kind: "validator",
+		name: "isArbitraryVariable"
+	});
+	return items;
+}
+/**
+* One exemplar vanilla class per built-in group, with lazily computed signatures — most groups are never compared against, and compiling ~300 exemplars eagerly would cost more than the whole rest of the pass.
+*/
+function collectGroupSignatures(vanilla, vanillaClassGroupId) {
+	const exemplars = /* @__PURE__ */ new Map();
+	for (const [className] of vanilla.getClassList()) {
+		const groupId = vanillaClassGroupId(className);
+		if (groupId !== void 0 && !exemplars.has(groupId)) exemplars.set(groupId, className);
+	}
+	const signatureCache = /* @__PURE__ */ new Map();
+	return {
+		groupIds: () => exemplars.keys(),
+		signature: (groupId) => {
+			let signature = signatureCache.get(groupId);
+			if (signature === void 0) {
+				const exemplar = exemplars.get(groupId);
+				signature = exemplar === void 0 ? null : declaredProperties(vanilla, exemplar);
+				signatureCache.set(groupId, signature);
+			}
+			return signature;
+		},
+		declarations: (groupId) => {
+			const exemplar = exemplars.get(groupId);
+			return exemplar === void 0 ? null : declaredDeclarations(vanilla, exemplar);
+		}
+	};
+}
+/**
+* Finds the single built-in group whose classes set exactly what the static utility sets: the signatures (context-qualified property names) must be equal, and utility and group exemplar must cover each other. Coverage checks conditions and importance, so media-query padding or inline-important padding cannot alias into the normal unconditional `p` group. Zero matches means the utility does its own thing; several matches would make the choice a guess, so both fall back to self-conflict grouping.
+*/
+function findAliasGroup(project, className, groupSignatures) {
+	const properties = declaredProperties(project, className);
+	if (properties === null || properties.size === 0) return null;
+	const declarations = declaredDeclarations(project, className);
+	const matches = [];
+	for (const groupId of groupSignatures.groupIds()) {
+		const signature = groupSignatures.signature(groupId);
+		if (signature !== null && signature.size === properties.size && [...properties].every((key) => signature.has(key)) && aliasEquivalent(declarations, groupSignatures.declarations(groupId))) matches.push(groupId);
+	}
+	return matches.length === 1 ? matches[0] : null;
+}
+/**
+* Signature equality alone is blind to conditions and importance. Aliases need an unconditional element-level effect and mutual coverage: a later built-in color must never remove a custom utility's important, hover, or dark-mode color, even when both touch only `color`.
+*/
+function aliasEquivalent(first, second) {
+	if (first === null || second === null) return false;
+	return first.some((entry) => entry.context === "" && !entry.conditional) && fullyCovers(first, second) && fullyCovers(second, first);
+}
+/**
+* Whether a class fully covers another, meaning: with the coverer coming later, the covered class has no independent effect left, so removing it loses nothing. Each declaration of the target must be accounted for — an unconditional element-level real property by an equal or shorthand property of the coverer, an unconditional element-level custom property (a state carrier like `--hit-area-l`) by the coverer re-declaring the same one, and everything conditional or targeting another element (shared `::before` scaffolding) only by a byte-identical declaration under the same enclosing rules in the coverer. Anything unaccounted for means partial overlap, and partial overlap never justifies removal — the same rule the default config applies between `px` and `p`.
+* Every match also needs at least the target declaration's importance: a normal declaration cannot replace an inline-important property or custom-property state, even when the names and values agree.
+*/
+function fullyCovers(coverer, target) {
+	if (coverer === null || target === null || target.length === 0) return false;
+	return target.every((targetEntry) => coverer.some((entry) => {
+		if (targetEntry.important && !entry.important) return false;
+		if (targetEntry.context === "" && !targetEntry.conditional) {
+			if (entry.context !== "" || entry.conditional) return false;
+			return targetEntry.property.startsWith("--") ? entry.property === targetEntry.property : !entry.property.startsWith("--") && propertyCovers(entry.property, targetEntry.property);
+		}
+		return sameDeclarationScope(entry, targetEntry) && entry.property === targetEntry.property && entry.value === targetEntry.value;
+	}));
+}
+/**
+* For every custom group, finds the groups whose exemplar declarations its utility fully covers — whenever the utility comes later in a class list, the covered class is redundant and gets removed. One class stands in for each group: custom functional values are partitioned by their observed effects first, while built-in groups retain the representative-class approximation used in classification.
+*/
+function inferOverrideConflicts(project, customGroups, groupSignatures) {
+	const customDeclarations = /* @__PURE__ */ new Map();
+	for (const [groupId, { exemplar }] of customGroups) customDeclarations.set(groupId, exemplar === null ? null : declaredDeclarations(project, exemplar));
+	const conflicts = /* @__PURE__ */ new Map();
+	for (const [groupId, declarations] of customDeclarations) {
+		if (declarations === null || declarations.length === 0) continue;
+		const covered = [];
+		for (const targetGroupId of groupSignatures.groupIds()) if (fullyCovers(declarations, groupSignatures.declarations(targetGroupId))) covered.push(targetGroupId);
+		for (const [otherGroupId, otherDeclarations] of customDeclarations) if (otherGroupId !== groupId && fullyCovers(declarations, otherDeclarations)) covered.push(otherGroupId);
+		if (covered.length > 0) conflicts.set(groupId, covered);
+	}
+	return conflicts;
+}
+//#endregion
+//#region ../configurator/src/emit.ts
+/**
+* Serializes a plan into the source code of a standalone module exporting `getConfig` and `twMerge`.
+*
+* The whole config is built inside `getConfig` so that nothing is allocated at module evaluation — `createTailwindMerge` invokes the callback on the first `twMerge` call, preserving the library's lazy-init behavior. The module imports only `createTailwindMerge` and `validators` from tailwind-merge, so bundlers tree-shake the default config away.
+*
+* Two measured insights shape the output. Validators are destructured once and referenced as bare identifiers because property accesses like `v.isArbitraryVariable` survive minification while local bindings get mangled. And only the resolved theme scales are shared as consts, emitted as references or spreads (e.g. `['none', ...scaleBlur]`): deduplicating other repetition into consts shrinks the minified size but *grows* the compressed size, since references add entropy where gzip/brotli handled the repetition nearly for free (measured on the vanilla theme: 31,989 / 8,822 / 7,706 bytes minified / gzip / brotli with scale sharing, against 28,492 / 9,364 / 8,197 with every paying repetition hoisted). Sharing array identity across class groups is safe because tailwind-merge never mutates config arrays. Output is deterministic for identical input so the CLI's `--check` mode can diff against the file on disk.
+*/
+function emitModule(plan, options = {}) {
+	const format = options.format ?? "ts";
+	const candidates = collectConstantCandidates(plan);
+	const output = serializeAll(plan, candidates, new Map([...candidates].map(([canonical, candidate]) => [canonical, candidate.name])), format);
+	const usedCanonicals = resolveTransitiveUsage(output);
+	const { configBody } = output;
+	const lines = [];
+	lines.push("// Generated by @tailwind-merge/configurator. Do not edit manually.");
+	if (options.banner) lines.push(options.banner);
+	lines.push("");
+	const usedValidators = collectUsedValidatorNames(plan);
+	const importSource = options.importSource ?? "tailwind-merge";
+	const validatorsImport = usedValidators.length > 0 ? ", validators as v" : "";
+	lines.push(format === "ts" ? `import { createTailwindMerge${validatorsImport}, type Config } from '${importSource}'` : `import { createTailwindMerge${validatorsImport} } from '${importSource}'`);
+	lines.push("");
+	lines.push("/**");
+	lines.push(" * Builds the tailwind-merge config for this project. Called lazily on the first `twMerge` call. Can be composed further via `createTailwindMerge(getConfig, ...extensions)`.");
+	lines.push(" *");
+	lines.push(" * The structure mirrors tailwind-merge's default config. The `scale*` consts hold this project's resolved theme scales — each one's comment says which theme namespace it came from — and class groups use them by reference or as spreads. Patterns like `isTshirtSize` come from tailwind-merge's public validators.");
+	lines.push(" */");
+	lines.push("export const getConfig = () => {");
+	if (usedValidators.length > 0) {
+		const inline = `${INDENT}const { ${usedValidators.join(", ")} } = v`;
+		if (inline.length <= MAX_LINE_LENGTH) lines.push(inline);
+		else {
+			lines.push(`${INDENT}const {`);
+			lines.push(...usedValidators.map((name) => `${INDENT}${INDENT}${name},`));
+			lines.push(`${INDENT}} = v`);
+		}
+		lines.push("");
+	}
+	const emittedConstants = sortByDependencies(output, usedCanonicals);
+	for (const [canonical, body] of emittedConstants) {
+		const { name, comment } = candidates.get(canonical);
+		if (comment) lines.push(`${INDENT}/** ${comment} */`);
+		lines.push(`${INDENT}const ${name} = ${body}`);
+	}
+	if (emittedConstants.length > 0) lines.push("");
+	lines.push(...configBody);
+	lines.push("}");
+	lines.push("");
+	lines.push("export const twMerge = createTailwindMerge(getConfig)");
+	lines.push("");
+	return lines.join("\n");
+}
+const MAX_LINE_LENGTH = 100;
+const INDENT = "    ";
+/** Validator names in first-use order, for the destructuring statement at the top of `getConfig`. */
+function collectUsedValidatorNames(plan) {
+	const names = /* @__PURE__ */ new Set();
+	function visitItems(items) {
+		for (const item of items) if (item.kind === "validator") names.add(item.name);
+		else if (item.kind === "object") for (const [, entryItems] of item.entries) visitItems(entryItems);
+	}
+	for (const [, items] of plan.classGroups) visitItems(items);
+	return [...names];
+}
+/** Gathers the resolved theme scales as shared-const candidates; group arrays contain them verbatim wherever a theme getter was substituted. Theme keys are unique, so the derived names are too. */
+function collectConstantCandidates(plan) {
+	const candidates = /* @__PURE__ */ new Map();
+	for (const [themeKey, scale] of plan.scales) {
+		if (scale.items.length < 2) continue;
+		const canonical = canonicalArray(scale.items);
+		const existing = candidates.get(canonical);
+		if (!existing) candidates.set(canonical, {
+			items: scale.items,
+			itemCanonicals: scale.items.map(canonicalValue),
+			name: scaleConstName(themeKey),
+			comment: scale.comment
+		});
+		else if (scale.comment !== null) existing.comment = `${existing.comment ?? ""} ${scale.comment}`.trim();
+	}
+	return candidates;
+}
+/** `color` → `scaleColor`, `font-weight` → `scaleFontWeight`. The `scale` prefix avoids collisions with destructured validator names. */
+function scaleConstName(themeKey) {
+	return `scale${themeKey.split("-").map((segment) => `${segment[0]?.toUpperCase() ?? ""}${segment.slice(1)}`).join("")}`;
+}
+/**
+* Serializes the config body and every candidate's body with the given name map, recording which candidates each output references so usage can be resolved before final naming.
+*/
+function serializeAll(plan, candidates, names, format) {
+	const directUsage = /* @__PURE__ */ new Set();
+	const usageByConstant = /* @__PURE__ */ new Map();
+	const constantBodies = /* @__PURE__ */ new Map();
+	for (const [canonical, candidate] of candidates) {
+		const usage = /* @__PURE__ */ new Set();
+		constantBodies.set(canonical, serializeArrayBody(candidate.items, 4, {
+			candidates,
+			names,
+			usage,
+			selfCanonical: canonical
+		}));
+		usageByConstant.set(canonical, usage);
+	}
+	const context = {
+		candidates,
+		names,
+		usage: directUsage,
+		selfCanonical: null
+	};
+	const configBody = [];
+	configBody.push(`${INDENT}return {`);
+	configBody.push(`${INDENT}${INDENT}cacheSize: ${plan.cacheSize},`);
+	if (plan.prefix !== null) configBody.push(`${INDENT}${INDENT}prefix: ${quote(plan.prefix)},`);
+	configBody.push(`${INDENT}${INDENT}theme: {},`);
+	configBody.push(`${INDENT}${INDENT}classGroups: {`);
+	for (const [classGroupId, items] of plan.classGroups) configBody.push(`${INDENT.repeat(3)}${propertyKey(classGroupId)}: ${serializeArray(items, 12, context)},`);
+	configBody.push(`${INDENT}${INDENT}},`);
+	pushStringRecordMap(configBody, "conflictingClassGroups", plan.conflictingClassGroups);
+	pushStringRecordMap(configBody, "conflictingClassGroupModifiers", plan.conflictingClassGroupModifiers);
+	configBody.push(`${INDENT}${INDENT}postfixLookupClassGroups: ${serializeStringArray(plan.postfixLookupClassGroups)},`);
+	configBody.push(`${INDENT}${INDENT}orderSensitiveModifiers: ${serializeStringArray(plan.orderSensitiveModifiers)},`);
+	configBody.push(format === "ts" ? `${INDENT}} satisfies Config<string, never>` : `${INDENT}}`);
+	return {
+		configBody,
+		constantBodies,
+		directUsage,
+		usageByConstant
+	};
+}
+/** Usage is transitive: a const referenced only from another used const's body still has to be emitted. */
+function resolveTransitiveUsage(output) {
+	const used = new Set(output.directUsage);
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const canonical of used) for (const referenced of output.usageByConstant.get(canonical) ?? []) if (!used.has(referenced)) {
+			used.add(referenced);
+			changed = true;
+		}
+	}
+	return used;
+}
+/** Orders the used consts so that every reference points to an already-declared name, using the exact usage sets recorded during serialization. Containment makes cycles impossible. */
+function sortByDependencies(output, used) {
+	const remaining = new Map([...output.constantBodies].filter(([canonical]) => used.has(canonical)));
+	const declared = /* @__PURE__ */ new Set();
+	const sorted = [];
+	while (remaining.size > 0) {
+		let progressed = false;
+		for (const [canonical, body] of remaining) if ([...output.usageByConstant.get(canonical) ?? []].filter((dependency) => used.has(dependency) && dependency !== canonical).every((dependency) => declared.has(dependency))) {
+			declared.add(canonical);
+			sorted.push([canonical, body]);
+			remaining.delete(canonical);
+			progressed = true;
+		}
+		if (!progressed) throw new Error("Cyclic references between generated consts, this is a bug in emit.ts");
+	}
+	return sorted;
+}
+function serializeArray(items, indent, context) {
+	const canonical = canonicalArray(items);
+	if (canonical !== context.selfCanonical) {
+		const name = context.names.get(canonical);
+		if (name) {
+			context.usage.add(canonical);
+			return name;
+		}
+	}
+	return serializeArrayBody(items, indent, context);
+}
+function serializeArrayBody(items, indent, context) {
+	const itemCanonicals = items.map(canonicalValue);
+	const parts = [];
+	let index = 0;
+	while (index < items.length) {
+		const run = findLongestRun(items, itemCanonicals, index, context);
+		if (run) {
+			parts.push(`...${run.name}`);
+			context.usage.add(run.canonical);
+			index += run.length;
+		} else {
+			parts.push(serializeValue(items[index], indent + 4, context));
+			index += 1;
+		}
+	}
+	const inline = `[${parts.join(", ")}]`;
+	if (indent + inline.length <= MAX_LINE_LENGTH && !inline.includes("\n")) return inline;
+	const itemIndent = INDENT.repeat(indent / 4 + 1);
+	const closingIndent = INDENT.repeat(indent / 4);
+	return `[\n${parts.map((part) => `${itemIndent}${part},`).join("\n")}\n${closingIndent}]`;
+}
+/** Finds the longest candidate array matching the items starting at `start`, to be emitted as a spread. Skips the candidate currently being defined and full-array matches (those are handled as plain references). */
+function findLongestRun(items, itemCanonicals, start, context) {
+	let best = null;
+	for (const [canonical, candidate] of context.candidates) {
+		if (canonical === context.selfCanonical) continue;
+		const length = candidate.itemCanonicals.length;
+		if (length < 2 || start === 0 && length === items.length || start + length > items.length || best && length <= best.length) continue;
+		const name = context.names.get(canonical);
+		if (!name) continue;
+		let matches = true;
+		for (let offset = 0; offset < length; offset++) if (itemCanonicals[start + offset] !== candidate.itemCanonicals[offset]) {
+			matches = false;
+			break;
+		}
+		if (matches) best = {
+			name,
+			canonical,
+			length
+		};
+	}
+	return best;
+}
+function serializeValue(value, indent, context) {
+	if (value.kind === "class") return quote(value.value);
+	if (value.kind === "validator") return value.name;
+	return serializeObjectBody(value, indent, context);
+}
+function serializeObjectBody(value, indent, context) {
+	const entryParts = value.entries.map(([key, items]) => `${propertyKey(key)}: ${serializeArray(items, indent + 4, context)}`);
+	const inline = `{ ${entryParts.join(", ")} }`;
+	if (indent + inline.length <= MAX_LINE_LENGTH && !inline.includes("\n")) return inline;
+	const entryIndent = INDENT.repeat(indent / 4 + 1);
+	const closingIndent = INDENT.repeat(indent / 4);
+	return `{\n${entryParts.map((part) => `${entryIndent}${part},`).join("\n")}\n${closingIndent}}`;
+}
+/**
+* Canonical string form used as identity for scale references and run matching: fully inlined, ignoring shared consts and line breaks, so identical content always produces identical keys. Cached by node identity since plans reuse instances for repeated scales.
+*/
+function canonicalArray(items) {
+	let canonical = canonicalArrayCache.get(items);
+	if (!canonical) {
+		canonical = `[${items.map(canonicalValue).join(", ")}]`;
+		canonicalArrayCache.set(items, canonical);
+	}
+	return canonical;
+}
+function canonicalValue(value) {
+	if (value.kind === "class") return quote(value.value);
+	if (value.kind === "validator") return `v.${value.name}`;
+	let canonical = canonicalObjectCache.get(value);
+	if (!canonical) {
+		canonical = `{ ${value.entries.map(([key, items]) => `${propertyKey(key)}: ${canonicalArray(items)}`).join(", ")} }`;
+		canonicalObjectCache.set(value, canonical);
+	}
+	return canonical;
+}
+const canonicalArrayCache = /* @__PURE__ */ new WeakMap();
+const canonicalObjectCache = /* @__PURE__ */ new WeakMap();
+function pushStringRecordMap(lines, property, map) {
+	if (map.size === 0) {
+		lines.push(`${INDENT}${INDENT}${property}: {},`);
+		return;
+	}
+	lines.push(`${INDENT}${INDENT}${property}: {`);
+	for (const [key, values] of map) lines.push(`${INDENT.repeat(3)}${propertyKey(key)}: ${serializeStringArray(values)},`);
+	lines.push(`${INDENT}${INDENT}},`);
+}
+function serializeStringArray(values) {
+	return `[${values.map(quote).join(", ")}]`;
+}
+/** Object literals treat __proto__ as a prototype setter even when quoted; computed syntax preserves the theme entry as an own property. */
+function propertyKey(key) {
+	if (key === "__proto__") return `[${quote(key)}]`;
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : quote(key);
+}
+function quote(value) {
+	return `'${value.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
+}
+//#endregion
+//#region ../configurator/src/materialize.ts
+/**
+* Turns a plan into a runtime config object, the in-memory equivalent of the emitted module.
+*
+* Exists so tests and programmatic consumers can use the generated behavior directly without writing the emitted source to disk and importing it. Because both this and the emitter read the same plan, the two outputs describe the same config by construction.
+*/
+function materializeConfig(plan) {
+	return {
+		cacheSize: plan.cacheSize,
+		...plan.prefix === null ? {} : { prefix: plan.prefix },
+		theme: {},
+		classGroups: Object.fromEntries([...plan.classGroups].map(([classGroupId, items]) => [classGroupId, items.map(materializeValue)])),
+		conflictingClassGroups: Object.fromEntries(plan.conflictingClassGroups),
+		conflictingClassGroupModifiers: Object.fromEntries(plan.conflictingClassGroupModifiers),
+		postfixLookupClassGroups: plan.postfixLookupClassGroups,
+		orderSensitiveModifiers: plan.orderSensitiveModifiers
+	};
+}
+function materializeValue(value) {
+	if (value.kind === "class") return value.value;
+	if (value.kind === "validator") return validators[value.name];
+	return Object.fromEntries(value.entries.map(([key, items]) => [key, items.map(materializeValue)]));
+}
+//#endregion
+//#region ../configurator/src/plan.ts
+/**
+* Transforms the default config skeleton into a plan with all theme references resolved against the design-system snapshot.
+*
+* Walking `getDefaultConfig()` instead of maintaining a parallel structure means class group semantics, group ordering (which decides validator precedence in the class map), and conflict relationships automatically stay in sync with tailwind-merge.
+*/
+function buildPlan({ snapshot, cacheSize, encoding = "compact" }) {
+	const skeleton = getDefaultConfig();
+	const scaleEncodings = /* @__PURE__ */ new Map();
+	function resolveScale(themeKey) {
+		let scaleEncoding = scaleEncodings.get(themeKey);
+		if (!scaleEncoding) {
+			scaleEncoding = encodeThemeScale(themeKey, snapshot, encoding);
+			scaleEncodings.set(themeKey, scaleEncoding);
+		}
+		return scaleEncoding;
+	}
+	function planGroup(group) {
+		return dedupeValues(group.flatMap(planDefinition));
+	}
+	function planDefinition(definition) {
+		if (typeof definition === "string") return [{
+			kind: "class",
+			value: definition
+		}];
+		if (typeof definition === "function") {
+			if (isThemeGetter(definition)) {
+				if (definition.themeKey === void 0) throw new Error("Theme getter without a themeKey property — the configurator requires a tailwind-merge version that exposes it");
+				return cloneValues(resolveScale(definition.themeKey).items);
+			}
+			const name = validatorNames.get(definition);
+			if (!name) throw new Error("Unknown validator in default config, cannot emit a reference to it");
+			return [{
+				kind: "validator",
+				name
+			}];
+		}
+		const entries = Object.entries(definition).map(([key, value]) => [key, planGroup(value)]).filter(([, items]) => items.length > 0);
+		return entries.length === 0 ? [] : [{
+			kind: "object",
+			entries
+		}];
+	}
+	const classGroups = /* @__PURE__ */ new Map();
+	const prunedClassGroups = [];
+	for (const [classGroupId, group] of Object.entries(skeleton.classGroups)) {
+		const items = planGroup(group);
+		if (items.length === 0) prunedClassGroups.push(classGroupId);
+		else classGroups.set(classGroupId, items);
+	}
+	for (const [classGroupId, classNames] of Object.entries(UTILITY_STATIC_CLASSES)) {
+		const items = classGroups.get(classGroupId);
+		if (items) items.push(...classNames.map((value) => ({
+			kind: "class",
+			value
+		})));
+	}
+	return {
+		cacheSize: cacheSize ?? skeleton.cacheSize,
+		prefix: snapshot.prefix,
+		classGroups,
+		scales: new Map([...scaleEncodings].map(([themeKey, encoding]) => [themeKey, {
+			items: encoding.items,
+			comment: describeScale(themeKey, encoding.strategy)
+		}])),
+		conflictingClassGroups: filterConflictMap(skeleton.conflictingClassGroups, classGroups),
+		conflictingClassGroupModifiers: filterConflictMap(skeleton.conflictingClassGroupModifiers, classGroups),
+		postfixLookupClassGroups: (skeleton.postfixLookupClassGroups ?? []).filter((classGroupId) => classGroups.has(classGroupId)),
+		orderSensitiveModifiers: [...skeleton.orderSensitiveModifiers],
+		report: {
+			encoding,
+			scaleStrategies: Object.fromEntries([...scaleEncodings].map(([themeKey, scaleEncoding]) => [themeKey, scaleEncoding.strategy])),
+			prunedClassGroups,
+			customUtilityGroups: [],
+			aliasedUtilityClasses: {},
+			customUtilityConflicts: {},
+			augmentedClassGroups: {},
+			resolvedCollisions: [],
+			unassignedClasses: []
+		}
+	};
+}
+/**
+* Applies the custom-utility plan: self-conflict groups join `classGroups` like any other group, alias classes join their built-in group as literals (the trie gives named paths precedence, and joining wires up the group's full conflict behavior), and inferred override relationships land in `conflictingClassGroups` so a custom utility coming later removes the classes it fully covers.
+*/
+function applyCustomUtilityPlan(plan, customUtilityPlan) {
+	for (const [groupId, items] of customUtilityPlan.groups) {
+		plan.classGroups.set(groupId, items);
+		plan.report.customUtilityGroups.push(groupId);
+	}
+	plan.postfixLookupClassGroups.push(...customUtilityPlan.postfixLookupClassGroups);
+	for (const root of customUtilityPlan.extendedBuiltInRoots) plan.report.unassignedClasses.push({
+		className: `${root}-*`,
+		reason: "custom utility extends a built-in root; only values the built-in matchers accept are classified"
+	});
+	for (const [className, groupId] of customUtilityPlan.aliases) {
+		const items = plan.classGroups.get(groupId);
+		if (!items) plan.classGroups.set(groupId, [{
+			kind: "class",
+			value: className
+		}]);
+		else items.push({
+			kind: "class",
+			value: className
+		});
+		plan.report.aliasedUtilityClasses[className] = groupId;
+	}
+	for (const [groupId, coveredGroupIds] of customUtilityPlan.conflicts) {
+		const existingTargets = coveredGroupIds.filter((targetId) => plan.classGroups.has(targetId));
+		if (existingTargets.length === 0) continue;
+		const conflictTargets = plan.conflictingClassGroups.get(groupId);
+		if (conflictTargets) conflictTargets.push(...existingTargets);
+		else plan.conflictingClassGroups.set(groupId, existingTargets);
+		plan.report.customUtilityConflicts[groupId] = existingTargets;
+	}
+}
+/**
+* Appends augmentation classes (full class names determined by the vanilla-diff pass) to their class groups and records them in the report. Appending literals is enough: the trie gives named paths precedence over validators, and joining an existing group wires up all its conflict relations automatically.
+*/
+function applyAugmentations(plan, augmentations) {
+	for (const [classGroupId, classNames] of augmentations.assignments) {
+		const items = plan.classGroups.get(classGroupId);
+		if (!items) plan.classGroups.set(classGroupId, classNames.map((value) => ({
+			kind: "class",
+			value
+		})));
+		else items.push(...classNames.map((value) => ({
+			kind: "class",
+			value
+		})));
+		plan.report.augmentedClassGroups[classGroupId] = classNames;
+	}
+	plan.report.unassignedClasses.push(...augmentations.unassigned);
+	for (const { className, claimingGroupId, ownerGroupId, resolution } of augmentations.collisions) {
+		const groupIdsToRemoveFrom = resolution === "restore" ? [claimingGroupId] : [.../* @__PURE__ */ new Set([claimingGroupId, ownerGroupId])];
+		const removedFromGroupIds = groupIdsToRemoveFrom.filter((groupId) => {
+			const items = plan.classGroups.get(groupId);
+			return items !== void 0 && removeClassClaim(items, className);
+		});
+		const fullyRemoved = removedFromGroupIds.length === groupIdsToRemoveFrom.length;
+		if (resolution === "restore") {
+			const ownerItems = plan.classGroups.get(ownerGroupId);
+			if (!fullyRemoved && ownerItems !== void 0 && !hasClassClaim(ownerItems, className)) ownerItems.push({
+				kind: "class",
+				value: className
+			});
+			plan.report.resolvedCollisions.push({
+				className,
+				keptGroupId: ownerGroupId,
+				removedFromGroupIds
+			});
+		} else {
+			if (!fullyRemoved) plan.classGroups.set(neutralizedGroupId(className), [{
+				kind: "class",
+				value: className
+			}]);
+			plan.report.resolvedCollisions.push({
+				className,
+				keptGroupId: null,
+				removedFromGroupIds
+			});
+		}
+	}
+}
+/** Group ID for a neutralized class that keeps a validator-based claim somewhere: a group of its own, referenced by no conflict map, so the class behaves like a non-Tailwind class while still outranking the validator through its literal path. */
+function neutralizedGroupId(className) {
+	return `collision.${className}`;
+}
+/** Whether `className` already resolves into these items through a literal — the check that keeps a restore from appending a duplicate literal to the owner group. Mirrors the walk in `removeClassClaim`. */
+function hasClassClaim(items, className) {
+	return items.some((item) => {
+		if (item.kind === "class") return item.value === className;
+		if (item.kind === "object") return item.entries.some(([key, entryItems]) => className.startsWith(`${key}-`) && hasClassClaim(entryItems, className.slice(key.length + 1)));
+		return false;
+	});
+}
+/** Deep copy of plan values, so group arrays can be edited independently of each other and of the shared scale definitions. */
+function cloneValues(values) {
+	return values.map((value) => value.kind === "object" ? {
+		kind: "object",
+		entries: value.entries.map(([key, items]) => [key, cloneValues(items)])
+	} : value);
+}
+/**
+* Removes the item that makes `className` resolve into this group: a full-class literal, or a literal reached through object entries whose keys prefix the class name — recursively, because the family encoding nests (`background-alternative-200` may live at `{ background: [{ alternative: ['200'] }] }`). Returns false when the claim comes from something else (a validator), which the caller reports instead of guessing.
+*/
+function removeClassClaim(items, className) {
+	for (let index = 0; index < items.length; index++) {
+		const item = items[index];
+		if (item.kind === "class" && item.value === className) {
+			items.splice(index, 1);
+			return true;
+		}
+		if (item.kind === "object") {
+			for (const [key, entryItems] of item.entries) if (className.startsWith(`${key}-`) && removeClassClaim(entryItems, className.slice(key.length + 1))) return true;
+		}
+	}
+	return false;
+}
+/**
+* Colors that every color utility accepts as static keywords in addition to theme values. They are utility semantics rather than theme variables, so the design system's theme does not contain them. Today's default config matches them implicitly through the permissive `isAny` color scale.
+*/
+const COLOR_KEYWORDS = [
+	"inherit",
+	"current",
+	"transparent"
+];
+/**
+* Static utility classes that belong to specific class groups but are neither theme values nor skeleton literals — the default config catches them through permissive validators or its approximated theme scales, both of which the plan replaces with exact values. The shadow `*-initial` utilities reset the corresponding `--tw-*-shadow-color` custom property, the gradient `*-none` utilities reset gradient stops, and `perspective-none` is a static value the skeleton keeps in its theme approximation. All verified via `candidatesToCss` probing against tailwindcss 4.3; P2's probing infrastructure should derive or at least verify this list automatically.
+*/
+const UTILITY_STATIC_CLASSES = {
+	"shadow-color": ["shadow-initial"],
+	"inset-shadow-color": ["inset-shadow-initial"],
+	"text-shadow-color": ["text-shadow-initial"],
+	"gradient-from": ["from-none"],
+	"gradient-via": ["via-none"],
+	"gradient-to": ["to-none"],
+	accent: ["accent-auto"],
+	leading: ["leading-none"],
+	perspective: ["perspective-none"]
+};
+/**
+* Encodes the scale for one theme key, applying per-key knowledge on top of the generic encoding.
+*/
+function encodeThemeScale(themeKey, snapshot, encoding) {
+	const scale = snapshot.scales.get(themeKey);
+	const names = scale?.names ?? [];
+	if (themeKey === "color") {
+		const scaleEncoding = encodeScale(names, encoding);
+		return {
+			items: [...COLOR_KEYWORDS.map((value) => ({
+				kind: "class",
+				value
+			})), ...scaleEncoding.items],
+			strategy: scaleEncoding.strategy
+		};
+	}
+	if (themeKey === "spacing") {
+		const scaleEncoding = encodeScale(names, encoding);
+		const items = [{
+			kind: "class",
+			value: "px"
+		}];
+		let strategy = scaleEncoding.strategy;
+		if (scale?.hasBareValue) {
+			items.push({
+				kind: "validator",
+				name: "isNumber"
+			});
+			strategy = names.length === 0 ? "multiplier" : `multiplier+${scaleEncoding.strategy}`;
+		}
+		items.push(...scaleEncoding.items);
+		return {
+			items,
+			strategy
+		};
+	}
+	return encodeScale(names, encoding);
+}
+/**
+* Explains where a scale's values come from and why they are encoded the way they are, so the generated file stays debuggable without readers having to know the compression policy. Derived from the encoding strategy instead of restating the values, which the code right below the comment already shows.
+*/
+function describeScale(themeKey, strategy) {
+	const namespace = `\`--${themeKey}-*\``;
+	if (themeKey === "spacing" && strategy.startsWith("multiplier")) {
+		const base = `The bare \`--spacing\` multiplier is set, which makes every number a valid spacing value (e.g. p-13).`;
+		return strategy === "multiplier" ? base : `Named ${namespace} theme values. ${base}`;
+	}
+	const prefix = themeKey === "color" ? `Color keywords plus the ${namespace} theme values` : `The ${namespace} theme values`;
+	if (strategy === "families") return `${prefix}, with families sharing numeric suffixes compressed into nested matchers.`;
+	if (strategy.startsWith("validator:")) return `${prefix}, all matching \`${strategy.slice(10)}\`.`;
+	if (strategy.startsWith("mixed:")) return `${prefix}: enumerated outliers plus the \`${strategy.slice(6)}\` pattern covering the rest.`;
+	return `${prefix}.`;
+}
+const validatorNames = new Map(Object.entries(validators).map(([name, validator]) => [validator, name]));
+function isThemeGetter(value) {
+	return "isThemeGetter" in value && value.isThemeGetter === true;
+}
+/**
+* Removes duplicate literals and validator references while keeping the first occurrence, since substituting a theme scale can repeat values the skeleton already defines statically (e.g. `text-base` exists both as skeleton literal and as `--text-base` theme value).
+*/
+function dedupeValues(values) {
+	const seen = /* @__PURE__ */ new Set();
+	return values.filter((value) => {
+		if (value.kind === "object") return true;
+		const key = value.kind === "class" ? `c:${value.value}` : `v:${value.name}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+function filterConflictMap(conflictMap, classGroups) {
+	const filtered = /* @__PURE__ */ new Map();
+	for (const [classGroupId, conflicts] of Object.entries(conflictMap)) {
+		if (!classGroups.has(classGroupId) || !conflicts) continue;
+		const existingConflicts = conflicts.filter((conflictId) => classGroups.has(conflictId));
+		if (existingConflicts.length > 0) filtered.set(classGroupId, existingConflicts);
+	}
+	return filtered;
+}
+//#endregion
+//#region ../configurator/src/prune.ts
+/**
+* Shrinks a plan to the class names a project actually uses: groups and members survive only when needed by a used class's lookup, including intermediate base matchers for slash-modified classes — literals a used class names, nested prefix objects a used class descends into, and validators a used class's remaining tail satisfies.
+*
+* The pruned plan merges exactly like the full plan for every class list made of used classes, by construction: it is a subset of the full plan with tailwind-merge's lookup precedence intact. Classification of a used class records the lookups of tailwind-merge's own merge engine (prefix, variants, important marker, and postfix modifiers), so a class matched via a literal keeps that literal and a class matched via a validator keeps that validator, in the same group and at the same trie position; removing other members can never promote a previously losing candidate, because lookup tries deeper literal paths first and validators in definition order, and that order is preserved among the survivors. Members are only ever removed, never re-encoded, and validators are kept whenever any used tail satisfies them — over-keeping is always safe, under-keeping never is. Retained validators can also classify names outside the used set, so the result is not a strict allowlist. Only supplied candidates carry the equivalence guarantee; consumers with externally supplied, separately styled class names should keep the full config.
+*
+* Used classes are raw tokens as a scanner finds them (`hover:bg-red-500/50`, `tw:p-4!`, `-mt-2`), deduplicated here; anything that does not classify is ignored. Conflict maps are filtered to the kept groups, `scales` stay untouched (the emitter drops shared consts nothing references anymore), and the result records what happened in `report.pruning`. The input plan is not mutated.
+*/
+function prunePlan(plan, usedClasses) {
+	const config = materializeConfig(plan);
+	const lookupClass = createClassGroupLookup(config);
+	/** Every successful lookup needed by a used class, including a base group that enables a subsequent postfix lookup. Names contain only the part the class map matched, with a leading minus removed. */
+	const matchedNamesByGroup = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	let classifiedClassCount = 0;
+	for (const rawClassName of usedClasses) {
+		const className = rawClassName.trim();
+		if (className === "" || seen.has(className)) continue;
+		seen.add(className);
+		const matches = lookupClass(className);
+		if (matches.length > 0) classifiedClassCount += 1;
+		for (const match of matches) {
+			const { classGroupId } = match;
+			let names = matchedNamesByGroup.get(classGroupId);
+			if (!names) {
+				names = /* @__PURE__ */ new Set();
+				matchedNamesByGroup.set(classGroupId, names);
+			}
+			names.add(lookupName(match.className));
+		}
+	}
+	const classGroups = /* @__PURE__ */ new Map();
+	const removedClassGroups = [];
+	const unprunedClassGroups = [];
+	for (const [classGroupId, items] of plan.classGroups) {
+		const names = matchedNamesByGroup.get(classGroupId);
+		if (!names) {
+			removedClassGroups.push(classGroupId);
+			continue;
+		}
+		const prunedItems = pruneItems(items, names);
+		if (prunedItems.length === 0) {
+			unprunedClassGroups.push(classGroupId);
+			classGroups.set(classGroupId, items);
+		} else classGroups.set(classGroupId, prunedItems);
+	}
+	return {
+		...plan,
+		classGroups,
+		conflictingClassGroups: filterConflictMap(Object.fromEntries(plan.conflictingClassGroups), classGroups),
+		conflictingClassGroupModifiers: filterConflictMap(Object.fromEntries(plan.conflictingClassGroupModifiers), classGroups),
+		postfixLookupClassGroups: plan.postfixLookupClassGroups.filter((classGroupId) => classGroups.has(classGroupId)),
+		report: {
+			...plan.report,
+			pruning: {
+				usedClassCount: seen.size,
+				classifiedClassCount,
+				classGroupsBefore: plan.classGroups.size,
+				classGroupsAfter: classGroups.size,
+				removedClassGroups,
+				unprunedClassGroups
+			}
+		}
+	};
+}
+/**
+* Keeps the items of one class-group level that some name in `names` reaches, walking nested prefix objects the way tailwind-merge's class map does: an object entry's key is a dash-separated prefix, so a name descends into it with the key stripped (`red-500` enters `{ red: […] }` as `500`), a name equal to the key enters as the empty string (the `''` literal marks "the prefix alone is a class"), and validators see the remaining tail at their level. Literal strings must match the remaining name exactly.
+*/
+function pruneItems(items, names) {
+	const kept = [];
+	for (const item of items) if (item.kind === "class") {
+		if (names.has(item.value)) kept.push(item);
+	} else if (item.kind === "validator") {
+		const validator = validators[item.name];
+		for (const name of names) if (validator(name)) {
+			kept.push(item);
+			break;
+		}
+	} else {
+		const entries = [];
+		for (const [key, entryItems] of item.entries) {
+			const tails = /* @__PURE__ */ new Set();
+			for (const name of names) if (name === key) tails.add("");
+			else if (name.startsWith(`${key}-`)) tails.add(name.slice(key.length + 1));
+			if (tails.size === 0) continue;
+			const prunedEntryItems = pruneItems(entryItems, tails);
+			if (prunedEntryItems.length > 0) entries.push([key, prunedEntryItems]);
+		}
+		if (entries.length > 0) kept.push({
+			kind: "object",
+			entries
+		});
+	}
+	return kept;
+}
+/** The string the class map walks for a matched class: negative classes like `-mt-2` start their lookup after the empty first part, exactly as `getClassGroupId` skips it. */
+function lookupName(matchedClassName) {
+	const parts = matchedClassName.split("-");
+	return parts[0] === "" && parts.length > 1 ? parts.slice(1).join("-") : matchedClassName;
+}
+//#endregion
+//#region ../configurator/src/snapshot.ts
+/**
+* Captures the effective theme per namespace from a loaded design system.
+*
+* Reading the design system instead of parsing CSS text means defaults, `@import` chains, namespace resets (`--color-*: initial`), `@config`/`@plugin` contributions and value precedence are all Tailwind's responsibility — the snapshot only records the result. Values are intentionally not resolved: only which names exist matters for class classification.
+*
+* Variables outside the supported namespaces (e.g. `--z-index-*`) and in Tailwind's compat sub-namespaces (e.g. `--text-color-*`, which shares the `--text` prefix but feeds other utilities) are not captured here — the classes they create are picked up by the vanilla-diff augmentation pass instead, which classifies them empirically.
+*/
+function snapshotTheme(designSystem, themeKeys) {
+	const prefix = designSystem.theme.prefix ?? null;
+	const scales = new Map(themeKeys.map((themeKey) => [themeKey, {
+		names: [],
+		hasBareValue: false
+	}]));
+	const keysByLength = [...themeKeys].sort((a, b) => b.length - a.length);
+	for (const [variableName] of designSystem.theme.entries()) {
+		if (!variableName.startsWith("--")) continue;
+		let path = variableName.slice(2);
+		if (prefix !== null) {
+			if (!path.startsWith(`${prefix}-`)) continue;
+			path = path.slice(prefix.length + 1);
+		}
+		const themeKey = keysByLength.find((key) => path === key || path.startsWith(`${key}-`));
+		if (!themeKey || IGNORED_SUB_NAMESPACES[themeKey]?.some((subNamespace) => path === subNamespace || path.startsWith(`${subNamespace}-`))) continue;
+		const scale = scales.get(themeKey);
+		if (path === themeKey) {
+			scale.hasBareValue = true;
+			continue;
+		}
+		const name = path.slice(themeKey.length + 1);
+		if (!name.includes("--")) scale.names.push(name);
+	}
+	return {
+		prefix,
+		scales
+	};
+}
+/**
+* Tailwind's compat sub-namespaces, keyed by the theme key whose prefix they share: `--text-color-brand` is not a `text-*` font size, `--font-size-huge` not a `font-*` family. Mirrors the map Tailwind's theme resolution excludes when it reads a namespace (`ignoredThemeKeyMap` in tailwindcss's theme.ts) in full; sub-namespaces that are theme keys of their own (`text-shadow`, `font-weight`, `inset-shadow`, `inset-ring`) are listed as well so the exclusion does not depend on key length. Prefix matching alone would enumerate these names as scale members, and a name Tailwind never turns into a class would then evict a real one.
+*/
+const IGNORED_SUB_NAMESPACES = {
+	font: ["font-weight", "font-size"],
+	inset: ["inset-shadow", "inset-ring"],
+	text: [
+		"text-color",
+		"text-decoration-color",
+		"text-decoration-thickness",
+		"text-indent",
+		"text-shadow",
+		"text-underline-offset"
+	],
+	"grid-column": ["grid-column-start", "grid-column-end"],
+	"grid-row": ["grid-row-start", "grid-row-end"]
+};
+//#endregion
+//#region ../configurator/src/generate.ts
+/**
+* Generates a project-specific tailwind-merge setup from a Tailwind CSS v4 entrypoint.
+*
+* The design system is loaded through Tailwind's own APIs with defaults merged, overrides applied, and resets executed. Keep the installed compiler aligned with the version that builds the project's CSS. The default tailwind-merge config acts as the structural skeleton — class group semantics and conflict relationships — while every theme reference in it is replaced with exact values from the design system.
+*
+* Classes the theme creates outside the standard namespaces (compat sub-namespaces like `--text-color-*`, or namespaces without a theme key like `--z-index-*`) are found by diffing against a vanilla design system of the same Tailwind installation and classified empirically by their compiled CSS declarations, so no namespace mapping needs to be hand-maintained anywhere.
+*/
+async function generate(options) {
+	return generateFromDesignSystems(await loadDesignSystems({
+		css: options.css,
+		base: options.base,
+		integration: options.integration
+	}), options);
+}
+/**
+* The classification and emission half of `generate`, on design systems the caller has already loaded. Not part of the public API — `generate` is the entry point and loads the systems itself. The test fixtures use the split to hand one loaded project to both generation and their own conformance sweeps, sharing its class list and compiled-declaration caches instead of loading and compiling the same theme twice, and to reuse one vanilla system across every fixture in a worker.
+*/
+async function generateFromDesignSystems({ project, vanilla }, options) {
+	const themeKeys = Object.keys(getDefaultConfig().theme);
+	const encoding = options.encoding ?? "compact";
+	const plan = buildPlan({
+		snapshot: snapshotTheme(project, themeKeys),
+		cacheSize: options.cacheSize,
+		encoding
+	});
+	const vanillaPlan = buildPlan({ snapshot: snapshotTheme(vanilla, themeKeys) });
+	const vanillaClassGroupUtils = createClassGroupUtils(materializeConfig(vanillaPlan));
+	const customUtilities = buildCustomUtilityPlan({
+		project,
+		vanilla,
+		vanillaClassGroupId: vanillaClassGroupUtils.getClassGroupId,
+		encoding
+	});
+	applyCustomUtilityPlan(plan, customUtilities);
+	const projectClassGroupUtils = createClassGroupUtils(materializeConfig({
+		...plan,
+		prefix: null
+	}));
+	const groupPrefixKeys = /* @__PURE__ */ new Map();
+	for (const [groupId, items] of plan.classGroups) {
+		const prefixes = items.flatMap((item) => item.kind === "object" ? item.entries.map(([key]) => key) : []);
+		if (prefixes.length > 0) groupPrefixKeys.set(groupId, prefixes);
+	}
+	applyAugmentations(plan, buildAugmentations({
+		project,
+		vanilla,
+		projectClassGroupId: projectClassGroupUtils.getClassGroupId,
+		vanillaClassGroupId: vanillaClassGroupUtils.getClassGroupId,
+		groupPrefixKeys,
+		customGroupIds: new Set(customUtilities.groups.keys()),
+		preservedCustomClasses: customUtilities.preservedClasses
+	}));
+	plan.postfixLookupClassGroups = [.../* @__PURE__ */ new Set([...plan.postfixLookupClassGroups, ...staticPostfixLookupGroups(project, plan)])];
+	plan.orderSensitiveModifiers = [.../* @__PURE__ */ new Set([...plan.orderSensitiveModifiers, ...customOrderSensitiveModifiers(project, vanilla)])];
+	return assembleResult(plan, options.prune ? await options.prune.usedClasses : null, {
+		banner: await options.banner,
+		format: options.format,
+		importSource: options.importSource
+	});
+}
+/** Everything after classification: prune to the used classes, if any, then emit and materialize. Kept apart so a result can be re-pruned for other classes without repeating the expensive part. */
+function assembleResult(plan, usedClasses, emitOptions) {
+	const finalPlan = usedClasses ? prunePlan(plan, usedClasses) : plan;
+	return {
+		code: emitModule(finalPlan, emitOptions),
+		config: materializeConfig(finalPlan),
+		plan: finalPlan,
+		prune: (nextUsedClasses) => assembleResult(plan, nextUsedClasses, emitOptions)
+	};
+}
+/** Added or redefined variants that style another target are ordering barriers, like the default before/after/child modifiers. Compile their suggested spellings so theme-only media changes and ordinary state variants keep commuting; selector lists are conservative because they can mix targets. */
+function customOrderSensitiveModifiers(project, vanilla) {
+	const defaults = new Map(vanilla.getVariants().map((variant) => [variant.name, variant]));
+	const modifiers = /* @__PURE__ */ new Set();
+	for (const variant of project.getVariants()) {
+		const original = defaults.get(variant.name);
+		if (!original || JSON.stringify(variant.selectors()) !== JSON.stringify(original.selectors())) modifiers.add(variant.name);
+		for (const value of variant.values) if (!original || !original.values.includes(value) || JSON.stringify(variant.selectors({ value })) !== JSON.stringify(original.selectors({ value }))) modifiers.add(`${variant.name}${variant.hasDash ? "-" : ""}${value}`);
+	}
+	return [...modifiers].filter((modifier) => declaredDeclarations(project, `${modifier}:block`)?.some((entry) => entry.context !== "" || entry.scope.some((rule) => !rule.startsWith("@") && segment(rule, ",").length > 1)));
+}
+/** Static names can contain slashes too: badge/icon must reach its own group instead of inheriting badge's group. Use the final classifier after aliases and augmentation establish both owners, and the runtime parser for the exact postfix boundary. Pruning then retains both lookups. */
+function staticPostfixLookupGroups(project, plan) {
+	const classNames = project.utilities.keys("static").filter((name) => name.includes("/"));
+	if (classNames.length === 0) return [];
+	const config = materializeConfig({
+		...plan,
+		prefix: null
+	});
+	const parseClassName = createParseClassName(config);
+	const { getClassGroupId } = createClassGroupUtils(config);
+	const groups = /* @__PURE__ */ new Set();
+	for (const className of classNames) {
+		const { baseClassName, maybePostfixModifierPosition } = parseClassName(className);
+		if (!maybePostfixModifierPosition) continue;
+		const baseGroup = getClassGroupId(baseClassName.slice(0, maybePostfixModifierPosition));
+		const fullGroup = getClassGroupId(baseClassName);
+		if (baseGroup && fullGroup && baseGroup !== fullGroup) groups.add(baseGroup);
+	}
+	return [...groups];
+}
+//#endregion
+//#region ../configurator/src/scan.ts
+/**
+* Finds the class names a project can render, the way Tailwind does: the same candidate extractor (`@tailwindcss/oxide`'s scanner), over the same sources (`source(…)`, automatic detection, every `@source`), plus the `@source inline(…)` safelist. Pruning uses these candidates to preserve the full generated config's merge behavior for the same source usage.
+*
+* The sources come from Tailwind's own `compile()` (its `root` and `sources` results), which is also what reports the CSS graph's dependencies, so one compile serves both. What `compile()` does not expose is the safelist: `@source inline(…)` candidates stay private to its `build()`, so they are parsed from the entrypoint and every CSS dependency here, with Tailwind's brace-expansion rules. Negated inline sources exclude candidates even when they occur in files, exactly like Tailwind, which refuses to generate them.
+*
+* `@tailwindcss/oxide` is loaded lazily because it is a native module: a setup without a binary for its platform should fail only when scanning is requested, not when the configurator is imported.
+*/
+async function createSourceScanner(options) {
+	const dependencies = /* @__PURE__ */ new Set();
+	const stylesheets = /* @__PURE__ */ new Set();
+	const compiler = await compile(options.css, {
+		base: options.base,
+		customCssResolver: createStylesheetResolver(options.integration?.resolveCss, (file) => stylesheets.add(file), options.integration?.onDependency),
+		customJsResolver: createModuleResolver(options.integration?.resolveJs, options.integration?.onDependency),
+		onDependency: (dependencyPath) => {
+			dependencies.add(dependencyPath);
+			options.integration?.onDependency?.(dependencyPath);
+		}
+	});
+	const sources = [...autoDetectSources(compiler.root, options.autoDetectBases), ...compiler.sources];
+	const scansUtilities = (compiler.features & Features.Utilities) !== 0;
+	const { safelist, exclusions } = await collectInlineSources(options.css, stylesheets);
+	const scanner = new (await (loadScanner()))({ sources });
+	return {
+		dependencies,
+		sources,
+		scansUtilities,
+		safelist,
+		scan() {
+			const classes = new Set(scansUtilities ? scanner.scan() : []);
+			for (const className of safelist) classes.add(className);
+			for (const className of exclusions) classes.delete(className);
+			return {
+				classes: [...classes],
+				files: scanner.files,
+				globs: scanner.globs
+			};
+		}
+	};
+}
+/** Mirrors how `@tailwindcss/vite`, `@tailwindcss/postcss`, and the CLI turn the compiler's `root` into scanner sources: `source(none)` disables automatic detection, no `source(…)` means "everything under the base directory", and an explicit `source(…)` is the one directory to detect in. */
+function autoDetectSources(root, autoDetectBases) {
+	if (root === "none") return [];
+	if (root === null) return autoDetectBases.map((base) => ({
+		base,
+		pattern: "**/*",
+		negated: false
+	}));
+	return [{
+		...root,
+		negated: false
+	}];
+}
+async function loadScanner() {
+	try {
+		return (await import("@tailwindcss/oxide")).Scanner;
+	} catch (error) {
+		throw new Error(`Scanning sources needs @tailwindcss/oxide with a binary for this platform (${process.platform}-${process.arch}): ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+/**
+* Collects `@source inline(…)` safelist entries and `@source not inline(…)` exclusions from the entrypoint and the CSS files of its import graph. Tailwind's rules: the quoted argument is split into patterns at top-level whitespace, each pattern is brace-expanded, and the result is a plain candidate list — variants included (`{hover:,}underline`).
+*/
+async function collectInlineSources(css, stylesheets) {
+	const safelist = /* @__PURE__ */ new Set();
+	const exclusions = /* @__PURE__ */ new Set();
+	const cssTexts = [css];
+	for (const file of stylesheets) {
+		const content = await readFile(file, "utf8").catch(() => null);
+		if (content !== null) cssTexts.push(content);
+	}
+	for (const text of cssTexts) for (const statement of cssStatements(text)) {
+		const match = INLINE_SOURCE_RE.exec(statement);
+		if (!match) continue;
+		const target = match[1] ? exclusions : safelist;
+		for (const pattern of segment(match[3], " ")) {
+			if (pattern === "") continue;
+			for (const candidate of expandBraces(pattern)) target.add(candidate);
+		}
+	}
+	return {
+		safelist: [...safelist],
+		exclusions: [...exclusions]
+	};
+}
+/** `@source inline("…")` and `@source not inline('…')`, argument in either quote style. Tailwind requires the quotes, so unquoted forms are not a thing. */
+const INLINE_SOURCE_RE = /^@source\s+(not\s+)?inline\(\s*(["'])((?:\\.|(?!\2)[^\\])*)\2\s*\)$/;
+const NUMERICAL_RANGE_RE = /^(-?\d+)\.\.(-?\d+)(?:\.\.(-?\d+))?$/;
+/**
+* Brace expansion with Tailwind's semantics (`packages/tailwindcss/src/utils/brace-expansion.ts`): comma lists (`{hover:,focus:}`), numeric ranges with optional step and direction (`{100..900..100}`, `{5..0}`), nesting (`bg-red-{50,{100..900..100},950}`), and cartesian products across several groups. Unbalanced braces and zero steps throw like upstream; decimal ranges stay literal.
+*/
+function expandBraces(pattern) {
+	const openIndex = pattern.indexOf("{");
+	if (openIndex === -1) return [pattern];
+	const prefix = pattern.slice(0, openIndex);
+	const rest = pattern.slice(openIndex);
+	let depth = 0;
+	let closeIndex = -1;
+	for (let index = 0; index < rest.length; index++) {
+		const character = rest[index];
+		if (character === "{") depth += 1;
+		else if (character === "}") {
+			depth -= 1;
+			if (depth === 0) {
+				closeIndex = index;
+				break;
+			}
+		}
+	}
+	if (closeIndex === -1) throw new Error(`The pattern \`${pattern}\` is not balanced.`);
+	const inside = rest.slice(1, closeIndex);
+	const suffix = rest.slice(closeIndex + 1);
+	const parts = (NUMERICAL_RANGE_RE.test(inside) ? expandSequence(inside) : segment(inside, ",")).flatMap((part) => expandBraces(part));
+	const expanded = [];
+	for (const suffixVariant of expandBraces(suffix)) for (const part of parts) expanded.push(prefix + part + suffixVariant);
+	return expanded;
+}
+function expandSequence(sequence) {
+	const match = NUMERICAL_RANGE_RE.exec(sequence);
+	if (!match) return [sequence];
+	const start = Number.parseInt(match[1], 10);
+	const end = Number.parseInt(match[2], 10);
+	let step = match[3] === void 0 ? start <= end ? 1 : -1 : Number.parseInt(match[3], 10);
+	if (step === 0) throw new Error("Step cannot be zero in sequence expansion.");
+	const increasing = start < end;
+	if (increasing && step < 0) step = -step;
+	if (!increasing && step > 0) step = -step;
+	const values = [];
+	for (let value = start; increasing ? value <= end : value >= end; value += step) values.push(String(value));
+	return values;
+}
+//#endregion
+//#region ../plugin-core/src/discovery.ts
+/**
+* Finds the project's Tailwind CSS entrypoint by scanning `root` for CSS files with Tailwind root markers.
+*
+* The scan is eager and filesystem-based on purpose: bundler integrations of Tailwind discover roots lazily from the module graph, but a plugin's runtime module can be requested before any CSS has flowed through the pipeline, so the plugin must know the root up front.
+*
+* When several files carry markers, files transitively `@import`ed by another candidate are dropped — a root is the top of its own import graph (a multi-file theme's token and utility layers all contain `@theme`/`@utility` markers of their own). Follow import-only intermediates, including explicit paths outside the scan root, and visit each file once to bound shared dependencies and cycles. More than one root after that is a hard error asking for the plugin's `css` option; none found returns null and the caller falls back to default tailwind-merge behavior.
+*/
+async function discoverCssRoot(root, { resolveCss, packageName } = {}) {
+	const candidates = /* @__PURE__ */ new Map();
+	const statementsByFile = /* @__PURE__ */ new Map();
+	for (const file of await collectCssFiles(root)) {
+		const identity = await realpath(file).catch(() => file);
+		const statements = await readStatements(file);
+		statementsByFile.set(identity, statements);
+		if (statements?.some((statement) => ROOT_MARKER_RE.test(statement))) candidates.set(identity, file);
+	}
+	if (candidates.size === 0) return null;
+	const importedByCandidate = /* @__PURE__ */ new Set();
+	const resolveImport = createStylesheetResolver(resolveCss);
+	const pending = [...candidates];
+	const visited = /* @__PURE__ */ new Set();
+	while (pending.length > 0) {
+		const [identity, file] = pending.pop();
+		if (visited.has(identity)) continue;
+		visited.add(identity);
+		if (!statementsByFile.has(identity)) statementsByFile.set(identity, await readStatements(file));
+		const statements = statementsByFile.get(identity);
+		if (statements === null || statements === void 0) continue;
+		for (const statement of statements) {
+			const match = CSS_IMPORT_RE.exec(statement);
+			if (!match) continue;
+			const target = await resolveImport(match[1], path.dirname(file)).catch(() => null);
+			if (target !== null) {
+				const targetIdentity = await realpath(target).catch(() => target);
+				importedByCandidate.add(targetIdentity);
+				pending.push([targetIdentity, target]);
+			}
+		}
+	}
+	const roots = [...candidates].filter(([identity]) => !importedByCandidate.has(identity)).map(([, file]) => file);
+	if (roots.length === 1) return roots[0];
+	const listed = (roots.length > 1 ? roots : [...candidates.values()]).map((file) => `  - ${path.relative(root, file)}`).join("\n");
+	const prefix = packageName ? `[${packageName}] ` : "";
+	throw new Error(`${prefix}Found multiple Tailwind CSS roots and cannot decide which one configures tailwind-merge:\n${listed}\nSet the plugin's \`css\` option to the entrypoint that defines your theme.`);
+}
+/** Matches active statements that can mark a Tailwind v4 root: the `tailwindcss` import (or one of its sub-imports) or Tailwind's own at-rules, `@source` included — an app entrypoint may add nothing but source directives on top of an imported shared theme, and the pruning scanner only sees the directives of the compiled root. Anchoring excludes directive-like text inside selectors and declaration values. */
+const ROOT_MARKER_RE = /^@import\s+(?:url\(\s*)?["']tailwindcss(?:\/[^"']*)?["']|^@(?:theme|config|plugin|tailwind|utility|custom-variant|source)(?:\s|$)/;
+const CSS_IMPORT_RE = /^@import\s+(?:url\(\s*)?["']([^"']+)["']/;
+/** Tokenize each stylesheet once so marker detection and import traversal share the same comment/string boundaries. Missing or unreadable files cannot contribute discovery candidates. */
+async function readStatements(file) {
+	const content = await readFile(file, "utf-8").catch(() => null);
+	return content === null ? null : [...cssStatements(content)];
+}
+/** Directories that never contain the project's own Tailwind entrypoint. Dot-directories (.git, .next, .svelte-kit, …) are skipped wholesale in the walk. */
+const IGNORED_DIRECTORY_NAMES = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"build",
+	"out",
+	"coverage",
+	"public"
+]);
+const CSS_EXTENSIONS = /* @__PURE__ */ new Set([
+	".css",
+	".pcss",
+	".postcss"
+]);
+/** Limit the eager scan to plain-CSS filenames. Following explicit imports is separate and does not impose an extension requirement. Symlinks are followed (a shared theme package linked into the app is a common layout), with directories visited once by real path so linked cycles terminate. */
+async function collectCssFiles(directory, visited = /* @__PURE__ */ new Set()) {
+	const identity = await realpath(directory).catch(() => directory);
+	if (visited.has(identity)) return [];
+	visited.add(identity);
+	const entries = await readdir(directory, { withFileTypes: true }).catch(() => []);
+	const files = [];
+	await Promise.all(entries.map(async (entry) => {
+		const entryPath = path.join(directory, entry.name);
+		const target = entry.isSymbolicLink() ? await stat(entryPath).catch(() => null) : entry;
+		if (target?.isDirectory()) {
+			if (entry.name.startsWith(".") || IGNORED_DIRECTORY_NAMES.has(entry.name)) return;
+			files.push(...await collectCssFiles(entryPath, visited));
+		} else if (target?.isFile() && CSS_EXTENSIONS.has(path.extname(entry.name))) files.push(entryPath);
+	}));
+	return files;
+}
+//#endregion
+//#region ../plugin-core/src/generation.ts
+/**
+* Generates the runtime module from the project's Tailwind CSS entrypoint.
+*
+* Always supplies dependency hooks to the configurator's loaders, even without custom resolution. The same load that generates the config therefore discovers its dependencies; a separate compile for watching is unnecessary. Each dependency's modification time is taken when it is reported, as it is read: taken after generation, an edit landing mid-generation would be recorded as the baseline and a later refresh would keep the stale module.
+*
+* The source scan runs alongside generation rather than before it — its compile of the CSS graph and the source walk only have to finish before pruning, which runs last. A failing scan (no oxide binary for the platform, sources Tailwind can't resolve) never fails the generation: the module is generated with the full config and `pruningError` carries the reason — pruning is an optimization, and falling back preserves the full generated config's behavior.
+*/
+async function generateRuntimeModule(options) {
+	const dependencies = /* @__PURE__ */ new Set();
+	const dependencyMtimes = /* @__PURE__ */ new Map();
+	const recordDependency = (file) => {
+		dependencies.add(file);
+		if (!dependencyMtimes.has(file)) dependencyMtimes.set(file, readMtime(file));
+	};
+	recordDependency(options.cssPath);
+	const css = await readFile(options.cssPath, "utf-8");
+	const base = path.dirname(options.cssPath);
+	const integration = {
+		...options.integration,
+		onDependency(file) {
+			recordDependency(file);
+			options.integration?.onDependency?.(file);
+		}
+	};
+	let pruningError;
+	const scanning = options.prune ? createSourceScanner({
+		css,
+		base,
+		autoDetectBases: options.prune.autoDetectBases,
+		integration
+	}).then((scanner) => ({
+		scanner,
+		scan: scanner.scan()
+	})).catch((error) => {
+		pruningError = error instanceof Error ? error : new Error(String(error));
+		return null;
+	}) : Promise.resolve(null);
+	const sourceLine = `// Source: ${path.relative(options.root, options.cssPath) || options.cssPath} (served in-memory by ${options.packageName})`;
+	const result = await generate({
+		css,
+		base,
+		integration,
+		cacheSize: options.cacheSize,
+		encoding: options.encoding,
+		format: "js",
+		importSource: options.importSource,
+		banner: scanning.then((scanned) => [sourceLine, ...scanned ? [PRUNED_LINE] : []].join("\n")),
+		prune: options.prune ? { usedClasses: scanning.then((scanned) => scanned?.scan.classes ?? null) } : void 0
+	});
+	const scanned = await scanning;
+	for (const file of scanned?.scanner.dependencies ?? []) recordDependency(file);
+	return {
+		...assembleModule(result, options.importSource),
+		dependencies,
+		dependencyMtimes: new Map(await Promise.all([...dependencyMtimes].map(async ([file, mtime]) => [file, await mtime]))),
+		cssPath: options.cssPath,
+		importSource: options.importSource,
+		pruning: scanned && result.plan.report.pruning ? pruningState(scanned.scanner, scanned.scan, result.plan.report.pruning) : void 0,
+		pruningError
+	};
+}
+/**
+* Re-prunes a module for a fresh scan of the same, unchanged CSS graph — a plugin's reaction to a source edit that changed the used classes. Pruning and emission run on the retained classification; nothing is loaded or classified again, and the dependency graph and its modification times carry over.
+*/
+function pruneRuntimeModule(generated, pruning, scan) {
+	const result = generated.result.prune(scan.classes);
+	return {
+		...generated,
+		...assembleModule(result, generated.importSource),
+		pruning: pruningState(pruning.scanner, scan, result.plan.report.pruning)
+	};
+}
+function assembleModule(result, importSource) {
+	const code = result.code + runtimeAppendix(importSource);
+	return {
+		code,
+		hash: createHash("sha256").update(code).digest("hex"),
+		result
+	};
+}
+function pruningState(scanner, scan, report) {
+	return {
+		report,
+		scanner,
+		classesHash: hashClasses(scan.classes),
+		files: scan.files,
+		globs: scan.globs
+	};
+}
+const PRUNED_LINE = "// Pruned to the classes found in the project's sources";
+/** Order-independent fingerprint of a scan's class names. */
+function hashClasses(classes) {
+	return createHash("sha256").update([...classes].sort().join("\n")).digest("hex");
+}
+/** Whether any dependency's modification time differs from the recorded one — deleted files count as changed. */
+async function dependenciesChanged(generated) {
+	const current = await readMtimes(generated.dependencies);
+	for (const [file, mtime] of generated.dependencyMtimes) if (current.get(file) !== mtime) return true;
+	return false;
+}
+async function readMtimes(files) {
+	const mtimes = /* @__PURE__ */ new Map();
+	await Promise.all([...files].map(async (file) => {
+		mtimes.set(file, await readMtime(file));
+	}));
+	return mtimes;
+}
+/** A missing file reads as null, which differs from any real modification time. */
+function readMtime(file) {
+	return stat(file).then((stats) => stats.mtimeMs, () => null);
+}
+/**
+* Appended to the configurator's emitted module (which exports `getConfig` and `twMerge` and already imports `createTailwindMerge`) so the served module's export surface mirrors each plugin's runtime fallback. Plain JavaScript on purpose — types live in the plugin's runtime file, which is what TypeScript resolves for the subpath.
+*/
+function runtimeAppendix(importSource) {
+	return `
+export { createTailwindMerge, mergeConfigs, twJoin, validators } from '${importSource}'
+import { mergeConfigs as mergeConfigsForExtend } from '${importSource}'
+
+// Like tailwind-merge's extendTailwindMerge, but extending this project's generated config instead of the default one.
+export const extendTailwindMerge = (configExtension, ...createConfig) =>
+    typeof configExtension === 'function'
+        ? createTailwindMerge(getConfig, configExtension, ...createConfig)
+        : createTailwindMerge(() => mergeConfigsForExtend(getConfig(), configExtension), ...createConfig)
+`;
+}
+/**
+* Served for the runtime subpath when generation has never succeeded (the CSS is broken from the start, or a `@plugin` package is missing): the same default-config surface as a plugin's runtime fallback file. Once a generation has succeeded, later failures keep serving the last good module instead.
+*/
+function fallbackModuleCode(importSource) {
+	return `
+export { createTailwindMerge, extendTailwindMerge, getDefaultConfig as getConfig, mergeConfigs, twJoin, twMerge, validators } from '${importSource}'
+`;
+}
+//#endregion
+//#region ../plugin-core/src/generation-session.ts
+/** Owns generation for one resolved plugin configuration. Failed attempts retain their dependency discoveries alongside the last good graph; only a success replaces serving state and dependencies. Dev updates, watch builds, and bundler loader re-runs all go through this lifecycle. */
+function createGenerationSession(options) {
+	const { cssRoot, onGenerated, onError, ...generationOptions } = options;
+	let current = null;
+	let dependencies = /* @__PURE__ */ new Set();
+	let generation = run();
+	return {
+		get current() {
+			return current;
+		},
+		get dependencies() {
+			return dependencies;
+		},
+		get generation() {
+			return generation;
+		},
+		/** Schedule after the previous attempt, including a rejection. */
+		regenerate() {
+			generation = generation.catch(() => null).then(() => run());
+			return generation;
+		},
+		/** Source-only changes re-prune the current module for the caller's fresh scan — no loading, no classification — behind any running attempt, like a regeneration. Without a pruned module there is nothing to re-prune. */
+		reprune(scan) {
+			generation = generation.catch(() => null).then(() => {
+				if (current?.pruning) reprune(current, current.pruning, scan);
+				return current;
+			});
+			return generation;
+		},
+		/** Reuses an unchanged success but always retries a failure, even before the first successful generation. A module holding the full config because its source scan failed is retried too, so pruning returns (and the warning repeats) once the cause is gone rather than after the next CSS edit. */
+		refresh() {
+			generation = generation.catch(() => null).then(async (previous) => {
+				if (!previous || previous.pruningError || await dependenciesChanged(previous)) return run();
+				if (previous.pruning) {
+					const scan = previous.pruning.scanner.scan();
+					if (hashClasses(scan.classes) !== previous.pruning.classesHash) reprune(previous, previous.pruning, scan);
+				}
+				return current;
+			});
+			return generation;
+		},
+		/** Programmatic restarts may reuse the plugin object. Drain its old attempt before clearing cached modules and replacing this session. */
+		async dispose() {
+			await generation.catch(() => {});
+			clearRequireCache([...dependencies]);
+		}
+	};
+	async function run() {
+		const cssPath = await cssRoot;
+		if (cssPath === null) return null;
+		try {
+			clearRequireCache([...dependencies]);
+			trackDependency(cssPath);
+			const generated = await generateRuntimeModule({
+				...generationOptions,
+				cssPath,
+				integration: {
+					...generationOptions.integration,
+					onDependency: trackDependency
+				}
+			});
+			current = generated;
+			dependencies = new Set(generated.dependencies);
+			onGenerated(generated);
+		} catch (error) {
+			onError(error, current);
+		}
+		return current;
+	}
+	function reprune(generated, pruning, scan) {
+		current = pruneRuntimeModule(generated, pruning, scan);
+		onGenerated(current);
+	}
+	/** Observe files, missing targets, and recovery directories before an attempt can fail. The caller registers its watcher immediately or drains the accumulated set when the watcher starts. */
+	function trackDependency(file) {
+		if (!dependencies.has(file)) {
+			dependencies.add(file);
+			generationOptions.integration?.onDependency?.(file);
+		}
+	}
+}
+//#endregion
+//#region src/loader.ts
+/**
+* Replaces the content of this package's runtime module with the module generated from the project's Tailwind CSS. Registered by `withTailwindMerge` (src/index.ts) with both Turbopack and webpack; runs once per compilation environment (server components, server rendering, browser), which the per-process project state below turns into one generation.
+*
+* Every run registers the CSS configuration graph — entrypoint, imported stylesheets, `@config`/`@plugin` modules, and the directories a missing import would appear in — as dependencies, so the bundler re-runs the loader when any of them changes and `refresh()` decides whether that change regenerates the module. A regeneration with identical output changes nothing downstream: both bundlers hash module content. With pruning active (builds, or dev with `prune.dev`), the scanned source directories are context dependencies too, so a class-usage change re-prunes the retained classification, and Turbopack's persistent cache cannot serve a module pruned for other sources.
+*
+* Failure policy mirrors the Vite plugin's: a build fails on a configuration-generation failure (the loader rejects, which fails the compilation), while the dev server logs the error and keeps serving the last good module — or the default fallback before the first success. A project without a Tailwind root warns once and serves the default fallback as well. A failed source scan is not a generation failure: the module holds the full config and the warning says so.
+*/
+async function tailwindMergeLoader() {
+	const options = this.getOptions();
+	const project = projectState(this.rootContext, options);
+	const generated = await project.next();
+	registerDependencies(this, project, generated);
+	return generated?.code ?? fallbackModuleCode(IMPORT_SOURCE);
+}
+/** One state per project and option set for the life of the loader process — Next.js runs webpack loaders in its own process and Turbopack loaders in a pool process it keeps alive across compilations, so the session's retained classification and dependency graph survive from one loader run to the next. */
+const projects = /* @__PURE__ */ new Map();
+function projectState(root, options) {
+	const key = `${root}\0${JSON.stringify(options)}`;
+	let state = projects.get(key);
+	if (state) return state;
+	const cssRoot = options.css !== void 0 ? Promise.resolve(path.resolve(root, options.css)) : discoverCssRoot(root, { packageName: PACKAGE_NAME }).then((found) => {
+		if (found === null) console.warn(`[${PACKAGE_NAME}] No Tailwind CSS root found — serving default tailwind-merge behavior. Set the \`css\` option to your Tailwind entrypoint if it uses another extension or is outside the scanned directories.`);
+		return found;
+	});
+	state = {
+		root,
+		session: createGenerationSession({
+			cssRoot,
+			root,
+			packageName: PACKAGE_NAME,
+			importSource: IMPORT_SOURCE,
+			cacheSize: options.cacheSize,
+			encoding: options.encoding,
+			prune: options.prune ? { autoDetectBases: [root] } : void 0,
+			onGenerated: (generated) => reportPruning(generated, options),
+			onError(error, current) {
+				if (options.mode === "build") throw error;
+				console.error(`[${PACKAGE_NAME}] Generating the tailwind-merge config failed${current ? " — keeping the previous one" : ""}: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}),
+		cssRoot: void 0,
+		inFlight: void 0,
+		started: false,
+		next() {
+			if (!this.inFlight) {
+				const attempt = this.started ? this.session.refresh() : this.session.generation;
+				this.started = true;
+				this.inFlight = attempt.finally(() => {
+					this.inFlight = void 0;
+				});
+			}
+			return this.inFlight;
+		}
+	};
+	cssRoot.then((found) => {
+		state.cssRoot = found;
+	}, () => {});
+	projects.set(key, state);
+	return state;
+}
+/**
+* Hands the session's dependency graph to the bundler: files as file dependencies, directories (the recovery directories reported for missing imports, and a missing explicit entrypoint's nearest existing parent) as context dependencies, and nonexistent paths as missing dependencies for webpack, which acts on them. With pruning, the scanned source bases join as context dependencies.
+*/
+function registerDependencies(context, project, generated) {
+	const dependencies = new Set(project.session.dependencies);
+	if (project.cssRoot) dependencies.add(project.cssRoot);
+	for (const dependency of dependencies) {
+		const stats = statSync(dependency, { throwIfNoEntry: false });
+		if (!stats) {
+			context.addMissingDependency(dependency);
+			if (dependency === project.cssRoot) context.addContextDependency(nearestExistingDirectory(dependency));
+		} else if (stats.isDirectory()) context.addContextDependency(dependency);
+		else context.addDependency(dependency);
+	}
+	for (const source of generated?.pruning?.scanner.sources ?? []) if (!source.negated) context.addContextDependency(source.base);
+}
+function nearestExistingDirectory(file) {
+	let directory = path.dirname(file);
+	while (!statSync(directory, { throwIfNoEntry: false })?.isDirectory()) {
+		const parent = path.dirname(directory);
+		if (parent === directory) break;
+		directory = parent;
+	}
+	return directory;
+}
+/** One line per generation about pruning, so the behavior and its effect are visible where someone debugging a production-only merge difference would look; a failed scan is always reported, since the module then silently holds the full config. */
+function reportPruning(generated, options) {
+	if (generated.pruningError) console.warn(`[${PACKAGE_NAME}] Could not scan your sources, serving the full tailwind-merge config instead: ${generated.pruningError.message}`);
+	else if (generated.pruning && options.log) {
+		const { classGroupsAfter, classGroupsBefore, classifiedClassCount } = generated.pruning.report;
+		console.log(`[${PACKAGE_NAME}] Pruned the tailwind-merge config to ${classGroupsAfter} of ${classGroupsBefore} class groups from the ${classifiedClassCount} classes found in your sources`);
+	}
+}
+const PACKAGE_NAME = "@tailwind-merge/next";
+/** The generated module replaces a real file inside this package, so it can import tailwind-merge the ordinary way: resolution starts in the package's own directory, where its dependency is installed under any package manager. */
+const IMPORT_SOURCE = "tailwind-merge";
+//#endregion
+export { tailwindMergeLoader as default };
+
+//# sourceMappingURL=loader.mjs.map