styled-components-to-stylex-codemod 0.0.37 → 0.0.38

package/dist/{bridge-consumer-patcher-CKOMofN8.mjs → bridge-consumer-patcher-BzAIO9pC.mjs}

@@ -1,6 +1,6 @@
-import { n as toRealPath } from "./path-utils-CMR9NmMm.mjs";
-import { r as escapeRegex } from "./string-utils-ChXtospT.mjs";
-import { t as isSelectorContext } from "./selector-context-heuristic-DE3JAmpc.mjs";
+import { n as toRealPath } from "./path-utils-BIpoL4Ue.mjs";
+import { r as escapeRegex } from "./string-utils-KggM5TNH.mjs";
+import { t as isSelectorContext } from "./selector-context-heuristic-6_jSRGkZ.mjs";
 import { readFileSync } from "node:fs";
 //#region src/internal/bridge-consumer-patcher.ts
 /**

package/dist/compute-leaf-set-Drcu2eju.mjs

@@ -0,0 +1,239 @@
+import { i as resolveBarrelReExport, r as findImportSource } from "./extract-external-interface-CdHbvfxu.mjs";
+//#region src/internal/prepass/compute-leaf-set.ts
+/**
+* Computes which styled-component bindings are "leaves" for leaves-only mode:
+* intrinsic bases (`styled.div`) or transitive wrappers around other leaf styled
+* components in the transform set. Uses AST extraction (primary), regex fallback,
+* fixed-point + import resolution (same helpers as consumer analysis).
+*/
+const RX_EXPORT_DECL = String.raw`(?:export\s+)?(?:const|let|var)\s+`;
+/** `const Name = styled.tag` — intrinsic HTML/SVG tag member. */
+const STYLED_INTRINSIC_MEMBER_RE = new RegExp(String.raw`\b${RX_EXPORT_DECL}([A-Z][A-Za-z0-9]*)\b[^=]*=\s*styled\.([a-z][a-zA-Z0-9]*)\b`, "g");
+/** `const Name = styled("tag")` — intrinsic string tag. */
+const STYLED_INTRINSIC_STRING_RE = new RegExp(String.raw`\b${RX_EXPORT_DECL}([A-Z][A-Za-z0-9]*)\b[^=]*=\s*styled\s*\(\s*["']([^"']+)["']`, "g");
+/** `const Name = styled(Component)` — wraps another component identifier. */
+const STYLED_COMPONENT_RE = new RegExp(String.raw`\b${RX_EXPORT_DECL}([A-Z][A-Za-z0-9]*)\b[^=]*=\s*styled\s*\(\s*([A-Z][A-Za-z0-9]*)\s*\)`, "g");
+/**
+* Regex-derived styled definition bases for files in the transform set.
+* Later entries for the same component name overwrite earlier ones (rare).
+*/
+function extractStyledDefBasesFromSource(filePath, source, into) {
+	let map = into.get(filePath);
+	if (!map) {
+		map = /* @__PURE__ */ new Map();
+		into.set(filePath, map);
+	}
+	STYLED_INTRINSIC_MEMBER_RE.lastIndex = 0;
+	for (const m of source.matchAll(STYLED_INTRINSIC_MEMBER_RE)) {
+		const name = m[1];
+		if (name) map.set(name, { kind: "intrinsic" });
+	}
+	STYLED_INTRINSIC_STRING_RE.lastIndex = 0;
+	for (const m of source.matchAll(STYLED_INTRINSIC_STRING_RE)) {
+		const name = m[1];
+		if (name) map.set(name, { kind: "intrinsic" });
+	}
+	STYLED_COMPONENT_RE.lastIndex = 0;
+	for (const m of source.matchAll(STYLED_COMPONENT_RE)) {
+		const name = m[1];
+		const ident = m[2];
+		if (name && ident) map.set(name, {
+			kind: "component",
+			ident
+		});
+	}
+}
+/**
+* AST-based extraction: understands `let`/`var`, export blocks, named `styled` imports,
+* and `.attrs` / `.withConfig` chains before the tagged template.
+* Results merge into `into`; bindings found here override regex entries for the same name.
+*/
+function extractStyledDefBasesFromAstProgram(filePath, program, styledLocalNames, into) {
+	if (styledLocalNames.size === 0) return;
+	let map = into.get(filePath);
+	if (!map) {
+		map = /* @__PURE__ */ new Map();
+		into.set(filePath, map);
+	}
+	const body = program.body;
+	if (!body) return;
+	for (const stmt of body) walkStatement(stmt);
+	function walkStatement(stmt) {
+		if (stmt.type === "VariableDeclaration") {
+			for (const d of stmt.declarations ?? []) processDeclarator(d);
+			return;
+		}
+		if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) walkStatement(stmt.declaration);
+	}
+	function processDeclarator(decl) {
+		if (decl.type !== "VariableDeclarator") return;
+		const id = decl.id;
+		if (id.type !== "Identifier" || typeof id.name !== "string") return;
+		const tpl = findTaggedTemplate(unwrapInitializer(decl.init));
+		if (!tpl || tpl.type !== "TaggedTemplateExpression") return;
+		const base = classifyStyledTemplateTag(tpl.tag, styledLocalNames);
+		if (base) map.set(id.name, base);
+	}
+}
+function unwrapInitializer(node) {
+	let cur = node ?? void 0;
+	while (cur) {
+		if (cur.type === "TSAsExpression" || cur.type === "AsExpression") {
+			cur = cur.expression;
+			continue;
+		}
+		if (cur.type === "ParenthesizedExpression") {
+			cur = cur.expression;
+			continue;
+		}
+		return cur;
+	}
+}
+function findTaggedTemplate(node) {
+	const n = unwrapInitializer(node);
+	if (!n) return;
+	if (n.type === "TaggedTemplateExpression") return n;
+}
+/** Peel `.attrs` / `.withConfig` / nested calls down to `styled.div` or `styled(X)`. */
+function peelStyledApplication(tag, styledNames) {
+	let cur = tag;
+	while (cur) {
+		if (cur.type === "CallExpression") {
+			const callee = cur.callee;
+			if (callee?.type === "MemberExpression") {
+				cur = callee;
+				continue;
+			}
+			if (callee?.type === "Identifier" && typeof callee.name === "string" && styledNames.has(callee.name)) return cur;
+			return null;
+		}
+		if (cur.type === "MemberExpression") {
+			const obj = cur.object;
+			if (obj?.type === "Identifier" && typeof obj.name === "string" && styledNames.has(obj.name)) return cur;
+			cur = obj;
+			continue;
+		}
+		break;
+	}
+	return null;
+}
+function classifyStyledTemplateTag(tag, styledNames) {
+	const root = peelStyledApplication(tag, styledNames);
+	if (!root) return null;
+	if (root.type === "MemberExpression") {
+		const obj = root.object;
+		const prop = root.property;
+		const objName = obj?.type === "Identifier" ? obj.name : void 0;
+		if (obj?.type !== "Identifier" || typeof objName !== "string" || !styledNames.has(objName)) return null;
+		const isComputed = Boolean(root.computed);
+		if (isComputed && prop?.type === "StringLiteral" && typeof prop.value === "string") return { kind: "intrinsic" };
+		if (!isComputed && prop?.type === "Identifier" && typeof prop.name === "string") return { kind: "intrinsic" };
+		return null;
+	}
+	if (root.type === "CallExpression") {
+		const callee = root.callee;
+		const arg0 = root.arguments?.[0];
+		const calleeName = callee?.type === "Identifier" ? callee.name : void 0;
+		if (callee?.type !== "Identifier" || typeof calleeName !== "string" || !styledNames.has(calleeName) || !arg0) return null;
+		if (arg0.type === "Identifier" && typeof arg0.name === "string") return {
+			kind: "component",
+			ident: arg0.name
+		};
+		if (arg0.type === "StringLiteral" && typeof arg0.value === "string") return { kind: "intrinsic" };
+		return null;
+	}
+	return null;
+}
+/**
+* Fixed-point: a styled binding is a leaf if its base is intrinsic, or its base
+* component resolves (same-file or import) to another leaf binding in the transform set.
+*
+* @param transformSet - Absolute realpaths of files being transformed
+* @param styledDefBases - From {@link extractStyledDefBasesFromSource}
+* @param resolve - Module path resolver
+* @param cachedRead - Read file source for import resolution
+*/
+function computeGlobalLeafKeys(args) {
+	const { transformSet, styledDefBases, resolve, cachedRead, toRealPath, resolveBaseComponent } = args;
+	/** fileRealPath → Set of local binding names that are leaves */
+	const globalLeaves = /* @__PURE__ */ new Map();
+	const ensureSet = (file) => {
+		let s = globalLeaves.get(file);
+		if (!s) {
+			s = /* @__PURE__ */ new Set();
+			globalLeaves.set(file, s);
+		}
+		return s;
+	};
+	const isLeaf = (file, name) => globalLeaves.get(file)?.has(name) ?? false;
+	const tryResolveImportedLeaf = (file, ident) => {
+		const importInfo = findImportSource(cachedRead(file), ident);
+		if (!importInfo) return false;
+		const initialDefFile = resolve(importInfo.source, file);
+		if (!initialDefFile) return false;
+		const defReal = toRealPath(resolveBarrelReExport(initialDefFile, importInfo.isDefault ? "default" : importInfo.exportedName, resolve, cachedRead) ?? initialDefFile);
+		if (!transformSet.has(defReal)) return false;
+		return leafKeyExists(defReal, importInfo.exportedName, importInfo.isDefault, cachedRead, globalLeaves);
+	};
+	const tryResolveAdapterIntrinsic = (file, ident) => {
+		if (!resolveBaseComponent) return false;
+		const importInfo = findImportSource(cachedRead(file), ident);
+		if (!importInfo) return false;
+		try {
+			const result = resolveBaseComponent({
+				importSource: importInfo.source,
+				importedName: importInfo.exportedName,
+				staticProps: {},
+				filePath: file
+			});
+			return typeof result?.tagName === "string" && result.tagName.trim() !== "";
+		} catch {
+			return false;
+		}
+	};
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const [filePath, nameMap] of styledDefBases) {
+			const fileReal = toRealPath(filePath);
+			if (!transformSet.has(fileReal)) continue;
+			for (const [name, base] of nameMap) {
+				if (isLeaf(fileReal, name)) continue;
+				if (base.kind === "intrinsic") {
+					ensureSet(fileReal).add(name);
+					changed = true;
+					continue;
+				}
+				const ident = base.ident;
+				if (isLeaf(fileReal, ident)) {
+					ensureSet(fileReal).add(name);
+					changed = true;
+					continue;
+				}
+				if (tryResolveAdapterIntrinsic(filePath, ident)) {
+					ensureSet(fileReal).add(name);
+					changed = true;
+					continue;
+				}
+				if (tryResolveImportedLeaf(filePath, ident)) {
+					ensureSet(fileReal).add(name);
+					changed = true;
+				}
+			}
+		}
+	}
+	const globalLeafKeys = /* @__PURE__ */ new Set();
+	for (const [file, names] of globalLeaves) for (const name of names) globalLeafKeys.add(`${file}:${name}`);
+	return globalLeafKeys;
+}
+function leafKeyExists(defFile, exportedName, allowDefaultFallback, cachedRead, globalLeaves) {
+	if (globalLeaves.get(defFile)?.has(exportedName) ?? false) return true;
+	if (!allowDefaultFallback) return false;
+	const defaultLocalName = findDefaultExportedLocalName(cachedRead(defFile));
+	return defaultLocalName ? globalLeaves.get(defFile)?.has(defaultLocalName) ?? false : false;
+}
+function findDefaultExportedLocalName(source) {
+	return source.match(/\bexport\s+default\s+([A-Z][A-Za-z0-9]*)\b/)?.[1] ?? source.match(/\bexport\s*\{[^}]*\b([A-Z][A-Za-z0-9]*)\s+as\s+default\b[^}]*\}/)?.[1];
+}
+//#endregion
+export { extractStyledDefBasesFromAstProgram as n, extractStyledDefBasesFromSource as r, computeGlobalLeafKeys as t };

package/dist/{extract-external-interface-BgvS5GC0.mjs → extract-external-interface-CdHbvfxu.mjs}

@@ -119,9 +119,20 @@ var Logger = class Logger {
 	}
 	static formatContext(context) {
 		if (typeof context === "undefined") return null;
-		return JSON.stringify(context, null, 2);
+		return JSON.stringify(context, createContextReplacer(), 2);
 	}
 };
+function createContextReplacer() {
+	const seen = /* @__PURE__ */ new WeakSet();
+	return (key, value) => {
+		if (key === "loc" || key === "tokens" || key === "comments" || key === "start" || key === "end") return;
+		if (value && typeof value === "object") {
+			if (seen.has(value)) return "[Circular]";
+			seen.add(value);
+		}
+		return value;
+	};
+}
 var LoggerReport = class {
 	warnings;
 	fileCount;

package/dist/{forwarded-as-consumer-patcher-CqxniQIc.mjs → forwarded-as-consumer-patcher-Cs0X-olz.mjs}

@@ -1,5 +1,5 @@
-import { n as toRealPath } from "./path-utils-CMR9NmMm.mjs";
-import { r as escapeRegex } from "./string-utils-ChXtospT.mjs";
+import { n as toRealPath } from "./path-utils-BIpoL4Ue.mjs";
+import { r as escapeRegex } from "./string-utils-KggM5TNH.mjs";
 import { readFileSync } from "node:fs";
 //#region src/internal/forwarded-as-consumer-patcher.ts
 /**

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { a as CollectedWarning, c as MarkerFileContext, l as defineAdapter, n as TransformMode, o as AdapterInput, s as ImportSource } from "./transform-types-CY57kiqK.mjs";
+import { a as CollectedWarning, c as MarkerFileContext, l as defineAdapter, n as TransformMode, o as AdapterInput, s as ImportSource } from "./transform-types--9qCqNSJ.mjs";
 
 //#region src/run.d.ts
 interface RunTransformOptions {

package/dist/index.mjs

@@ -1,6 +1,7 @@
-import { o as assertValidAdapterInput, r as defineAdapter, s as describeValue, t as mergeMarkerDeclarations } from "./merge-markers-CJ02ZuW0.mjs";
-import { a as Logger, i as resolveBarrelReExport } from "./extract-external-interface-BgvS5GC0.mjs";
-import { n as toRealPath } from "./path-utils-CMR9NmMm.mjs";
+import { o as assertValidAdapterInput, r as defineAdapter, s as describeValue, t as mergeMarkerDeclarations } from "./merge-markers-BC5YNB7D.mjs";
+import { a as Logger, i as resolveBarrelReExport } from "./extract-external-interface-CdHbvfxu.mjs";
+import { r as extractStyledDefBasesFromSource } from "./compute-leaf-set-Drcu2eju.mjs";
+import { n as toRealPath } from "./path-utils-BIpoL4Ue.mjs";
 import jscodeshift from "jscodeshift";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { dirname, join, resolve } from "node:path";
@@ -148,7 +149,7 @@ async function runTransform(options) {
 	const { createModuleResolver } = await import("./resolve-imports-BlxKezSJ.mjs").then((n) => n.n);
 	const sharedResolver = createModuleResolver();
 	filePaths = orderFilesByLocalImportDependencies(filePaths, sharedResolver, toRealPath);
-	const { runPrepass } = await import("./run-prepass-5LTAQkG0.mjs");
+	const { runPrepass } = await import("./run-prepass-Us5SBTib.mjs");
 	const absoluteFiles = filePaths.map((f) => resolve(f));
 	const absoluteConsumers = consumerFilePaths.map((f) => resolve(f));
 	let prepassResult;
@@ -197,6 +198,33 @@ async function runTransform(options) {
 				}
 			};
 			const lookupAutoExternalInterface = (filePath, componentName) => analysisMap.get(`${toRealPath(filePath)}:${componentName}`);
+			const styledDefinitionNamesByFile = /* @__PURE__ */ new Map();
+			const resolveExistingSourcePath = (filePath) => {
+				for (const ext of [
+					"",
+					".tsx",
+					".ts",
+					".jsx",
+					".js"
+				]) {
+					const candidate = `${filePath}${ext}`;
+					if (existsSync(candidate)) return candidate;
+				}
+				return filePath;
+			};
+			const getStyledDefinitionNames = (filePath) => {
+				const realPath = toRealPath(resolveExistingSourcePath(filePath));
+				const cached = styledDefinitionNamesByFile.get(realPath);
+				if (cached) return cached;
+				const extracted = /* @__PURE__ */ new Map();
+				extractStyledDefBasesFromSource(realPath, cachedRead(realPath), extracted);
+				const names = new Set(extracted.get(realPath)?.keys() ?? []);
+				styledDefinitionNamesByFile.set(realPath, names);
+				return names;
+			};
+			const getDefaultExportedName = (filePath) => {
+				return cachedRead(toRealPath(resolveExistingSourcePath(filePath))).match(/\bexport\s+default\s+([A-Z][A-Za-z0-9]*)\b/)?.[1] ?? null;
+			};
 			return {
 				...adapterInput,
 				externalInterface: (ctx) => {
@@ -213,9 +241,14 @@ async function runTransform(options) {
 					const resolvedImport = sharedResolver.resolve(resolve(ctx.filePath), ctx.importSource);
 					if (!resolvedImport) return;
 					const resolvedPath = toRealPath(resolvedImport);
-					const definitionPath = resolveBarrelReExport(resolvedPath, ctx.importedName, prepassResolve, cachedRead) ?? resolvedPath;
-					if (!transformedFiles.has(toRealPath(definitionPath))) return;
-					return (ctx.importedName === "default" ? [ctx.localName, ctx.importedName] : [ctx.importedName]).map((name) => lookupAutoExternalInterface(definitionPath, name)).find((result) => result !== void 0)?.styles ? { acceptsSx: true } : void 0;
+					const definitionSourcePath = resolveExistingSourcePath(resolveBarrelReExport(resolvedPath, ctx.importedName, prepassResolve, cachedRead) ?? resolvedPath);
+					if (!transformedFiles.has(toRealPath(definitionSourcePath))) return;
+					const autoInterfaceNames = ctx.importedName === "default" ? [ctx.localName, ctx.importedName] : [ctx.importedName];
+					const styledDefinitionNames = getStyledDefinitionNames(definitionSourcePath);
+					const sourceComponentNames = ctx.importedName === "default" ? [ctx.localName, getDefaultExportedName(definitionSourcePath)].filter((name) => typeof name === "string") : [ctx.importedName];
+					const definitionSource = cachedRead(definitionSourcePath);
+					if (!(definitionSource.includes("sx?: stylex.StyleXStyles") && sourceComponentNames.some((name) => definitionSource.includes(name))) && !sourceComponentNames.some((name) => styledDefinitionNames.has(name))) return;
+					return autoInterfaceNames.map((name) => lookupAutoExternalInterface(definitionSourcePath, name)).find((result) => result !== void 0)?.styles ? { acceptsSx: true } : void 0;
 				}
 			};
 		}
@@ -275,7 +308,7 @@ async function runTransform(options) {
 	const result = await runTransformSequentially(transformModule, filePaths, runnerOptions);
 	if (sidecarFiles.size > 0 && !dryRun) for (const [sidecarPath, content] of sidecarFiles) await writeFile(sidecarPath, mergeSidecarContent(sidecarPath, content), "utf-8");
 	if (bridgeResults.size > 0 && !dryRun) {
-		const { buildConsumerReplacements, patchConsumerFile } = await import("./bridge-consumer-patcher-CKOMofN8.mjs");
+		const { buildConsumerReplacements, patchConsumerFile } = await import("./bridge-consumer-patcher-BzAIO9pC.mjs");
 		const consumerReplacements = buildConsumerReplacements(crossFilePrepassResult.selectorUsages, bridgeResults, transformedFiles);
 		const patchedFiles = [];
 		for (const [consumerPath, replacements] of consumerReplacements) {
@@ -288,7 +321,7 @@ async function runTransform(options) {
 		if (formatterCommands && patchedFiles.length > 0) await runFormatters(formatterCommands, patchedFiles);
 	}
 	if (prepassResult.forwardedAsConsumers.size > 0 && !dryRun) {
-		const { buildForwardedAsReplacements, patchConsumerForwardedAs } = await import("./forwarded-as-consumer-patcher-CqxniQIc.mjs");
+		const { buildForwardedAsReplacements, patchConsumerForwardedAs } = await import("./forwarded-as-consumer-patcher-Cs0X-olz.mjs");
 		const forwardedAsReplacements = buildForwardedAsReplacements(prepassResult.forwardedAsConsumers, transformedFiles);
 		const patchedFiles = [];
 		for (const [consumerPath, entries] of forwardedAsReplacements) {
@@ -301,7 +334,7 @@ async function runTransform(options) {
 		if (formatterCommands && patchedFiles.length > 0) await runFormatters(formatterCommands, patchedFiles);
 	}
 	if (transientPropRenames.size > 0 && !dryRun) {
-		const { collectTransientPropPatches } = await import("./transient-prop-consumer-patcher-CKAzqPfK.mjs");
+		const { collectTransientPropPatches } = await import("./transient-prop-consumer-patcher-DLsKxg1R.mjs");
 		const patches = collectTransientPropPatches({
 			transientPropRenames,
 			consumerFilePaths: consumerFilePaths.map((p) => resolve(p)),

package/dist/{merge-markers-CJ02ZuW0.mjs → merge-markers-BC5YNB7D.mjs}

@@ -55,6 +55,7 @@ function assertAdapterShape(candidate, where, allowAutoExtIf) {
 		"",
 		"resolveSelector(context) is called with:",
 		"  - { kind: \"selectorInterpolation\", importedName, source, path? }",
+		"  - { kind: \"mediaQueryInterpolation\", importedName, source, path?, mediaQuery }",
 		"",
 		`Docs/examples: ${ADAPTER_DOCS_URL}`
 	].join("\n"));
@@ -250,6 +251,8 @@ const DEFAULT_THEME_HOOK = {
 *       // - { 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;
 *     },
 *
@@ -292,24 +295,98 @@ function defineAdapter(adapter) {
 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 incomingExports = [...incoming.matchAll(MARKER_EXPORT_RE)].map((m) => m[0]);
-	if (incomingExports.length === 0) return base;
+	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 base;
+	if (newExportLines.length === 0) return [];
 	const newExportSet = new Set(newExportLines);
-	const blocksToAdd = [...incoming.matchAll(MARKER_BLOCK_RE)].map((m) => m[0]).filter((block) => {
-		const exportLine = block.match(MARKER_EXPORT_RE);
+	return [...incoming.matchAll(blockRegex)].map((m) => m[0]).filter((block) => {
+		const exportLine = block.match(exportRegex);
 		return exportLine && newExportSet.has(exportLine[0]);
 	});
-	if (blocksToAdd.length === 0) return base;
+}
+function mergeDefineVarsBlocks(base, incoming) {
 	let merged = base;
-	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";
+	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
 export { assertValidAdapter as a, isDirectionalResult as i, DEFAULT_THEME_HOOK as n, assertValidAdapterInput as o, defineAdapter as r, describeValue as s, mergeMarkerDeclarations as t };