tw-migrate 0.1.0 → 0.3.0

package/dist/index.js

@@ -0,0 +1,2187 @@
+import { createRequire } from "node:module";
+import { promisify } from "node:util";
+import { chmod, lstat, readFile, readdir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { execFile } from "node:child_process";
+import { parse } from "parse5";
+import { fileURLToPath, pathToFileURL } from "node:url";
+//#region src/util/diff.ts
+function unifiedDiff(path, before, after) {
+	const oldLines = before.split("\n");
+	const newLines = after.split("\n");
+	return [
+		`--- a/${path}\n`,
+		`+++ b/${path}\n`,
+		`@@ -1,${oldLines.length} +1,${newLines.length} @@\n`,
+		...oldLines.map((line, index) => `${index === oldLines.length - 1 && line === "" ? " " : "-"}${line}\n`),
+		...newLines.map((line, index) => `${index === newLines.length - 1 && line === "" ? " " : "+"}${line}\n`)
+	].join("");
+}
+//#endregion
+//#region src/parser/html.ts
+const RECOVERABLE_PARSE_ERRORS = /* @__PURE__ */ new Set(["missing-doctype"]);
+const TEMPLATE_MARKERS = /\{\{|\}\}|\$\{|<%|%>|<#|#>|\[%|%\]/;
+function parseHtmlSource(path, source) {
+	const errors = [];
+	const document = parse(source, {
+		sourceCodeLocationInfo: true,
+		onParseError(error) {
+			if (!RECOVERABLE_PARSE_ERRORS.has(error.code)) errors.push(error);
+		}
+	});
+	if (errors.length > 0) throw new Error(`Failed to parse ${path}: ${errors.map((error) => error.code).join(", ")}`);
+	const links = [];
+	const bases = [];
+	const elements = [];
+	const dynamicAttributes = [];
+	const scriptTexts = [];
+	const unquoted = (attribute) => source[attribute.start - 1] !== "\"" && source[attribute.start - 1] !== "'";
+	function visit(node) {
+		if (node.tagName === "script") {
+			for (const child of node.childNodes ?? []) if (child.nodeName === "#text" && child.value) scriptTexts.push(child.value);
+		}
+		if (node.tagName) {
+			const attributes = new Map((node.attrs ?? []).map((attribute) => [attribute.name, attribute.value]));
+			const locations = node.sourceCodeLocation?.attrs;
+			if (locations) {
+				if (node.tagName === "link" && stylesheetRel(attributes.get("rel")) && !attributes.has("disabled")) {
+					const href = locatedAttribute(source, locations.href, attributes.get("href"));
+					const media = locatedAttribute(source, locations.media, attributes.get("media"));
+					const tag = node.sourceCodeLocation?.startTag ?? node.sourceCodeLocation;
+					if (href && tag) links.push({
+						href: href.value,
+						media: media?.value ?? "",
+						start: href.start,
+						end: href.end,
+						tagStart: tag.startOffset,
+						tagEnd: tag.endOffset
+					});
+				}
+				if (node.tagName === "base" && bases.length === 0) {
+					const href = locatedAttribute(source, locations.href, attributes.get("href"));
+					if (href) bases.push({
+						href: href.value,
+						writable: href.writable,
+						start: href.start,
+						end: href.end
+					});
+				}
+				let classAttribute = locatedAttribute(source, locations.class, attributes.get("class"));
+				const idAttribute = locatedAttribute(source, locations.id, attributes.get("id"));
+				const dynamic = (!classAttribute && idAttribute && locations.class ? {
+					start: locations.class.startOffset,
+					end: locations.class.endOffset
+				} : void 0) ?? [classAttribute, idAttribute].find((attribute) => attribute && (!attribute.writable || TEMPLATE_MARKERS.test(attribute.value))) ?? (classAttribute && unquoted(classAttribute) ? classAttribute : void 0);
+				if (dynamic) dynamicAttributes.push({
+					start: dynamic.start,
+					end: dynamic.end
+				});
+				else if (classAttribute || idAttribute) {
+					if (!classAttribute && idAttribute) {
+						const insertion = classInsertionOffset$1(source, node.sourceCodeLocation?.startTag);
+						if (insertion !== void 0) classAttribute = {
+							value: "",
+							start: insertion,
+							end: insertion,
+							synthetic: true
+						};
+					}
+					elements.push({
+						classAttribute,
+						idAttribute
+					});
+				}
+			}
+		}
+		for (const child of node.childNodes ?? []) visit(child);
+		if (node.content) visit(node.content);
+	}
+	visit(document);
+	return {
+		...toByteOffsets(source, {
+			links,
+			bases,
+			elements,
+			dynamicAttributes
+		}),
+		scriptText: scriptTexts.join("\n")
+	};
+}
+function utf8OffsetMap(source, indices) {
+	const sorted = [...new Set(indices)].sort((left, right) => left - right);
+	const map = /* @__PURE__ */ new Map();
+	let lastIndex = 0;
+	let bytes = 0;
+	for (const index of sorted) {
+		bytes += Buffer.byteLength(source.slice(lastIndex, index));
+		lastIndex = index;
+		map.set(index, bytes);
+	}
+	return map;
+}
+function offsetLookup(offsets) {
+	return (index) => {
+		const byte = offsets.get(index);
+		if (byte === void 0) throw new Error(`No byte offset was mapped for index ${index}`);
+		return byte;
+	};
+}
+function toByteOffsets(source, parsed) {
+	const offset = offsetLookup(utf8OffsetMap(source, [
+		...parsed.links.flatMap((link) => [
+			link.start,
+			link.end,
+			link.tagStart,
+			link.tagEnd
+		]),
+		...parsed.bases.flatMap((base) => [base.start, base.end]),
+		...parsed.elements.flatMap((element) => [element.classAttribute, element.idAttribute].flatMap((value) => value ? [value.start, value.end] : [])),
+		...parsed.dynamicAttributes.flatMap((value) => [value.start, value.end])
+	]));
+	const attribute = (value) => ({
+		...value,
+		start: offset(value.start),
+		end: offset(value.end)
+	});
+	return {
+		links: parsed.links.map((link) => ({
+			...link,
+			start: offset(link.start),
+			end: offset(link.end),
+			tagStart: offset(link.tagStart),
+			tagEnd: offset(link.tagEnd)
+		})),
+		bases: parsed.bases.map((base) => attribute(base)),
+		elements: parsed.elements.map((element) => ({
+			classAttribute: element.classAttribute && attribute(element.classAttribute),
+			idAttribute: element.idAttribute && attribute(element.idAttribute)
+		})),
+		dynamicAttributes: parsed.dynamicAttributes.map((value) => attribute(value))
+	};
+}
+function classInsertionOffset$1(source, startTag) {
+	if (!startTag) return void 0;
+	let offset = startTag.endOffset - 1;
+	if (source[offset] !== ">") return void 0;
+	while (offset > startTag.startOffset && /\s/.test(source[offset - 1] ?? "")) offset -= 1;
+	if (source[offset - 1] === "/") offset -= 1;
+	return offset;
+}
+function stylesheetRel(value = "") {
+	const tokens = value.toLowerCase().split(/\s+/);
+	return tokens.includes("stylesheet") && !tokens.includes("alternate");
+}
+function locatedAttribute(source, location, parsedValue) {
+	if (!location || parsedValue === void 0) return void 0;
+	const raw = source.slice(location.startOffset, location.endOffset);
+	const equals = raw.indexOf("=");
+	if (equals < 0) return void 0;
+	let start = equals + 1;
+	while (/\s/.test(raw[start] ?? "")) start += 1;
+	const quote = raw[start];
+	let end;
+	if (quote === "\"" || quote === "'") {
+		start += 1;
+		end = raw.lastIndexOf(quote);
+		if (end < start) return void 0;
+	} else {
+		end = start;
+		while (end < raw.length && !/\s/.test(raw[end] ?? "")) end += 1;
+	}
+	const value = raw.slice(start, end);
+	return {
+		value: value.includes("&") ? parsedValue : value,
+		writable: !value.includes("&"),
+		start: location.startOffset + start,
+		end: location.startOffset + end
+	};
+}
+//#endregion
+//#region src/native.ts
+const require = createRequire(import.meta.url);
+const target = {
+	"darwin-arm64": "darwin-arm64",
+	"darwin-x64": "darwin-x64",
+	"linux-arm64": "linux-arm64-gnu",
+	"linux-x64": "linux-x64-gnu",
+	"win32-x64": "win32-x64-msvc"
+}[`${process.platform}-${process.arch}`];
+if (!target) throw new Error(`Unsupported platform: ${process.platform}-${process.arch}`);
+let binding;
+try {
+	binding = require(`../tw-migrate.${target}.node`);
+} catch (localError) {
+	if (errorCode(localError) !== "MODULE_NOT_FOUND") throw localError;
+	try {
+		binding = require(`tw-migrate-${target}`);
+	} catch (packageError) {
+		if (errorCode(packageError) !== "MODULE_NOT_FOUND") throw packageError;
+		throw new Error(`No tw-migrate native addon was found for ${target}. Reinstall the package or build it locally.`);
+	}
+}
+const { decodeSourceMap, planBatchMigration, staticImportBindings, staticImports, staticStringExpression, validateCss } = binding;
+//#endregion
+//#region src/parser/style-compiler.ts
+const SASS_EXTENSIONS = /* @__PURE__ */ new Set([".scss", ".sass"]);
+function isSassPath(path) {
+	return SASS_EXTENSIONS.has(extname(path));
+}
+function isPreprocessorPath(path) {
+	return isSassPath(path) || extname(path) === ".less";
+}
+async function loadProjectModule(packageRoot, name, errorMessage) {
+	const projectRequire = createRequire(join(packageRoot, "package.json"));
+	let modulePath;
+	try {
+		modulePath = projectRequire.resolve(name);
+	} catch {
+		throw new Error(errorMessage);
+	}
+	const imported = await import(pathToFileURL(modulePath).href);
+	return imported.default ?? imported;
+}
+function loadProjectSass(packageRoot) {
+	return loadProjectModule(packageRoot, "sass", "Sass must be installed in the target project.");
+}
+function loadProjectLess(packageRoot) {
+	return loadProjectModule(packageRoot, "less", "Less must be installed in the target project.");
+}
+async function compileStyleEntry(compilers, packageRoot, entryPath, source, options = {}) {
+	if (isSassPath(entryPath)) return compileSassEntry(compilers.sass ??= await loadProjectSass(packageRoot), entryPath, source, options);
+	return compileLessEntry(compilers.less ??= await loadProjectLess(packageRoot), entryPath, source);
+}
+async function compileSassEntry(sass, entryPath, source, { virtualEntry = false } = {}) {
+	const result = await sass.compileStringAsync(source, {
+		sourceMap: true,
+		sourceMapIncludeSources: true,
+		url: pathToFileURL(entryPath),
+		syntax: extname(entryPath) === ".sass" ? "indented" : "scss"
+	});
+	if (!result.sourceMap) throw new Error(`Sass did not produce a source map for ${entryPath}`);
+	const loadedPaths = result.loadedUrls.filter((url) => url.protocol === "file:").map((url) => fileURLToPath(url));
+	const mappings = sourceMappings(result.sourceMap);
+	const normalizedPaths = await normalizeEntryPaths([...loadedPaths, ...mappings.map((mapping) => mapping.sourcePath)], entryPath, virtualEntry);
+	return {
+		css: result.css,
+		loadedPaths: loadedPaths.map((path) => normalizedPaths.get(path) ?? path),
+		sourceMappings: mappings.map((mapping) => ({
+			...mapping,
+			sourcePath: normalizedPaths.get(mapping.sourcePath) ?? mapping.sourcePath
+		}))
+	};
+}
+async function normalizeEntryPaths(paths, entryPath, virtualEntry) {
+	const canonicalEntryPath = virtualEntry ? entryPath : await realpath(entryPath);
+	return new Map(await Promise.all([...new Set(paths)].map(async (path) => {
+		if (path === entryPath) return [path, path];
+		try {
+			return [path, await realpath(path) === canonicalEntryPath ? entryPath : path];
+		} catch {
+			return [path, path];
+		}
+	})));
+}
+async function compileLessEntry(less, entryPath, source) {
+	const result = await less.render(source, {
+		filename: entryPath,
+		sourceMap: {
+			outputSourceFiles: true,
+			sourceMapBasepath: dirname(entryPath),
+			sourceMapOutputFilename: `${basename(entryPath, ".less")}.css`
+		}
+	});
+	return {
+		css: result.css,
+		loadedPaths: result.imports.map((path) => isAbsolute(path) ? path : resolve(dirname(entryPath), path)),
+		sourceMappings: result.map ? sourceMappings(JSON.parse(result.map), dirname(entryPath)) : []
+	};
+}
+function sourceMappings(sourceMap, sourceBase) {
+	return JSON.parse(decodeSourceMap(JSON.stringify(sourceMap))).flatMap(({ source, ...mapping }) => {
+		const sourcePath = sourcePathFromMap(sourceReferenceFromMap(source, sourceMap.sourceRoot), sourceBase);
+		return sourcePath ? [{
+			...mapping,
+			sourcePath
+		}] : [];
+	});
+}
+function sourceReferenceFromMap(source, sourceRoot) {
+	if (!sourceRoot) return source;
+	if (isAbsolute(sourceRoot)) return resolve(sourceRoot, source);
+	try {
+		const root = new URL(sourceRoot);
+		root.pathname = `${root.pathname.replace(/\/+$/, "")}/`;
+		return new URL(source, root).href;
+	} catch {
+		return join(sourceRoot, source);
+	}
+}
+function sourcePathFromMap(source, sourceBase) {
+	if (isAbsolute(source)) return resolve(source);
+	try {
+		const url = new URL(source);
+		return url.protocol === "file:" ? resolve(fileURLToPath(url)) : void 0;
+	} catch {
+		return sourceBase ? resolve(sourceBase, source) : void 0;
+	}
+}
+//#endregion
+//#region src/util/shared.ts
+const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".html",
+	".vue",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".ts",
+	".tsx",
+	".mts",
+	".cts"
+]);
+const STYLESHEET_SYNTAX = /* @__PURE__ */ new Map([
+	[".css", "css"],
+	[".scss", "scss"],
+	[".sass", "sass"],
+	[".less", "less"]
+]);
+const IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+	".git",
+	".next",
+	"build",
+	"dist",
+	"node_modules"
+]);
+const RECOVERABLE_INPUT_ERROR = "TW_MIGRATE_RECOVERABLE_INPUT:";
+function errorCode(error) {
+	return error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+function isWithin(root, path) {
+	return path === root || path.startsWith(`${root}${sep}`);
+}
+function isStylesheetPath(path) {
+	return STYLESHEET_SYNTAX.has(extname(path));
+}
+function stylesheetSyntax(path) {
+	return STYLESHEET_SYNTAX.get(extname(path));
+}
+function isStylesheetModule(path) {
+	const syntax = stylesheetSyntax(path);
+	return syntax !== void 0 && path.endsWith(`.module.${syntax}`);
+}
+function sourceReferencesStyle(file, stylePath) {
+	let importPath = normalizedRelativePath(dirname(file.path), stylePath);
+	if (!importPath.startsWith(".")) importPath = `./${importPath}`;
+	return [
+		`'${importPath}'`,
+		`"${importPath}"`,
+		`\`${importPath}\``
+	].some((literal) => file.source.includes(literal));
+}
+function isProjectInput(workspaceRoot, path) {
+	return isWithin(workspaceRoot, path) && !relative(workspaceRoot, path).split(/[\\/]/).includes("node_modules");
+}
+async function rejectSymlinkTarget(path, root) {
+	for (let current = path; isWithin(root, current); current = dirname(current)) {
+		if ((await lstat(current)).isSymbolicLink()) throw new Error(`Refusing to migrate a symbolic-link target: ${path}`);
+		if (current === root) break;
+	}
+}
+async function snapshotFile(snapshots, path) {
+	return recordSnapshot(snapshots, path, await readFile(path, "utf8"));
+}
+async function snapshotLoadedSource(snapshots, path) {
+	try {
+		return await snapshotFile(snapshots, path);
+	} catch (error) {
+		if (errorCode(error) === "ENOENT") throw new Error(`Source changed during planning: ${path}`);
+		throw error;
+	}
+}
+function recordSnapshot(snapshots, path, source) {
+	if (snapshots.has(path) && snapshots.get(path) !== source) throw new Error(`Source changed during planning: ${path}`);
+	snapshots.set(path, source);
+	return source;
+}
+function packageFailure(workspaceRoot, packageRoot, error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return {
+		package: normalizedRelativePath(workspaceRoot, packageRoot) || ".",
+		message: message.startsWith("TW_MIGRATE_RECOVERABLE_INPUT:") ? message.slice(29) : message
+	};
+}
+function isRecoverablePlanningError(error) {
+	return (error instanceof Error ? error.message : String(error)).startsWith(RECOVERABLE_INPUT_ERROR);
+}
+function isMissingStyleCompilerError(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return /^(?:Sass|Less) must be installed in the target project\.$/.test(message);
+}
+function isIntegrityError(error) {
+	return (error instanceof Error ? error.message : String(error)).startsWith("Source changed during planning:");
+}
+function normalizedRelativePath(root, path) {
+	return relative(root, path).split(sep).join("/");
+}
+function maskCssComments(source) {
+	return source.replace(/\/\*[\s\S]*?\*\//g, (comment) => comment.replace(/[^\r\n]/g, " "));
+}
+function indexStylesheetDependents(styleSources) {
+	const dependents = /* @__PURE__ */ new Map();
+	for (const [path, rawSource] of styleSources) {
+		const source = maskCssComments(rawSource);
+		const references = [
+			...[...source.matchAll(/composes\s*:[^;{}]*?\bfrom\s+["']([^"']+)["']/g)].map((match) => match[1]),
+			...[...source.matchAll(/@(?:use|forward)\s+["']([^"']+)["']/g)].map((match) => match[1]),
+			...[...source.matchAll(/@import\s+(?:\([^)]*\)\s*)?(?:([^;{}]+);|([^;{}\r\n]+))/g)].flatMap((statement) => [...(statement[1] ?? statement[2]).matchAll(/["']([^"']+)["']/g)].map((match) => match[1])),
+			...[...source.matchAll(/@import\s+url\(\s*([^"'()\s]+)\s*\)/g)].map((match) => match[1])
+		];
+		for (const reference of new Set(references)) for (const target of stylesheetReferenceTargets(path, reference, styleSources)) {
+			if (target === path || !isStylesheetModule(target) && !isPreprocessorPath(target)) continue;
+			const paths = dependents.get(target) ?? [];
+			paths.push(path);
+			dependents.set(target, paths);
+		}
+	}
+	for (const [target, paths] of dependents) dependents.set(target, [...new Set(paths)].sort());
+	return dependents;
+}
+function addStyleDependent(styleDependents, target, importer) {
+	const paths = styleDependents.get(target) ?? [];
+	if (paths.includes(importer)) return;
+	paths.push(importer);
+	paths.sort();
+	styleDependents.set(target, paths);
+}
+function stylesheetReferenceTargets(importer, reference, styleSources) {
+	const target = resolve(dirname(importer), reference);
+	return (STYLESHEET_SYNTAX.has(extname(target)) ? [target] : [...STYLESHEET_SYNTAX.keys()].flatMap((syntax) => [
+		`${target}${syntax}`,
+		join(dirname(target), `_${basename(target)}${syntax}`),
+		join(target, `_index${syntax}`),
+		join(target, `index${syntax}`)
+	])).filter((path) => styleSources.has(path));
+}
+function cssImports(source) {
+	const imports = [];
+	const masked = maskCssComments(source);
+	let depth = 0;
+	let quote;
+	let importsAllowed = true;
+	for (let index = 0; index < masked.length; index += 1) {
+		const character = masked[index];
+		if (quote) {
+			if (character === "\\") index += 1;
+			else if (character === quote) quote = void 0;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			continue;
+		}
+		if (character === "{") {
+			depth += 1;
+			importsAllowed = false;
+			continue;
+		}
+		if (character === "}") {
+			depth = Math.max(0, depth - 1);
+			continue;
+		}
+		if (!importsAllowed || depth !== 0 || masked.slice(index, index + 7).toLowerCase() !== "@import" || /[-\w]/.test(masked[index + 7] ?? "")) continue;
+		let end = index + 7;
+		let importQuote;
+		let parentheses = 0;
+		for (; end < masked.length; end += 1) {
+			const next = masked[end];
+			if (importQuote) {
+				if (next === "\\") end += 1;
+				else if (next === importQuote) importQuote = void 0;
+			} else if (next === "\"" || next === "'") importQuote = next;
+			else if (next === "(") parentheses += 1;
+			else if (next === ")") parentheses = Math.max(0, parentheses - 1);
+			else if (next === ";" && parentheses === 0) break;
+		}
+		if (end >= masked.length) continue;
+		const statement = masked.slice(index, end + 1);
+		const match = /^@import\s+(?:url\(\s*)?(?:["']([^"']+)["']|([^"'()\s;]+))\s*\)?\s*([^;]*);$/i.exec(statement);
+		if (match) imports.push({
+			href: match[1] ?? match[2],
+			media: match[3].trim(),
+			start: index,
+			end: end + 1
+		});
+		index = end;
+	}
+	const offsets = utf8OffsetMap(source, imports.flatMap((imported) => [imported.start, imported.end]));
+	return imports.map((imported) => ({
+		...imported,
+		start: offsets.get(imported.start) ?? imported.start,
+		end: offsets.get(imported.end) ?? imported.end
+	}));
+}
+//#endregion
+//#region src/discovery.ts
+const run = promisify(execFile);
+async function resolveScope(options) {
+	const cwd = await realpath(resolve(options.cwd ?? process.cwd()));
+	const currentPackage = await findPackageRoot(cwd);
+	const gitRoot = await findGitRoot(currentPackage);
+	const workspaceRoot = gitRoot && !await isIgnoredByGit(gitRoot, currentPackage) ? gitRoot : currentPackage;
+	const allPaths = await discoverFiles(workspaceRoot, workspaceRoot === gitRoot);
+	const scannedPaths = workspaceRoot === gitRoot ? [.../* @__PURE__ */ new Set([...allPaths, ...await collectFiles(workspaceRoot, isRelevantDiscoveredFile)])] : [...allPaths];
+	const explicitStyle = options.styleFile ? resolve(cwd, options.styleFile) : void 0;
+	const configuredEntry = options.tailwindCss ? resolve(cwd, options.tailwindCss) : void 0;
+	if (explicitStyle && !isStylesheetPath(explicitStyle) && extname(explicitStyle) !== ".vue") throw new TypeError("Only .css, .scss, .sass, .less, and .vue files can be migrated");
+	if (configuredEntry && extname(configuredEntry) !== ".css") throw new TypeError("The Tailwind CSS entry must be a .css file");
+	if (configuredEntry && !(await stat(configuredEntry)).isFile()) throw new TypeError("The Tailwind CSS entry must be a file");
+	for (const path of [explicitStyle, configuredEntry]) if (path) await rejectSymlinkTarget(path, currentPackage);
+	if (explicitStyle && !isWithin(currentPackage, explicitStyle)) throw new TypeError("The selected stylesheet must belong to the current package");
+	for (const path of [explicitStyle, configuredEntry]) {
+		if (path && !allPaths.includes(path)) allPaths.push(path);
+		if (path && !scannedPaths.includes(path)) scannedPaths.push(path);
+	}
+	allPaths.sort();
+	scannedPaths.sort();
+	const targetable = new Set(allPaths);
+	const allPackageRoots = await discoverPackageRoots(workspaceRoot, allPaths);
+	if (!allPackageRoots.includes(currentPackage)) allPackageRoots.push(currentPackage);
+	for (const path of [explicitStyle, configuredEntry]) {
+		if (!path) continue;
+		const owner = await findPackageRoot(dirname(path));
+		if (!allPackageRoots.includes(owner)) allPackageRoots.push(owner);
+	}
+	allPackageRoots.sort();
+	const rootsByDepth = [...allPackageRoots].sort((left, right) => right.length - left.length);
+	const pathOwners = new Map(scannedPaths.map((path) => [path, rootsByDepth.find((root) => isWithin(root, path))]));
+	if (explicitStyle && pathOwners.get(explicitStyle) !== currentPackage) throw new TypeError("The selected stylesheet must belong to the current package");
+	if (configuredEntry && pathOwners.get(configuredEntry) !== currentPackage) throw new TypeError("The Tailwind CSS entry must belong to the current package");
+	return {
+		cwd,
+		workspaceRoot,
+		scannedPaths,
+		targetable,
+		explicitStyle,
+		configuredEntry,
+		pathOwners,
+		selectedPackages: options.workspaces ? allPackageRoots : [currentPackage]
+	};
+}
+async function findPackageRoot(start) {
+	let directory = start;
+	while (true) {
+		try {
+			await readFile(join(directory, "package.json"), "utf8");
+			return directory;
+		} catch (error) {
+			if (errorCode(error) !== "ENOENT") throw error;
+		}
+		const parent = dirname(directory);
+		if (parent === directory) throw new Error(`No package.json was found from ${start}`);
+		directory = parent;
+	}
+}
+async function findGitRoot(cwd) {
+	try {
+		const { stdout } = await run("git", ["rev-parse", "--show-toplevel"], { cwd });
+		return resolve(stdout.trim());
+	} catch {
+		return;
+	}
+}
+async function isIgnoredByGit(gitRoot, path) {
+	if (gitRoot === path) return false;
+	try {
+		await run("git", [
+			"check-ignore",
+			"-q",
+			"--",
+			relative(gitRoot, path)
+		], { cwd: gitRoot });
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function discoverFiles(root, useGit) {
+	if (!useGit) return collectFiles(root, isRelevantDiscoveredFile);
+	const { stdout } = await run("git", [
+		"ls-files",
+		"-co",
+		"--exclude-standard",
+		"-z",
+		"--",
+		"."
+	], {
+		cwd: root,
+		maxBuffer: 64 * 1024 * 1024
+	});
+	const paths = stdout.split("\0").filter(Boolean).map((path) => resolve(root, path)).filter((path) => !hasIgnoredDirectory(root, path) && isRelevantDiscoveredFile(path));
+	return (await Promise.all(paths.map(async (path) => {
+		try {
+			return (await stat(path)).isFile() ? path : void 0;
+		} catch {
+			return;
+		}
+	}))).flatMap((path) => path ? [path] : []).sort();
+}
+async function discoverPackageRoots(workspaceRoot, paths) {
+	const roots = paths.filter((path) => basename(path) === "package.json").map(dirname);
+	try {
+		await readFile(join(workspaceRoot, "package.json"), "utf8");
+		roots.push(workspaceRoot);
+	} catch (error) {
+		if (errorCode(error) !== "ENOENT") throw error;
+	}
+	return [...new Set(roots)].sort();
+}
+function hasIgnoredDirectory(root, path) {
+	return relative(root, path).split(/[\\/]/).some((part) => IGNORED_DIRECTORIES.has(part));
+}
+function isRelevantDiscoveredFile(path) {
+	return basename(path) === "package.json" || isStylesheetPath(path) || SOURCE_EXTENSIONS.has(extname(path));
+}
+async function collectFiles(root, include) {
+	const files = [];
+	async function visit(directory) {
+		const entries = await readdir(directory, { withFileTypes: true });
+		entries.sort((left, right) => left.name.localeCompare(right.name));
+		for (const entry of entries) {
+			const path = join(directory, entry.name);
+			if (entry.isDirectory()) {
+				if (!IGNORED_DIRECTORIES.has(entry.name)) await visit(path);
+			} else if (entry.isFile() && include(path)) files.push(path);
+		}
+	}
+	await visit(root);
+	return files;
+}
+//#endregion
+//#region src/plan/html.ts
+async function preparePackageHtml({ packageRoot, sourceFiles, styleSources, snapshots, pathOwners, styleDependents }) {
+	const files = [];
+	const stylePaths = /* @__PURE__ */ new Set();
+	const generatedPaths = /* @__PURE__ */ new Set();
+	const removableLinks = [];
+	const warnings = [];
+	const htmlFiles = sourceFiles.filter((file) => extname(file.path) === ".html");
+	const orderedFiles = [...htmlFiles.filter((file) => pathOwners.get(file.path) === packageRoot), ...htmlFiles.filter((file) => pathOwners.get(file.path) !== packageRoot)];
+	for (const file of orderedFiles) {
+		const owner = pathOwners.get(file.path);
+		const foreign = owner !== packageRoot;
+		if (foreign && !owner) continue;
+		const referenceRoot = foreign ? owner : packageRoot;
+		const parsed = parseHtmlSource(file.path, file.source);
+		const contexts = [];
+		let linkBase = dirname(file.path);
+		const base = parsed.bases[0];
+		if (base) {
+			const baseReference = base.href.split(/[?#]/, 1)[0];
+			const basePath = base.writable && (baseReference === "" ? file.path : localHtmlReference(referenceRoot, dirname(file.path), base.href));
+			if (!basePath || !isWithin(referenceRoot, basePath)) {
+				if (!foreign) warnings.push(htmlWarning("unsupported-html-base", file.path, base.start, base.end, "A remote or unrepresentable base URL prevents safe stylesheet link resolution."));
+				linkBase = void 0;
+			} else linkBase = base.href.split(/[?#]/, 1)[0].endsWith("/") ? basePath : dirname(basePath);
+		}
+		for (const link of parsed.links) {
+			const linkedPath = linkBase && localHtmlReference(referenceRoot, linkBase, link.href);
+			if (!linkedPath || !isWithin(packageRoot, linkedPath) || foreign && pathOwners.get(linkedPath) !== packageRoot) {
+				if (!foreign) warnings.push(htmlWarning("unsupported-html-stylesheet-link", file.path, link.start, link.end, "Only local package stylesheet links are analyzed."));
+				continue;
+			}
+			const variants = mediaVariants(link.media);
+			if (variants === void 0) {
+				const cssPath = (foreign ? void 0 : inferredPreprocessorPath({
+					path: linkedPath,
+					packageRoot,
+					styleSources,
+					pathOwners,
+					styleDependents
+				})) ?? linkedPath;
+				contexts.push({
+					cssPath,
+					variants: [],
+					direct: true,
+					analyzable: false
+				});
+				if (!foreign) warnings.push(htmlWarning("unsupported-link-media", file.path, link.start, link.end, `The stylesheet link media condition ${JSON.stringify(link.media)} cannot be represented safely.`));
+				continue;
+			}
+			const contextStart = contexts.length;
+			await collectHtmlStyleContexts({
+				path: linkedPath,
+				variants,
+				direct: true,
+				packageRoot,
+				sourceFiles,
+				styleSources,
+				snapshots,
+				pathOwners,
+				styleDependents,
+				stylePaths,
+				generatedPaths,
+				contexts,
+				warnings,
+				visited: /* @__PURE__ */ new Set()
+			});
+			const directContext = contexts[contextStart];
+			if (directContext?.direct) removableLinks.push({
+				filePath: file.path,
+				cssPath: directContext.cssPath,
+				href: link.href,
+				media: link.media
+			});
+		}
+		if (foreign && contexts.length === 0) continue;
+		if (!foreign && contexts.length > 0) for (const attribute of parsed.dynamicAttributes) warnings.push(htmlWarning("dynamic-html-attribute", file.path, attribute.start, attribute.end, "This HTML attribute is not a safely writable quoted literal."));
+		files.push({
+			...file,
+			htmlElements: parsed.elements,
+			htmlStylesheets: deduplicateHtmlContexts(contexts),
+			htmlReferencesSafe: parsed.dynamicAttributes.length === 0,
+			htmlScriptText: parsed.scriptText
+		});
+	}
+	return {
+		files,
+		stylePaths,
+		generatedPaths,
+		removableLinks,
+		warnings
+	};
+}
+async function collectHtmlStyleContexts(state) {
+	const key = `${state.path}\0${state.variants.join(":")}`;
+	if (state.visited.has(key)) return;
+	state.visited.add(key);
+	if (!isStylesheetPath(state.path)) return;
+	const owner = state.pathOwners.get(state.path);
+	if (owner && owner !== state.packageRoot) {
+		state.warnings.push(htmlWarning("cross-package-stylesheet-link", state.path, 0, 0, "A stylesheet owned by another package is not analyzed outside workspace mode."));
+		return;
+	}
+	let source;
+	try {
+		source = state.styleSources.get(state.path) ?? await snapshotFile(state.snapshots, state.path);
+	} catch (error) {
+		if (errorCode(error) === "ENOENT") {
+			if (extname(state.path) === ".css") addInferredPreprocessorContext(state);
+			return;
+		}
+		throw error;
+	}
+	if (!state.styleSources.has(state.path)) state.styleSources.set(state.path, source);
+	if (!owner) state.pathOwners.set(state.path, state.packageRoot);
+	if (extname(state.path) === ".css" && addInferredPreprocessorContext(state)) return;
+	state.stylePaths.add(state.path);
+	state.contexts.push({
+		cssPath: state.path,
+		variants: state.variants,
+		direct: state.direct,
+		analyzable: true
+	});
+	if (extname(state.path) !== ".css") return;
+	for (const imported of cssImports(source)) {
+		const variants = mediaVariants(imported.media);
+		if (variants === void 0) {
+			state.warnings.push(htmlWarning("unsupported-link-media", state.path, imported.start, imported.end, `The stylesheet import media condition ${JSON.stringify(imported.media)} cannot be represented safely.`));
+			continue;
+		}
+		const importedPath = localHtmlReference(state.packageRoot, dirname(state.path), imported.href);
+		if (!importedPath || !isWithin(state.packageRoot, importedPath)) continue;
+		if (importedPath !== state.path && (isStylesheetModule(importedPath) || isPreprocessorPath(importedPath))) addStyleDependent(state.styleDependents, importedPath, state.path);
+		await collectHtmlStyleContexts({
+			...state,
+			path: importedPath,
+			variants: [.../* @__PURE__ */ new Set([...state.variants, ...variants])],
+			direct: false
+		});
+	}
+}
+function inferredPreprocessorPath(state) {
+	const stem = basename(state.path, ".css");
+	const matches = [...state.styleSources.keys()].filter((path) => isPreprocessorPath(path) && state.pathOwners.get(path) === state.packageRoot && !basename(path).startsWith("_") && !state.styleDependents.has(path) && basename(path, extname(path)) === stem);
+	return matches.length === 1 ? matches[0] : void 0;
+}
+function addInferredPreprocessorContext(state) {
+	if (state.styleSources.has(state.path) && state.sourceFiles.some((file) => extname(file.path) !== ".html" && sourceReferencesStyle(file, state.path))) return false;
+	const path = inferredPreprocessorPath(state);
+	if (!path) return false;
+	state.generatedPaths.add(state.path);
+	state.stylePaths.add(path);
+	state.contexts.push({
+		cssPath: path,
+		variants: state.variants,
+		direct: state.direct,
+		analyzable: true
+	});
+	state.warnings.push(htmlWarning("inferred-preprocessor-source", state.path, 0, 0, `The linked CSS was matched to the unique preprocessor filename ${basename(path)}.`));
+	return true;
+}
+function localHtmlReference(packageRoot, base, reference) {
+	const path = reference.split(/[?#]/, 1)[0];
+	if (!path || path.startsWith("//") || /^[a-z][a-z\d+.-]*:/i.test(path)) return void 0;
+	let decoded;
+	try {
+		decoded = decodeURIComponent(path);
+	} catch {
+		return;
+	}
+	return decoded.startsWith("/") ? resolve(packageRoot, `.${decoded}`) : resolve(base, decoded);
+}
+function mediaVariants(media) {
+	const normalized = media.trim().toLowerCase();
+	if (!normalized || normalized === "all") return [];
+	if (normalized === "print") return ["print"];
+}
+function deduplicateHtmlContexts(contexts) {
+	const unique = /* @__PURE__ */ new Map();
+	for (const context of contexts) {
+		const key = `${context.cssPath}\0${context.variants.join(":")}\0${context.analyzable}`;
+		const existing = unique.get(key);
+		if (existing) existing.direct ||= context.direct;
+		else unique.set(key, { ...context });
+	}
+	return [...unique.values()];
+}
+function htmlWarning(code, file, start, end, message) {
+	return {
+		code,
+		file,
+		start,
+		end,
+		message
+	};
+}
+//#endregion
+//#region src/tailwind.ts
+function resolveTailwindEntry(stylePaths, styleSources, configuredPath) {
+	const entries = stylePaths.filter((path) => {
+		if (extname(path) !== ".css") return false;
+		const source = maskCssComments(styleSources.get(path) ?? "");
+		return /@import\s+["']tailwindcss(?:\/[^"']*)?["']/.test(source);
+	});
+	if (configuredPath) return {
+		path: configuredPath,
+		entries
+	};
+	if (entries.length === 0) throw new Error("No Tailwind v4 CSS entry was found. Pass --tailwind-css.");
+	if (entries.length > 1) throw new Error("Multiple Tailwind CSS entries were found. Pass --tailwind-css.");
+	return {
+		path: entries[0],
+		entries
+	};
+}
+async function loadTailwind(packageRoot, tailwindCss, snapshots, workspaceRoot) {
+	const projectRequire = createRequire(join(packageRoot, "package.json"));
+	let packagePath;
+	try {
+		packagePath = projectRequire.resolve("tailwindcss/package.json");
+	} catch {
+		throw new Error("Tailwind v4 must be installed in the target project.");
+	}
+	const packageJson = JSON.parse(await readFile(packagePath, "utf8"));
+	if (!String(packageJson.version).startsWith("4.")) throw new Error(`Tailwind v4 is required; found ${packageJson.version}.`);
+	const { __unstable__loadDesignSystem: loadDesignSystem } = await loadProjectModule(packageRoot, "tailwindcss", "Tailwind v4 must be installed in the target project.");
+	const css = await snapshotFile(snapshots, tailwindCss);
+	const base = dirname(tailwindCss);
+	const loadModule = createModuleLoader(snapshots, workspaceRoot);
+	const loadStylesheet = createStylesheetLoader(projectRequire, packagePath, snapshots, workspaceRoot);
+	const themeTokens = {
+		...extractThemeTokens(await readFile(join(dirname(packagePath), "theme.css"), "utf8")),
+		...await extractThemeTokensFromGraph(css, base, loadStylesheet)
+	};
+	return {
+		designSystem: await loadDesignSystem(css, {
+			base,
+			loadModule,
+			loadStylesheet
+		}),
+		css,
+		path: tailwindCss,
+		themeTokens
+	};
+}
+function extractThemeTokens(css) {
+	const tokens = {};
+	for (const block of css.matchAll(/@theme[^{]*\{([^}]*)\}/gs)) for (const match of block[1].matchAll(/--([\w-]+):\s*([^;{}]+);/g)) tokens[match[1]] = match[2].trim();
+	return tokens;
+}
+async function extractThemeTokensFromGraph(css, base, loadStylesheet, seen = /* @__PURE__ */ new Set()) {
+	const tokens = {};
+	for (const match of css.matchAll(/@import\s+["']([^"']+)["']/g)) {
+		const key = `${base}\0${match[1]}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		const loaded = await loadStylesheet(match[1], base);
+		Object.assign(tokens, await extractThemeTokensFromGraph(loaded.content, loaded.base, loadStylesheet, seen));
+	}
+	return Object.assign(tokens, extractThemeTokens(css));
+}
+function invalidCandidates(tailwind, candidates) {
+	const generated = tailwind.designSystem.candidatesToCss(candidates);
+	return candidates.filter((_, index) => generated[index] === null);
+}
+function createModuleLoader(snapshots, workspaceRoot) {
+	return async (id, base) => {
+		const path = createRequire(join(base, "package.json")).resolve(id);
+		if (isProjectInput(workspaceRoot, path)) await snapshotFile(snapshots, path);
+		const imported = await import(pathToFileURL(path).href);
+		return {
+			path,
+			base: dirname(path),
+			module: imported.default ?? imported
+		};
+	};
+}
+function createStylesheetLoader(projectRequire, tailwindPackagePath, snapshots, workspaceRoot) {
+	const tailwindRoot = dirname(tailwindPackagePath);
+	return async (id, base) => {
+		let path;
+		if (id === "tailwindcss") path = join(tailwindRoot, "index.css");
+		else if (id.startsWith("tailwindcss/")) {
+			const subpath = id.slice(12);
+			path = join(tailwindRoot, subpath.endsWith(".css") ? subpath : `${subpath}.css`);
+		} else if (id.startsWith(".") || isAbsolute(id)) path = resolve(base, id);
+		else path = projectRequire.resolve(id);
+		return {
+			content: isProjectInput(workspaceRoot, path) ? await snapshotFile(snapshots, path) : await readFile(path, "utf8"),
+			base: dirname(path)
+		};
+	};
+}
+//#endregion
+//#region src/parser/vue.ts
+const ESCAPE_SELECTOR = /(?:::v-|:)(?:deep|global|slotted)\(([^)]*)\)/g;
+const ESCAPE_RESIDUE = /(?:>>>|\/deep\/|::v-deep|:deep|::v-slotted|:slotted|::v-global|:global)/;
+const SUPPORTED_STYLE_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"lang",
+	"module",
+	"scoped",
+	"src"
+]);
+const SUPPORTED_STYLE_LANGUAGES = /* @__PURE__ */ new Set([
+	void 0,
+	"css",
+	"scss",
+	"sass",
+	"less"
+]);
+const NODE_ELEMENT = 1;
+const NODE_TEXT = 2;
+const NODE_INTERPOLATION = 5;
+const PROP_ATTRIBUTE = 6;
+const PROP_DIRECTIVE = 7;
+const TAG_ELEMENT = 0;
+const TAG_COMPONENT = 1;
+const TAG_SLOT = 2;
+async function loadProjectVueCompiler(packageRoot) {
+	const projectRequire = createRequire(join(packageRoot, "package.json"));
+	let packagePath;
+	try {
+		packagePath = projectRequire.resolve("vue/package.json");
+	} catch {
+		throw new Error("Vue 3 with compiler-sfc must be installed in the target project.");
+	}
+	const { version } = JSON.parse(await readFile(packagePath, "utf8"));
+	if (!String(version).startsWith("3.")) return { unsupportedVersion: String(version) };
+	return { compiler: await loadProjectModule(packageRoot, "vue/compiler-sfc", "Vue 3 with compiler-sfc must be installed in the target project.") };
+}
+function analyzeVueSource(compiler, path, source) {
+	const warnings = [];
+	const warn = (code, start, end, message) => warnings.push({
+		code,
+		file: path,
+		start,
+		end,
+		message
+	});
+	const { descriptor, errors } = compiler.parse(source, { filename: path });
+	if (errors.length > 0) {
+		const offset = errors[0]?.loc?.start?.offset ?? 0;
+		warn("unsupported-sfc-block", offset, offset, `The SFC could not be parsed: ${errors[0].message}`);
+		return {
+			warnings: toByteWarnings(source, warnings),
+			retained: true
+		};
+	}
+	const template = descriptor.template;
+	if (!template || template.lang || template.src) {
+		warn("unsupported-sfc-block", 0, 0, !template ? "The SFC has no template block, so its class usage cannot be analyzed." : "Only the default template language with inline content is analyzed.");
+		return {
+			warnings: toByteWarnings(source, warnings),
+			retained: true
+		};
+	}
+	if (descriptor.customBlocks.length > 0) {
+		const block = descriptor.customBlocks[0];
+		warn("unsupported-sfc-block", block.loc.start.offset, block.loc.end.offset, `The custom <${block.type}> block is not analyzed.`);
+		return {
+			warnings: toByteWarnings(source, warnings),
+			retained: true
+		};
+	}
+	const blocks = [];
+	const unscopedBlocks = [];
+	const moduleBlocks = [];
+	const styleBlockImports = [];
+	const shadowCssTexts = [];
+	const unscopedShadowCssTexts = [];
+	const shadowModuleCssTexts = [];
+	const shadowPreprocessorTexts = [];
+	const unscopedShadowPreprocessorTexts = [];
+	let escapeUnverifiable = false;
+	let moduleSiblingUnsupported = false;
+	for (const style of descriptor.styles) {
+		const start = style.loc.start.offset;
+		const end = style.loc.end.offset;
+		const usesDefaultModuleBinding = style.module === true || style.module === "$style";
+		const unsupportedAttributes = Object.keys(style.attrs).filter((attribute) => !SUPPORTED_STYLE_ATTRIBUTES.has(attribute));
+		if (unsupportedAttributes.length > 0) {
+			warn("unsupported-sfc-block", start, end, `Unsupported <style> attributes: ${unsupportedAttributes.join(", ")}.`);
+			if (usesDefaultModuleBinding) moduleSiblingUnsupported = true;
+			escapeUnverifiable = true;
+			continue;
+		}
+		if (style.src !== void 0) {
+			if (style.module !== void 0) {
+				warn("unsupported-sfc-block", start, end, "A <style module src> block is not supported.");
+				if (usesDefaultModuleBinding) moduleSiblingUnsupported = true;
+				escapeUnverifiable = true;
+			} else styleBlockImports.push({
+				reference: style.src,
+				start,
+				end
+			});
+			continue;
+		}
+		if (style.module !== void 0 && style.module !== true) {
+			if (usesDefaultModuleBinding) moduleSiblingUnsupported = true;
+			warn("unsupported-sfc-block", start, end, "Named <style module> blocks are not supported.");
+			shadowModuleCssTexts.push(style.content);
+			continue;
+		}
+		if (!SUPPORTED_STYLE_LANGUAGES.has(style.lang)) {
+			if (usesDefaultModuleBinding) moduleSiblingUnsupported = true;
+			warn("preprocessor-style-block", start, end, `The <style lang="${style.lang}"> language is not supported.`);
+			shadowPreprocessorTexts.push(style.content);
+			continue;
+		}
+		const outerStart = source.lastIndexOf("<style", start);
+		const closing = source.slice(end).match(/^<\/style\s*>/)?.[0];
+		if (outerStart < 0 || !closing) {
+			warn("unsupported-sfc-block", start, end, "The style block tags could not be located.");
+			escapeUnverifiable = true;
+			continue;
+		}
+		const block = {
+			outerStart,
+			outerEnd: end + closing.length,
+			contentStart: start,
+			contentEnd: end,
+			syntax: style.lang ?? "css",
+			content: style.content
+		};
+		if (style.module === true) {
+			moduleBlocks.push(block);
+			continue;
+		}
+		if (!style.scoped) {
+			unscopedBlocks.push(block);
+			if (style.lang && style.lang !== "css") unscopedShadowPreprocessorTexts.push(style.content);
+			else unscopedShadowCssTexts.push(style.content);
+			continue;
+		}
+		for (const [, inner] of style.content.matchAll(ESCAPE_SELECTOR)) {
+			shadowCssTexts.push(`${inner} {}`);
+			if (inner.includes("(")) escapeUnverifiable = true;
+		}
+		if (ESCAPE_RESIDUE.test(style.content.replace(ESCAPE_SELECTOR, " "))) escapeUnverifiable = true;
+		blocks.push(block);
+	}
+	const state = {
+		elements: [],
+		components: [],
+		dynamic: false,
+		vHtml: false,
+		hasSlot: false,
+		expressionTexts: []
+	};
+	visitTemplateNode(source, template.ast, state);
+	const alwaysRenderedRoots = template.ast.children.filter((node) => node.type === NODE_ELEMENT && (node.tagType === TAG_ELEMENT || node.tagType === TAG_COMPONENT) && !node.props?.some((prop) => prop.type === PROP_DIRECTIVE && [
+		"if",
+		"else-if",
+		"else",
+		"for"
+	].includes(prop.name))).length;
+	const scriptText = [descriptor.script?.content, descriptor.scriptSetup?.content].filter(Boolean).join("\n");
+	const fallthroughUnverifiable = Boolean(descriptor.script) || descriptor.scriptSetup?.src !== void 0 || /\b(?:defineOptions|defineProps|inheritAttrs)\b/.test(descriptor.scriptSetup?.content ?? "");
+	let scriptImportsUnverifiable = false;
+	const styleImports = [descriptor.script, descriptor.scriptSetup].flatMap((script) => {
+		if (!script) return [];
+		if (script.src || ![
+			void 0,
+			"js",
+			"jsx",
+			"ts",
+			"tsx"
+		].includes(script.lang)) {
+			scriptImportsUnverifiable = true;
+			return [];
+		}
+		try {
+			return staticImports(`${path}.${script.lang ?? "js"}`, script.content);
+		} catch {
+			scriptImportsUnverifiable = true;
+			return [];
+		}
+	});
+	let componentImports = [];
+	if (descriptor.scriptSetup && !descriptor.scriptSetup.src && [
+		void 0,
+		"js",
+		"jsx",
+		"ts",
+		"tsx"
+	].includes(descriptor.scriptSetup.lang)) try {
+		componentImports = staticImportBindings(`${path}.${descriptor.scriptSetup.lang ?? "js"}`, descriptor.scriptSetup.content);
+	} catch {
+		componentImports = [];
+	}
+	const offsets = utf8OffsetMap(source, [
+		...warnings.flatMap((warning) => [warning.start, warning.end]),
+		...[
+			...blocks,
+			...unscopedBlocks,
+			...moduleBlocks
+		].flatMap((block) => [
+			block.outerStart,
+			block.outerEnd,
+			block.contentStart,
+			block.contentEnd
+		]),
+		...styleBlockImports.flatMap((entry) => [entry.start, entry.end]),
+		...[...state.elements, ...state.components].flatMap((element) => [
+			element.nodeStart,
+			element.classAttribute,
+			element.idAttribute,
+			element.moduleBinding
+		].flatMap((value) => value === void 0 ? [] : typeof value === "number" ? [value] : [value.start, value.end]))
+	]);
+	const offset = offsetLookup(offsets);
+	const attribute = (value) => value && {
+		...value,
+		start: offset(value.start),
+		end: offset(value.end)
+	};
+	const toByteBlock = (block) => ({
+		...block,
+		outerStart: offset(block.outerStart),
+		outerEnd: offset(block.outerEnd),
+		contentStart: offset(block.contentStart),
+		contentEnd: offset(block.contentEnd)
+	});
+	const toByteSite = (element) => ({
+		tag: element.tag,
+		nodeStart: offset(element.nodeStart),
+		classAttribute: attribute(element.classAttribute),
+		idAttribute: attribute(element.idAttribute),
+		matchClasses: element.matchClasses,
+		moduleBinding: element.moduleBinding && {
+			name: element.moduleBinding.name,
+			start: offset(element.moduleBinding.start),
+			end: offset(element.moduleBinding.end)
+		}
+	});
+	return {
+		warnings: warnings.map((warning) => ({
+			...warning,
+			start: offset(warning.start),
+			end: offset(warning.end)
+		})),
+		blocks: blocks.map(toByteBlock),
+		unscopedBlocks: unscopedBlocks.map(toByteBlock),
+		moduleBlocks: moduleBlocks.map(toByteBlock),
+		moduleClosureBroken: moduleSiblingUnsupported || scriptImportsUnverifiable || /\$style|useCssModule/.test([...state.expressionTexts, scriptText].join("\n")),
+		htmlElements: state.elements.map(toByteSite),
+		componentSites: state.components.map(toByteSite),
+		rootStarts: template.ast.children.filter((node) => node.type === NODE_ELEMENT).map((node) => offsets.get(node.loc.start.offset)),
+		rootVFor: template.ast.children.some((node) => node.type === NODE_ELEMENT && node.props?.some((prop) => prop.type === PROP_DIRECTIVE && prop.name === "for")),
+		rootFragment: template.ast.children.filter((node) => node.type === NODE_ELEMENT || node.type === NODE_INTERPOLATION || node.type === NODE_TEXT && node.content?.trim?.() !== "").length !== 1,
+		scriptText,
+		scriptStyleImports: [...new Set(styleImports)],
+		scriptImportsUnverifiable,
+		styleBlockImports: styleBlockImports.map((entry) => ({
+			...entry,
+			start: offset(entry.start),
+			end: offset(entry.end)
+		})),
+		componentImports,
+		fallthroughUnverifiable,
+		dynamic: state.dynamic,
+		vHtml: state.vHtml,
+		hasSlot: state.hasSlot,
+		alwaysRenderedRoots,
+		shadowCssTexts,
+		unscopedShadowCssTexts,
+		shadowModuleCssTexts,
+		shadowPreprocessorTexts,
+		unscopedShadowPreprocessorTexts,
+		escapeUnverifiable,
+		retained: false
+	};
+}
+function verifyVueSource(compiler, path, source, includeUnscoped = false) {
+	const { descriptor, errors } = compiler.parse(source, { filename: path });
+	if (errors.length > 0) throw new Error(`Edited SFC no longer parses: ${path}: ${errors[0].message}`);
+	return descriptor.styles.filter((style) => style.src === void 0 && (style.module === void 0 || style.module === true) && (style.scoped || style.module === true || includeUnscoped) && SUPPORTED_STYLE_LANGUAGES.has(style.lang)).map((style) => ({
+		content: style.content,
+		syntax: style.lang ?? "css"
+	}));
+}
+function visitTemplateNode(source, node, state) {
+	if (node.type === NODE_ELEMENT) {
+		if (node.tagType === TAG_SLOT) state.hasSlot = true;
+		const bindingClasses = [];
+		let classOpaque = false;
+		let moduleBinding;
+		for (const prop of node.props ?? []) {
+			if (prop.type !== PROP_DIRECTIVE) continue;
+			let provenModuleExpression = false;
+			if (prop.name === "bind") {
+				if (!prop.arg || !prop.arg.isStatic) classOpaque = true;
+				else if (prop.arg.content === "class") {
+					const member = node.tagType === TAG_ELEMENT && prop.exp ? /^\s*\$style\s*\.\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*$/.exec(prop.exp.content) : void 0;
+					if (member && !moduleBinding) {
+						moduleBinding = {
+							name: member[1],
+							start: attributeRemovalStart(source, node, prop),
+							end: prop.loc.end.offset
+						};
+						provenModuleExpression = true;
+					} else {
+						const value = staticClassBinding(prop);
+						if (value === void 0) classOpaque = true;
+						else bindingClasses.push(...value.split(/[\t\n\f\r ]+/).filter(Boolean));
+					}
+				} else if (prop.arg.content === "id") classOpaque = true;
+			}
+			if (!provenModuleExpression && prop.exp?.content) state.expressionTexts.push(prop.exp.content);
+			if (prop.arg && !prop.arg.isStatic && prop.arg.content) state.expressionTexts.push(prop.arg.content);
+			if (prop.name === "html") state.vHtml = true;
+		}
+		if (classOpaque) state.dynamic = true;
+		const site = templateSite(source, node, bindingClasses, classOpaque, state);
+		const element = {
+			tag: node.tag,
+			nodeStart: node.loc.start.offset,
+			moduleBinding,
+			...site
+		};
+		if (node.tagType === TAG_COMPONENT) state.components.push(element);
+		else if (node.tagType === TAG_ELEMENT) state.elements.push(element);
+	}
+	if (node.type === NODE_INTERPOLATION && node.content?.content) state.expressionTexts.push(node.content.content);
+	for (const child of node.children ?? []) visitTemplateNode(source, child, state);
+}
+function attributeRemovalStart(source, node, prop) {
+	const attributeStart = prop.loc.start.offset;
+	let start = attributeStart;
+	while (start > node.loc.start.offset + 1 && /\s/.test(source[start - 1])) start -= 1;
+	return /[\r\n]/.test(source.slice(start, attributeStart)) ? attributeStart : start;
+}
+function staticClassBinding(prop) {
+	if (!prop.exp) return void 0;
+	try {
+		return staticStringExpression("Component.js", prop.exp.content) ?? void 0;
+	} catch {
+		return;
+	}
+}
+function templateSite(source, node, bindingClasses, classOpaque, state) {
+	let classAttribute = literalAttribute(source, node, "class");
+	const idAttribute = literalAttribute(source, node, "id");
+	const hasClassAttr = node.props?.some((prop) => prop.type === PROP_ATTRIBUTE && prop.name === "class");
+	const hasIdAttr = node.props?.some((prop) => prop.type === PROP_ATTRIBUTE && prop.name === "id");
+	if (hasClassAttr && !classAttribute || hasIdAttr && !idAttribute) {
+		state.dynamic = true;
+		return { idAttribute };
+	}
+	const matchClasses = bindingClasses.length ? [...classAttribute?.value.split(/[\t\n\f\r ]+/).filter(Boolean) ?? [], ...bindingClasses] : void 0;
+	if (!classAttribute && (bindingClasses.length > 0 || !classOpaque && (node.tagType === TAG_COMPONENT || idAttribute))) {
+		const insertion = classInsertionOffset(source, node);
+		if (insertion === void 0) state.dynamic = true;
+		else classAttribute = {
+			value: "",
+			start: insertion,
+			end: insertion,
+			synthetic: true
+		};
+	}
+	return {
+		classAttribute,
+		idAttribute,
+		matchClasses
+	};
+}
+function literalAttribute(source, node, name) {
+	const prop = node.props?.find((prop) => prop.type === PROP_ATTRIBUTE && prop.name === name);
+	if (!prop?.value) return void 0;
+	const start = prop.value.loc.start.offset;
+	const end = prop.value.loc.end.offset;
+	const raw = source.slice(start, end);
+	const quote = raw[0];
+	if (quote !== "\"" && quote !== "'" || raw[raw.length - 1] !== quote) return void 0;
+	const value = raw.slice(1, -1);
+	if (value !== prop.value.content || value.includes("&")) return void 0;
+	return {
+		value,
+		start: start + 1,
+		end: end - 1
+	};
+}
+function classInsertionOffset(source, node) {
+	const propsEnd = Math.max(node.loc.start.offset + 1 + node.tag.length, ...(node.props ?? []).map((prop) => prop.loc.end.offset));
+	const tagEnd = source.indexOf(">", propsEnd);
+	if (tagEnd < 0) return void 0;
+	let offset = tagEnd;
+	if (source[offset - 1] === "/") offset -= 1;
+	while (offset > node.loc.start.offset && /\s/.test(source[offset - 1])) offset -= 1;
+	return offset;
+}
+function toByteWarnings(source, warnings) {
+	const offsets = utf8OffsetMap(source, warnings.flatMap((warning) => [warning.start, warning.end]));
+	return warnings.map((warning) => ({
+		...warning,
+		start: offsets.get(warning.start) ?? warning.start,
+		end: offsets.get(warning.end) ?? warning.end
+	}));
+}
+//#endregion
+//#region src/plan/vue.ts
+function isLocalVueReference(reference) {
+	return reference.startsWith(".") || reference.startsWith("#") || reference.includes("/") || reference.includes(".vue");
+}
+function couldResolveToVue(reference) {
+	const path = reference.split(/[?#]/, 1)[0];
+	return path.endsWith(".vue") || extname(path) === "";
+}
+function vueReferenceTarget(importer, reference, vuePaths) {
+	if (!reference.startsWith(".")) return void 0;
+	const target = resolve(dirname(importer), reference);
+	return [
+		target,
+		`${target}.vue`,
+		join(target, "index.vue")
+	].find((path) => vuePaths.has(path));
+}
+function vueLiteralTargets(file, vuePaths) {
+	return new Set([...file.source.matchAll(/(["'`])([^"'`\r\n]+)\1/g)].flatMap((match) => {
+		if (/[?*[\]{}]/.test(match[2]) && (match[2].includes("vue") || isLocalVueReference(match[2]))) return [...vuePaths];
+		const target = vueReferenceTarget(file.path, match[2], vuePaths);
+		if (target) return [target];
+		return match[2].includes(".vue") ? [...vuePaths] : [];
+	}));
+}
+function normalizedVueTag(value) {
+	return value.replaceAll("-", "").toLowerCase();
+}
+function buildVueComponentGraph(ownedVue, sourceFiles, analyses, { styleSources, pathOwners, packageRoot }) {
+	const vuePaths = new Set(ownedVue.map((file) => file.path));
+	const callers = new Map([...vuePaths].map((path) => [path, []]));
+	const callerOpen = /* @__PURE__ */ new Set();
+	let unresolvedStyleImport = false;
+	const stylesheetReference = /\.(?:css|scss|sass|less)(?:$|[?#])/;
+	for (const file of ownedVue) {
+		const analysis = analyses.get(file.path);
+		if (!analysis || analysis.retained) {
+			for (const target of vuePaths) callerOpen.add(target);
+			continue;
+		}
+		const bindings = analysis.componentImports.flatMap((entry) => {
+			const target = vueReferenceTarget(file.path, entry.source, vuePaths);
+			return target ? [{
+				...entry,
+				target
+			}] : [];
+		});
+		analysis.resolvedComponents = analysis.componentSites.flatMap((site) => {
+			const matches = bindings.filter((entry) => normalizedVueTag(entry.local) === normalizedVueTag(site.tag));
+			if (matches.length !== 1) return [];
+			const edge = {
+				parent: file.path,
+				child: matches[0].target,
+				site
+			};
+			callers.get(edge.child)?.push(edge);
+			if (site.idAttribute || analysis.dynamic) {
+				callerOpen.add(edge.child);
+				const childAnalysis = analyses.get(edge.child);
+				if (childAnalysis) childAnalysis.rootIdsOverridden = true;
+			}
+			if (analysis.alwaysRenderedRoots < 2 && analysis.rootStarts.includes(site.nodeStart)) callerOpen.add(edge.child);
+			return [edge];
+		});
+		analysis.componentsOpen = analysis.resolvedComponents.length !== analysis.componentSites.length;
+		analysis.setupImports = new Set(bindings.map((entry) => entry.target));
+		if (analysis.componentsOpen) for (const target of vuePaths) callerOpen.add(target);
+	}
+	for (const file of sourceFiles) {
+		let references;
+		let blockReferences = [];
+		if (extname(file.path) === ".vue") {
+			const fileAnalysis = analyses.get(file.path);
+			if (fileAnalysis && !fileAnalysis.retained) {
+				references = fileAnalysis.scriptStyleImports;
+				blockReferences = fileAnalysis.styleBlockImports.map((entry) => entry.reference);
+			} else references = [];
+		} else try {
+			references = staticImports(file.path, file.source);
+		} catch {
+			references = [];
+		}
+		if (/\bimport\s*\(/.test(file.source) || references.some((reference) => !stylesheetReference.test(reference) && isLocalVueReference(reference) && couldResolveToVue(reference) && !vueReferenceTarget(file.path, reference, vuePaths))) for (const target of vuePaths) callerOpen.add(target);
+		const resolvesOwned = (reference) => stylesheetReferenceTargets(file.path, reference, styleSources).some((path) => pathOwners.get(path) === packageRoot);
+		if (pathOwners.get(file.path) === packageRoot && (references.some((reference) => stylesheetReference.test(reference) && (!reference.startsWith(".") || !resolvesOwned(reference))) || blockReferences.some((reference) => !resolvesOwned(reference)))) unresolvedStyleImport = true;
+		const imported = new Set(references.flatMap((reference) => {
+			const target = vueReferenceTarget(file.path, reference, vuePaths);
+			return target ? [target] : [];
+		}));
+		for (const target of imported) if (extname(file.path) !== ".vue" || !analyses.get(file.path)?.setupImports?.has(target)) callerOpen.add(target);
+		for (const target of vueLiteralTargets(file, vuePaths)) if (!imported.has(target)) callerOpen.add(target);
+	}
+	return {
+		callers,
+		callerOpen,
+		unresolvedStyleImport
+	};
+}
+function vueWarningsOnlyResult(preparedVue) {
+	if (preparedVue.warnings.length === 0) return {};
+	return { plan: {
+		files: [],
+		deletedFiles: [],
+		unlinkedFiles: [],
+		candidates: [],
+		rules: [],
+		warnings: preparedVue.warnings,
+		convertedRules: 0,
+		retainedRules: 0
+	} };
+}
+async function preparePackageVue({ packageRoot, styleCompilers, sourceFiles, styleSources, pathOwners, targetable, explicitStyle, snapshots, workspaceRoot, workspaces, scannedPaths }) {
+	const none = {
+		files: /* @__PURE__ */ new Map(),
+		stylesheets: [],
+		stylePaths: /* @__PURE__ */ new Set(),
+		unscopedPaths: /* @__PURE__ */ new Set(),
+		warnings: [],
+		compiler: void 0
+	};
+	if (explicitStyle && extname(explicitStyle) !== ".vue") return none;
+	const ownedVue = sourceFiles.filter((file) => extname(file.path) === ".vue" && pathOwners.get(file.path) === packageRoot);
+	const selected = ownedVue.filter((file) => targetable.has(file.path) && (!explicitStyle || file.path === explicitStyle));
+	if (selected.length === 0) return none;
+	const loaded = await loadProjectVueCompiler(packageRoot);
+	const warnings = [];
+	if (loaded.unsupportedVersion || !loaded.compiler) {
+		for (const file of selected) warnings.push({
+			code: "unsupported-vue-version",
+			file: file.path,
+			start: 0,
+			end: 0,
+			message: `Vue ${loaded.unsupportedVersion} is not supported; only Vue 3 SFCs are analyzed.`
+		});
+		return {
+			...none,
+			warnings
+		};
+	}
+	const compiler = loaded.compiler;
+	const analyses = new Map(ownedVue.map((file) => [file.path, analyzeVueSource(compiler, file.path, file.source)]));
+	const analysisOf = (path) => {
+		const analysis = analyses.get(path);
+		if (!analysis) throw new Error(`No Vue analysis was recorded for ${path}`);
+		return analysis;
+	};
+	const selectedPaths = new Set(selected.map((file) => file.path));
+	for (const file of ownedVue) {
+		const analysis = analysisOf(file.path);
+		if (analysis.retained) continue;
+		for (const edge of analysis.styleBlockImports) {
+			if (stylesheetReferenceTargets(file.path, edge.reference, styleSources).some((path) => pathOwners.get(path) === packageRoot)) continue;
+			analysis.escapeUnverifiable = true;
+			if (selectedPaths.has(file.path)) warnings.push({
+				code: "unsupported-sfc-block",
+				file: file.path,
+				start: edge.start,
+				end: edge.end,
+				message: `The external style ${JSON.stringify(edge.reference)} could not be resolved inside the package.`
+			});
+		}
+	}
+	const compileBlocks = async (file, blocks) => {
+		for (const block of blocks.filter((block) => block.syntax !== "css")) {
+			const virtualPath = `${file.path}.${block.syntax}`;
+			const compiled = await compileStyleEntry(styleCompilers, packageRoot, virtualPath, block.content, { virtualEntry: true });
+			validateCss(compiled.css);
+			for (const loadedPath of compiled.loadedPaths) {
+				if (loadedPath === virtualPath || !isProjectInput(workspaceRoot, loadedPath)) continue;
+				const source = await snapshotLoadedSource(snapshots, loadedPath);
+				if (!styleSources.has(loadedPath)) styleSources.set(loadedPath, source);
+				if (!pathOwners.has(loadedPath)) pathOwners.set(loadedPath, packageRoot);
+			}
+			block.analysisSource = compiled.css;
+			block.sourcePath = virtualPath;
+			block.sourceMappings = compiled.sourceMappings;
+		}
+	};
+	for (const file of selected) {
+		const analysis = analysisOf(file.path);
+		if (!analysis.retained) await compileBlocks(file, [...analysis.blocks, ...analysis.moduleBlocks]);
+	}
+	const vueGraph = buildVueComponentGraph(ownedVue, sourceFiles, analyses, {
+		styleSources,
+		pathOwners,
+		packageRoot
+	});
+	const generatesSelectors = (text) => /#\{|@\{|&[\w-]/.test(text);
+	const vueShadowCss = [];
+	const vueShadowModuleCss = [];
+	let vueShadowUnverifiable = vueGraph.unresolvedStyleImport;
+	for (const [path, source] of styleSources) {
+		if (pathOwners.get(path) !== packageRoot) continue;
+		if (isPreprocessorPath(path) && generatesSelectors(source)) {
+			vueShadowUnverifiable = true;
+			continue;
+		}
+		if (isStylesheetModule(path)) vueShadowModuleCss.push(source);
+		else vueShadowCss.push({
+			path,
+			source
+		});
+	}
+	for (const file of sourceFiles) if (extname(file.path) === ".html" && pathOwners.get(file.path) === packageRoot && /<style/i.test(file.source)) vueShadowUnverifiable = true;
+	for (const file of ownedVue) {
+		const analysis = analysisOf(file.path);
+		if (analysis.retained) {
+			if (/<style/i.test(file.source)) vueShadowUnverifiable = true;
+			continue;
+		}
+		if (analysis.escapeUnverifiable || analysis.scriptImportsUnverifiable) vueShadowUnverifiable = true;
+		for (const text of analysis.shadowPreprocessorTexts) if (generatesSelectors(text)) vueShadowUnverifiable = true;
+		else vueShadowCss.push({
+			path: file.path,
+			source: text
+		});
+		for (const text of analysis.unscopedShadowPreprocessorTexts) if (generatesSelectors(text)) vueShadowUnverifiable = true;
+		else vueShadowCss.push({
+			path: file.path,
+			source: text,
+			migratingUnscoped: true
+		});
+		vueShadowCss.push(...analysis.shadowCssTexts.map((source) => ({
+			path: file.path,
+			source
+		})), ...analysis.unscopedShadowCssTexts.map((source) => ({
+			path: file.path,
+			source,
+			migratingUnscoped: true
+		})), ...analysis.blocks.map((block) => ({
+			path: file.path,
+			source: block.analysisSource ?? block.content,
+			scoped: true
+		})));
+		vueShadowModuleCss.push(...analysis.shadowModuleCssTexts, ...analysis.moduleBlocks.map((block) => block.analysisSource ?? block.content));
+	}
+	const packageIsPrivate = JSON.parse(await snapshotFile(snapshots, join(packageRoot, "package.json"))).private === true;
+	const files = /* @__PURE__ */ new Map();
+	const stylesheets = [];
+	const stylePaths = /* @__PURE__ */ new Set();
+	const unscopedPaths = /* @__PURE__ */ new Set();
+	const ownedSources = sourceFiles.filter((file) => pathOwners.get(file.path) === packageRoot);
+	const sourcePathSet = new Set(sourceFiles.map((file) => file.path));
+	const hiddenHtml = scannedPaths.some((path) => extname(path) === ".html" && pathOwners.get(path) === packageRoot && !sourcePathSet.has(path));
+	const projectWideUsageProven = packageIsPrivate && workspaceRoot === packageRoot && !workspaces && !explicitStyle && !hiddenHtml && ownedSources.every((file) => targetable.has(file.path)) && ownedVue.every((file) => !analysisOf(file.path).retained);
+	const elementsByFile = /* @__PURE__ */ new Map();
+	const addElement = (path, element, cssPaths) => {
+		if (!element.classAttribute && !element.moduleBinding || cssPaths.length === 0) return;
+		const elements = elementsByFile.get(path) ?? [];
+		elements.push({
+			...element,
+			cssPaths: [...new Set(cssPaths)]
+		});
+		elementsByFile.set(path, elements);
+	};
+	const elementClasses = (element) => element.matchClasses ?? element.classAttribute?.value.split(/\s+/).filter(Boolean) ?? [];
+	const componentRootSite = (site, root) => {
+		const matchId = site.idAttribute?.value ?? root.idAttribute?.value;
+		return {
+			...site,
+			matchClasses: [...elementClasses(site), ...elementClasses(root)],
+			matchIds: matchId ? [matchId] : [],
+			matchTag: root.tag
+		};
+	};
+	for (const file of selected) {
+		const analysis = analysisOf(file.path);
+		if (analysis.retained) continue;
+		const importedStyles = new Set([...analysis.scriptStyleImports.filter((reference) => reference.startsWith(".") && STYLESHEET_SYNTAX.has(extname(reference.split(/[?#]/, 1)[0]))).flatMap((reference) => stylesheetReferenceTargets(file.path, reference, styleSources)), ...analysis.styleBlockImports.flatMap((entry) => stylesheetReferenceTargets(file.path, entry.reference, styleSources))].filter((path) => pathOwners.get(path) === packageRoot));
+		for (const path of importedStyles) {
+			stylePaths.add(path);
+			if (extname(path) !== ".css") continue;
+			for (const imported of cssImports(styleSources.get(path) ?? "")) {
+				if (imported.media) continue;
+				for (const target of stylesheetReferenceTargets(path, imported.href, styleSources)) if (pathOwners.get(target) === packageRoot) importedStyles.add(target);
+			}
+		}
+		const ownContexts = [...analysis.blocks.length > 0 || analysis.unscopedBlocks.length > 0 || analysis.moduleBlocks.length > 0 && !analysis.moduleClosureBroken ? [file.path] : [], ...[...importedStyles].filter((path) => !isStylesheetModule(path))];
+		for (const element of analysis.htmlElements) {
+			const ownElement = analysis.rootIdsOverridden && analysis.rootStarts.includes(element.nodeStart) ? {
+				...element,
+				matchIds: []
+			} : element;
+			addElement(file.path, ownElement, ownContexts);
+		}
+	}
+	for (const parent of ownedVue) {
+		const analysis = analysisOf(parent.path);
+		if (analysis.retained) continue;
+		for (const edge of analysis.resolvedComponents ?? []) {
+			const childAnalysis = analyses.get(edge.child);
+			const childDetails = childAnalysis && !childAnalysis.retained ? childAnalysis : void 0;
+			const singleRoot = childDetails?.rootStarts.length === 1 && !childDetails.rootVFor && !childDetails.rootFragment;
+			const childRoots = childDetails?.htmlElements.filter((element) => childDetails.rootStarts.includes(element.nodeStart));
+			if (selectedPaths.has(parent.path) && singleRoot && childRoots?.length === 1 && !childDetails?.fallthroughUnverifiable) addElement(parent.path, componentRootSite(edge.site, childRoots[0]), [parent.path]);
+			if (selectedPaths.has(edge.child) && singleRoot && edge.parent !== edge.child && !childDetails?.fallthroughUnverifiable) {
+				addElement(parent.path, edge.site, [edge.child]);
+				if (childRoots?.length === 1) {
+					const shadowSite = {
+						...componentRootSite(edge.site, childRoots[0]),
+						moduleBinding: childRoots[0].moduleBinding
+					};
+					if (shadowSite.classAttribute) {
+						shadowSite.classAttribute = {
+							...shadowSite.classAttribute,
+							writable: false
+						};
+						addElement(parent.path, shadowSite, [edge.child]);
+					}
+				}
+			}
+		}
+	}
+	for (const file of selected) {
+		await rejectSymlinkTarget(file.path, packageRoot);
+		const analysis = analysisOf(file.path);
+		warnings.push(...analysis.warnings);
+		if (analysis.retained) continue;
+		const componentOpen = analysis.componentsOpen || (analysis.resolvedComponents ?? []).some((edge) => {
+			const child = analyses.get(edge.child);
+			return !child || child.retained || child.dynamic || child.fallthroughUnverifiable || child.rootVFor || child.rootFragment || child.rootStarts.length !== 1 || !child.htmlElements.some((element) => element.nodeStart === child.rootStarts[0]);
+		});
+		const callers = vueGraph.callers.get(file.path) ?? [];
+		const callerOpen = !packageIsPrivate || callers.length === 0 || vueGraph.callerOpen.has(file.path) || callers.some((edge) => {
+			const parent = analyses.get(edge.parent);
+			return parent ? parent.retained || parent.dynamic : false;
+		});
+		const retentionReason = (open) => {
+			if (analysis.dynamic) return "dynamic-template-class";
+			if (open) return "component-class-target";
+			if (analysis.alwaysRenderedRoots < 2 && callerOpen) return "open-root-fallthrough";
+		};
+		const retention = retentionReason(componentOpen);
+		const migrateUnscoped = analysis.blocks.length === 0 && analysis.unscopedBlocks.length > 0 && projectWideUsageProven && !analysis.dynamic && !analysis.vHtml && !analysis.hasSlot && !analysis.escapeUnverifiable && !componentOpen && ownedSources.length === 1 && ownedSources[0].path === file.path;
+		if (migrateUnscoped) {
+			await compileBlocks(file, analysis.unscopedBlocks);
+			unscopedPaths.add(file.path);
+		}
+		if (analysis.unscopedBlocks.length > 0 && !migrateUnscoped) for (const block of analysis.unscopedBlocks) warnings.push({
+			code: "unscoped-style-block",
+			file: file.path,
+			start: block.contentStart,
+			end: block.contentEnd,
+			message: "The global reach of this unscoped style block could not be proven."
+		});
+		const moduleRetention = retentionReason(false);
+		const migrateModule = analysis.moduleBlocks.length > 0 && !analysis.moduleClosureBroken && !moduleRetention;
+		if (analysis.moduleBlocks.length > 0 && !migrateModule) {
+			const [code, message] = analysis.moduleClosureBroken ? ["unsupported-css-module-reference", "`$style` is referenced outside provable direct member accesses, so the module is retained."] : moduleRetention === "dynamic-template-class" ? ["dynamic-template-class", "A dynamic class binding makes the template's class set unprovable, so the module is retained."] : ["open-root-fallthrough", "A parent component can merge classes onto the single root element, so the module is retained."];
+			for (const block of analysis.moduleBlocks) warnings.push({
+				code,
+				file: file.path,
+				start: block.contentStart,
+				end: block.contentEnd,
+				message
+			});
+		}
+		const vueBlocks = migrateUnscoped ? analysis.unscopedBlocks : analysis.blocks;
+		if (vueBlocks.length === 0 && !migrateModule) continue;
+		const vueRetention = migrateUnscoped ? void 0 : retention;
+		const shadowCss = vueShadowCss.filter((entry) => entry.path !== file.path || !entry.scoped && !(migrateUnscoped && entry.migratingUnscoped)).map((entry) => entry.source);
+		if (migrateModule) stylesheets.push({
+			cssPath: file.path,
+			cssSource: file.source,
+			cssModuleId: normalizedRelativePath(packageRoot, file.path),
+			syntax: "css",
+			isModule: true,
+			vueBlocks: analysis.moduleBlocks,
+			vueModule: true,
+			vueShadowCss: shadowCss,
+			vueShadowModuleCss,
+			vueShadowUnverifiable
+		});
+		if (vueBlocks.length > 0) stylesheets.push({
+			cssPath: file.path,
+			cssSource: file.source,
+			cssModuleId: normalizedRelativePath(packageRoot, file.path),
+			syntax: "css",
+			isModule: !vueRetention,
+			vueBlocks,
+			vueRetention,
+			vueUnscoped: migrateUnscoped,
+			vueShadowCss: vueRetention ? void 0 : shadowCss,
+			vueShadowModuleCss: vueRetention ? void 0 : vueShadowModuleCss,
+			vueShadowUnverifiable: vueRetention ? void 0 : vueShadowUnverifiable
+		});
+	}
+	for (const file of ownedVue) {
+		const analysis = analysisOf(file.path);
+		if (analysis.retained) continue;
+		const elements = elementsByFile.get(file.path) ?? [];
+		const contextPaths = [...new Set(elements.flatMap((element) => element.cssPaths))];
+		if (contextPaths.length === 0) continue;
+		await rejectSymlinkTarget(file.path, packageRoot);
+		files.set(file.path, {
+			...file,
+			htmlElements: elements,
+			htmlStylesheets: contextPaths.map((cssPath) => ({
+				cssPath,
+				variants: [],
+				direct: cssPath === file.path,
+				analyzable: true
+			})),
+			htmlReferencesSafe: !analysis.dynamic,
+			htmlScriptText: analysis.scriptText
+		});
+	}
+	return {
+		files,
+		stylesheets,
+		stylePaths,
+		unscopedPaths,
+		warnings,
+		compiler
+	};
+}
+//#endregion
+//#region src/util/write.ts
+async function verifySnapshots(snapshots) {
+	const entries = [...snapshots].sort(([left], [right]) => left.localeCompare(right));
+	const reads = await Promise.allSettled(entries.map(([path]) => readFile(path, "utf8")));
+	for (const [index, [path, before]] of entries.entries()) {
+		const read = reads[index];
+		if (read.status === "rejected") {
+			const error = read.reason;
+			const detail = errorCode(error) ?? (error instanceof Error ? error.message : String(error));
+			throw new Error(`Source changed after planning: ${path} (${detail})`);
+		}
+		if (read.value !== before) throw new Error(`Source changed after planning: ${path}`);
+	}
+}
+async function writeChanges(changes, deletions) {
+	const token = `${process.pid}-${Date.now()}`;
+	const staged = changes.map((change, index) => [join(dirname(change.path), `.${basename(change.path)}.tw-migrate-${token}-${index}`), change]);
+	const backups = [...changes, ...deletions].map((change, index) => [join(dirname(change.path), `.${basename(change.path)}.tw-migrate-backup-${token}-${index}`), change.path]);
+	const backedUp = [];
+	let succeeded = false;
+	try {
+		const stagingResults = await Promise.allSettled(staged.map(async ([temporaryPath, change]) => {
+			const { mode } = await stat(change.path);
+			await writeFile(temporaryPath, change.source);
+			await chmod(temporaryPath, mode & 511);
+		}));
+		for (const result of stagingResults) if (result.status === "rejected") throw result.reason;
+		for (const [backupPath, originalPath] of backups) {
+			await rename(originalPath, backupPath);
+			backedUp.push([backupPath, originalPath]);
+		}
+		for (const [temporaryPath, change] of staged) await rename(temporaryPath, change.path);
+		succeeded = true;
+	} finally {
+		if (succeeded) await Promise.all(backups.map(([backupPath]) => rm(backupPath, { force: true })));
+		else for (const [backupPath, originalPath] of backedUp.reverse()) try {
+			await rename(backupPath, originalPath);
+		} catch {}
+		await Promise.all(staged.map(([temporaryPath]) => rm(temporaryPath, { force: true })));
+	}
+}
+//#endregion
+//#region src/index.ts
+async function migrate(options = {}) {
+	if (options.styleFile && options.workspaces) throw new TypeError("styleFile cannot be combined with workspaces");
+	if (options.tailwindCss && options.workspaces) throw new TypeError("tailwindCss cannot be combined with workspaces");
+	const scope = await resolveScope(options);
+	const { cwd, workspaceRoot, selectedPackages, explicitStyle, configuredEntry } = scope;
+	const leftovers = await collectFiles(workspaceRoot, (path) => basename(path).includes(".tw-migrate-"));
+	if (leftovers.length > 0) {
+		const listed = leftovers.sort().map((path) => `  ${normalizedRelativePath(cwd, path)}`).join("\n");
+		throw new Error(`Found leftover tw-migrate files from an interrupted run:\n${listed}\nRestore each ".<name>.tw-migrate-backup-*" file by renaming it back to "<name>", delete any remaining ".<name>.tw-migrate-*" staging files, then re-run.`);
+	}
+	const snapshots = /* @__PURE__ */ new Map();
+	const stylePaths = scope.scannedPaths.filter(isStylesheetPath);
+	const sourcePaths = scope.scannedPaths.filter((path) => SOURCE_EXTENSIONS.has(extname(path)));
+	const [styleSources, sourceCandidates] = await Promise.all([
+		Promise.all(stylePaths.map(async (path) => [path, await snapshotFile(snapshots, path)])).then((entries) => new Map(entries)),
+		Promise.all(sourcePaths.map(async (path) => {
+			const source = await readFile(path, "utf8");
+			const mayReferenceModule = extname(path) !== ".html" || /<link\b/i.test(source);
+			if (!scope.targetable.has(path) && !mayReferenceModule) return void 0;
+			return {
+				path,
+				source: recordSnapshot(snapshots, path, source)
+			};
+		})),
+		...selectedPackages.map((packageRoot) => snapshotFile(snapshots, join(packageRoot, "package.json")))
+	]);
+	const sourceFiles = sourceCandidates.flatMap((file) => file ? [file] : []);
+	if (explicitStyle && isStylesheetPath(explicitStyle) && !styleSources.has(explicitStyle)) styleSources.set(explicitStyle, await snapshotFile(snapshots, explicitStyle));
+	if (configuredEntry && !styleSources.has(configuredEntry)) styleSources.set(configuredEntry, await snapshotFile(snapshots, configuredEntry));
+	const context = {
+		...scope,
+		options,
+		snapshots,
+		styleSources,
+		sourceFiles,
+		styleDependents: indexStylesheetDependents(styleSources)
+	};
+	const failures = [];
+	const plans = [];
+	for (const packageRoot of selectedPackages) {
+		const result = await planPackage(context, packageRoot);
+		if (result.failure) failures.push(result.failure);
+		else if (result.plan) plans.push(result.plan);
+	}
+	const originals = new Map([...styleSources, ...sourceFiles.map((file) => [file.path, file.source])]);
+	const { filesByPath, deletedPaths, candidates, rules, warnings, convertedRules, retainedRules } = mergePlans(plans, originals);
+	const changed = [...filesByPath.values()].map((file) => ({
+		...file,
+		before: originals.get(file.path) ?? ""
+	})).filter((file) => file.before !== file.source);
+	const deleted = [...deletedPaths].map((path) => ({
+		path,
+		before: originals.get(path) ?? ""
+	}));
+	const operations = [...changed, ...deleted].sort((left, right) => left.path.localeCompare(right.path));
+	const changedFiles = operations.map((file) => normalizedRelativePath(cwd, file.path));
+	const diff = operations.map((file) => unifiedDiff(normalizedRelativePath(cwd, file.path), file.before, file.source ?? "")).join("");
+	if (options.write && operations.length > 0) {
+		await verifySnapshots(snapshots);
+		await writeChanges(changed, deleted);
+	}
+	warnings.sort((left, right) => left.file.localeCompare(right.file) || left.start - right.start || left.end - right.end || left.code.localeCompare(right.code));
+	failures.sort((left, right) => left.package.localeCompare(right.package));
+	return {
+		changedFiles,
+		diff,
+		convertedRules,
+		retainedRules,
+		rules: rules.map(({ stylesheet: _, ...rule }) => ({
+			...rule,
+			file: normalizedRelativePath(cwd, rule.file)
+		})),
+		candidates: [...candidates].sort(),
+		warnings: warnings.map((warning) => ({
+			...warning,
+			file: normalizedRelativePath(cwd, warning.file)
+		})),
+		failures
+	};
+}
+async function planPackage(context, packageRoot) {
+	const { options, snapshots, workspaceRoot, explicitStyle, configuredEntry, styleSources, sourceFiles, styleDependents, pathOwners, targetable, selectedPackages, scannedPaths } = context;
+	const recover = (error, fatal = false) => {
+		if (!options.force || fatal) throw error;
+		return { failure: packageFailure(workspaceRoot, packageRoot, error) };
+	};
+	let preparedHtml;
+	try {
+		preparedHtml = await preparePackageHtml({
+			packageRoot,
+			sourceFiles,
+			styleSources,
+			snapshots,
+			pathOwners,
+			styleDependents
+		});
+	} catch (error) {
+		return recover(error, isIntegrityError(error));
+	}
+	const styleCompilers = {};
+	let preparedVue;
+	try {
+		preparedVue = await preparePackageVue({
+			packageRoot,
+			styleCompilers,
+			sourceFiles,
+			styleSources,
+			pathOwners,
+			targetable,
+			explicitStyle,
+			snapshots,
+			workspaceRoot,
+			workspaces: options.workspaces,
+			scannedPaths
+		});
+	} catch (error) {
+		return recover(error, isIntegrityError(error));
+	}
+	if (explicitStyle && extname(explicitStyle) === ".vue" && preparedVue.stylesheets.length === 0 && ![...preparedVue.stylePaths].some((path) => !isStylesheetModule(path))) return vueWarningsOnlyResult(preparedVue);
+	const packageSources = [...sourceFiles.filter((file) => extname(file.path) !== ".html").map((file) => preparedVue.files.get(file.path) ?? file), ...preparedHtml.files];
+	const ownedStyles = [...styleSources.keys()].filter((path) => pathOwners.get(path) === packageRoot && (targetable.has(path) || preparedHtml.stylePaths.has(path) || preparedVue.stylePaths.has(path)));
+	if (ownedStyles.length === 0 && preparedVue.stylesheets.length === 0) return vueWarningsOnlyResult(preparedVue);
+	let tailwindPath;
+	let tailwindEntries;
+	try {
+		({path: tailwindPath, entries: tailwindEntries} = resolveTailwindEntry(ownedStyles, styleSources, configuredEntry));
+	} catch (error) {
+		return recover(error);
+	}
+	const excludedEntries = /* @__PURE__ */ new Set([...tailwindEntries, tailwindPath]);
+	const explicitCss = explicitStyle && extname(explicitStyle) !== ".vue" ? explicitStyle : void 0;
+	const targets = explicitCss ? [explicitCss] : explicitStyle ? [...preparedVue.stylePaths].filter((path) => !isStylesheetModule(path) && !excludedEntries.has(path)) : ownedStyles.filter((path) => !excludedEntries.has(path) && !preparedHtml.generatedPaths.has(path) && (!isPreprocessorPath(path) || preparedHtml.stylePaths.has(path) || packageSources.some((file) => sourceReferencesStyle(file, path))));
+	if (targets.length === 0 && preparedVue.stylesheets.length === 0) return vueWarningsOnlyResult(preparedVue);
+	if (targets.some((path) => excludedEntries.has(path))) throw new Error("The Tailwind CSS entry cannot be migrated.");
+	let tailwind;
+	try {
+		tailwind = await loadTailwind(packageRoot, tailwindPath, snapshots, workspaceRoot);
+	} catch (error) {
+		return recover(error, isIntegrityError(error));
+	}
+	const files = packageSources.map((file) => {
+		const owner = pathOwners.get(file.path);
+		return {
+			...file,
+			writable: targetable.has(file.path) && (options.workspaces ? owner !== void 0 && selectedPackages.includes(owner) : owner === packageRoot)
+		};
+	});
+	let stylesheets;
+	try {
+		stylesheets = [];
+		const compilerDependents = /* @__PURE__ */ new Map();
+		for (const stylePath of targets.sort()) {
+			await rejectSymlinkTarget(stylePath, packageRoot);
+			const isPartial = isSassPath(stylePath) && basename(stylePath).startsWith("_");
+			const stylesheet = {
+				cssPath: stylePath,
+				cssSource: styleSources.get(stylePath) ?? "",
+				cssModuleId: normalizedRelativePath(packageRoot, stylePath),
+				cssDependents: styleDependents.get(stylePath) ?? [],
+				syntax: stylesheetSyntax(stylePath),
+				isModule: isStylesheetModule(stylePath),
+				isPartial
+			};
+			let compiled;
+			if (isSassPath(stylePath) && !isPartial || extname(stylePath) === ".less") compiled = await compileStyleEntry(styleCompilers, packageRoot, stylePath, stylesheet.cssSource);
+			if (compiled) {
+				validateCss(compiled.css);
+				for (const loadedPath of compiled.loadedPaths) {
+					if (!isProjectInput(workspaceRoot, loadedPath)) continue;
+					const source = await snapshotLoadedSource(snapshots, loadedPath);
+					if (!styleSources.has(loadedPath)) styleSources.set(loadedPath, source);
+					if (loadedPath !== stylePath) {
+						const dependents = compilerDependents.get(loadedPath) ?? [];
+						dependents.push(stylePath);
+						compilerDependents.set(loadedPath, dependents);
+					}
+				}
+				stylesheet.analysisSource = compiled.css;
+				stylesheet.sourceMappings = compiled.sourceMappings;
+			}
+			stylesheets.push(stylesheet);
+		}
+		for (const stylesheet of stylesheets) {
+			const dependents = compilerDependents.get(stylesheet.cssPath) ?? [];
+			if (dependents.length === 0) continue;
+			stylesheet.isPartial = true;
+			stylesheet.cssDependents = [.../* @__PURE__ */ new Set([...stylesheet.cssDependents ?? [], ...dependents])].sort();
+		}
+	} catch (error) {
+		return recover(error, isIntegrityError(error));
+	}
+	stylesheets.push(...preparedVue.stylesheets);
+	const request = {
+		stylesheets,
+		tailwindPath: tailwind.path,
+		tailwindSource: tailwind.css,
+		utilityPrefix: tailwind.designSystem.theme.prefix,
+		themeTokens: tailwind.themeTokens,
+		files
+	};
+	let plan;
+	try {
+		plan = JSON.parse(planBatchMigration(JSON.stringify(request)));
+	} catch (error) {
+		return recover(error, !isRecoverablePlanningError(error));
+	}
+	try {
+		plan = replanCompileFailures(tailwind, request, plan);
+	} catch (error) {
+		return recover(error);
+	}
+	removeMigratedHtmlLinks(plan, preparedHtml);
+	plan.warnings.push(...preparedHtml.warnings);
+	plan.warnings.push(...preparedVue.warnings);
+	try {
+		for (const file of plan.files.filter((file) => extname(file.path) === ".html")) parseHtmlSource(file.path, file.source);
+		for (const file of plan.files.filter((file) => extname(file.path) === ".vue")) {
+			const vueCompiler = preparedVue.compiler;
+			if (!vueCompiler) throw new Error(`No Vue compiler is available to verify ${file.path}`);
+			const includeUnscoped = preparedVue.unscopedPaths.has(file.path);
+			const blocks = verifyVueSource(vueCompiler, file.path, file.source, includeUnscoped);
+			const untouched = /* @__PURE__ */ new Map();
+			for (const block of verifyVueSource(vueCompiler, file.path, snapshots.get(file.path) ?? "", includeUnscoped)) {
+				const key = `${block.syntax}\0${block.content}`;
+				untouched.set(key, (untouched.get(key) ?? 0) + 1);
+			}
+			for (const [index, block] of blocks.entries()) {
+				const key = `${block.syntax}\0${block.content}`;
+				const remaining = untouched.get(key) ?? 0;
+				if (remaining > 0) {
+					untouched.set(key, remaining - 1);
+					continue;
+				}
+				if (block.syntax === "css") validateCss(block.content);
+				else validateCss((await compileStyleEntry(styleCompilers, packageRoot, `${file.path}.${index}.${block.syntax}`, block.content, { virtualEntry: true })).css);
+			}
+		}
+		for (const stylesheet of stylesheets.filter((stylesheet) => isPreprocessorPath(stylesheet.cssPath))) {
+			const changed = plan.files.find((file) => file.path === stylesheet.cssPath);
+			if (!changed && !plan.deletedFiles.includes(stylesheet.cssPath)) continue;
+			const source = changed?.source ?? "";
+			validateCss((await compileStyleEntry(styleCompilers, packageRoot, stylesheet.cssPath, source)).css);
+		}
+	} catch (error) {
+		return recover(error, !isMissingStyleCompilerError(error));
+	}
+	return { plan };
+}
+function replanCompileFailures(tailwind, request, initialPlan) {
+	let plan = initialPlan;
+	const blockedByStylesheet = /* @__PURE__ */ new Map();
+	while (true) {
+		const failing = invalidCandidates(tailwind, plan.candidates);
+		if (failing.length === 0) break;
+		let progressed = false;
+		for (const rule of plan.rules) {
+			const failed = rule.candidates.filter((candidate) => failing.includes(candidate));
+			if (failed.length === 0) continue;
+			let blocked = blockedByStylesheet.get(rule.stylesheet);
+			if (!blocked) blockedByStylesheet.set(rule.stylesheet, blocked = /* @__PURE__ */ new Map());
+			const key = `${rule.ruleId.start}-${rule.ruleId.end}`;
+			let entry = blocked.get(key);
+			if (!entry) {
+				blocked.set(key, entry = {
+					ruleId: rule.ruleId,
+					authoredSpan: rule.authoredSpan,
+					candidates: /* @__PURE__ */ new Set()
+				});
+				progressed = true;
+			}
+			for (const candidate of failed) entry.candidates.add(candidate);
+		}
+		if (!progressed) throw new Error(`Tailwind did not generate CSS for candidate: ${failing[0]}`);
+		plan = JSON.parse(planBatchMigration(JSON.stringify({
+			...request,
+			stylesheets: request.stylesheets.map((stylesheet, index) => ({
+				...stylesheet,
+				blockedRules: [...blockedByStylesheet.get(index)?.values() ?? []].map((entry) => entry.ruleId)
+			}))
+		})));
+	}
+	for (const [index, blocked] of blockedByStylesheet) {
+		const cssPath = request.stylesheets[index].cssPath;
+		for (const { authoredSpan, candidates } of blocked.values()) {
+			const failed = [...candidates].sort().map((candidate) => `\`${candidate}\``).join(", ");
+			plan.warnings.push({
+				code: "candidate-compilation-failure",
+				file: cssPath,
+				start: authoredSpan.start,
+				end: authoredSpan.end,
+				message: `Tailwind did not generate CSS for ${failed}, so the rule is retained.`
+			});
+		}
+	}
+	return plan;
+}
+function removeMigratedHtmlLinks(plan, preparedHtml) {
+	const unlinked = new Set(plan.unlinkedFiles);
+	const linksByFile = /* @__PURE__ */ new Map();
+	for (const link of preparedHtml.removableLinks) {
+		if (!unlinked.has(link.cssPath)) continue;
+		const links = linksByFile.get(link.filePath) ?? /* @__PURE__ */ new Set();
+		links.add(`${link.href}\0${link.media}`);
+		linksByFile.set(link.filePath, links);
+	}
+	for (const [filePath, removable] of linksByFile) {
+		const planned = plan.files.find((file) => file.path === filePath);
+		const original = preparedHtml.files.find((file) => file.path === filePath);
+		if (!original) continue;
+		const source = planned?.source ?? original.source;
+		const links = parseHtmlSource(filePath, source).links.filter((link) => removable.has(`${link.href}\0${link.media}`)).sort((left, right) => right.tagStart - left.tagStart);
+		let bytes = Buffer.from(source);
+		for (const link of links) bytes = Buffer.concat([bytes.subarray(0, link.tagStart), bytes.subarray(link.tagEnd)]);
+		const updated = bytes.toString();
+		if (updated === source) continue;
+		if (planned) planned.source = updated;
+		else plan.files.push({
+			path: filePath,
+			source: updated
+		});
+	}
+}
+function mergePlans(plans, originals) {
+	const filesByPath = /* @__PURE__ */ new Map();
+	const deletedPaths = /* @__PURE__ */ new Set();
+	const candidates = /* @__PURE__ */ new Set();
+	const rules = [];
+	const warnings = [];
+	const seenWarnings = /* @__PURE__ */ new Set();
+	let convertedRules = 0;
+	let retainedRules = 0;
+	const claimPath = (path, kind) => {
+		if (!originals.has(path)) throw new Error(`Planned ${kind} is outside the source snapshot: ${path}`);
+		if (filesByPath.has(path) || deletedPaths.has(path)) throw new Error(`Multiple package groups planned changes for ${path}`);
+	};
+	for (const plan of plans) {
+		for (const file of plan.files) {
+			claimPath(file.path, "file");
+			filesByPath.set(file.path, file);
+		}
+		for (const path of plan.deletedFiles) {
+			claimPath(path, "deletion");
+			deletedPaths.add(path);
+		}
+		for (const candidate of plan.candidates) candidates.add(candidate);
+		convertedRules += plan.convertedRules;
+		retainedRules += plan.retainedRules;
+		rules.push(...plan.rules);
+		for (const warning of plan.warnings) {
+			const key = `${warning.code}\0${warning.file}\0${warning.start}\0${warning.end}`;
+			if (seenWarnings.has(key)) continue;
+			seenWarnings.add(key);
+			warnings.push(warning);
+		}
+	}
+	return {
+		filesByPath,
+		deletedPaths,
+		candidates,
+		rules,
+		warnings,
+		convertedRules,
+		retainedRules
+	};
+}
+//#endregion
+export { migrate };