styled-components-to-stylex-codemod 0.0.13 → 0.0.15

package/dist/run-prepass-BcidTT9f.mjs

@@ -0,0 +1,885 @@
+import { t as PLACEHOLDER_RE } from "./styled-css-DBryFqQM.mjs";
+import { t as isSelectorContext } from "./selector-context-heuristic-CGwiJ3HL.mjs";
+import path, { relative, resolve } from "node:path";
+import { readFileSync, realpathSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { parse } from "@babel/parser";
+
+//#region src/internal/utilities/collection-utils.ts
+/** Add a value to a Set stored in a Map, creating the Set if it doesn't exist. */
+function addToSetMap(map, key, value) {
+	let set = map.get(key);
+	if (!set) {
+		set = /* @__PURE__ */ new Set();
+		map.set(key, set);
+	}
+	set.add(value);
+}
+
+//#endregion
+//#region src/internal/prepass/extract-external-interface.ts
+function findImportSource(src, localName) {
+	const [aliasRe, namedRe, defaultRe] = getImportSourceRes(localName);
+	const aliasMatch = src.match(aliasRe);
+	if (aliasMatch?.[1] && aliasMatch[1] !== "default" && aliasMatch[2]) return {
+		source: aliasMatch[2],
+		exportedName: aliasMatch[1]
+	};
+	const namedMatch = src.match(namedRe);
+	if (namedMatch?.[1]) return {
+		source: namedMatch[1],
+		exportedName: localName
+	};
+	const defaultMatch = src.match(defaultRe);
+	if (defaultMatch?.[1]) return {
+		source: defaultMatch[1],
+		exportedName: localName
+	};
+	return null;
+}
+const importSourceReCache = /* @__PURE__ */ new Map();
+function getImportSourceRes(localName) {
+	let cached = importSourceReCache.get(localName);
+	if (!cached) {
+		cached = [
+			new RegExp(String.raw`import\s+\{[^}]*\b(\w+)\s+as\s+${localName}\b[^}]*\}\s+from\s+["']([^"']+)["']`),
+			new RegExp(String.raw`import\s+\{[^}]*\b${localName}\b[^}]*\}\s+from\s+["']([^"']+)["']`),
+			new RegExp(String.raw`import\s+${localName}(?:\s*,\s*\{[^}]*\})?\s+from\s+["']([^"']+)["']`)
+		];
+		importSourceReCache.set(localName, cached);
+	}
+	return cached;
+}
+function resolveBarrelReExport(filePath, name, resolve, read) {
+	const basename = path.basename(filePath);
+	if (basename !== "index.ts" && basename !== "index.tsx") return null;
+	let src;
+	try {
+		src = read(filePath);
+	} catch {
+		return null;
+	}
+	const namedMatch = src.match(getBarrelExportRe(name));
+	if (namedMatch?.[1]) return resolve(namedMatch[1], filePath);
+	for (const match of src.matchAll(/export\s*\*\s*from\s*["']([^"']+)["']/g)) {
+		const specifier = match[1];
+		if (!specifier) continue;
+		const resolved = resolve(specifier, filePath);
+		if (resolved) try {
+			if (fileExports(read(resolved), name)) return resolved;
+		} catch {}
+	}
+	return null;
+}
+function fileExports(src, name) {
+	return getFileExportsRe(name).test(src);
+}
+const fileExportsReCache = /* @__PURE__ */ new Map();
+function getFileExportsRe(name) {
+	let re = fileExportsReCache.get(name);
+	if (!re) {
+		re = new RegExp(String.raw`export\s+(?:(?:const|function|class|let|var)\s+${name}\b|default\s+${name}\b)` + String.raw`|export\s*\{[^}]*\b${name}\b[^}]*\}`);
+		fileExportsReCache.set(name, re);
+	}
+	return re;
+}
+const barrelExportReCache = /* @__PURE__ */ new Map();
+function getBarrelExportRe(name) {
+	let re = barrelExportReCache.get(name);
+	if (!re) {
+		re = new RegExp(String.raw`export\s*\{[^}]*\b${name}\b[^}]*\}\s*from\s*["']([^"']+)["']`);
+		barrelExportReCache.set(name, re);
+	}
+	return re;
+}
+function fileImportsFrom(usageSrc, usageFile, name, defFile, resolve) {
+	const [namedRe, defaultRe] = getFileImportsFromRes(name);
+	namedRe.lastIndex = 0;
+	defaultRe.lastIndex = 0;
+	const stem = path.parse(defFile).name;
+	const parent = path.basename(path.dirname(defFile));
+	for (const re of [namedRe, defaultRe]) for (const match of usageSrc.matchAll(re)) {
+		const specifier = match[1];
+		if (!specifier) continue;
+		const resolved = resolve(specifier, usageFile);
+		if (resolved && path.resolve(resolved) === path.resolve(defFile)) return true;
+		if (specifier.endsWith(stem) || specifier.endsWith(`${parent}/${stem}`) || specifier.endsWith(parent)) return true;
+	}
+	return false;
+}
+const fileImportsFromReCache = /* @__PURE__ */ new Map();
+function getFileImportsFromRes(name) {
+	let cached = fileImportsFromReCache.get(name);
+	if (!cached) {
+		cached = [new RegExp(String.raw`import\s+\{[^}]*\b${name}\b[^}]*\}\s+from\s+["']([^"']+)["']`, "g"), new RegExp(String.raw`import\s+${name}(?:\s*,\s*\{[^}]*\})?\s+from\s+["']([^"']+)["']`, "g")];
+		fileImportsFromReCache.set(name, cached);
+	}
+	return cached;
+}
+
+//#endregion
+//#region src/internal/prepass/prepass-parser.ts
+/**
+* Shared babel parser for prepass modules.
+*
+* Uses @babel/parser directly with `tokens: false` for ~35% faster parsing
+* compared to jscodeshift's getParser (which enables token generation).
+*
+* Both scan-cross-file-selectors and extract-external-interface can share this parser
+* to avoid duplicate parser initialization.
+*/
+/**
+* Create a babel parser with tokens disabled, matching jscodeshift's plugin set
+* for the given parser name.
+*
+* - `tsx` / `ts`: TypeScript plugins (tsx also includes JSX)
+* - `babel` / `babylon` / `flow`: Flow plugins + JSX
+*
+* Note: jscodeshift's `flow` parser uses the `flow-parser` package (not babel).
+* We always use `@babel/parser` with the `flow` plugin instead, since it produces
+* the same AST node types (ImportDeclaration, TaggedTemplateExpression) that the
+* prepass walks, and avoids an extra parser dependency.
+*/
+function createPrepassParser(parserName = "tsx") {
+	const options = parserName === "ts" || parserName === "tsx" ? buildOptions(TS_PLUGINS, parserName === "tsx") : buildOptions(FLOW_PLUGINS, true);
+	return { parse(source) {
+		return parse(source, options);
+	} };
+}
+function buildOptions(plugins, includeJsx) {
+	return {
+		sourceType: "module",
+		allowImportExportEverywhere: true,
+		allowReturnOutsideFunction: true,
+		startLine: 1,
+		tokens: false,
+		plugins: includeJsx ? ["jsx", ...plugins] : plugins
+	};
+}
+/**
+* Plugins for TypeScript parsers (ts, tsx).
+* Same as jscodeshift's tsOptions.plugins minus "jsx" (added conditionally).
+*/
+const TS_PLUGINS = [
+	"asyncGenerators",
+	"decoratorAutoAccessors",
+	"bigInt",
+	"classPrivateMethods",
+	"classPrivateProperties",
+	"classProperties",
+	"decorators-legacy",
+	"doExpressions",
+	"dynamicImport",
+	"exportDefaultFrom",
+	"exportNamespaceFrom",
+	"functionBind",
+	"functionSent",
+	"importAttributes",
+	"importMeta",
+	"nullishCoalescingOperator",
+	"numericSeparator",
+	"objectRestSpread",
+	"optionalCatchBinding",
+	"optionalChaining",
+	["pipelineOperator", { proposal: "minimal" }],
+	"throwExpressions",
+	"typescript"
+];
+/**
+* Plugins for Flow/Babylon parsers (babel, babylon, flow).
+* Same as jscodeshift's babylon parser plugins minus "jsx" (added conditionally).
+*/
+const FLOW_PLUGINS = [
+	["flow", { all: true }],
+	"flowComments",
+	"asyncGenerators",
+	"bigInt",
+	"classProperties",
+	"classPrivateProperties",
+	"classPrivateMethods",
+	["decorators", { decoratorsBeforeExport: false }],
+	"doExpressions",
+	"dynamicImport",
+	"exportDefaultFrom",
+	"exportNamespaceFrom",
+	"functionBind",
+	"functionSent",
+	"importMeta",
+	"logicalAssignment",
+	"nullishCoalescingOperator",
+	"numericSeparator",
+	"objectRestSpread",
+	"optionalCatchBinding",
+	"optionalChaining",
+	["pipelineOperator", { proposal: "minimal" }],
+	"throwExpressions"
+];
+
+//#endregion
+//#region src/internal/prepass/scan-cross-file-selectors.ts
+/**
+* Pre-filter: matches any bare `${Identifier}` template expression.
+* Used to skip files that only contain arrow functions or member expressions
+* in template literals (e.g. `${props => ...}`, `${theme.color}`).
+*/
+const BARE_TEMPLATE_IDENTIFIER_RE = /\$\{\s*[a-zA-Z_$][\w$]*\s*\}/;
+/**
+* Categorize cross-file selector usages into marker sidecar and global selector bridge maps.
+*
+* Bridge usages (from already-converted files) are skipped — the consumer handles marker
+* generation via the forward selector handler, so no sidecar/bridge is needed on the target.
+*/
+function categorizeSelectorUsages(usages, componentsNeedingMarkerSidecar, componentsNeedingGlobalSelectorBridge) {
+	for (const usage of usages) {
+		if (usage.bridgeComponentName) continue;
+		if (usage.consumerIsTransformed) addToSetMap(componentsNeedingMarkerSidecar, usage.resolvedPath, usage.importedName);
+		else addToSetMap(componentsNeedingGlobalSelectorBridge, usage.resolvedPath, usage.importedName);
+	}
+}
+/** Regex matching `export const XGlobalSelector = ".sc2sx-` pattern (global for matchAll). */
+const BRIDGE_EXPORT_RE = /export\s+const\s+(\w+GlobalSelector)\s*=\s*["']\.sc2sx-/g;
+/**
+* Detect whether an imported name is a bridge GlobalSelector from an
+* already-converted StyleX file.
+*
+* Detection criteria (hybrid fast + safe):
+* 1. Variable name ends with "GlobalSelector" AND the stripped name starts uppercase
+* 2. Target file contains "@stylexjs/stylex" (string check, no parse)
+* 3. Target file has a matching `export const XGlobalSelector = ".sc2sx-"` pattern
+*
+* @returns The stripped component name (e.g., "CollapseArrowIcon" for
+*   "CollapseArrowIconGlobalSelector"), or null if not a bridge.
+*/
+function detectBridgeGlobalSelector(importedName, resolvedPath, readFile) {
+	if (!importedName.endsWith("GlobalSelector")) return null;
+	const stripped = importedName.slice(0, -14);
+	if (!stripped || !/^[A-Z]/.test(stripped)) return null;
+	const content = readFile(resolvedPath);
+	if (!content || !content.includes("@stylexjs/stylex")) return null;
+	let found = false;
+	for (const m of content.matchAll(BRIDGE_EXPORT_RE)) if (m[1] === importedName) {
+		found = true;
+		break;
+	}
+	if (!found) return null;
+	return stripped;
+}
+/**
+* If `importedName` is a bridge GlobalSelector, populate bridge fields on `usage`
+* and find the corresponding component import from the same source.
+*/
+function applyBridgeFields(usage, importedName, localName, resolvedPath, importMap, readFile) {
+	const bridgeName = detectBridgeGlobalSelector(importedName, resolvedPath, readFile);
+	if (!bridgeName) return;
+	usage.bridgeComponentName = bridgeName;
+	const imp = importMap.get(localName);
+	if (!imp) return;
+	let defaultImportLocal;
+	for (const [otherLocal, otherImp] of importMap) {
+		if (otherImp.source !== imp.source || otherLocal === localName) continue;
+		if (otherImp.importedName === bridgeName) {
+			usage.bridgeComponentLocalName = otherLocal;
+			defaultImportLocal = void 0;
+			break;
+		}
+		if (otherImp.importedName === "default" && defaultImportLocal === void 0) defaultImportLocal = otherLocal;
+	}
+	if (defaultImportLocal !== void 0) usage.bridgeComponentLocalName = defaultImportLocal;
+}
+/** Global version for matchAll/replace operations */
+const PLACEHOLDER_RE_G = new RegExp(PLACEHOLDER_RE.source, "g");
+/**
+* Walk the AST collecting ImportDeclaration and TaggedTemplateExpression nodes.
+*
+* Uses a targeted recursive walk — only descends into node types that can
+* contain these targets (skips type annotations, comments, etc.).
+*/
+function walkForImportsAndTemplates(node, imports, templates) {
+	if (!node || typeof node !== "object") return;
+	const n = node;
+	if (n.type === "ImportDeclaration") {
+		imports.push(n);
+		return;
+	}
+	if (n.type === "TaggedTemplateExpression") {
+		templates.push(n);
+		return;
+	}
+	for (const key of Object.keys(n)) {
+		if (key === "type" || key === "start" || key === "end" || key === "loc") continue;
+		const val = n[key];
+		if (Array.isArray(val)) for (const child of val) walkForImportsAndTemplates(child, imports, templates);
+		else if (val && typeof val === "object" && val.type) walkForImportsAndTemplates(val, imports, templates);
+	}
+}
+/** Build a map of localName → import info from raw ImportDeclaration nodes. */
+function buildImportMapFromNodes(importNodes) {
+	const map = /* @__PURE__ */ new Map();
+	for (const node of importNodes) {
+		const sourceValue = node.source?.value;
+		if (typeof sourceValue !== "string") continue;
+		const specifiers = node.specifiers;
+		if (!specifiers) continue;
+		for (const spec of specifiers) {
+			const localName = getNodeName(spec.local);
+			if (!localName) continue;
+			if (spec.type === "ImportDefaultSpecifier") map.set(localName, {
+				source: sourceValue,
+				importedName: "default"
+			});
+			else if (spec.type === "ImportSpecifier") {
+				const importedName = getNodeName(spec.imported) ?? localName;
+				map.set(localName, {
+					source: sourceValue,
+					importedName
+				});
+			}
+		}
+	}
+	return map;
+}
+/** Find the local name for the styled-components default import. */
+function findStyledImportNameFromNodes(importNodes) {
+	for (const node of importNodes) {
+		if (node.source?.value !== "styled-components") continue;
+		const specifiers = node.specifiers;
+		if (!specifiers) continue;
+		for (const spec of specifiers) if (spec.type === "ImportDefaultSpecifier") {
+			const name = getNodeName(spec.local);
+			if (name) return name;
+		}
+	}
+}
+/**
+* Find local names of imported components used as selectors inside
+* styled-components template literals.
+*/
+function findComponentSelectorLocalsFromNodes(templateNodes, styledImportName) {
+	const selectorLocals = /* @__PURE__ */ new Set();
+	for (const node of templateNodes) {
+		if (!isStyledTag(node.tag, styledImportName)) continue;
+		const quasi = node.quasi;
+		if (!quasi) continue;
+		const quasis = quasi.quasis;
+		const expressions = quasi.expressions;
+		if (!quasis || !expressions) continue;
+		const rawParts = [];
+		for (let i = 0; i < quasis.length; i++) {
+			const value = quasis[i]?.value;
+			rawParts.push(value?.raw ?? "");
+			if (i < expressions.length) rawParts.push(`__SC_EXPR_${i}__`);
+		}
+		const rawCss = rawParts.join("");
+		for (const match of rawCss.matchAll(PLACEHOLDER_RE_G)) {
+			const exprIndex = Number(match[1]);
+			const pos = match.index;
+			if (isPlaceholderInSelectorContext(rawCss, pos, match[0].length)) {
+				const expr = expressions[exprIndex];
+				if (expr?.type === "Identifier" && typeof expr.name === "string") selectorLocals.add(expr.name);
+			}
+		}
+	}
+	return selectorLocals;
+}
+/**
+* Check whether a styled-components tag expression is a styled call.
+* Matches: styled.div, styled(X), styled.div.attrs(...), styled(X).withConfig(...), etc.
+*/
+function isStyledTag(tag, styledName) {
+	if (!tag || typeof tag !== "object") return false;
+	if (tag.type === "MemberExpression") {
+		const obj = tag.object;
+		if (obj?.type === "Identifier" && obj.name === styledName) return true;
+	}
+	if (tag.type === "CallExpression") {
+		const callee = tag.callee;
+		if (callee?.type === "Identifier" && callee.name === styledName) return true;
+		if (callee?.type === "MemberExpression" && callee.object) return isStyledTag(callee.object, styledName);
+	}
+	return false;
+}
+/** Check if a placeholder at the given position is in a CSS selector context. */
+function isPlaceholderInSelectorContext(rawCss, pos, length) {
+	const after = rawCss.slice(pos + length).trimStart();
+	return isSelectorContext(rawCss.slice(0, pos).trimEnd().replace(PLACEHOLDER_RE_G, "hover"), after);
+}
+/** Safely extract the name string from an AST identifier-like node. */
+function getNodeName(node) {
+	if (!node || typeof node !== "object") return;
+	if (node.type === "Identifier" && typeof node.name === "string") return node.name;
+}
+/** Deduplicate and resolve two file lists into a single array of absolute paths. */
+function deduplicateAndResolve(filesToTransform, consumerPaths) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const f of filesToTransform) {
+		const abs = resolve(f);
+		if (!seen.has(abs)) {
+			seen.add(abs);
+			result.push(abs);
+		}
+	}
+	for (const f of consumerPaths) {
+		const abs = resolve(f);
+		if (!seen.has(abs)) {
+			seen.add(abs);
+			result.push(abs);
+		}
+	}
+	return result;
+}
+
+//#endregion
+//#region src/internal/prepass/run-prepass.ts
+/**
+* Unified prepass: single pass for both cross-file selector scanning
+* and consumer analysis (external interface detection).
+*
+* Reads each file once, classifies by content (styled-components / as-prop),
+* and runs AST parsing + consumer analysis only on relevant files.
+*/
+const AS_PROP_RE = /\bas[={]/;
+const STYLED_CALL_RE = /styled\(([A-Z][A-Za-z0-9]+)/g;
+const STYLED_DEF_RE = /const\s+([A-Z][A-Za-z0-9]*)\b[^=]*=\s*styled[.(]/g;
+/** Matches <Component ...as= across lines. [^<>]* avoids crossing tag boundaries. */
+const JSX_AS_COMPONENT_RE = /<([A-Z][A-Za-z0-9]*)\b[^<>]*\bas[={]/g;
+async function runPrepass(options) {
+	const { filesToTransform, consumerPaths, resolver, parserName, createExternalInterface, enableAstCache } = options;
+	const t0 = performance.now();
+	const astCache = enableAstCache ? /* @__PURE__ */ new Map() : void 0;
+	const needsRealpath = (() => {
+		if (filesToTransform.length === 0) return false;
+		const sample = resolve(filesToTransform[0]);
+		try {
+			return realpathSync(sample) !== sample;
+		} catch {
+			return false;
+		}
+	})();
+	const realPathCache = /* @__PURE__ */ new Map();
+	const toRealPath = needsRealpath ? (p) => {
+		const abs = resolve(p);
+		let real = realPathCache.get(abs);
+		if (real === void 0) {
+			try {
+				real = realpathSync(abs);
+			} catch {
+				real = abs;
+			}
+			realPathCache.set(abs, real);
+		}
+		return real;
+	} : (p) => resolve(p);
+	const transformSet = new Set(filesToTransform.map(toRealPath));
+	const allFiles = deduplicateAndResolve(filesToTransform, consumerPaths).map(toRealPath);
+	const allFilesSet = new Set(allFiles);
+	const uniqueAllFiles = [...allFilesSet];
+	const parser = createPrepassParser(parserName);
+	const resolveCache = /* @__PURE__ */ new Map();
+	const resolve$1 = (specifier, fromFile) => {
+		const absFromFile = resolve(fromFile);
+		const key = `${absFromFile}\0${specifier}`;
+		const cached = resolveCache.get(key);
+		if (cached !== void 0) return cached;
+		const result = resolver.resolve(absFromFile, specifier);
+		const normalized = result ? toRealPath(result) : null;
+		resolveCache.set(key, normalized);
+		return normalized;
+	};
+	const selectorUsages = /* @__PURE__ */ new Map();
+	const componentsNeedingMarkerSidecar = /* @__PURE__ */ new Map();
+	const componentsNeedingGlobalSelectorBridge = /* @__PURE__ */ new Map();
+	const asUsages = /* @__PURE__ */ new Map();
+	const styledCallUsages = [];
+	const styledDefFiles = /* @__PURE__ */ new Map();
+	const classNameStyleUsages = /* @__PURE__ */ new Map();
+	const fileContents = /* @__PURE__ */ new Map();
+	const cachedRead = (filePath) => {
+		const content = fileContents.get(filePath);
+		if (content !== void 0) return content;
+		try {
+			const src = readFileSync(filePath, "utf-8");
+			fileContents.set(filePath, src);
+			return src;
+		} catch {
+			return "";
+		}
+	};
+	const rgFiltered = rgPreFilter(uniqueAllFiles);
+	for (const filePath of uniqueAllFiles) {
+		if (rgFiltered && !rgFiltered.has(filePath)) continue;
+		let source;
+		try {
+			source = readFileSync(filePath, "utf-8");
+		} catch {
+			continue;
+		}
+		const hasStyled = source.includes("styled-components");
+		const hasAsProp = createExternalInterface && AS_PROP_RE.test(source);
+		if (!hasStyled && !hasAsProp) continue;
+		fileContents.set(filePath, source);
+		if (hasStyled && BARE_TEMPLATE_IDENTIFIER_RE.test(source) && hasRegexSelectorCandidate(source)) {
+			const usages = scanFileForSelectorsAst(filePath, source, transformSet, resolver, parser, toRealPath, cachedRead, astCache, createExternalInterface);
+			if (usages.length > 0) {
+				selectorUsages.set(filePath, usages);
+				categorizeSelectorUsages(usages, componentsNeedingMarkerSidecar, componentsNeedingGlobalSelectorBridge);
+			}
+		}
+		if (createExternalInterface && hasStyled) {
+			STYLED_CALL_RE.lastIndex = 0;
+			for (const m of source.matchAll(STYLED_CALL_RE)) if (m[1]) styledCallUsages.push({
+				file: filePath,
+				name: m[1]
+			});
+			STYLED_DEF_RE.lastIndex = 0;
+			for (const m of source.matchAll(STYLED_DEF_RE)) if (m[1]) addToSetMap(styledDefFiles, filePath, m[1]);
+		}
+		if (hasAsProp) {
+			JSX_AS_COMPONENT_RE.lastIndex = 0;
+			for (const m of source.matchAll(JSX_AS_COMPONENT_RE)) if (m[1]) addToSetMap(asUsages, m[1], filePath);
+		}
+	}
+	const styledFileCount = fileContents.size;
+	if (createExternalInterface && styledDefFiles.size > 0) {
+		const allStyledNames = /* @__PURE__ */ new Set();
+		for (const names of styledDefFiles.values()) for (const name of names) allStyledNames.add(name);
+		if (allStyledNames.size > 0) {
+			const rgHits = rgClassNameStyleFilter(uniqueAllFiles);
+			for (const [filePath, source] of fileContents) for (const name of scanClassNameStyleUsages(source, allStyledNames)) addToSetMap(classNameStyleUsages, name, filePath);
+			const filesToScan = rgHits ? [...rgHits].filter((f) => allFilesSet.has(f) && !fileContents.has(f)) : uniqueAllFiles.filter((f) => !fileContents.has(f));
+			for (const filePath of filesToScan) {
+				const source = cachedRead(filePath);
+				if (!source) continue;
+				for (const name of scanClassNameStyleUsages(source, allStyledNames)) addToSetMap(classNameStyleUsages, name, filePath);
+			}
+		}
+	}
+	let consumerAnalysis;
+	if (createExternalInterface) {
+		consumerAnalysis = /* @__PURE__ */ new Map();
+		const ensure = (filePath, name) => {
+			const key = `${toRealPath(filePath)}:${name}`;
+			let entry = consumerAnalysis.get(key);
+			if (!entry) {
+				entry = {
+					styles: false,
+					as: false
+				};
+				consumerAnalysis.set(key, entry);
+			}
+			return entry;
+		};
+		if (asUsages.size > 0) for (const [defFile, names] of styledDefFiles) {
+			const defSrc = cachedRead(defFile);
+			for (const name of names) {
+				const usageFiles = asUsages.get(name);
+				if (!usageFiles) continue;
+				if (!fileExports(defSrc, name)) continue;
+				if (usageFiles.has(defFile)) {
+					ensure(defFile, name).as = true;
+					continue;
+				}
+				for (const usageFile of usageFiles) if (fileImportsFrom(cachedRead(usageFile), usageFile, name, defFile, resolve$1)) {
+					ensure(defFile, name).as = true;
+					break;
+				}
+			}
+		}
+		if (classNameStyleUsages.size > 0) for (const [defFile, names] of styledDefFiles) {
+			const defSrc = cachedRead(defFile);
+			for (const name of names) {
+				const usageFiles = classNameStyleUsages.get(name);
+				if (!usageFiles) continue;
+				if (!fileExports(defSrc, name)) continue;
+				if (usageFiles.has(defFile)) {
+					ensure(defFile, name).styles = true;
+					continue;
+				}
+				for (const usageFile of usageFiles) if (fileImportsFrom(cachedRead(usageFile), usageFile, name, defFile, resolve$1)) {
+					ensure(defFile, name).styles = true;
+					break;
+				}
+			}
+		}
+		{
+			const seen = /* @__PURE__ */ new Set();
+			for (const { file, name } of styledCallUsages) {
+				const importInfo = findImportSource(cachedRead(file), name);
+				if (!importInfo) continue;
+				const { source: importSource, exportedName } = importInfo;
+				let defFile = resolve$1(importSource, file);
+				if (!defFile) continue;
+				defFile = resolveBarrelReExport(defFile, exportedName, resolve$1, cachedRead) ?? defFile;
+				const key = `${defFile}:${exportedName}`;
+				if (seen.has(key)) continue;
+				seen.add(key);
+				try {
+					if (!fileExports(cachedRead(defFile), exportedName)) continue;
+				} catch {
+					continue;
+				}
+				ensure(defFile, exportedName).styles = true;
+			}
+		}
+	}
+	const crossFileInfo = {
+		selectorUsages,
+		componentsNeedingMarkerSidecar,
+		componentsNeedingGlobalSelectorBridge
+	};
+	{
+		const elapsed = ((performance.now() - t0) / 1e3).toFixed(1);
+		const reStyled = consumerAnalysis ? [...consumerAnalysis.values()].filter((v) => v.styles).length : 0;
+		const asProp = consumerAnalysis ? [...consumerAnalysis.values()].filter((v) => v.as).length : 0;
+		process.stdout.write(`Prepass: scanned ${uniqueAllFiles.length} files in ${elapsed}s — ${styledFileCount} with styled-components, ${selectorUsages.size} cross-file selectors, ${reStyled} re-styled, ${asProp} as-prop, ${classNameStyleUsages.size} className/style\n`);
+	}
+	if (process.env.DEBUG_CODEMOD) logPrepassDebug(uniqueAllFiles, crossFileInfo, consumerAnalysis);
+	return {
+		crossFileInfo,
+		consumerAnalysis
+	};
+}
+/** Matches `${Identifier}` in source — used to find potential selector expressions. */
+const SELECTOR_EXPR_RE = /\$\{\s*([A-Za-z_$][\w$]*)\s*\}/g;
+/** Matches static `import ... from "..."` declarations (multi-line safe). */
+const IMPORT_DECLARATION_RE = /import\s+[\s\S]*?\s+from\s+["'][^"']+["']/g;
+const IMPORT_IDENTIFIER_RE_CACHE = /* @__PURE__ */ new Map();
+/**
+* Fast regex pre-filter: checks if the source contains any `${Identifier}`
+* that appears to be in a CSS selector context (before `{`, not after `:`).
+*
+* This reduces the number of files needing AST parsing from ~888 to ~500,
+* saving ~120ms of babel parsing time per run.
+*/
+function hasRegexSelectorCandidate(source) {
+	const importText = collectImportDeclarationText(source);
+	if (importText.length === 0) return false;
+	SELECTOR_EXPR_RE.lastIndex = 0;
+	for (const m of source.matchAll(SELECTOR_EXPR_RE)) {
+		const identifier = m[1];
+		if (!identifier || !importTextMentionsIdentifier(importText, identifier)) continue;
+		const pos = m.index;
+		if (isSelectorContext(source.slice(0, pos).trimEnd(), source.slice(pos + m[0].length).trimStart())) return true;
+	}
+	return false;
+}
+function collectImportDeclarationText(source) {
+	IMPORT_DECLARATION_RE.lastIndex = 0;
+	const blocks = [];
+	for (const match of source.matchAll(IMPORT_DECLARATION_RE)) if (match[0]) blocks.push(match[0]);
+	return blocks.join("\n");
+}
+function importTextMentionsIdentifier(importText, identifier) {
+	let re = IMPORT_IDENTIFIER_RE_CACHE.get(identifier);
+	if (!re) {
+		re = new RegExp(`(?:^|[^A-Za-z0-9_$])${escapeRegexForRegExp(identifier)}(?:$|[^A-Za-z0-9_$])`);
+		IMPORT_IDENTIFIER_RE_CACHE.set(identifier, re);
+	}
+	return re.test(importText);
+}
+function escapeRegexForRegExp(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Quick pre-check: does this source mention className or style in a JSX prop context? */
+const CLASSNAME_STYLE_QUICK_RE = /\b(className|style)\s*[={]/;
+/** Matches `import { Original as Local, ... }` — captures original and local names. */
+const IMPORT_ALIAS_ENTRY_RE = /\b(\w+)\s+as\s+(\w+)/g;
+/**
+* Build a mapping from local alias names to original imported names for a source file.
+* Only includes PascalCase names that differ from their original (actual aliases).
+*/
+function buildLocalToImportedMap(source) {
+	const map = /* @__PURE__ */ new Map();
+	IMPORT_ALIAS_ENTRY_RE.lastIndex = 0;
+	for (const m of source.matchAll(IMPORT_ALIAS_ENTRY_RE)) {
+		const original = m[1];
+		const local = m[2];
+		if (original !== local && /^[A-Z]/.test(local)) map.set(local, original);
+	}
+	return map;
+}
+/**
+* Scan source for JSX usage of specific components with className or style props.
+* Uses a two-step approach: first quick-checks for className/style keywords,
+* then scans JSX open tags to match component names — avoids building a huge
+* alternation regex when there are hundreds of component names.
+* Handles aliased imports (e.g., `import { Alert as MyAlert }`) by resolving
+* local tag names back to their original exported names.
+*/
+function scanClassNameStyleUsages(source, componentNames) {
+	if (!CLASSNAME_STYLE_QUICK_RE.test(source)) return [];
+	let aliasMap;
+	const matches = [];
+	for (const m of source.matchAll(/<([A-Z][A-Za-z0-9]*)\b[^<>]*\b(?:className|style)\s*[={]/gs)) {
+		const tagName = m[1];
+		if (!tagName) continue;
+		if (componentNames.has(tagName)) {
+			matches.push(tagName);
+			continue;
+		}
+		aliasMap ??= buildLocalToImportedMap(source);
+		const originalName = aliasMap.get(tagName);
+		if (originalName && componentNames.has(originalName)) matches.push(originalName);
+	}
+	return matches;
+}
+/**
+* Use ripgrep to find files containing `className` or `style` props.
+* Searches for the prop keywords (not component names) to keep the pattern
+* small and fast — the full component-name regex narrows results down.
+*/
+function rgClassNameStyleFilter(files) {
+	const dirs = deduplicateParentDirs(files);
+	if (dirs.length === 0) return;
+	try {
+		const globArgs = [
+			"*.tsx",
+			"*.ts",
+			"*.jsx",
+			"*.js",
+			"*.mts",
+			"*.cts",
+			"*.mjs",
+			"*.cjs"
+		].map((glob) => `--glob ${shellQuote(glob)}`).join(" ");
+		const output = execSync(`rg -l ${shellQuote(String.raw`\b(className|style)\s*[={]`)} ${globArgs} ${dirs.map(shellQuote).join(" ")}`, {
+			encoding: "utf-8",
+			maxBuffer: 10 * 1024 * 1024
+		});
+		return new Set(output.trim().split("\n").filter(Boolean).map((f) => resolve(f)));
+	} catch (err) {
+		if (err instanceof Error && "status" in err && err.status === 1) return /* @__PURE__ */ new Set();
+		return;
+	}
+}
+/** Scan a single file for cross-file selector usages using AST parsing. */
+function scanFileForSelectorsAst(filePath, source, transformSet, resolver, parser, toRealPath, readFile, cache, failOnParseError) {
+	const hash = cache ? createHash("md5").update(source).digest("hex") : void 0;
+	const cached = cache && hash ? cache.get(hash) : void 0;
+	let importMap;
+	let styledImportName;
+	let selectorLocals;
+	if (cached) {
+		importMap = cached.importMap;
+		styledImportName = cached.styledImportName;
+		selectorLocals = cached.selectorLocals;
+	} else {
+		let ast;
+		try {
+			ast = parser.parse(source);
+		} catch (err) {
+			if (failOnParseError) {
+				const reason = err instanceof Error ? err.message : String(err);
+				throw new Error(`Failed to parse ${filePath}: ${reason}`);
+			}
+			return [];
+		}
+		const program = ast.program ?? ast;
+		const importNodes = [];
+		const taggedTemplateNodes = [];
+		walkForImportsAndTemplates(program, importNodes, taggedTemplateNodes);
+		importMap = buildImportMapFromNodes(importNodes);
+		styledImportName = findStyledImportNameFromNodes(importNodes);
+		selectorLocals = styledImportName ? findComponentSelectorLocalsFromNodes(taggedTemplateNodes, styledImportName) : /* @__PURE__ */ new Set();
+		if (cache && hash) cache.set(hash, {
+			importMap,
+			styledImportName,
+			selectorLocals
+		});
+	}
+	if (importMap.size === 0 || !styledImportName || selectorLocals.size === 0) return [];
+	const consumerIsTransformed = transformSet.has(filePath);
+	const usages = [];
+	for (const localName of selectorLocals) {
+		const imp = importMap.get(localName);
+		if (!imp || imp.source === "styled-components") continue;
+		const resolvedPath = resolver.resolve(filePath, imp.source);
+		if (!resolvedPath) continue;
+		const realResolved = toRealPath(resolvedPath);
+		if (realResolved === filePath) continue;
+		const usage = {
+			localName,
+			importSource: imp.source,
+			importedName: imp.importedName,
+			resolvedPath: realResolved,
+			consumerPath: filePath,
+			consumerIsTransformed
+		};
+		applyBridgeFields(usage, imp.importedName, localName, realResolved, importMap, readFile);
+		usages.push(usage);
+	}
+	return usages;
+}
+/**
+* Use ripgrep to quickly find files containing "styled-components" or `as[={]`.
+* Returns a Set of absolute file paths, or undefined if rg is not available.
+*/
+function rgPreFilter(files) {
+	const dirs = deduplicateParentDirs(files);
+	if (dirs.length === 0) return;
+	try {
+		const pattern = String.raw`(styled-components|\bas[={])`;
+		const globArgs = [
+			"*.tsx",
+			"*.ts",
+			"*.jsx",
+			"*.js",
+			"*.mts",
+			"*.cts",
+			"*.mjs",
+			"*.cjs"
+		].map((glob) => `--glob ${shellQuote(glob)}`).join(" ");
+		const output = execSync(`rg -l ${shellQuote(pattern)} ${globArgs} ${dirs.map(shellQuote).join(" ")}`, {
+			encoding: "utf-8",
+			maxBuffer: 10 * 1024 * 1024
+		});
+		return new Set(output.trim().split("\n").filter(Boolean).map((f) => resolve(f)));
+	} catch (err) {
+		if (err instanceof Error && "status" in err && err.status === 1) return /* @__PURE__ */ new Set();
+		return;
+	}
+}
+function shellQuote(s) {
+	return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+/**
+* Given a list of absolute file paths, extract the minimal set of parent directories.
+* E.g., ["/a/b/c.ts", "/a/b/d.ts", "/a/e/f.ts"] → ["/a/b/", "/a/e/"]
+* Then dedup so "/a/" subsumes both "/a/b/" and "/a/e/".
+*/
+function deduplicateParentDirs(files) {
+	const dirSet = /* @__PURE__ */ new Set();
+	for (const f of files) dirSet.add(f.slice(0, f.lastIndexOf("/") + 1));
+	const sorted = [...dirSet].sort();
+	const result = [];
+	for (const d of sorted) {
+		if (result.length > 0 && d.startsWith(result[result.length - 1])) continue;
+		result.push(d);
+	}
+	return result;
+}
+function logPrepassDebug(scannedFiles, info, consumerAnalysis) {
+	const cwd = process.cwd();
+	const rel = (p) => relative(cwd, p);
+	const lines = ["[DEBUG_CODEMOD] Unified prepass:"];
+	lines.push(`  Scanned ${scannedFiles.length} file(s)`);
+	if (info.selectorUsages.size === 0) lines.push("  No cross-file selector usages found.");
+	else {
+		lines.push(`  Found cross-file selector usages in ${info.selectorUsages.size} file(s):`);
+		for (const [consumer, usages] of info.selectorUsages) for (const u of usages) lines.push(`    ${rel(consumer)} → ${u.importedName} (from ${rel(u.resolvedPath)}, transformed=${u.consumerIsTransformed})`);
+	}
+	if (info.componentsNeedingMarkerSidecar.size > 0) {
+		lines.push("  Components needing marker sidecar (both consumer and target transformed):");
+		for (const [file, names] of info.componentsNeedingMarkerSidecar) lines.push(`    ${rel(file)}: ${[...names].join(", ")}`);
+	}
+	if (info.componentsNeedingGlobalSelectorBridge.size > 0) {
+		lines.push("  Components needing global selector bridge className (consumer not transformed):");
+		for (const [file, names] of info.componentsNeedingGlobalSelectorBridge) lines.push(`    ${rel(file)}: ${[...names].join(", ")}`);
+	}
+	if (consumerAnalysis) lines.push(`  Consumer analysis: ${consumerAnalysis.size} entries`);
+	process.stderr.write(lines.join("\n") + "\n");
+}
+
+//#endregion
+export { runPrepass };