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

package/dist/sx-surface-Cth8EesU.mjs

@@ -0,0 +1,1280 @@
+import { r as toRealPath } from "./path-utils-BC4U8X_q.mjs";
+import { existsSync, readFileSync } from "node:fs";
+//#region src/internal/public-api-validation.ts
+function describeValue(value) {
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	if (Array.isArray(value)) return `Array(${value.length})`;
+	if (typeof value === "string") return `"${value}"`;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (typeof value === "bigint") return value.toString();
+	if (typeof value === "symbol") return value.description ? `Symbol(${value.description})` : "Symbol()";
+	if (typeof value === "function") return "[Function]";
+	if (typeof value === "object") {
+		const ctor = value?.constructor?.name ?? "Object";
+		let keys = [];
+		try {
+			keys = Object.keys(value);
+		} catch {}
+		const preview = keys.slice(0, 5).join(", ");
+		const suffix = keys.length > 5 ? ", ..." : "";
+		return keys.length ? `${ctor} { ${preview}${suffix} }` : ctor;
+	}
+	return "[Unknown]";
+}
+/** Validates that the candidate is a fully-resolved `Adapter` (externalInterface must be a function). */
+function assertValidAdapter(candidate, where) {
+	assertAdapterShape(candidate, where, false);
+}
+/** Validates that the candidate is a valid `AdapterInput` (externalInterface may be `"auto"` or a function). */
+function assertValidAdapterInput(candidate, where) {
+	assertAdapterShape(candidate, where, true);
+}
+function assertAdapterShape(candidate, where, allowAutoExtIf) {
+	const obj = candidate;
+	const resolveValue = obj?.resolveValue;
+	const resolveCall = obj?.resolveCall;
+	const resolveSelector = obj?.resolveSelector;
+	const resolveBaseComponent = obj?.resolveBaseComponent;
+	const externalInterface = obj?.externalInterface;
+	const usePhysicalProperties = obj?.usePhysicalProperties;
+	if (!candidate || typeof candidate !== "object") throw new Error([
+		`${where}: expected an adapter object.`,
+		`Received: ${describeValue(candidate)}`,
+		"",
+		"Adapter requirements:",
+		"  - adapter.resolveValue(context) is required",
+		"  - adapter.resolveCall(context) is required",
+		"  - adapter.resolveSelector(context) is required",
+		"  - adapter.externalInterface(context) is required",
+		"",
+		"resolveValue(context) is called with one of these shapes:",
+		"  - { kind: \"theme\", path }",
+		"  - { kind: \"cssVariable\", name, fallback?, definedValue? }",
+		"  - { kind: \"importedValue\", importedName, source, path? }",
+		"",
+		"resolveCall(context) is called with:",
+		"  - { callSiteFilePath, calleeImportedName, calleeSource, args }",
+		"",
+		"resolveSelector(context) is called with:",
+		"  - { kind: \"selectorInterpolation\", importedName, source, path? }",
+		"  - { kind: \"mediaQueryInterpolation\", importedName, source, path?, mediaQuery }",
+		"",
+		`Docs/examples: ${ADAPTER_DOCS_URL}`
+	].join("\n"));
+	if (typeof resolveValue !== "function") throw new Error([
+		`${where}: adapter.resolveValue must be a function.`,
+		`Received: resolveValue=${describeValue(resolveValue)}`,
+		"",
+		"Adapter shape:",
+		"  {",
+		"    resolveValue(context) {",
+		"      // theme/cssVariable -> { expr, imports, dropDefinition? } | null",
+		"    }",
+		"    resolveCall(context) { return { expr, imports } | null }",
+		"  }",
+		"",
+		`Docs/examples: ${ADAPTER_DOCS_URL}`
+	].join("\n"));
+	if (typeof resolveCall !== "function") throw new Error([
+		`${where}: adapter.resolveCall must be a function.`,
+		`Received: resolveCall=${describeValue(resolveCall)}`,
+		"",
+		"Adapter shape:",
+		"  {",
+		"    resolveCall(context) { return { expr: string, imports: ImportSpec[] } | null }",
+		"  }",
+		"",
+		`Docs/examples: ${ADAPTER_DOCS_URL}`
+	].join("\n"));
+	if (typeof resolveSelector !== "function") throw new Error([
+		`${where}: adapter.resolveSelector must be a function.`,
+		`Received: resolveSelector=${describeValue(resolveSelector)}`,
+		"",
+		"Adapter shape:",
+		"  {",
+		"    resolveSelector(context) { return { kind: \"media\" | \"pseudoAlias\" | \"pseudoExpand\", ... } | undefined }",
+		"  }",
+		"",
+		`Docs/examples: ${ADAPTER_DOCS_URL}`
+	].join("\n"));
+	if (resolveBaseComponent !== void 0 && typeof resolveBaseComponent !== "function") throw new Error([
+		`${where}: adapter.resolveBaseComponent must be a function when provided.`,
+		`Received: resolveBaseComponent=${describeValue(resolveBaseComponent)}`,
+		"",
+		"Adapter shape:",
+		"  {",
+		"    resolveBaseComponent(context) {",
+		"      return { tagName, consumedProps, sx?, mixins? } | undefined",
+		"    }",
+		"  }",
+		"",
+		`Docs/examples: ${ADAPTER_DOCS_URL}`
+	].join("\n"));
+	if (!(typeof externalInterface === "function" || allowAutoExtIf && externalInterface === "auto")) throw new Error([`${where}: ${allowAutoExtIf ? "adapter.externalInterface must be a function or \"auto\"." : "adapter.externalInterface must be a function."}`, `Received: externalInterface=${describeValue(externalInterface)}`].join("\n"));
+	if (typeof usePhysicalProperties !== "boolean") throw new Error([
+		`${where}: adapter.usePhysicalProperties must be explicitly set to true or false.`,
+		`Received: usePhysicalProperties=${describeValue(usePhysicalProperties)}`,
+		"",
+		"Set `usePhysicalProperties: true` to emit physical padding/margin longhands,",
+		"or `usePhysicalProperties: false` to emit logical block/inline properties."
+	].join("\n"));
+	const styleMerger = obj?.styleMerger;
+	if (styleMerger !== null && styleMerger !== void 0) {
+		if (typeof styleMerger !== "object") throw new Error([
+			`${where}: adapter.styleMerger must be null or an object.`,
+			`Received: styleMerger=${describeValue(styleMerger)}`,
+			"",
+			"Expected shape:",
+			"  {",
+			"    functionName: \"stylexProps\",",
+			"    importSource: { kind: \"specifier\", value: \"@company/ui-utils\" }",
+			"  }"
+		].join("\n"));
+		const { functionName, importSource } = styleMerger;
+		assertFunctionNameAndImportSource({
+			where,
+			configPath: "adapter.styleMerger",
+			functionName,
+			importSource,
+			specifierExample: "@company/ui-utils",
+			absolutePathExample: "/path/to/module.ts"
+		});
+	}
+	const markerFile = obj?.markerFile;
+	if (markerFile !== void 0 && markerFile !== null && typeof markerFile !== "function") throw new Error([
+		`${where}: adapter.markerFile must be a function when provided.`,
+		`Received: markerFile=${describeValue(markerFile)}`,
+		"",
+		"Expected signature:",
+		"  markerFile(ctx: { filePath: string }) => { kind: \"specifier\" | \"absolutePath\", value: string }"
+	].join("\n"));
+	const wrappedComponentInterface = obj?.wrappedComponentInterface;
+	if (wrappedComponentInterface !== void 0 && wrappedComponentInterface !== null && typeof wrappedComponentInterface !== "function") throw new Error([
+		`${where}: adapter.wrappedComponentInterface must be a function when provided.`,
+		`Received: wrappedComponentInterface=${describeValue(wrappedComponentInterface)}`,
+		"",
+		"Expected signature:",
+		"  wrappedComponentInterface(ctx: { localName: string; importSource: string; importedName: string; filePath: string })",
+		"    => { acceptsSx: boolean; sxAllowedProperties?: string[]; sxExcludedProperties?: string[] } | undefined"
+	].join("\n"));
+	const themeHook = obj?.themeHook;
+	if (themeHook !== null && themeHook !== void 0) {
+		if (typeof themeHook !== "object") throw new Error([
+			`${where}: adapter.themeHook must be an object when provided.`,
+			`Received: themeHook=${describeValue(themeHook)}`,
+			"",
+			"Expected shape:",
+			"  {",
+			"    functionName: \"useTheme\",",
+			"    importSource: { kind: \"specifier\", value: \"@company/theme-hooks\" }",
+			"  }"
+		].join("\n"));
+		const { functionName, importSource } = themeHook;
+		assertFunctionNameAndImportSource({
+			where,
+			configPath: "adapter.themeHook",
+			functionName,
+			importSource,
+			specifierExample: "@company/theme-hooks",
+			absolutePathExample: "/path/to/theme-hooks.ts"
+		});
+	}
+}
+function assertFunctionNameAndImportSource(args) {
+	const { where, configPath, functionName, importSource, specifierExample, absolutePathExample } = args;
+	if (typeof functionName !== "string" || !functionName.trim()) throw new Error([`${where}: ${configPath}.functionName must be a non-empty string.`, `Received: functionName=${describeValue(functionName)}`].join("\n"));
+	if (!importSource || typeof importSource !== "object") throw new Error([
+		`${where}: ${configPath}.importSource must be an object.`,
+		`Received: importSource=${describeValue(importSource)}`,
+		"",
+		"Expected shape:",
+		`  { kind: "specifier", value: "${specifierExample}" }`,
+		"  or",
+		`  { kind: "absolutePath", value: "${absolutePathExample}" }`
+	].join("\n"));
+	const { kind, value } = importSource;
+	if (kind !== "specifier" && kind !== "absolutePath") throw new Error([`${where}: ${configPath}.importSource.kind must be "specifier" or "absolutePath".`, `Received: kind=${describeValue(kind)}`].join("\n"));
+	if (typeof value !== "string" || !value.trim()) throw new Error([`${where}: ${configPath}.importSource.value must be a non-empty string.`, `Received: value=${describeValue(value)}`].join("\n"));
+}
+const ADAPTER_DOCS_URL = `https://github.com/skovhus/styled-components-to-stylex-codemod#adapter`;
+//#endregion
+//#region src/adapter.ts
+/**
+* Adapter entry point for customizing the codemod.
+* Core concepts: value resolution hooks and adapter validation.
+*/
+/**
+* Type guard: checks whether a resolve result is a directional expansion.
+*/
+function isDirectionalResult(r) {
+	return "directional" in r;
+}
+const DEFAULT_THEME_HOOK = {
+	functionName: "useTheme",
+	importSource: {
+		kind: "specifier",
+		value: "styled-components"
+	}
+};
+/**
+* Helper for nicer user authoring + type inference.
+*
+* `defineAdapter(...)` also performs runtime validation (helpful for JS consumers)
+* and will throw a descriptive error message if the adapter shape is invalid.
+*
+* Usage:
+*   export default defineAdapter({
+*     resolveValue(ctx) {
+*       if (ctx.kind === "theme") {
+*         // For shorthand properties with multi-value tokens, return directional entries
+*         if (ctx.cssProperty === "padding" && ctx.path === "input.padding") {
+*           return {
+*             directional: [
+*               { prop: "paddingBlock", expr: "$input.paddingBlock", imports: [{ from: { kind: "specifier", value: "./tokens" }, names: [{ imported: "$input" }] }] },
+*               { prop: "paddingInline", expr: "$input.paddingInline", imports: [{ from: { kind: "specifier", value: "./tokens" }, names: [{ imported: "$input" }] }] },
+*             ],
+*           };
+*         }
+*         return {
+*           expr: `tokens.${ctx.path}`,
+*           imports: [
+*             { from: { kind: "specifier", value: "./tokens" }, names: [{ imported: "tokens" }] },
+*           ],
+*         };
+*       }
+*       // Return undefined to bail/skip the file
+*     },
+*
+*     resolveCall(ctx) {
+*       // Resolve helper calls inside template interpolations.
+*       // Use ctx.cssProperty to determine context:
+*       // - If ctx.cssProperty exists → return a CSS value expression
+*       // - If ctx.cssProperty is undefined → return a StyleX style object reference
+*       // Return { expr, imports } or undefined to bail/skip the file
+*       void ctx;
+*     },
+*
+*     resolveSelector(ctx) {
+*       // Resolve imported values used in selector position.
+*       // Return one of:
+*       // - { kind: "media", expr, imports } for media queries (e.g., breakpoints.phone)
+*       // - { kind: "pseudoAlias", values, styleSelectorExpr?, imports? } for pseudo-class expansion
+*       // - undefined to bail/skip the file
+*       // For @media placeholders, check ctx.kind === "mediaQueryInterpolation" and
+*       // use ctx.mediaQuery.feature to choose the correct defineConsts media key.
+*       void ctx;
+*     },
+*
+*     // Configure external interface for exported components
+*     externalInterface(ctx) {
+*       // Example: Enable styles, `as`, and `ref` for shared components folder
+*       if (ctx.filePath.includes("/shared/components/")) {
+*         return { styles: true, as: true, ref: true };
+*       }
+*       return { styles: false, as: false, ref: false };
+*     },
+*
+*     // Optional: provide a custom merger, or use `null` for the default verbose merge output
+*     styleMerger: null,
+*
+*     // Emit sx={} JSX attributes instead of {...stylex.props()} spreads (requires StyleX ≥0.18)
+*     useSxProp: false,
+*
+*     // Choose how 2-value padding/margin shorthands are expanded.
+*     usePhysicalProperties: true,
+*
+*     // Optional: customize runtime theme hook import/call used by emitted wrappers
+*     themeHook: {
+*       functionName: "useTheme",
+*       importSource: { kind: "specifier", value: "styled-components" },
+*     },
+*   });
+*/
+function defineAdapter(adapter) {
+	assertValidAdapterInput(adapter, "defineAdapter(adapter)");
+	return adapter;
+}
+//#endregion
+//#region src/internal/merge-markers.ts
+/**
+* Shared utility for merging marker sidecar content.
+* Core concepts: deduplication of defineMarker declarations across files.
+*/
+/** Regex matching a marker block: optional JSDoc comment followed by the export line. */
+const MARKER_BLOCK_RE = /(?:\/\*\*[^]*?\*\/\n)?export const \w+ = stylex\.defineMarker\(\);/gm;
+/** Regex matching just the export line (used for dedup checks). */
+const MARKER_EXPORT_RE = /^export const \w+ = stylex\.defineMarker\(\);$/gm;
+/** Regex matching a generated defineVars export block. */
+const DEFINE_VARS_BLOCK_RE = /export const \w+ = stylex\.defineVars\(\{\n[\s\S]*?\n\}\);/gm;
+/** Regex matching just the defineVars export line (used for dedup checks). */
+const DEFINE_VARS_EXPORT_RE = /^export const \w+ = stylex\.defineVars\(\{$/gm;
+/**
+* Merge marker declarations from `incoming` into `base`, appending only new
+* marker blocks (JSDoc + export). Returns `base` unchanged if all markers already exist.
+*/
+function mergeMarkerDeclarations(base, incoming) {
+	const mergedDefineVars = mergeDefineVarsBlocks(base, incoming);
+	const markerBlocks = getNewBlocks({
+		base: mergedDefineVars,
+		incoming,
+		blockRegex: MARKER_BLOCK_RE,
+		exportRegex: MARKER_EXPORT_RE
+	});
+	const defineVarsBlocks = getNewBlocks({
+		base: mergedDefineVars,
+		incoming,
+		blockRegex: DEFINE_VARS_BLOCK_RE,
+		exportRegex: DEFINE_VARS_EXPORT_RE
+	});
+	const blocksToAdd = [...markerBlocks, ...defineVarsBlocks];
+	if (blocksToAdd.length === 0) return mergedDefineVars;
+	let merged = mergedDefineVars;
+	if (!merged.includes("@stylexjs/stylex")) merged = `import * as stylex from "@stylexjs/stylex";\n\n${merged}`;
+	return merged.trimEnd() + "\n\n" + blocksToAdd.join("\n\n") + "\n";
+}
+function getNewBlocks(args) {
+	const { base, incoming, blockRegex, exportRegex } = args;
+	const incomingExports = [...incoming.matchAll(exportRegex)].map((m) => m[0]);
+	if (incomingExports.length === 0) return [];
+	const newExportLines = incomingExports.filter((line) => !base.includes(line));
+	if (newExportLines.length === 0) return [];
+	const newExportSet = new Set(newExportLines);
+	return [...incoming.matchAll(blockRegex)].map((m) => m[0]).filter((block) => {
+		const exportLine = block.match(exportRegex);
+		return exportLine && newExportSet.has(exportLine[0]);
+	});
+}
+function mergeDefineVarsBlocks(base, incoming) {
+	let merged = base;
+	for (const incomingBlock of incoming.matchAll(DEFINE_VARS_BLOCK_RE)) {
+		const incomingText = incomingBlock[0];
+		const exportName = readDefineVarsExportName(incomingText);
+		if (!exportName) continue;
+		const existingBlock = findDefineVarsBlockByExportName(merged, exportName);
+		if (!existingBlock) continue;
+		const entriesToAdd = getMissingDefineVarsEntries({
+			existingBlock: existingBlock.text,
+			incomingBlock: incomingText
+		});
+		if (entriesToAdd.length === 0) continue;
+		const insertionPoint = existingBlock.start + existingBlock.text.lastIndexOf("\n});");
+		const linesToAdd = entriesToAdd.map((entry) => entry.line);
+		merged = `${merged.slice(0, insertionPoint)}\n${linesToAdd.join("\n")}${merged.slice(insertionPoint)}`;
+	}
+	return merged;
+}
+function readDefineVarsExportName(block) {
+	return /^export const ([A-Za-z_$][\w$]*) = stylex\.defineVars\(\{/m.exec(block)?.[1] ?? null;
+}
+function findDefineVarsBlockByExportName(source, exportName) {
+	for (const match of source.matchAll(DEFINE_VARS_BLOCK_RE)) {
+		const text = match[0];
+		if (readDefineVarsExportName(text) === exportName && match.index !== void 0) return {
+			text,
+			start: match.index
+		};
+	}
+	return null;
+}
+function getMissingDefineVarsEntries(args) {
+	const { existingBlock, incomingBlock } = args;
+	const existingKeys = new Set(readDefineVarsEntryKeys(existingBlock));
+	return readDefineVarsEntries(incomingBlock).filter((entry) => !existingKeys.has(entry.key));
+}
+function readDefineVarsEntryKeys(block) {
+	return readDefineVarsEntries(block).map((entry) => entry.key);
+}
+function readDefineVarsEntries(block) {
+	return block.split("\n").map((line) => ({
+		line,
+		match: /^\s*(?:(["']--[^"']+["'])|([A-Za-z_$][\w$]*))\s*:/.exec(line)
+	})).filter((entry) => Boolean(entry.match)).map(({ line, match }) => ({
+		key: normalizeDefineVarsEntryKey(match[1] ?? match[2]),
+		line
+	}));
+}
+function normalizeDefineVarsEntryKey(key) {
+	if (key.length >= 2 && (key.startsWith("\"") && key.endsWith("\"") || key.startsWith("'") && key.endsWith("'"))) return key.slice(1, -1);
+	return key;
+}
+//#endregion
+//#region src/internal/utilities/jscodeshift-utils.ts
+/**
+* Extracts the root identifier and member path from an expression.
+*
+* Examples:
+*   `zIndex`                  → { rootName: "zIndex", rootNode: <ident>, path: [] }
+*   `zIndex.modal`            → { rootName: "zIndex", rootNode: <ident>, path: ["modal"] }
+*   `config.ui.spacing.small` → { rootName: "config", rootNode: <ident>, path: ["ui", "spacing", "small"] }
+*
+* Returns null for computed properties, non-identifier roots, or invalid expressions.
+*/
+function extractRootAndPath(node) {
+	if (!node || typeof node !== "object") return null;
+	if (isIdentifierNode(node)) return {
+		rootName: node.name,
+		rootNode: node,
+		path: []
+	};
+	if (!isMemberExpressionNode(node)) return null;
+	const parts = [];
+	let cur = node;
+	while (cur && typeof cur === "object") {
+		if (!isMemberExpressionNode(cur)) break;
+		if (cur.computed) return null;
+		const prop = cur.property;
+		if (!isIdentifierNode(prop)) return null;
+		parts.unshift(prop.name);
+		cur = cur.object;
+	}
+	if (!cur || typeof cur !== "object") return null;
+	if (!isIdentifierNode(cur)) return null;
+	return {
+		rootName: cur.name,
+		rootNode: cur,
+		path: parts
+	};
+}
+/**
+* Extracts the member path from an expression, validating that the root is a specific identifier.
+*
+* Examples (with rootIdentName="props"):
+*   `props.theme.color.primary` → ["theme", "color", "primary"]
+*   `props.className`           → ["className"]
+*   `other.theme`               → null (root doesn't match)
+*
+* Returns null if:
+*   - The expression contains computed properties
+*   - The root identifier doesn't match rootIdentName
+*   - The expression is not a valid member chain
+*/
+function getMemberPathFromIdentifier(expr, rootIdentName) {
+	const info = extractRootAndPath(expr);
+	if (!info || info.rootName !== rootIdentName) return null;
+	return info.path;
+}
+/**
+* Extracts a single prop name from a member expression like `props.foo`.
+* Returns null if the expression doesn't resolve to a single-level property access.
+*/
+function getSinglePropFromMemberExpr(node, rootIdentName) {
+	if (!node || typeof node !== "object") return null;
+	const path = getMemberPathFromIdentifier(node, rootIdentName);
+	if (!path || path.length !== 1 || !path[0]) return null;
+	return path[0];
+}
+/**
+* Extracts the root JSX identifier name from a JSX name node.
+*
+* Examples:
+*   `Foo`              → "Foo"
+*   `Foo.Bar`          → "Foo"
+*   `Foo.Bar.Baz`      → "Foo"
+*
+* Returns null for invalid or non-JSX name nodes.
+*/
+function getRootJsxIdentifierName(node) {
+	let current = node;
+	while (current && typeof current === "object") {
+		if (isJsxIdentifierNode(current)) return current.name;
+		const typed = current;
+		if (typed.type === "JSXMemberExpression") {
+			current = typed.object;
+			continue;
+		}
+		break;
+	}
+	return null;
+}
+/**
+* Extracts the JSX element name with optional member-expression support.
+*
+* When allowMemberExpression is false, only simple JSX identifiers are returned.
+*/
+function getJsxElementName(node, options) {
+	if (!options?.allowMemberExpression) return isJsxIdentifierNode(node) ? node.name : null;
+	return getRootJsxIdentifierName(node);
+}
+/**
+* Type guard for IdentifierNode (minimal type with just type and name).
+*/
+function isIdentifierNode(node) {
+	if (!node || typeof node !== "object") return false;
+	const typed = node;
+	return typed.type === "Identifier" && typeof typed.name === "string";
+}
+/**
+* Type guard for CallExpression nodes.
+*/
+function isCallExpressionNode(node) {
+	return !!node && typeof node === "object" && node.type === "CallExpression";
+}
+/** Type guard for `MemberExpression` and `OptionalMemberExpression` nodes. */
+function isMemberExpressionNode(node) {
+	if (!node || typeof node !== "object") return false;
+	const type = node.type;
+	return type === "MemberExpression" || type === "OptionalMemberExpression";
+}
+/**
+* Reads `object.property` when both sides are identifiers and the property is
+* non-optional and non-computed. Returns null for optional/computed paths the
+* caller cannot safely treat as a static member reference.
+*/
+function getIdentifierMemberPropertyName(node, objectName) {
+	if (!isMemberExpressionNode(node) || node.type !== "MemberExpression" || node.computed) return null;
+	if (!isIdentifierNode(node.object) || node.object.name !== objectName) return null;
+	return isIdentifierNode(node.property) ? node.property.name : null;
+}
+/** Matches a static `objectName.propertyName` member reference. */
+function isIdentifierMemberExpression(node, objectName, propertyName) {
+	return getIdentifierMemberPropertyName(node, objectName) === propertyName;
+}
+/**
+* Type guard for AstPath objects (jscodeshift path wrappers).
+*/
+function isAstPath(value) {
+	return !!value && typeof value === "object" && "node" in value;
+}
+/**
+* Type guard for AST nodes (objects with a string `type` property).
+* Returns false for arrays and non-objects.
+*/
+function isAstNode(v) {
+	return !!v && typeof v === "object" && !Array.isArray(v) && typeof v.type === "string";
+}
+/**
+* Generic type guard narrowing an unknown value to an AST node of a specific `type`.
+* Returns false for arrays and non-objects.
+*/
+function isNodeOfType(node, type) {
+	return isAstNode(node) && node.type === type;
+}
+/**
+* Type guard for function-like nodes including class/object methods.
+*/
+function isFunctionNode(node) {
+	if (!node || typeof node !== "object") return false;
+	const type = node.type;
+	return type === "FunctionDeclaration" || type === "FunctionExpression" || type === "ArrowFunctionExpression" || type === "ObjectMethod" || type === "ClassMethod";
+}
+/**
+* Returns true when a destructuring/binding pattern (or nested pattern) binds
+* any of the given names. Handles Identifier, Rest/Assignment patterns, object
+* and array patterns, and Property/ObjectProperty nodes.
+*/
+function patternBindsAnyName(node, names) {
+	if (!node || typeof node !== "object") return false;
+	const record = node;
+	if (record.type === "Identifier") return typeof record.name === "string" && names.has(record.name);
+	if (record.type === "RestElement") return patternBindsAnyName(record.argument, names);
+	if (record.type === "AssignmentPattern") return patternBindsAnyName(record.left, names);
+	if (record.type === "ObjectPattern") return Array.isArray(record.properties) && record.properties.some((prop) => patternBindsAnyName(prop, names));
+	if (record.type === "ObjectProperty" || record.type === "Property") return patternBindsAnyName(record.value, names);
+	if (record.type === "ArrayPattern") return Array.isArray(record.elements) && record.elements.some((element) => patternBindsAnyName(element, names));
+	return false;
+}
+/**
+* Returns true when `name` is one of React's `ComponentProps` utility-type
+* names (`ComponentProps`, `ComponentPropsWithRef`, `ComponentPropsWithoutRef`).
+*/
+function isReactComponentPropsUtilityName(name) {
+	return name === "ComponentProps" || name === "ComponentPropsWithRef" || name === "ComponentPropsWithoutRef";
+}
+/**
+* Returns true when a TS type node is numeric (`number`, numeric literal, or a
+* union of such). When `allowOptional` is true, union members may also be
+* `undefined`/`null` (matching an optional numeric prop); otherwise the union
+* must be non-empty and every member must itself be numeric.
+*/
+function isNumericTsType(tsType, options = {}) {
+	if (!tsType || typeof tsType !== "object") return false;
+	const allowOptional = options.allowOptional ?? false;
+	const type = tsType;
+	if (type.type === "TSNumberKeyword") return true;
+	if (type.type === "TSLiteralType") return typeof type.literal?.value === "number";
+	if (type.type === "TSUnionType" && Array.isArray(type.types)) {
+		if (allowOptional) return type.types.every((member) => {
+			const memberType = member?.type;
+			return memberType === "TSUndefinedKeyword" || memberType === "TSNullKeyword" || isNumericTsType(member, options);
+		});
+		return type.types.length > 0 && type.types.every((member) => isNumericTsType(member, options));
+	}
+	return false;
+}
+/**
+* Extracts the name of an Identifier node, or null when the node is not a
+* (named) Identifier. Accepts any value for convenient optional-chaining use.
+*/
+function identifierName(node) {
+	if (!node || typeof node !== "object") return null;
+	const typed = node;
+	return typed.type === "Identifier" && typeof typed.name === "string" ? typed.name : null;
+}
+/** Returns true when `node` is an Identifier whose name equals `name`. */
+function isIdentifierNamed(node, name) {
+	const typed = node;
+	return typed?.type === "Identifier" && typed.name === name;
+}
+/** Type guard for the `undefined` identifier literal. */
+function isUndefinedIdentifier(node) {
+	return isIdentifierNamed(node, "undefined");
+}
+/**
+* Type guard for ArrowFunctionExpression nodes.
+*/
+function isArrowFunctionExpression(node) {
+	return !!node && typeof node === "object" && node.type === "ArrowFunctionExpression";
+}
+/**
+* Extracts the id from a VariableDeclarator node.
+*/
+function getDeclaratorId(decl) {
+	if (!decl || typeof decl !== "object") return null;
+	if (!("id" in decl)) return null;
+	return decl.id ?? null;
+}
+function getArrowFnSingleParamName(fn) {
+	if (fn.params.length !== 1) return null;
+	const p = fn.params[0];
+	return isIdentifier(p) ? p.name : null;
+}
+/**
+* Extracts parameter binding information from an arrow function.
+*
+* Supports:
+* - Simple identifier params: `(props) => ...`
+* - Destructured params: `({ color }) => ...`
+* - Renamed destructured params: `({ color: color_ }) => ...`
+* - Default values: `({ color = "red" }) => ...`
+* - Renamed with defaults: `({ color: color_ = "red" }) => ...`
+*
+* Returns null for:
+* - Functions with != 1 parameter
+* - Rest elements in destructuring (not supported)
+* - Computed property keys
+*/
+function getArrowFnParamBindings(fn) {
+	if (fn.params.length !== 1) return null;
+	const p = fn.params[0];
+	if (isIdentifier(p)) return {
+		kind: "simple",
+		paramName: p.name
+	};
+	if (p?.type === "ObjectPattern" && Array.isArray(p.properties)) {
+		const bindings = /* @__PURE__ */ new Map();
+		const defaults = /* @__PURE__ */ new Map();
+		const props = p.properties;
+		for (const prop of props) {
+			if (prop.type === "RestElement") return null;
+			if (prop.type !== "Property" && prop.type !== "ObjectProperty") continue;
+			if (prop.computed === true) return null;
+			const key = prop.key;
+			if (!key || key.type !== "Identifier") return null;
+			const propName = key.name;
+			if (!propName) continue;
+			const value = prop.value;
+			if (value?.type === "Identifier" && typeof value.name === "string") bindings.set(value.name, propName);
+			else if (value?.type === "AssignmentPattern") {
+				const left = value.left;
+				if (left?.type === "Identifier" && typeof left.name === "string") {
+					bindings.set(left.name, propName);
+					if (value.right) defaults.set(propName, value.right);
+				}
+			}
+		}
+		if (bindings.size === 0) return null;
+		return {
+			kind: "destructured",
+			bindings,
+			defaults: defaults.size > 0 ? defaults : void 0
+		};
+	}
+	return null;
+}
+/**
+* Given an identifier node and param bindings, resolves the original prop name.
+*
+* For destructured params like `({ color: color_ }) => color_`:
+*   resolveIdentifierToPropName(color_Node, bindings) -> "color"
+*
+* Returns null if the identifier doesn't correspond to a destructured prop.
+*/
+function resolveIdentifierToPropName(node, bindings) {
+	if (!node || typeof node !== "object") return null;
+	const typed = node;
+	if (typed.type !== "Identifier" || typeof typed.name !== "string") return null;
+	if (bindings.kind === "simple") return null;
+	return bindings.bindings.get(typed.name) ?? null;
+}
+function getNodeLocStart(node) {
+	const loc = node?.loc?.start;
+	if (!loc) return null;
+	return {
+		line: loc.line,
+		column: loc.column
+	};
+}
+const isExpressionKindNode = (node) => isAstNode(node);
+const isReturnStatementNode = (node) => isAstNode(node) && node.type === "ReturnStatement";
+const isIfStatementNode = (node) => isAstNode(node) && node.type === "IfStatement";
+/**
+* Extracts the single ReturnStatement expression from a statement.
+* Handles both bare ReturnStatements and BlockStatements containing exactly one ReturnStatement.
+*/
+function extractReturnExpr(stmt) {
+	if (isReturnStatementNode(stmt)) return isExpressionKindNode(stmt.argument) ? stmt.argument : void 0;
+	if (isAstNode(stmt) && stmt.type === "BlockStatement") {
+		const body = stmt.body;
+		if (Array.isArray(body) && body.length === 1) return extractReturnExpr(body[0]);
+	}
+}
+/**
+* Converts a series of if/return statements into a nested ternary (ConditionalExpression).
+*
+* Handles patterns like:
+* ```
+* if (A) { return E1; }
+* if (B) { return E2; }
+* return E3;
+* ```
+* → `A ? E1 : B ? E2 : E3`
+*
+* Constraints (returns undefined if not met):
+* - All statements are IfStatement (no else) or ReturnStatement
+* - Last statement must be ReturnStatement with an expression argument
+* - Each IfStatement consequent has exactly one ReturnStatement
+*/
+function tryFlattenIfReturnChainToExpr(blockBody) {
+	const last = blockBody[blockBody.length - 1];
+	if (!isReturnStatementNode(last) || !isExpressionKindNode(last.argument)) return;
+	let result = last.argument;
+	for (let i = blockBody.length - 2; i >= 0; i--) {
+		const stmt = blockBody[i];
+		if (!isIfStatementNode(stmt)) return;
+		if (stmt.alternate != null) return;
+		const test = stmt.test;
+		if (!isExpressionKindNode(test)) return;
+		const consequentExpr = extractReturnExpr(stmt.consequent);
+		if (!consequentExpr) return;
+		result = {
+			type: "ConditionalExpression",
+			test,
+			consequent: consequentExpr,
+			alternate: result
+		};
+	}
+	return result;
+}
+/**
+* Extracts the expression from an arrow/function expression body.
+* - For expression bodies: returns the expression directly
+* - For block bodies: returns the argument of the return statement,
+*   but ONLY if the block contains exactly one statement (a ReturnStatement).
+*   This ensures we don't support arrow functions with complex logic in the body.
+*/
+function getFunctionBodyExpr(fn) {
+	const body = fn.body;
+	if (!body || typeof body !== "object") return;
+	if (isAstNode(body) && body.type === "BlockStatement") {
+		const blockBody = body.body;
+		if (!Array.isArray(blockBody) || blockBody.length === 0) return;
+		if (blockBody.length !== 1) return tryFlattenIfReturnChainToExpr(blockBody);
+		const statement = blockBody[0];
+		if (!isReturnStatementNode(statement)) return;
+		const argument = statement.argument ?? null;
+		if (argument === null) return null;
+		return isExpressionKindNode(argument) ? argument : void 0;
+	}
+	return isExpressionKindNode(body) ? body : void 0;
+}
+/**
+* Recursively collects all Identifier names from an AST node into a Set.
+* Skips 'loc' and 'comments' properties to avoid traversing metadata.
+*
+* @param node - The AST node to traverse
+* @param out - The Set to collect identifier names into
+*/
+function collectIdentifiers(node, out) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const child of node) collectIdentifiers(child, out);
+		return;
+	}
+	const typed = node;
+	if (typed.type === "Identifier" && typed.name) out.add(typed.name);
+	for (const key of Object.keys(node)) {
+		if (key === "loc" || key === "comments") continue;
+		collectIdentifiers(node[key], out);
+	}
+}
+/**
+* Collects binding names introduced by an object/array destructuring pattern.
+*/
+function collectPatternBindingNames(node, names) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const child of node) collectPatternBindingNames(child, names);
+		return;
+	}
+	const typed = node;
+	if (typed.type === "Identifier" && typed.name) {
+		names.add(typed.name);
+		return;
+	}
+	if (typed.type === "MemberExpression" || typed.type === "OptionalMemberExpression" || typed.type === "TSQualifiedName") return;
+	for (const key of Object.keys(node)) {
+		if (key === "loc" || key === "comments" || key === "leadingComments") continue;
+		collectPatternBindingNames(node[key], names);
+	}
+}
+/**
+* Converts an AST literal node to its static JavaScript value.
+*
+* Supports:
+* - StringLiteral, NumericLiteral, BooleanLiteral (Babel AST)
+* - Literal (ESTree/recast AST)
+* - TemplateLiteral without expressions (static template strings)
+* - TaggedTemplateExpression with css tag (styled-components css helper)
+* - TSAsExpression and TSSatisfiesExpression wrapping static values
+* - ArrowFunctionExpression with no params and a static body (e.g., `() => "value"` or `() => \`value\``)
+*
+* Returns null for non-literal or dynamic nodes.
+*/
+function literalToStaticValue(node, options = {}) {
+	if (!node || typeof node !== "object") return null;
+	const allowCssTaggedTemplates = options.allowCssTaggedTemplates ?? true;
+	const allowStaticArrowFunctions = options.allowStaticArrowFunctions ?? true;
+	const type = node.type;
+	if (type === "TSAsExpression" || type === "TSSatisfiesExpression") return literalToStaticValue(node.expression, options);
+	if (type === "StringLiteral") return node.value;
+	if (type === "BooleanLiteral") return node.value;
+	if (type === "Literal") {
+		const v = node.value;
+		if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") return v;
+	}
+	if (type === "NumericLiteral") return node.value;
+	if (type === "UnaryExpression") {
+		const n = node;
+		if (n.prefix && (n.operator === "-" || n.operator === "+")) {
+			const argVal = literalToStaticValue(n.argument, options);
+			if (typeof argVal === "number") return n.operator === "-" ? -argVal : argVal;
+		}
+	}
+	if (type === "TemplateLiteral") {
+		const n = node;
+		if (!n.expressions || n.expressions.length === 0) {
+			const quasis = n.quasis ?? [];
+			const parts = [];
+			for (const q of quasis) {
+				const cooked = q.value?.cooked;
+				if (cooked == null) return null;
+				parts.push(cooked);
+			}
+			return parts.join("");
+		}
+	}
+	if (type === "TaggedTemplateExpression" && allowCssTaggedTemplates) {
+		const n = node;
+		if (n.tag?.type === "Identifier" && n.tag.name === "css") return literalToStaticValue(n.quasi, options);
+	}
+	if (type === "ArrowFunctionExpression" && allowStaticArrowFunctions) {
+		const n = node;
+		if (!n.params || n.params.length === 0) return literalToStaticValue(n.body, options);
+	}
+	return null;
+}
+/**
+* Extracts a static literal value from an AST node, distinguishing null literals
+* from extraction failure. Returns `undefined` when the node is not a recognized
+* static literal, and the actual value (including `null`) otherwise.
+*
+* Function expressions are not coerced by default: a function-valued expression
+* is runtime data, even if its body is a static literal.
+*/
+function extractStaticLiteralValue(node, options = {}) {
+	if (!node || typeof node !== "object") return;
+	const typed = node;
+	if (typed.type === "TSAsExpression" || typed.type === "TSSatisfiesExpression") return extractStaticLiteralValue(typed.expression, options);
+	if (typed.type === "NullLiteral" || typed.type === "Literal" && typed.value === null) return null;
+	const v = literalToStaticValue(node, {
+		...options,
+		allowStaticArrowFunctions: options.allowStaticArrowFunctions ?? false
+	});
+	return v !== null ? v : void 0;
+}
+/**
+* Converts an AST literal node to a string value.
+* Returns null if the node is not a string literal.
+*/
+function literalToString(node) {
+	const v = literalToStaticValue(node);
+	return typeof v === "string" ? v : null;
+}
+/**
+* Scans the file AST for TypeScript string/numeric enum declarations and
+* returns a two-level map: enumName -> memberName -> static value.
+* Only handles members with literal initializers.
+*/
+function buildEnumValueMap(root, j) {
+	const map = /* @__PURE__ */ new Map();
+	root.find(j.TSEnumDeclaration).forEach((path) => {
+		const enumNode = path.value;
+		const enumName = enumNode.id.name;
+		const members = /* @__PURE__ */ new Map();
+		let nextNumericValue = 0;
+		for (const member of enumNode.members) {
+			const memberName = member.id.type === "Identifier" ? member.id.name : member.id.value;
+			if (member.initializer) {
+				const val = literalToStaticValue(member.initializer);
+				if (val !== null) {
+					members.set(memberName, val);
+					nextNumericValue = typeof val === "number" ? val + 1 : 0;
+				}
+			} else {
+				members.set(memberName, nextNumericValue);
+				nextNumericValue++;
+			}
+		}
+		if (members.size > 0) map.set(enumName, members);
+	});
+	return map;
+}
+/**
+* Resolves a MemberExpression node (e.g., `ProgressType.success`) to its
+* static enum value using a pre-built enum map. Returns null if the node
+* is not a MemberExpression or doesn't reference a known enum member.
+*/
+function resolveStaticExpressionValue(node, enumValueMap) {
+	const v = literalToStaticValue(node);
+	if (v !== null) return v;
+	if (!enumValueMap || !node || typeof node !== "object") return null;
+	const n = node;
+	if (n.type !== "MemberExpression" || n.computed) return null;
+	const obj = n.object;
+	const prop = n.property;
+	if (obj?.type !== "Identifier" || !obj.name || prop?.type !== "Identifier" || !prop.name) return null;
+	return enumValueMap.get(obj.name)?.get(prop.name) ?? null;
+}
+/**
+* Returns true if an AST node represents an "empty" CSS branch value.
+* Styled-components treats falsy interpolations as "omit this declaration".
+*
+* Recognized empty values: `""`, empty TemplateLiteral, `null`, `undefined`,
+* `false`, and trivial `void` expressions (`void 0`, `void null`, etc.).
+*/
+function isEmptyCssBranch(node) {
+	if (!node || typeof node !== "object") return false;
+	const n = node;
+	if ((n.type === "StringLiteral" || n.type === "Literal") && n.value === "") return true;
+	if (n.type === "TemplateLiteral") {
+		const tpl = node;
+		if (tpl.expressions && tpl.expressions.length > 0) return false;
+		return (tpl.quasis ?? []).every((q) => (q.value?.raw ?? "") === "");
+	}
+	if (n.type === "NullLiteral") return true;
+	if (n.type === "Identifier" && n.name === "undefined") return true;
+	if (n.type === "BooleanLiteral" && n.value === false) return true;
+	if (n.type === "UnaryExpression" && n.operator === "void") return isTriviallyPureVoidArg(node.argument);
+	return false;
+}
+/**
+* Creates a literal AST node from a static JavaScript value.
+* This is the inverse of `literalToStaticValue`.
+*
+* @param j - The jscodeshift API
+* @param value - The static value to convert
+* @returns A literal AST node (StringLiteral, NumericLiteral, or BooleanLiteral)
+*/
+function staticValueToLiteral(j, value) {
+	if (typeof value === "string") return j.stringLiteral(value);
+	if (typeof value === "boolean") return j.booleanLiteral(value);
+	return j.numericLiteral(value);
+}
+/**
+* Set of AST metadata keys that should typically be skipped during traversal or cloning.
+* These keys contain position/source information and are not part of the logical AST structure.
+*/
+const AST_METADATA_KEYS = new Set([
+	"loc",
+	"start",
+	"end",
+	"range",
+	"comments",
+	"tokens"
+]);
+/**
+* Deep clones an AST node, stripping metadata properties (loc, comments, tokens, etc.).
+* Useful for creating modified copies of AST nodes without mutating the original.
+*
+* @param node - The AST node to clone
+* @returns A deep clone with metadata properties removed
+*/
+function cloneAstNode(node) {
+	if (!node || typeof node !== "object") return node;
+	if (Array.isArray(node)) return node.map(cloneAstNode);
+	const out = {};
+	for (const key of Object.keys(node)) {
+		if (AST_METADATA_KEYS.has(key)) continue;
+		out[key] = cloneAstNode(node[key]);
+	}
+	return out;
+}
+/**
+* Conservative purity check for a JS expression: returns true when evaluating
+* the expression repeatedly yields the same value and produces no observable
+* side effects (assignment, function call, mutation, await, etc.).
+*
+* Use this before lifting an expression out of N evaluations into a single
+* shared evaluation (e.g. collapsing `cond ? a : b` repeated for several
+* properties into one `cond && variant` guard). Anything that *might* return a
+* different value on a subsequent call (function/method calls, `new`, `yield`,
+* `await`, assignments, increment/decrement) is treated as impure.
+*
+* Conservatively returns false for unfamiliar node types.
+*/
+function isPureIdempotentExpression(node) {
+	if (!isAstNode(node)) return false;
+	const n = node;
+	switch (n.type) {
+		case "Identifier":
+		case "ThisExpression":
+		case "Super":
+		case "NullLiteral":
+		case "BooleanLiteral":
+		case "NumericLiteral":
+		case "StringLiteral":
+		case "BigIntLiteral":
+		case "RegExpLiteral":
+		case "Literal": return true;
+		case "TemplateLiteral": return Array.isArray(n.expressions) && n.expressions.every(isPureIdempotentExpression);
+		case "UnaryExpression":
+			if (n.operator === "delete") return false;
+			return isPureIdempotentExpression(n.argument);
+		case "BinaryExpression": return isPureIdempotentExpression(n.left) && isPureIdempotentExpression(n.right);
+		case "LogicalExpression": return isPureIdempotentExpression(n.left) && isPureIdempotentExpression(n.right);
+		case "ConditionalExpression": return isPureIdempotentExpression(n.test) && isPureIdempotentExpression(n.consequent) && isPureIdempotentExpression(n.alternate);
+		case "MemberExpression":
+		case "OptionalMemberExpression":
+			if (!isPureIdempotentExpression(n.object)) return false;
+			if (n.computed) return false;
+			return true;
+		case "TSAsExpression":
+		case "TSTypeAssertion":
+		case "TSNonNullExpression":
+		case "TSSatisfiesExpression": return isPureIdempotentExpression(n.expression);
+		case "ParenthesizedExpression": return isPureIdempotentExpression(n.expression);
+		case "ArrayExpression": return Array.isArray(n.elements) && n.elements.every((el) => el === null || isPureIdempotentExpression(el));
+		case "ObjectExpression": return Array.isArray(n.properties) && n.properties.every((p) => {
+			if (!isAstNode(p)) return false;
+			const prop = p;
+			if (prop.type !== "Property" && prop.type !== "ObjectProperty") return false;
+			if (prop.computed && !isPureIdempotentExpression(prop.key)) return false;
+			return isPureIdempotentExpression(prop.value);
+		});
+		default: return false;
+	}
+}
+/**
+* Structural equality check for AST nodes.
+* Compares two nodes recursively, ignoring metadata (loc, start/end, comments, tokens).
+* Returns true when the nodes have the same shape and values.
+*/
+function astNodesEqual(a, b) {
+	if (a === b) return true;
+	if (a === null || b === null || a === void 0 || b === void 0) return false;
+	if (typeof a !== "object" || typeof b !== "object") return false;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!astNodesEqual(a[i], b[i])) return false;
+		return true;
+	}
+	const aKeys = Object.keys(a).filter((k) => !AST_METADATA_KEYS.has(k));
+	const bKeys = Object.keys(b).filter((k) => !AST_METADATA_KEYS.has(k));
+	if (aKeys.length !== bKeys.length) return false;
+	for (const key of aKeys) {
+		if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+		if (!astNodesEqual(a[key], b[key])) return false;
+	}
+	return true;
+}
+/**
+* Type guard for LogicalExpression nodes.
+*/
+function isLogicalExpressionNode(node) {
+	return !!node && typeof node === "object" && node.type === "LogicalExpression";
+}
+/**
+* Extracts the left side of a `??` or `||` logical expression when it's a
+* MemberExpression or OptionalMemberExpression. Returns null if the pattern
+* doesn't match.
+*
+* Used to extract the theme access part from fallback patterns like
+* `props.theme.color.labelBase ?? "black"` for resolution. Callers are
+* responsible for re-wrapping the resolved value with the original fallback.
+*/
+function unwrapLogicalFallback(expr) {
+	if (isLogicalExpressionNode(expr) && (expr.operator === "??" || expr.operator === "||") && isMemberExpressionNode(expr.left)) return expr.left;
+	return null;
+}
+/**
+* Returns true when `expr` is a `??` / `||` logical expression whose
+* right-hand side is a non-literal value (e.g., `props.fallbackColor`).
+*
+* Used to bail on theme resolution when the fallback references a runtime
+* value the user depends on — dropping it silently would change semantics.
+*/
+function hasNonLiteralLogicalFallback(expr) {
+	return isLogicalExpressionNode(expr) && (expr.operator === "??" || expr.operator === "||") && literalToStaticValue(expr.right) === null;
+}
+/**
+* Type guard for ConditionalExpression nodes.
+*/
+function isConditionalExpressionNode(node) {
+	return !!node && typeof node === "object" && node.type === "ConditionalExpression";
+}
+/**
+* Sets the type annotation on an identifier node.
+* This encapsulates the pattern needed because jscodeshift's TypeScript types
+* don't include `typeAnnotation` on Identifier nodes in all contexts.
+*
+* @param identifier - The identifier node to annotate
+* @param typeAnnotation - The type annotation (typically from j.tsTypeAnnotation())
+*/
+function setIdentifierTypeAnnotation(identifier, typeAnnotation) {
+	identifier.typeAnnotation = typeAnnotation;
+}
+/**
+* Builds the appropriate expression for a style function call based on condition type.
+*
+* Handles three cases:
+* - "truthy": wraps with `prop ? call : undefined` to avoid passing false/"" into stylex.props
+* - "always": returns call directly (the callArg already handles null, e.g., `${$prop ?? 0}ms`)
+* - undefined (default): wraps with `prop != null && call` for optional props, or returns call for required props
+*/
+function buildStyleFnConditionExpr(args) {
+	const { j, condition, propExpr, call, isRequired } = args;
+	if (condition === "truthy") return j.conditionalExpression(propExpr, call, j.identifier("undefined"));
+	if (condition === "always" || isRequired) return call;
+	return j.logicalExpression("&&", j.binaryExpression("!=", propExpr, j.nullLiteral()), call);
+}
+function isIdentifier(node, name) {
+	return isIdentifierNode(node) && (name ? node.name === name : true);
+}
+function isJsxIdentifierNode(node) {
+	if (!node || typeof node !== "object") return false;
+	const typed = node;
+	return typed.type === "JSXIdentifier" && typeof typed.name === "string";
+}
+/** Allow `void 0`, `void null`, `void ""`, `void 1`, `void false` as empty. */
+function isTriviallyPureVoidArg(arg) {
+	if (!arg || typeof arg !== "object") return false;
+	const n = arg;
+	if (n.type === "NumericLiteral" && n.value === 0) return true;
+	if (n.type === "NullLiteral") return true;
+	if (n.type === "StringLiteral" && n.value === "") return true;
+	if (n.type === "BooleanLiteral" && n.value === false) return true;
+	if (n.type === "Literal") {
+		const v = n.value;
+		return v === 0 || v === null || v === "" || v === false;
+	}
+	return false;
+}
+//#endregion
+//#region src/internal/utilities/sx-surface.ts
+function transformedComponentAcceptsSx(args) {
+	const source = readTransformedSource(args.absolutePath, args.sourceOverrides);
+	if (!source) return false;
+	return args.componentNames.some((componentName) => componentHasSxProp(source, componentName));
+}
+function readTransformedSource(absolutePath, sourceOverrides) {
+	for (const candidate of sourcePathCandidates(absolutePath)) {
+		const source = sourceOverrides?.get(toRealPath(candidate));
+		if (source !== void 0) return source;
+		if (existsSync(candidate)) try {
+			return readFileSync(candidate, "utf8");
+		} catch {
+			return;
+		}
+	}
+}
+function sourcePathCandidates(absolutePath) {
+	return [
+		"",
+		".tsx",
+		".ts",
+		".jsx",
+		".js"
+	].map((ext) => absolutePath + ext);
+}
+function componentHasSxProp(source, componentName) {
+	const propsType = readFunctionPropsType(source, componentName) ?? readArrowFunctionPropsType(source, componentName);
+	return propsType ? typeTextHasSx(source, propsType, /* @__PURE__ */ new Set()) : false;
+}
+function readFunctionPropsType(source, componentName) {
+	if (componentName === "default") {
+		const defaultMatch = source.match(/export\s+default\s+function\s*\(/);
+		if (defaultMatch?.index !== void 0) return readFirstPropsType(source, defaultMatch.index + defaultMatch[0].length);
+	}
+	const match = source.match(new RegExp(`(?:export\\s+)?function\\s+${escapeRegex(componentName)}\\s*\\(`));
+	return match?.index === void 0 ? void 0 : readFirstPropsType(source, match.index + match[0].length);
+}
+function readArrowFunctionPropsType(source, componentName) {
+	const match = source.match(new RegExp(`(?:export\\s+)?(?:const|let|var)\\s+${escapeRegex(componentName)}\\s*=\\s*\\(`));
+	return match?.index === void 0 ? void 0 : readFirstPropsType(source, match.index + match[0].length);
+}
+function readFirstPropsType(source, startIndex) {
+	const prefix = source.slice(startIndex).match(/^\s*props\s*:\s*/);
+	if (!prefix) return;
+	let depth = 0;
+	const typeStart = startIndex + prefix[0].length;
+	for (let i = typeStart; i < source.length; i++) {
+		const ch = source[i];
+		if (ch === "{" || ch === "<" || ch === "[" || ch === "(") depth++;
+		else if (ch === "}" || ch === ">" || ch === "]" || ch === ")" && depth > 0) depth--;
+		else if ((ch === "," || ch === ")") && depth <= 0) return source.slice(typeStart, i);
+	}
+}
+function typeTextHasSx(source, typeText, visited) {
+	if (/\bsx\??\s*:\s*(?:stylex\.)?StyleXStyles\b/.test(typeText)) return true;
+	const typeName = typeText.trim().match(/^([A-Za-z_$][\w$]*)$/)?.[1];
+	if (!typeName || visited.has(typeName)) return false;
+	visited.add(typeName);
+	const declaration = readTypeAlias(source, typeName) ?? readInterfaceBody(source, typeName);
+	return declaration ? typeTextHasSx(source, declaration, visited) : false;
+}
+function readTypeAlias(source, typeName) {
+	const match = source.match(new RegExp(`type\\s+${escapeRegex(typeName)}\\b\\s*=\\s*`));
+	if (match?.index === void 0) return;
+	return readUntilTopLevelTerminator(source, match.index + match[0].length, ";");
+}
+function readInterfaceBody(source, typeName) {
+	const match = source.match(new RegExp(`interface\\s+${escapeRegex(typeName)}\\b[^{]*\\{`));
+	if (match?.index === void 0) return;
+	return readUntilMatchingBrace(source, match.index + match[0].length - 1);
+}
+function readUntilTopLevelTerminator(source, startIndex, terminator) {
+	let depth = 0;
+	for (let i = startIndex; i < source.length; i++) {
+		const ch = source[i];
+		if (ch === "{" || ch === "<" || ch === "[" || ch === "(") depth++;
+		else if (ch === "}" || ch === ">" || ch === "]" || ch === ")" && depth > 0) depth--;
+		else if (ch === terminator && depth <= 0) return source.slice(startIndex, i);
+	}
+}
+function readUntilMatchingBrace(source, braceIndex) {
+	let depth = 0;
+	for (let i = braceIndex; i < source.length; i++) {
+		const ch = source[i];
+		if (ch === "{") depth++;
+		else if (ch === "}") {
+			depth--;
+			if (depth === 0) return source.slice(braceIndex + 1, i);
+		}
+	}
+}
+function escapeRegex(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+export { describeValue as $, isIdentifierNamed as A, literalToString as B, isAstNode as C, isEmptyCssBranch as D, isConditionalExpressionNode as E, isNumericTsType as F, staticValueToLiteral as G, resolveIdentifierToPropName as H, isPureIdempotentExpression as I, DEFAULT_THEME_HOOK as J, unwrapLogicalFallback as K, isReactComponentPropsUtilityName as L, isLogicalExpressionNode as M, isMemberExpressionNode as N, isFunctionNode as O, isNodeOfType as P, assertValidAdapterInput as Q, isUndefinedIdentifier as R, isArrowFunctionExpression as S, isCallExpressionNode as T, resolveStaticExpressionValue as U, patternBindsAnyName as V, setIdentifierTypeAnnotation as W, isDirectionalResult as X, defineAdapter as Y, assertValidAdapter as Z, getNodeLocStart as _, cloneAstNode as a, hasNonLiteralLogicalFallback as b, extractRootAndPath as c, getArrowFnSingleParamName as d, getDeclaratorId as f, getMemberPathFromIdentifier as g, getJsxElementName as h, buildStyleFnConditionExpr as i, isIdentifierNode as j, isIdentifierMemberExpression as k, extractStaticLiteralValue as l, getIdentifierMemberPropertyName as m, astNodesEqual as n, collectIdentifiers as o, getFunctionBodyExpr as p, mergeMarkerDeclarations as q, buildEnumValueMap as r, collectPatternBindingNames as s, transformedComponentAcceptsSx as t, getArrowFnParamBindings as u, getRootJsxIdentifierName as v, isAstPath as w, identifierName as x, getSinglePropFromMemberExpr as y, literalToStaticValue as z };