styled-components-to-stylex-codemod 0.0.53 → 0.0.55

package/dist/{typescript-analysis-CmIDxfLv.mjs → typescript-analysis-BLyx4wAJ.mjs}

@@ -1,222 +1,84 @@
 import { n as resolveExistingFilePath } from "./path-utils-BC4U8X_q.mjs";
 import path from "node:path";
 import ts from "typescript";
-//#region src/internal/prepass/typescript-analysis.ts
-function analyzeTypeScriptProgram(options) {
-	const rootNames = normalizeFilePaths(options.files).filter(isTypeScriptLikeFile);
-	if (rootNames.length === 0) return {
-		version: 1,
-		files: []
-	};
-	const program = createProgram(rootNames, options.cwd ?? process.cwd());
-	const checker = program.getTypeChecker();
-	const rootNameSet = new Set(rootNames.map((filePath) => path.resolve(filePath)));
-	const compilerOptions = program.getCompilerOptions();
-	strictNullChecksOnForCurrentRun = Boolean(compilerOptions.strictNullChecks ?? compilerOptions.strict);
-	return {
-		version: 1,
-		files: program.getSourceFiles().filter((sourceFile) => rootNameSet.has(path.resolve(sourceFile.fileName))).map((sourceFile) => analyzeSourceFile(sourceFile, checker)).filter((file) => file.components.length > 0 || file.functions.length > 0).sort((a, b) => a.filePath.localeCompare(b.filePath))
-	};
-}
-function analyzeSourceFile(sourceFile, checker) {
-	const exportedNames = getExportedNames(sourceFile, checker);
-	const defaultExportedLocalNames = getDefaultExportedLocalNames(sourceFile);
-	const localFunctionInitializers = collectLocalFunctionInitializers(sourceFile);
-	const components = [];
-	const functions = [];
-	const visit = (node) => {
-		if (ts.isFunctionDeclaration(node) && (node.name || isDefaultExport(node))) {
-			const fn = readFunctionDeclaration(node, checker, exportedNames);
-			functions.push(fn);
-			if (isReactComponentFunction(node, checker)) components.push(readReactComponentFromFunction(node, checker, exportedNames, defaultExportedLocalNames));
-			return;
-		}
-		if (ts.isVariableStatement(node)) {
-			for (const declaration of node.declarationList.declarations) {
-				if (!ts.isIdentifier(declaration.name)) continue;
-				if (declaration.initializer && isStyledComponentInitializer(declaration.initializer)) {
-					components.push(readStyledComponent(declaration, node, checker, exportedNames));
-					continue;
-				}
-				const componentInitializer = declaration.initializer ? getComponentFunctionInitializerInfo(declaration.initializer, localFunctionInitializers) : void 0;
-				if (componentInitializer) {
-					functions.push(readVariableFunction(declaration.name.text, componentInitializer.fn, node, checker));
-					if (isReactComponentName(declaration.name.text) || returnsJsx(componentInitializer.fn)) components.push(readReactComponentFromVariable(declaration.name.text, componentInitializer.fn, componentInitializer.propTypeNode, node, checker, exportedNames, defaultExportedLocalNames));
-				}
-			}
-			return;
-		}
-		ts.forEachChild(node, visit);
-	};
-	ts.forEachChild(sourceFile, visit);
-	return {
-		filePath: normalizeFilePath(sourceFile.fileName),
-		components: components.sort(byName),
-		functions: functions.sort(byName)
-	};
-}
-function readFunctionDeclaration(node, checker, exportedNames) {
-	const name = node.name?.text ?? "default";
-	return {
-		name,
-		exported: exportedNames.has(name),
-		defaultExport: isDefaultExport(node),
-		typeParameters: readTypeParameters(node.typeParameters),
-		parameters: readParameters(node.parameters, checker)
-	};
+//#region src/internal/prepass/ts-ast-shared.ts
+function resolveAliasedSymbol(symbol, checker) {
+	if (!symbol || (symbol.flags & ts.SymbolFlags.Alias) === 0) return symbol;
+	return checker.getAliasedSymbol(symbol);
 }
-function readVariableFunction(name, node, statement, checker) {
+function readUtilityTypeReference(typeNode) {
 	return {
-		name,
-		exported: isExported(statement),
-		defaultExport: false,
-		typeParameters: readTypeParameters(node.typeParameters),
-		parameters: readParameters(node.parameters, checker)
+		name: typeNode.typeName.getText(),
+		typeArgs: typeNode.typeArguments ?? []
 	};
 }
-function readStyledComponent(declaration, statement, checker, exportedNames) {
-	const name = declaration.name.getText();
-	const typeNode = declaration.initializer ? findStyledPropsTypeNode(declaration.initializer) : void 0;
-	return buildComponentMetadata({
-		name,
-		kind: "styled",
-		exported: exportedNames.has(name) || isExported(statement),
-		defaultExport: false,
-		typeParameters: [],
-		propTypeNode: typeNode,
-		parameters: [],
-		restProps: [],
-		checker,
-		location: declaration
-	});
-}
-function readReactComponentFromFunction(node, checker, exportedNames, defaultExportedLocalNames) {
-	const name = node.name?.text ?? "default";
-	return buildComponentMetadata({
-		name,
-		kind: "react",
-		exported: exportedNames.has(name),
-		defaultExport: isDefaultExport(node) || defaultExportedLocalNames.has(name),
-		typeParameters: readTypeParameters(node.typeParameters),
-		propTypeNode: node.parameters[0]?.type,
-		parameters: readParameters(node.parameters, checker),
-		restProps: readRestProps(node.parameters[0], node.body),
-		bodySupportsSxProp: readsSxProp(node.parameters[0], node.body),
-		bodySxTarget: detectSxTarget(node.parameters[0], node.body),
-		checker,
-		location: node
-	});
+function isTransparentUtilityTypeName(typeName) {
+	return typeName === "Partial" || typeName === "Required" || typeName === "Readonly";
 }
-function readReactComponentFromVariable(name, node, propTypeNode, statement, checker, exportedNames, defaultExportedLocalNames) {
-	return buildComponentMetadata({
-		name,
-		kind: "react",
-		exported: exportedNames.has(name) || isExported(statement),
-		defaultExport: defaultExportedLocalNames.has(name),
-		typeParameters: readTypeParameters(node.typeParameters),
-		propTypeNode: propTypeNode ?? node.parameters[0]?.type,
-		parameters: readParameters(node.parameters, checker),
-		restProps: readRestProps(node.parameters[0], node.body),
-		bodySupportsSxProp: readsSxProp(node.parameters[0], node.body),
-		bodySxTarget: detectSxTarget(node.parameters[0], node.body),
-		checker,
-		location: node
-	});
+function typeNodeKeyIncludes(typeNode, key) {
+	if (!typeNode) return false;
+	if (ts.isLiteralTypeNode(typeNode) && ts.isStringLiteral(typeNode.literal)) return typeNode.literal.text === key;
+	if (ts.isUnionTypeNode(typeNode)) return typeNode.types.some((part) => typeNodeKeyIncludes(part, key));
+	return false;
 }
-function buildComponentMetadata(args) {
-	const propType = args.propTypeNode ? args.checker.getTypeFromTypeNode(args.propTypeNode) : null;
-	const props = propType ? readPropsFromType(propType, args.checker, args.location) : [];
-	const explicitPropNames = args.propTypeNode ? collectExplicitPropNames(args.propTypeNode, args.checker) : [];
-	const supportsResolvedSxProp = props.some((prop) => prop.name === "sx") && args.propTypeNode !== void 0 && typeNodeHasResolvableSxSurface(args.propTypeNode, args.checker, /* @__PURE__ */ new Set());
-	const sxExcludedProperties = args.propTypeNode !== void 0 ? collectSxExcludedProperties(args.propTypeNode, args.checker, /* @__PURE__ */ new Set()) : [];
-	const sxAllowedProperties = args.propTypeNode !== void 0 ? collectSxAllowedProperties(args.propTypeNode, args.checker, /* @__PURE__ */ new Set()) : void 0;
-	return {
-		name: args.name,
-		kind: args.kind,
-		exported: args.exported,
-		defaultExport: args.defaultExport,
-		typeParameters: args.typeParameters,
-		propType: args.propTypeNode ? describeTypeNode(args.propTypeNode, args.checker) : null,
-		props,
-		explicitPropNames,
-		parameters: args.parameters,
-		restProps: args.restProps,
-		hasIndexSignature: propType ? hasIndexSignature(propType, args.checker) : false,
-		supportsSxProp: explicitPropNames.includes("sx") || supportsResolvedSxProp || args.bodySupportsSxProp === true,
-		...args.bodySxTarget ? { sxTarget: args.bodySxTarget } : {},
-		sxExcludedProperties,
-		...sxAllowedProperties !== void 0 ? { sxAllowedProperties } : {}
-	};
+function isIntrinsicReactPropReference(typeNode) {
+	const typeName = typeNode.typeName.getText();
+	return /^(?:React\.)?(?:ComponentProps|ComponentPropsWithRef|ComponentPropsWithoutRef|HTMLAttributes|ButtonHTMLAttributes|AnchorHTMLAttributes|InputHTMLAttributes|SVGProps)$/.test(typeName);
 }
-function readPropsFromType(type, checker, location) {
-	return checker.getPropertiesOfType(type).map((symbol) => {
-		const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0] ?? location;
-		const optional = (symbol.flags & ts.SymbolFlags.Optional) !== 0;
-		return {
-			name: symbol.getName(),
-			optional,
-			readonly: isReadonlyProperty(symbol),
-			type: withOptionalUndefined(readPropTypeString(symbol, declaration, checker, location), optional)
-		};
-	}).sort(byName);
+function isIntrinsicReactHeritageReference(heritageType) {
+	const typeName = heritageType.expression.getText();
+	return /^(?:React\.)?(?:ComponentProps|ComponentPropsWithRef|ComponentPropsWithoutRef|HTMLAttributes|ButtonHTMLAttributes|AnchorHTMLAttributes|InputHTMLAttributes|SVGProps)$/.test(typeName);
 }
-/**
-* TS's resolved type for an optional property includes `| undefined` (because
-* the `?` modifier widens it). Syntactic type nodes don't — `?: number` has
-* `type === number`, not `number | undefined`. Downstream consumers
-* (lower-rules/types.ts) rely on the `| undefined` suffix to gate certain
-* emit decisions (e.g. wrapping a possibly-undefined value in a template
-* string). Reconstruct it here so the syntactic fast path stays
-* behaviorally equivalent to the typeToString path it replaced.
-*/
-function withOptionalUndefined(typeText, optional) {
-	if (!optional || !strictNullChecksOnForCurrentRun) return typeText;
-	if (/\bundefined\b/.test(typeText)) return typeText;
-	return `${typeText} | undefined`;
+function propertyNameText(name) {
+	if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
+	return null;
 }
-/**
-* Per-run capture of strictNullChecks. Set by `analyzeTypeScriptProgram` before
-* any per-file work runs; read by `withOptionalUndefined` to decide whether to
-* append `| undefined` to optional props. Module-scoped to avoid threading the
-* boolean through ~6 helper signatures for a single read site.
-*/
-let strictNullChecksOnForCurrentRun = false;
-/**
-* Returns the prop's TS type as a string. Prefers the syntactic type annotation
-* from the declaration AST (cheap, no checker call) and only falls back to
-* `checker.typeToString` when the declaration has no usable type node — typically
-* synthesized properties (mapped/intersection/spread-derived) where the checker
-* is the only source of truth.
-*
-* Why: typeToString with NoTruncation dominated the prepass at 39s / 723K calls.
-* For the consumers downstream (lower-rules/types.ts parseTypeText), the
-* syntactic representation is what they want anyway — they only handle
-* TSTypeReference / TSUnionType / TSLiteralType shapes.
-*/
-function readPropTypeString(symbol, declaration, _checker, _location) {
-	const typeNode = getDeclarationTypeNode(declaration);
-	if (typeNode) return typeNode.getText();
-	return "";
+function bindingPatternHasName(pattern, name) {
+	return pattern.elements.some((element) => element.name.getText() === name);
 }
-function getDeclarationTypeNode(declaration) {
-	if (ts.isPropertySignature(declaration) || ts.isPropertyDeclaration(declaration) || ts.isParameter(declaration)) return declaration.type;
+function bindingElementPropertyNameText(element) {
+	if (element.propertyName) return ts.isIdentifier(element.propertyName) || ts.isStringLiteral(element.propertyName) ? element.propertyName.text : null;
+	return ts.isIdentifier(element.name) ? element.name.text : null;
 }
-function readParameters(parameters, checker) {
-	return parameters.map((parameter) => ({
-		name: readParameterName(parameter.name),
-		optional: Boolean(parameter.questionToken || parameter.initializer),
-		rest: Boolean(parameter.dotDotDotToken),
-		type: parameter.type ? parameter.type.getText() : checker.typeToString(checker.getTypeAtLocation(parameter), parameter)
-	}));
+function unwrapExpression(expression) {
+	let current = expression;
+	while (ts.isAsExpression(current) || ts.isTypeAssertionExpression(current) || ts.isSatisfiesExpression(current) || ts.isParenthesizedExpression(current)) current = current.expression;
+	return current;
 }
-function hasIndexSignature(type, checker) {
-	return checker.getIndexTypeOfType(type, ts.IndexKind.String) !== void 0 || checker.getIndexTypeOfType(type, ts.IndexKind.Number) !== void 0;
+function isIdentifierNamed(expression, name) {
+	return ts.isIdentifier(expression) && expression.text === name;
 }
+//#endregion
+//#region src/internal/prepass/prop-name-collection.ts
 function collectExplicitPropNames(typeNode, checker, visited = /* @__PURE__ */ new Set()) {
 	const names = /* @__PURE__ */ new Set();
 	collectExplicitPropNamesInto(names, typeNode, checker, visited);
 	return [...names].sort();
 }
+function typeNodeHasResolvableSxSurface(typeNode, checker, visited) {
+	if (ts.isTypeLiteralNode(typeNode)) return typeNode.members.some((member) => ts.isPropertySignature(member) && propertyNameText(member.name) === "sx");
+	if (ts.isIntersectionTypeNode(typeNode)) return typeNode.types.some((part) => typeNodeHasResolvableSxSurface(part, checker, visited));
+	if (ts.isUnionTypeNode(typeNode)) return typeNode.types.every((part) => typeNodeHasResolvableSxSurface(part, checker, visited));
+	if (!ts.isTypeReferenceNode(typeNode) || isIntrinsicReactPropReference(typeNode)) return false;
+	const utilityType = readUtilityTypeReference(typeNode);
+	if (utilityType.name === "Pick") return utilityType.typeArgs.length >= 2 && typeNodeKeyIncludes(utilityType.typeArgs[1], "sx");
+	if (utilityType.name === "Omit") {
+		const baseType = utilityType.typeArgs[0];
+		return baseType !== void 0 && utilityType.typeArgs.length >= 2 && !typeNodeKeyIncludes(utilityType.typeArgs[1], "sx") && typeNodeHasResolvableSxSurface(baseType, checker, visited);
+	}
+	if (isTransparentUtilityTypeName(utilityType.name)) {
+		const baseType = utilityType.typeArgs[0];
+		return baseType !== void 0 && typeNodeHasResolvableSxSurface(baseType, checker, visited);
+	}
+	return (resolveAliasedSymbol(checker.getSymbolAtLocation(typeNode.typeName), checker)?.declarations ?? []).some((declaration) => declarationHasResolvableSxSurface(declaration, checker, visited));
+}
+function collectSxExcludedProperties(typeNode, checker, visited) {
+	return collectSxSurfaceProperties(typeNode, checker, visited, collectStyleXStylesWithoutKeys).properties;
+}
+function collectSxAllowedProperties(typeNode, checker, visited) {
+	const collection = collectSxSurfaceProperties(typeNode, checker, visited, collectStyleXStylesKeys);
+	return collection.found ? collection.properties : void 0;
+}
 function collectExplicitPropNamesInto(names, typeNode, checker, visited) {
 	if (ts.isTypeLiteralNode(typeNode)) {
 		for (const member of typeNode.members) if (ts.isPropertySignature(member)) {
@@ -265,39 +127,6 @@ function collectExplicitPropNamesInto(names, typeNode, checker, visited) {
 	const symbol = resolveAliasedSymbol(checker.getSymbolAtLocation(typeNode.typeName), checker);
 	for (const declaration of symbol?.declarations ?? []) collectExplicitPropNamesFromDeclaration(names, declaration, checker, visited);
 }
-function typeNodeHasResolvableSxSurface(typeNode, checker, visited) {
-	if (ts.isTypeLiteralNode(typeNode)) return typeNode.members.some((member) => ts.isPropertySignature(member) && propertyNameText(member.name) === "sx");
-	if (ts.isIntersectionTypeNode(typeNode)) return typeNode.types.some((part) => typeNodeHasResolvableSxSurface(part, checker, visited));
-	if (ts.isUnionTypeNode(typeNode)) return typeNode.types.every((part) => typeNodeHasResolvableSxSurface(part, checker, visited));
-	if (!ts.isTypeReferenceNode(typeNode) || isIntrinsicReactPropReference(typeNode)) return false;
-	const utilityType = readUtilityTypeReference(typeNode);
-	if (utilityType.name === "Pick") return utilityType.typeArgs.length >= 2 && typeNodeKeyIncludes(utilityType.typeArgs[1], "sx");
-	if (utilityType.name === "Omit") {
-		const baseType = utilityType.typeArgs[0];
-		return baseType !== void 0 && utilityType.typeArgs.length >= 2 && !typeNodeKeyIncludes(utilityType.typeArgs[1], "sx") && typeNodeHasResolvableSxSurface(baseType, checker, visited);
-	}
-	if (isTransparentUtilityTypeName(utilityType.name)) {
-		const baseType = utilityType.typeArgs[0];
-		return baseType !== void 0 && typeNodeHasResolvableSxSurface(baseType, checker, visited);
-	}
-	return (resolveAliasedSymbol(checker.getSymbolAtLocation(typeNode.typeName), checker)?.declarations ?? []).some((declaration) => declarationHasResolvableSxSurface(declaration, checker, visited));
-}
-function readUtilityTypeReference(typeNode) {
-	return {
-		name: typeNode.typeName.getText(),
-		typeArgs: typeNode.typeArguments ?? []
-	};
-}
-function isTransparentUtilityTypeName(typeName) {
-	return typeName === "Partial" || typeName === "Required" || typeName === "Readonly";
-}
-function collectSxExcludedProperties(typeNode, checker, visited) {
-	return collectSxSurfaceProperties(typeNode, checker, visited, collectStyleXStylesWithoutKeys).properties;
-}
-function collectSxAllowedProperties(typeNode, checker, visited) {
-	const collection = collectSxSurfaceProperties(typeNode, checker, visited, collectStyleXStylesKeys);
-	return collection.found ? collection.properties : void 0;
-}
 function collectSxSurfaceProperties(typeNode, checker, visited, collectFromSxType) {
 	const names = /* @__PURE__ */ new Set();
 	const found = collectSxSurfacePropertiesInto(names, typeNode, checker, visited, collectFromSxType);
@@ -507,16 +336,6 @@ function declarationHasResolvableSxSurface(declaration, checker, visited) {
 function declarationHeritageHasResolvableSxSurface(heritageType, checker, visited) {
 	return (resolveAliasedSymbol(checker.getSymbolAtLocation(heritageType.expression), checker)?.declarations ?? []).some((declaration) => declarationHasResolvableSxSurface(declaration, checker, visited));
 }
-function typeNodeKeyIncludes(typeNode, key) {
-	if (!typeNode) return false;
-	if (ts.isLiteralTypeNode(typeNode) && ts.isStringLiteral(typeNode.literal)) return typeNode.literal.text === key;
-	if (ts.isUnionTypeNode(typeNode)) return typeNode.types.some((part) => typeNodeKeyIncludes(part, key));
-	return false;
-}
-function resolveAliasedSymbol(symbol, checker) {
-	if (!symbol || (symbol.flags & ts.SymbolFlags.Alias) === 0) return symbol;
-	return checker.getAliasedSymbol(symbol);
-}
 function collectExplicitPropNamesFromDeclaration(names, declaration, checker, visited) {
 	if (visited.has(declaration)) return;
 	visited.add(declaration);
@@ -536,17 +355,423 @@ function collectExplicitPropNamesFromHeritage(names, heritageType, checker, visi
 	const symbol = resolveAliasedSymbol(checker.getSymbolAtLocation(heritageType.expression), checker);
 	for (const declaration of symbol?.declarations ?? []) collectExplicitPropNamesFromDeclaration(names, declaration, checker, visited);
 }
-function isIntrinsicReactPropReference(typeNode) {
-	const typeName = typeNode.typeName.getText();
-	return /^(?:React\.)?(?:ComponentProps|ComponentPropsWithRef|ComponentPropsWithoutRef|HTMLAttributes|ButtonHTMLAttributes|AnchorHTMLAttributes|InputHTMLAttributes|SVGProps)$/.test(typeName);
+//#endregion
+//#region src/internal/prepass/sx-target-detection.ts
+function readsSxProp(parameter, body) {
+	if (parameter?.name && ts.isObjectBindingPattern(parameter.name)) {
+		if (bindingPatternHasName(parameter.name, "sx")) return true;
+	}
+	if (!body || !parameter?.name || !ts.isIdentifier(parameter.name)) return false;
+	const propsName = parameter.name.text;
+	let found = false;
+	const visit = (node) => {
+		if (found) return;
+		if (isFunctionWithParameterNamed(node, propsName) || isFunctionWithParameterDestructuringName(node, "sx")) return;
+		if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === propsName && node.name.text === "sx") {
+			found = true;
+			return;
+		}
+		if (ts.isVariableDeclaration(node) && ts.isObjectBindingPattern(node.name) && node.initializer && isIdentifierNamed(unwrapExpression(node.initializer), propsName) && bindingPatternHasName(node.name, "sx")) {
+			found = true;
+			return;
+		}
+		ts.forEachChild(node, visit);
+	};
+	ts.forEachChild(body, visit);
+	return found;
+}
+function detectSxTarget(parameter, body) {
+	if (!body) return;
+	const sxNames = collectSxBindingNames(parameter, body);
+	if (sxNames.size === 0) return;
+	const sxPropContainerNames = collectSxPropContainerNames(parameter);
+	const sxPropsNames = collectStylexPropsBindingNames(body, sxNames, sxPropContainerNames);
+	const root = returnedJsxRoot(body);
+	if (!root) return;
+	if (jsxOpeningUsesSx(jsxRootOpening(root), sxNames, sxPropsNames, sxPropContainerNames)) return "root";
+	return jsxChildrenUseSx(root, sxNames, sxPropsNames, sxPropContainerNames) ? "inner" : void 0;
+}
+function collectSxBindingNames(parameter, body) {
+	const names = /* @__PURE__ */ new Set();
+	if (parameter?.name && ts.isObjectBindingPattern(parameter.name)) collectBindingElementLocalNames(parameter.name, "sx", names);
+	else names.add("sx");
+	if (parameter?.name && ts.isIdentifier(parameter.name)) {
+		const propsName = parameter.name.text;
+		const visit = (node) => {
+			if (ts.isVariableDeclaration(node) && ts.isObjectBindingPattern(node.name) && node.initializer && isIdentifierNamed(unwrapExpression(node.initializer), propsName)) collectBindingElementLocalNames(node.name, "sx", names);
+			ts.forEachChild(node, visit);
+		};
+		ts.forEachChild(body, visit);
+	}
+	return names;
+}
+function collectBindingElementLocalNames(pattern, propertyName, names) {
+	for (const element of pattern.elements) if (bindingElementPropertyNameText(element) === propertyName && ts.isIdentifier(element.name)) names.add(element.name.text);
+}
+function collectSxPropContainerNames(parameter) {
+	const names = /* @__PURE__ */ new Set();
+	if (parameter?.name && ts.isIdentifier(parameter.name)) names.add(parameter.name.text);
+	return names;
+}
+function collectStylexPropsBindingNames(body, sxNames, sxPropContainerNames) {
+	const names = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (ts.isVariableDeclaration(node) && node.initializer && isStylexPropsCallWithSx(node.initializer, sxNames, sxPropContainerNames)) {
+			if (ts.isIdentifier(node.name)) names.add(node.name.text);
+			else if (ts.isObjectBindingPattern(node.name)) collectBindingPatternIdentifierNames(node.name, names);
+		}
+		ts.forEachChild(node, visit);
+	};
+	ts.forEachChild(body, visit);
+	return names;
+}
+function collectBindingPatternIdentifierNames(pattern, names) {
+	for (const element of pattern.elements) if (ts.isIdentifier(element.name)) names.add(element.name.text);
+}
+function isStylexPropsCallWithSx(expr, sxNames, sxPropContainerNames) {
+	const unwrapped = unwrapExpression(expr);
+	const noSxPropsNames = /* @__PURE__ */ new Set();
+	return ts.isCallExpression(unwrapped) && isStylexPropsCallee(unwrapped.expression) && unwrapped.arguments.some((arg) => expressionReferencesNames(arg, sxNames, noSxPropsNames, sxPropContainerNames));
+}
+function isStylexPropsCallee(expr) {
+	return ts.isPropertyAccessExpression(expr) && expr.name.text === "props" && ts.isIdentifier(expr.expression) && expr.expression.text === "stylex";
+}
+function returnedJsxRoot(body) {
+	if (ts.isJsxElement(body) || ts.isJsxSelfClosingElement(body)) return body;
+	if (!ts.isBlock(body)) return null;
+	for (const statement of body.statements) {
+		if (!ts.isReturnStatement(statement) || !statement.expression) continue;
+		const expr = unwrapExpression(statement.expression);
+		if (ts.isJsxElement(expr) || ts.isJsxSelfClosingElement(expr)) return expr;
+	}
+	return null;
+}
+function jsxChildrenUseSx(root, sxNames, sxPropsNames, sxPropContainerNames) {
+	if (!ts.isJsxElement(root)) return false;
+	let found = false;
+	const visit = (node) => {
+		if (found) return;
+		if (functionShadowsSxReference(node, sxNames, sxPropContainerNames)) return;
+		if (ts.isJsxElement(node) && jsxOpeningUsesSx(node.openingElement, sxNames, sxPropsNames, sxPropContainerNames) || ts.isJsxSelfClosingElement(node) && jsxOpeningUsesSx(node, sxNames, sxPropsNames, sxPropContainerNames)) {
+			found = true;
+			return;
+		}
+		ts.forEachChild(node, visit);
+	};
+	for (const child of root.children) visit(child);
+	return found;
+}
+function jsxRootOpening(root) {
+	return ts.isJsxElement(root) ? root.openingElement : root;
+}
+function jsxOpeningUsesSx(opening, sxNames, sxPropsNames, sxPropContainerNames) {
+	return opening.attributes.properties.some((attribute) => {
+		if (ts.isJsxSpreadAttribute(attribute)) return expressionReferencesNames(attribute.expression, sxNames, sxPropsNames, sxPropContainerNames);
+		if (!ts.isIdentifier(attribute.name) || !attribute.initializer) return false;
+		if (!ts.isJsxExpression(attribute.initializer) || !attribute.initializer.expression) return false;
+		if (attribute.name.text === "className" || attribute.name.text === "style") return expressionReferencesStylexPropsBinding(attribute.initializer.expression, sxPropsNames);
+		if (attribute.name.text !== "sx") return false;
+		return expressionReferencesNames(attribute.initializer.expression, sxNames, sxPropsNames, sxPropContainerNames);
+	});
+}
+function expressionReferencesStylexPropsBinding(expr, sxPropsNames) {
+	const unwrapped = unwrapExpression(expr);
+	return ts.isIdentifier(unwrapped) && sxPropsNames.has(unwrapped.text);
+}
+function expressionReferencesNames(expr, sxNames, sxPropsNames, sxPropContainerNames) {
+	const unwrapped = unwrapExpression(expr);
+	if (ts.isIdentifier(unwrapped)) return sxNames.has(unwrapped.text) || sxPropsNames.has(unwrapped.text);
+	if (ts.isPropertyAccessExpression(unwrapped) && unwrapped.name.text === "sx" && ts.isIdentifier(unwrapped.expression)) return sxPropContainerNames.has(unwrapped.expression.text);
+	return isStylexPropsCallWithSx(unwrapped, sxNames, sxPropContainerNames);
+}
+function functionShadowsSxReference(node, sxNames, sxPropContainerNames) {
+	if (!isFunctionWithParameters(node)) return false;
+	for (const name of sxPropContainerNames) if (node.parameters.some((parameter) => isBindingNameNamed(parameter.name, name))) return true;
+	for (const name of sxNames) if (node.parameters.some((parameter) => isBindingNameNamed(parameter.name, name))) return true;
+	return node.parameters.some((parameter) => ts.isObjectBindingPattern(parameter.name) && bindingPatternHasName(parameter.name, "sx"));
+}
+function isFunctionWithParameterNamed(node, name) {
+	return isFunctionWithParameters(node) ? node.parameters.some((parameter) => isBindingNameNamed(parameter.name, name)) : false;
+}
+function isFunctionWithParameterDestructuringName(node, name) {
+	return isFunctionWithParameters(node) ? node.parameters.some((parameter) => ts.isObjectBindingPattern(parameter.name) && bindingPatternHasName(parameter.name, name)) : false;
+}
+function isFunctionWithParameters(node) {
+	return ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node);
+}
+function isBindingNameNamed(name, expected) {
+	return ts.isIdentifier(name) && name.text === expected;
+}
+//#endregion
+//#region src/internal/prepass/ts-program-setup.ts
+function createProgram(rootNames, cwd) {
+	const configPath = findTsConfig(rootNames, cwd);
+	const options = configPath ? readCompilerOptions(configPath) : defaultCompilerOptions();
+	return ts.createProgram({
+		rootNames: [...rootNames],
+		options: {
+			...options,
+			allowJs: true,
+			checkJs: false,
+			noEmit: true,
+			skipLibCheck: true,
+			skipDefaultLibCheck: true,
+			types: []
+		}
+	});
+}
+function getExportedNames(sourceFile, checker) {
+	const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+	if (!moduleSymbol) return /* @__PURE__ */ new Set();
+	return new Set(checker.getExportsOfModule(moduleSymbol).map((symbol) => symbol.getName()));
+}
+function getDefaultExportedLocalNames(sourceFile) {
+	const names = /* @__PURE__ */ new Set();
+	for (const statement of sourceFile.statements) {
+		if (!ts.isExportAssignment(statement) || !ts.isIdentifier(statement.expression)) continue;
+		names.add(statement.expression.text);
+	}
+	return names;
+}
+function normalizeFilePaths(files) {
+	return [...new Set(files.map(resolveExistingFilePath))].sort();
+}
+function normalizeFilePath(filePath) {
+	return resolveExistingFilePath(filePath);
+}
+function isTypeScriptLikeFile(filePath) {
+	return /\.(tsx?|jsx?)$/.test(filePath);
+}
+function readCompilerOptions(configPath) {
+	const config = ts.readConfigFile(configPath, (filePath) => ts.sys.readFile(filePath));
+	if (config.error) return defaultCompilerOptions();
+	return ts.parseJsonConfigFileContent(config.config, ts.sys, path.dirname(configPath)).options;
+}
+function defaultCompilerOptions() {
+	return {
+		target: ts.ScriptTarget.ES2022,
+		module: ts.ModuleKind.ESNext,
+		moduleResolution: ts.ModuleResolutionKind.Node10,
+		jsx: ts.JsxEmit.ReactJSX,
+		esModuleInterop: true,
+		skipLibCheck: true
+	};
+}
+function findTsConfig(rootNames, cwd) {
+	const start = rootNames.length > 0 ? path.dirname(rootNames[0]) : cwd;
+	return ts.findConfigFile(start, (filePath) => ts.sys.fileExists(filePath), "tsconfig.json") ?? void 0;
+}
+//#endregion
+//#region src/internal/prepass/typescript-analysis.ts
+function analyzeTypeScriptProgram(options) {
+	const rootNames = normalizeFilePaths(options.files).filter(isTypeScriptLikeFile);
+	if (rootNames.length === 0) return {
+		version: 1,
+		files: []
+	};
+	const program = createProgram(rootNames, options.cwd ?? process.cwd());
+	const checker = program.getTypeChecker();
+	const rootNameSet = new Set(rootNames.map((filePath) => path.resolve(filePath)));
+	const compilerOptions = program.getCompilerOptions();
+	strictNullChecksOnForCurrentRun = Boolean(compilerOptions.strictNullChecks ?? compilerOptions.strict);
+	return {
+		version: 1,
+		files: program.getSourceFiles().filter((sourceFile) => rootNameSet.has(path.resolve(sourceFile.fileName))).map((sourceFile) => analyzeSourceFile(sourceFile, checker)).filter((file) => file.components.length > 0 || file.functions.length > 0).sort((a, b) => a.filePath.localeCompare(b.filePath))
+	};
+}
+function analyzeSourceFile(sourceFile, checker) {
+	const exportedNames = getExportedNames(sourceFile, checker);
+	const defaultExportedLocalNames = getDefaultExportedLocalNames(sourceFile);
+	const localFunctionInitializers = collectLocalFunctionInitializers(sourceFile);
+	const components = [];
+	const functions = [];
+	const visit = (node) => {
+		if (ts.isFunctionDeclaration(node) && (node.name || isDefaultExport(node))) {
+			const fn = readFunctionDeclaration(node, checker, exportedNames);
+			functions.push(fn);
+			if (isReactComponentFunction(node, checker)) components.push(readReactComponentFromFunction(node, checker, exportedNames, defaultExportedLocalNames));
+			return;
+		}
+		if (ts.isVariableStatement(node)) {
+			for (const declaration of node.declarationList.declarations) {
+				if (!ts.isIdentifier(declaration.name)) continue;
+				if (declaration.initializer && isStyledComponentInitializer(declaration.initializer)) {
+					components.push(readStyledComponent(declaration, node, checker, exportedNames));
+					continue;
+				}
+				const componentInitializer = declaration.initializer ? getComponentFunctionInitializerInfo(declaration.initializer, localFunctionInitializers) : void 0;
+				if (componentInitializer) {
+					functions.push(readVariableFunction(declaration.name.text, componentInitializer.fn, node, checker));
+					if (isReactComponentName(declaration.name.text) || returnsJsx(componentInitializer.fn)) components.push(readReactComponentFromVariable(declaration.name.text, componentInitializer.fn, componentInitializer.propTypeNode, node, checker, exportedNames, defaultExportedLocalNames));
+				}
+			}
+			return;
+		}
+		ts.forEachChild(node, visit);
+	};
+	ts.forEachChild(sourceFile, visit);
+	return {
+		filePath: normalizeFilePath(sourceFile.fileName),
+		components: components.sort(byName),
+		functions: functions.sort(byName)
+	};
+}
+function readFunctionDeclaration(node, checker, exportedNames) {
+	const name = node.name?.text ?? "default";
+	return {
+		name,
+		exported: exportedNames.has(name),
+		defaultExport: isDefaultExport(node),
+		typeParameters: readTypeParameters(node.typeParameters),
+		parameters: readParameters(node.parameters, checker)
+	};
+}
+function readVariableFunction(name, node, statement, checker) {
+	return {
+		name,
+		exported: isExported(statement),
+		defaultExport: false,
+		typeParameters: readTypeParameters(node.typeParameters),
+		parameters: readParameters(node.parameters, checker)
+	};
+}
+function readStyledComponent(declaration, statement, checker, exportedNames) {
+	const name = declaration.name.getText();
+	const typeNode = declaration.initializer ? findStyledPropsTypeNode(declaration.initializer) : void 0;
+	return buildComponentMetadata({
+		name,
+		kind: "styled",
+		exported: exportedNames.has(name) || isExported(statement),
+		defaultExport: false,
+		typeParameters: [],
+		propTypeNode: typeNode,
+		parameters: [],
+		restProps: [],
+		checker,
+		location: declaration
+	});
+}
+function readReactComponentFromFunction(node, checker, exportedNames, defaultExportedLocalNames) {
+	const name = node.name?.text ?? "default";
+	return buildComponentMetadata({
+		name,
+		kind: "react",
+		exported: exportedNames.has(name),
+		defaultExport: isDefaultExport(node) || defaultExportedLocalNames.has(name),
+		typeParameters: readTypeParameters(node.typeParameters),
+		propTypeNode: node.parameters[0]?.type,
+		parameters: readParameters(node.parameters, checker),
+		restProps: readRestProps(node.parameters[0], node.body),
+		bodySupportsSxProp: readsSxProp(node.parameters[0], node.body),
+		bodySxTarget: detectSxTarget(node.parameters[0], node.body),
+		checker,
+		location: node
+	});
+}
+function readReactComponentFromVariable(name, node, propTypeNode, statement, checker, exportedNames, defaultExportedLocalNames) {
+	return buildComponentMetadata({
+		name,
+		kind: "react",
+		exported: exportedNames.has(name) || isExported(statement),
+		defaultExport: defaultExportedLocalNames.has(name),
+		typeParameters: readTypeParameters(node.typeParameters),
+		propTypeNode: propTypeNode ?? node.parameters[0]?.type,
+		parameters: readParameters(node.parameters, checker),
+		restProps: readRestProps(node.parameters[0], node.body),
+		bodySupportsSxProp: readsSxProp(node.parameters[0], node.body),
+		bodySxTarget: detectSxTarget(node.parameters[0], node.body),
+		checker,
+		location: node
+	});
+}
+function buildComponentMetadata(args) {
+	const propType = args.propTypeNode ? args.checker.getTypeFromTypeNode(args.propTypeNode) : null;
+	const props = propType ? readPropsFromType(propType, args.checker, args.location) : [];
+	const explicitPropNames = args.propTypeNode ? collectExplicitPropNames(args.propTypeNode, args.checker) : [];
+	const supportsResolvedSxProp = props.some((prop) => prop.name === "sx") && args.propTypeNode !== void 0 && typeNodeHasResolvableSxSurface(args.propTypeNode, args.checker, /* @__PURE__ */ new Set());
+	const sxExcludedProperties = args.propTypeNode !== void 0 ? collectSxExcludedProperties(args.propTypeNode, args.checker, /* @__PURE__ */ new Set()) : [];
+	const sxAllowedProperties = args.propTypeNode !== void 0 ? collectSxAllowedProperties(args.propTypeNode, args.checker, /* @__PURE__ */ new Set()) : void 0;
+	return {
+		name: args.name,
+		kind: args.kind,
+		exported: args.exported,
+		defaultExport: args.defaultExport,
+		typeParameters: args.typeParameters,
+		propType: args.propTypeNode ? describeTypeNode(args.propTypeNode, args.checker) : null,
+		props,
+		explicitPropNames,
+		parameters: args.parameters,
+		restProps: args.restProps,
+		hasIndexSignature: propType ? hasIndexSignature(propType, args.checker) : false,
+		supportsSxProp: explicitPropNames.includes("sx") || supportsResolvedSxProp || args.bodySupportsSxProp === true,
+		...args.bodySxTarget ? { sxTarget: args.bodySxTarget } : {},
+		sxExcludedProperties,
+		...sxAllowedProperties !== void 0 ? { sxAllowedProperties } : {}
+	};
+}
+function readPropsFromType(type, checker, location) {
+	return checker.getPropertiesOfType(type).map((symbol) => {
+		const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0] ?? location;
+		const optional = (symbol.flags & ts.SymbolFlags.Optional) !== 0;
+		return {
+			name: symbol.getName(),
+			optional,
+			readonly: isReadonlyProperty(symbol),
+			type: withOptionalUndefined(readPropTypeString(symbol, declaration, checker, location), optional)
+		};
+	}).sort(byName);
+}
+/**
+* TS's resolved type for an optional property includes `| undefined` (because
+* the `?` modifier widens it). Syntactic type nodes don't — `?: number` has
+* `type === number`, not `number | undefined`. Downstream consumers
+* (lower-rules/types.ts) rely on the `| undefined` suffix to gate certain
+* emit decisions (e.g. wrapping a possibly-undefined value in a template
+* string). Reconstruct it here so the syntactic fast path stays
+* behaviorally equivalent to the typeToString path it replaced.
+*/
+function withOptionalUndefined(typeText, optional) {
+	if (!optional || !strictNullChecksOnForCurrentRun) return typeText;
+	if (/\bundefined\b/.test(typeText)) return typeText;
+	return `${typeText} | undefined`;
+}
+/**
+* Per-run capture of strictNullChecks. Set by `analyzeTypeScriptProgram` before
+* any per-file work runs; read by `withOptionalUndefined` to decide whether to
+* append `| undefined` to optional props. Module-scoped to avoid threading the
+* boolean through ~6 helper signatures for a single read site.
+*/
+let strictNullChecksOnForCurrentRun = false;
+/**
+* Returns the prop's TS type as a string. Prefers the syntactic type annotation
+* from the declaration AST (cheap, no checker call) and only falls back to
+* `checker.typeToString` when the declaration has no usable type node — typically
+* synthesized properties (mapped/intersection/spread-derived) where the checker
+* is the only source of truth.
+*
+* Why: typeToString with NoTruncation dominated the prepass at 39s / 723K calls.
+* For the consumers downstream (lower-rules/types.ts parseTypeText), the
+* syntactic representation is what they want anyway — they only handle
+* TSTypeReference / TSUnionType / TSLiteralType shapes.
+*/
+function readPropTypeString(symbol, declaration, _checker, _location) {
+	const typeNode = getDeclarationTypeNode(declaration);
+	if (typeNode) return typeNode.getText();
+	return "";
+}
+function getDeclarationTypeNode(declaration) {
+	if (ts.isPropertySignature(declaration) || ts.isPropertyDeclaration(declaration) || ts.isParameter(declaration)) return declaration.type;
 }
-function isIntrinsicReactHeritageReference(heritageType) {
-	const typeName = heritageType.expression.getText();
-	return /^(?:React\.)?(?:ComponentProps|ComponentPropsWithRef|ComponentPropsWithoutRef|HTMLAttributes|ButtonHTMLAttributes|AnchorHTMLAttributes|InputHTMLAttributes|SVGProps)$/.test(typeName);
+function readParameters(parameters, checker) {
+	return parameters.map((parameter) => ({
+		name: readParameterName(parameter.name),
+		optional: Boolean(parameter.questionToken || parameter.initializer),
+		rest: Boolean(parameter.dotDotDotToken),
+		type: parameter.type ? parameter.type.getText() : checker.typeToString(checker.getTypeAtLocation(parameter), parameter)
+	}));
 }
-function propertyNameText(name) {
-	if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
-	return null;
+function hasIndexSignature(type, checker) {
+	return checker.getIndexTypeOfType(type, ts.IndexKind.String) !== void 0 || checker.getIndexTypeOfType(type, ts.IndexKind.Number) !== void 0;
 }
 function readRestProps(parameter, body) {
 	const restProps = [];
@@ -571,166 +796,6 @@ function readRestProps(parameter, body) {
 	ts.forEachChild(body, visit);
 	return restProps.sort(byName);
 }
-function readsSxProp(parameter, body) {
-	if (parameter?.name && ts.isObjectBindingPattern(parameter.name)) {
-		if (bindingPatternHasName(parameter.name, "sx")) return true;
-	}
-	if (!body || !parameter?.name || !ts.isIdentifier(parameter.name)) return false;
-	const propsName = parameter.name.text;
-	let found = false;
-	const visit = (node) => {
-		if (found) return;
-		if (isFunctionWithParameterNamed(node, propsName) || isFunctionWithParameterDestructuringName(node, "sx")) return;
-		if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === propsName && node.name.text === "sx") {
-			found = true;
-			return;
-		}
-		if (ts.isVariableDeclaration(node) && ts.isObjectBindingPattern(node.name) && node.initializer && isIdentifierNamed(unwrapExpression(node.initializer), propsName) && bindingPatternHasName(node.name, "sx")) {
-			found = true;
-			return;
-		}
-		ts.forEachChild(node, visit);
-	};
-	ts.forEachChild(body, visit);
-	return found;
-}
-function detectSxTarget(parameter, body) {
-	if (!body) return;
-	const sxNames = collectSxBindingNames(parameter, body);
-	if (sxNames.size === 0) return;
-	const sxPropContainerNames = collectSxPropContainerNames(parameter);
-	const sxPropsNames = collectStylexPropsBindingNames(body, sxNames, sxPropContainerNames);
-	const root = returnedJsxRoot(body);
-	if (!root) return;
-	if (jsxOpeningUsesSx(jsxRootOpening(root), sxNames, sxPropsNames, sxPropContainerNames)) return "root";
-	return jsxChildrenUseSx(root, sxNames, sxPropsNames, sxPropContainerNames) ? "inner" : void 0;
-}
-function collectSxBindingNames(parameter, body) {
-	const names = /* @__PURE__ */ new Set();
-	if (parameter?.name && ts.isObjectBindingPattern(parameter.name)) collectBindingElementLocalNames(parameter.name, "sx", names);
-	else names.add("sx");
-	if (parameter?.name && ts.isIdentifier(parameter.name)) {
-		const propsName = parameter.name.text;
-		const visit = (node) => {
-			if (ts.isVariableDeclaration(node) && ts.isObjectBindingPattern(node.name) && node.initializer && isIdentifierNamed(unwrapExpression(node.initializer), propsName)) collectBindingElementLocalNames(node.name, "sx", names);
-			ts.forEachChild(node, visit);
-		};
-		ts.forEachChild(body, visit);
-	}
-	return names;
-}
-function collectBindingElementLocalNames(pattern, propertyName, names) {
-	for (const element of pattern.elements) if (bindingElementPropertyNameText(element) === propertyName && ts.isIdentifier(element.name)) names.add(element.name.text);
-}
-function collectSxPropContainerNames(parameter) {
-	const names = /* @__PURE__ */ new Set();
-	if (parameter?.name && ts.isIdentifier(parameter.name)) names.add(parameter.name.text);
-	return names;
-}
-function bindingElementPropertyNameText(element) {
-	if (element.propertyName) return ts.isIdentifier(element.propertyName) || ts.isStringLiteral(element.propertyName) ? element.propertyName.text : null;
-	return ts.isIdentifier(element.name) ? element.name.text : null;
-}
-function collectStylexPropsBindingNames(body, sxNames, sxPropContainerNames) {
-	const names = /* @__PURE__ */ new Set();
-	const visit = (node) => {
-		if (ts.isVariableDeclaration(node) && node.initializer && isStylexPropsCallWithSx(node.initializer, sxNames, sxPropContainerNames)) {
-			if (ts.isIdentifier(node.name)) names.add(node.name.text);
-			else if (ts.isObjectBindingPattern(node.name)) collectBindingPatternIdentifierNames(node.name, names);
-		}
-		ts.forEachChild(node, visit);
-	};
-	ts.forEachChild(body, visit);
-	return names;
-}
-function collectBindingPatternIdentifierNames(pattern, names) {
-	for (const element of pattern.elements) if (ts.isIdentifier(element.name)) names.add(element.name.text);
-}
-function isStylexPropsCallWithSx(expr, sxNames, sxPropContainerNames) {
-	const unwrapped = unwrapExpression(expr);
-	const noSxPropsNames = /* @__PURE__ */ new Set();
-	return ts.isCallExpression(unwrapped) && isStylexPropsCallee(unwrapped.expression) && unwrapped.arguments.some((arg) => expressionReferencesNames(arg, sxNames, noSxPropsNames, sxPropContainerNames));
-}
-function isStylexPropsCallee(expr) {
-	return ts.isPropertyAccessExpression(expr) && expr.name.text === "props" && ts.isIdentifier(expr.expression) && expr.expression.text === "stylex";
-}
-function returnedJsxRoot(body) {
-	if (ts.isJsxElement(body) || ts.isJsxSelfClosingElement(body)) return body;
-	if (!ts.isBlock(body)) return null;
-	for (const statement of body.statements) {
-		if (!ts.isReturnStatement(statement) || !statement.expression) continue;
-		const expr = unwrapExpression(statement.expression);
-		if (ts.isJsxElement(expr) || ts.isJsxSelfClosingElement(expr)) return expr;
-	}
-	return null;
-}
-function jsxChildrenUseSx(root, sxNames, sxPropsNames, sxPropContainerNames) {
-	if (!ts.isJsxElement(root)) return false;
-	let found = false;
-	const visit = (node) => {
-		if (found) return;
-		if (functionShadowsSxReference(node, sxNames, sxPropContainerNames)) return;
-		if (ts.isJsxElement(node) && jsxOpeningUsesSx(node.openingElement, sxNames, sxPropsNames, sxPropContainerNames) || ts.isJsxSelfClosingElement(node) && jsxOpeningUsesSx(node, sxNames, sxPropsNames, sxPropContainerNames)) {
-			found = true;
-			return;
-		}
-		ts.forEachChild(node, visit);
-	};
-	for (const child of root.children) visit(child);
-	return found;
-}
-function jsxRootOpening(root) {
-	return ts.isJsxElement(root) ? root.openingElement : root;
-}
-function jsxOpeningUsesSx(opening, sxNames, sxPropsNames, sxPropContainerNames) {
-	return opening.attributes.properties.some((attribute) => {
-		if (ts.isJsxSpreadAttribute(attribute)) return expressionReferencesNames(attribute.expression, sxNames, sxPropsNames, sxPropContainerNames);
-		if (!ts.isIdentifier(attribute.name) || !attribute.initializer) return false;
-		if (!ts.isJsxExpression(attribute.initializer) || !attribute.initializer.expression) return false;
-		if (attribute.name.text === "className" || attribute.name.text === "style") return expressionReferencesStylexPropsBinding(attribute.initializer.expression, sxPropsNames);
-		if (attribute.name.text !== "sx") return false;
-		return expressionReferencesNames(attribute.initializer.expression, sxNames, sxPropsNames, sxPropContainerNames);
-	});
-}
-function expressionReferencesStylexPropsBinding(expr, sxPropsNames) {
-	const unwrapped = unwrapExpression(expr);
-	return ts.isIdentifier(unwrapped) && sxPropsNames.has(unwrapped.text);
-}
-function expressionReferencesNames(expr, sxNames, sxPropsNames, sxPropContainerNames) {
-	const unwrapped = unwrapExpression(expr);
-	if (ts.isIdentifier(unwrapped)) return sxNames.has(unwrapped.text) || sxPropsNames.has(unwrapped.text);
-	if (ts.isPropertyAccessExpression(unwrapped) && unwrapped.name.text === "sx" && ts.isIdentifier(unwrapped.expression)) return sxPropContainerNames.has(unwrapped.expression.text);
-	return isStylexPropsCallWithSx(unwrapped, sxNames, sxPropContainerNames);
-}
-function functionShadowsSxReference(node, sxNames, sxPropContainerNames) {
-	if (!isFunctionWithParameters(node)) return false;
-	for (const name of sxPropContainerNames) if (node.parameters.some((parameter) => isBindingNameNamed(parameter.name, name))) return true;
-	for (const name of sxNames) if (node.parameters.some((parameter) => isBindingNameNamed(parameter.name, name))) return true;
-	return node.parameters.some((parameter) => ts.isObjectBindingPattern(parameter.name) && bindingPatternHasName(parameter.name, "sx"));
-}
-function isFunctionWithParameterNamed(node, name) {
-	return isFunctionWithParameters(node) ? node.parameters.some((parameter) => isBindingNameNamed(parameter.name, name)) : false;
-}
-function isFunctionWithParameterDestructuringName(node, name) {
-	return isFunctionWithParameters(node) ? node.parameters.some((parameter) => ts.isObjectBindingPattern(parameter.name) && bindingPatternHasName(parameter.name, name)) : false;
-}
-function isFunctionWithParameters(node) {
-	return ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node);
-}
-function isBindingNameNamed(name, expected) {
-	return ts.isIdentifier(name) && name.text === expected;
-}
-function bindingPatternHasName(pattern, name) {
-	return pattern.elements.some((element) => element.name.getText() === name);
-}
-function unwrapExpression(expression) {
-	let current = expression;
-	while (ts.isAsExpression(current) || ts.isTypeAssertionExpression(current) || ts.isSatisfiesExpression(current) || ts.isParenthesizedExpression(current)) current = current.expression;
-	return current;
-}
-function isIdentifierNamed(expression, name) {
-	return ts.isIdentifier(expression) && expression.text === name;
-}
 function describeTypeNode(typeNode, checker) {
 	const declaration = resolveTypeDeclaration(typeNode, checker);
 	return {
@@ -871,19 +936,6 @@ function readParameterName(name) {
 function isReadonlyProperty(symbol) {
 	return Boolean(symbol.declarations?.some((declaration) => (ts.isPropertySignature(declaration) || ts.isPropertyDeclaration(declaration)) && declaration.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ReadonlyKeyword)));
 }
-function getExportedNames(sourceFile, checker) {
-	const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
-	if (!moduleSymbol) return /* @__PURE__ */ new Set();
-	return new Set(checker.getExportsOfModule(moduleSymbol).map((symbol) => symbol.getName()));
-}
-function getDefaultExportedLocalNames(sourceFile) {
-	const names = /* @__PURE__ */ new Set();
-	for (const statement of sourceFile.statements) {
-		if (!ts.isExportAssignment(statement) || !ts.isIdentifier(statement.expression)) continue;
-		names.add(statement.expression.text);
-	}
-	return names;
-}
 function isExported(node) {
 	return Boolean(ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword));
 }
@@ -893,50 +945,6 @@ function isDefaultExport(node) {
 function isReactComponentName(name) {
 	return /^[A-Z]/.test(name);
 }
-function createProgram(rootNames, cwd) {
-	const configPath = findTsConfig(rootNames, cwd);
-	const options = configPath ? readCompilerOptions(configPath) : defaultCompilerOptions();
-	return ts.createProgram({
-		rootNames: [...rootNames],
-		options: {
-			...options,
-			allowJs: true,
-			checkJs: false,
-			noEmit: true,
-			skipLibCheck: true,
-			skipDefaultLibCheck: true,
-			types: []
-		}
-	});
-}
-function readCompilerOptions(configPath) {
-	const config = ts.readConfigFile(configPath, (filePath) => ts.sys.readFile(filePath));
-	if (config.error) return defaultCompilerOptions();
-	return ts.parseJsonConfigFileContent(config.config, ts.sys, path.dirname(configPath)).options;
-}
-function defaultCompilerOptions() {
-	return {
-		target: ts.ScriptTarget.ES2022,
-		module: ts.ModuleKind.ESNext,
-		moduleResolution: ts.ModuleResolutionKind.Node10,
-		jsx: ts.JsxEmit.ReactJSX,
-		esModuleInterop: true,
-		skipLibCheck: true
-	};
-}
-function findTsConfig(rootNames, cwd) {
-	const start = rootNames.length > 0 ? path.dirname(rootNames[0]) : cwd;
-	return ts.findConfigFile(start, (filePath) => ts.sys.fileExists(filePath), "tsconfig.json") ?? void 0;
-}
-function normalizeFilePaths(files) {
-	return [...new Set(files.map(resolveExistingFilePath))].sort();
-}
-function normalizeFilePath(filePath) {
-	return resolveExistingFilePath(filePath);
-}
-function isTypeScriptLikeFile(filePath) {
-	return /\.(tsx?|jsx?)$/.test(filePath);
-}
 function byName(a, b) {
 	return a.name.localeCompare(b.name);
 }