@tamagui/codemod-flat-values 0.0.0-bootstrap.0 → 3.0.0-beta.1093.1

package/dist/convert.mjs

@@ -0,0 +1,1233 @@
+import { Node, SyntaxKind } from "ts-morph";
+import { compact, literalTree, numericValue, runtimeType, staticLeafValue, unwrapExpression } from "./expressions.mjs";
+import { assessFlatConversion, convertLegacyConditionProp, expandToLonghands, flatStringValue, mergeProgramValues, parseValue, printProgram, resolveProp, sharedPayload, shorthands, styleProps, tokenVariantProps, unitSuffix } from "./grammar.mjs";
+import { isLegacyConditionName, resolveLegacyName } from "./legacyNames.mjs";
+import { classifyStructuredNativeValue } from "./structuredNative.mjs";
+
+function assessmentVerdict(assessments) {
+	if (assessments.some((assessment) => assessment.verdict === "ineligible")) {
+		return "ineligible";
+	}
+	if (assessments.some((assessment) => assessment.verdict === "needs-relocation")) {
+		return "needs-relocation";
+	}
+	return assessments.length ? "unknown-host" : "clean";
+}
+function createSite(kind, registry, containers, targets, host) {
+	return {
+		kind,
+		registry,
+		containers,
+		targets,
+		host,
+		members: [],
+		comments: /* @__PURE__ */ new Map(),
+		extras: [],
+		respelled: [],
+		warnings: [],
+		flags: [],
+		inventory: [],
+		pending: [],
+		assessments: [],
+		notes: [],
+		legacy: false,
+		index: 0
+	};
+}
+function assessProgram(site, property, modifiers) {
+	const targetProperty = resolveProp(property);
+	const assessment = assessFlatConversion({
+		property: targetProperty,
+		modifiers,
+		targets: site.targets,
+		host: site.host
+	}, site.registry);
+	if (assessment.verdict !== "clean") addAssessment(site, targetProperty, assessment);
+	return assessment.verdict !== "ineligible";
+}
+function addAssessment(site, property, assessment) {
+	if (assessment.verdict === "clean") return;
+	if (!site.assessments.some((finding) => finding.property === property && finding.verdict === assessment.verdict && JSON.stringify(finding.reasons) === JSON.stringify(assessment.reasons))) {
+		site.assessments.push({
+			property,
+			verdict: assessment.verdict,
+			reasons: assessment.reasons
+		});
+	}
+}
+function legacyKeysInSpread(expression) {
+	const names = /* @__PURE__ */ new Set();
+	for (const object of expression.getDescendantsOfKind(SyntaxKind.ObjectLiteralExpression)) {
+		for (const property of object.getProperties()) {
+			if (!Node.isPropertyAssignment(property)) continue;
+			const name = propertyName(property.getNameNode());
+			if (name !== null && isLegacyConditionName(name)) names.add(name);
+		}
+	}
+	return [...names];
+}
+function pushSpread(site, expression, text) {
+	const keys = legacyKeysInSpread(expression);
+	if (keys.length) {
+		site.legacy = true;
+		addFlag(site.flags, "legacy-condition-in-spread", `"${compact(text)}" is not an inline object literal, so its ${keys.map((key) => `"${key}"`).join(", ")} ${keys.length === 1 ? "entry stays" : "entries stay"} authored`);
+	}
+	site.members.push({
+		type: "spread",
+		index: site.index++,
+		text,
+		legacy: keys.length > 0
+	});
+}
+function converted(site, report) {
+	return report.programs.length > 0 || site.extras.length > 0 || site.members.some((member) => member.type === "authored" && member.activated || member.type === "legacy" && !member.failed);
+}
+function legacyLeft(site) {
+	return site.members.filter((member) => member.type === "legacy" && member.failed || member.type === "spread" && member.legacy).length;
+}
+function isConvertedName(name) {
+	return name === "group" || styleProps.has(name) || tokenVariantProps.has(name) || isLegacyConditionName(name);
+}
+function addFlag(list, code, detail) {
+	if (!list.some((flag) => flag.code === code && flag.detail === detail)) {
+		list.push({
+			code,
+			detail
+		});
+	}
+}
+function addNote(site, note) {
+	if (!site.notes.includes(note)) site.notes.push(note);
+}
+const legacyPaletteStepPattern = /(?:^|[^\w-])\$?((?:gray|mauve|slate|sage|olive|sand|tomato|red|ruby|crimson|pink|plum|purple|violet|iris|indigo|blue|cyan|teal|jade|green|grass|bronze|gold|brown|orange|amber|yellow|lime|mint|sky)(?:1[0-2]|[1-9]))(?![\w-])/g;
+const legacyTrueTokenPattern = /(?:^|[^\w-])\$true(?![\w-])/;
+function legacyTokenWarnings(prop, values) {
+	const warnings = [];
+	if (values.some((value) => legacyTrueTokenPattern.test(value))) {
+		warnings.push({
+			code: "legacy-true-token",
+			detail: `${prop} spelled the \`$true\` alias, written as \`4\` because the default config aliased it there; confirm the app's tokens agree`
+		});
+	}
+	const names = /* @__PURE__ */ new Set();
+	for (const value of values) {
+		legacyPaletteStepPattern.lastIndex = 0;
+		for (const match of value.matchAll(legacyPaletteStepPattern)) names.add(match[1]);
+	}
+	if (!names.size) return warnings;
+	const formatted = [...names].sort().map((name) => `\`${name}\``).join(", ");
+	warnings.push({
+		code: "legacy-palette-token",
+		detail: `${prop} preserves ${formatted}, which @tamagui/config/v6 does not define; choose an absolute palette token or an adaptive colorN value`
+	});
+	return warnings;
+}
+const empty = {
+	payload: null,
+	text: null,
+	dynamic: false,
+	problem: null,
+	warnings: [],
+	blocked: null,
+	inventory: null
+};
+function interpolate(prop, text, kind, registry) {
+	return `\${${text}}${kind === "number" ? unitSuffix(resolveProp(prop), registry) : ""}`;
+}
+function classifyStatic(prop, value, registry) {
+	const probe = sharedPayload(prop, value, registry);
+	const error = probe.errors[0];
+	if (error || probe.payload === null) {
+		const flag = {
+			code: error?.code ?? "unsupported-legacy-value",
+			detail: `${prop}: ${error?.message ?? `"${String(value)}" has no flat spelling`}`
+		};
+		return {
+			...empty,
+			problem: flag,
+			blocked: flag
+		};
+	}
+	return {
+		...empty,
+		payload: probe.payload
+	};
+}
+function reparsesAsBase(value, registry) {
+	const parsed = parseValue(value, registry);
+	return parsed.ok && parsed.value.clauses.length === 0 && parsed.value.base === value.trim();
+}
+function classifyDynamic(prop, expression, registry) {
+	const current = unwrapExpression(expression);
+	const source = compact(current.getText());
+	const structured = classifyStructuredNativeValue(resolveProp(prop), current, source, registry);
+	if (structured) {
+		return {
+			...empty,
+			payload: structured.payload,
+			blocked: structured.blocked
+		};
+	}
+	const tree = literalTree(current, registry);
+	if (tree && tree.error) {
+		const flag2 = {
+			code: tree.error.code,
+			detail: `${prop}: ${tree.error.message}`
+		};
+		return {
+			...empty,
+			problem: flag2,
+			blocked: flag2
+		};
+	}
+	if (tree && tree.kind !== "nullish") {
+		const rewrittenTokenText = /\$(?=[\w-])/.test(source) && tree.text !== source ? tree.text : null;
+		return {
+			...empty,
+			payload: interpolate(prop, tree.text, tree.kind, registry),
+			text: rewrittenTokenText,
+			dynamic: true,
+			warnings: legacyTokenWarnings(prop, tree.strings)
+		};
+	}
+	if (tree) {
+		const flag2 = {
+			code: "empty-style-value",
+			detail: `${prop} value "${source}" is always nullish and cannot join a program`
+		};
+		return {
+			...empty,
+			blocked: flag2
+		};
+	}
+	const runtime = runtimeType(current);
+	if (runtime.kind === "number") {
+		return {
+			...empty,
+			payload: interpolate(prop, source, "number", registry),
+			dynamic: true
+		};
+	}
+	if (runtime.kind === "string") {
+		const tokens = runtime.literals?.filter((literal) => literal.startsWith("$"));
+		if (tokens?.length) {
+			const flag2 = {
+				code: "legacy-token-constant",
+				detail: `${prop} value "${source}" resolves to legacy token ${tokens.map((token) => `"${token}"`).join(", ")}; migrate the constant it comes from`
+			};
+			return {
+				...empty,
+				problem: flag2,
+				blocked: flag2
+			};
+		}
+		if (runtime.literals === null) {
+			return {
+				...empty,
+				payload: interpolate(prop, source, "string", registry),
+				dynamic: true,
+				inventory: {
+					code: "dynamic-string-value",
+					detail: `${prop} value "${source}" is an open string; confirm it never holds a legacy "$token" spelling`
+				}
+			};
+		}
+		return {
+			...empty,
+			payload: interpolate(prop, source, "string", registry),
+			dynamic: true
+		};
+	}
+	const flag = {
+		code: "unprovable-dynamic-value",
+		detail: `${prop} value "${source}" has no provable number or string type, so it cannot fold into a program`
+	};
+	return {
+		...empty,
+		blocked: flag
+	};
+}
+function pushBase(site, prop, text, value, literalString) {
+	const index = site.index++;
+	if (literalString !== null) {
+		for (const warning of legacyTokenWarnings(prop, [literalString])) {
+			addFlag(site.warnings, warning.code, warning.detail);
+		}
+		if (literalString.includes("$")) {
+			site.legacy = true;
+			const allowed2 = assessProgram(site, prop, []);
+			const flat = flatStringValue(literalString, site.registry);
+			const problem = flat.text === null ? {
+				code: flat.error?.code ?? "unsupported-legacy-value",
+				detail: `${prop}: ${flat.error?.message ?? `${JSON.stringify(literalString)} has no flat spelling`}`
+			} : !reparsesAsBase(flat.text, site.registry) ? {
+				code: "value-reparses-as-program",
+				detail: `${prop} value ${JSON.stringify(flat.text)} does not read back as one flat base value`
+			} : null;
+			if (problem !== null) addFlag(site.flags, problem.code, problem.detail);
+			site.members.push({
+				type: "authored",
+				index,
+				prop,
+				text,
+				payload: allowed2 && problem === null ? flat.text : null,
+				dynamic: false,
+				blocked: problem,
+				token: allowed2,
+				activated: false
+			});
+			return;
+		}
+		if (!reparsesAsBase(literalString, site.registry)) {
+			const flag = {
+				code: "value-reparses-as-program",
+				detail: `${prop} value ${JSON.stringify(literalString)} does not read back as one flat base value`
+			};
+			addFlag(site.flags, flag.code, flag.detail);
+			site.members.push({
+				type: "authored",
+				index,
+				prop,
+				text,
+				payload: null,
+				dynamic: false,
+				blocked: flag,
+				token: false,
+				activated: false
+			});
+			return;
+		}
+		site.members.push({
+			type: "authored",
+			index,
+			prop,
+			text,
+			payload: literalString,
+			dynamic: false,
+			blocked: null,
+			token: false,
+			activated: false
+		});
+		return;
+	}
+	const number = value ? numericValue(value) : null;
+	if (number !== null) {
+		const classified2 = classifyStatic(prop, number, site.registry);
+		site.members.push({
+			type: "authored",
+			index,
+			prop,
+			text,
+			payload: classified2.payload,
+			dynamic: false,
+			blocked: classified2.blocked,
+			token: false,
+			activated: false
+		});
+		return;
+	}
+	const kind = value?.getKind();
+	if (value === null || kind === SyntaxKind.TrueKeyword || kind === SyntaxKind.FalseKeyword || kind === SyntaxKind.NullKeyword) {
+		site.members.push({
+			type: "authored",
+			index,
+			prop,
+			text,
+			payload: null,
+			dynamic: false,
+			blocked: {
+				code: "non-css-style-value",
+				detail: `${prop} value "${compact(text)}" is not a CSS value and cannot join a program`
+			},
+			token: false,
+			activated: false
+		});
+		return;
+	}
+	const classified = classifyDynamic(prop, value, site.registry);
+	if (classified.problem) {
+		site.legacy = true;
+		addFlag(site.flags, classified.problem.code, classified.problem.detail);
+	}
+	for (const warning of classified.warnings) {
+		addFlag(site.warnings, warning.code, warning.detail);
+	}
+	if (classified.inventory) {
+		addFlag(site.inventory, classified.inventory.code, classified.inventory.detail);
+	}
+	if (classified.text !== null) site.legacy = true;
+	const allowed = classified.text === null || assessProgram(site, prop, []);
+	site.members.push({
+		type: "authored",
+		index,
+		prop,
+		text,
+		payload: allowed ? classified.payload : null,
+		dynamic: classified.dynamic,
+		blocked: classified.blocked,
+		token: allowed && classified.text !== null,
+		activated: false
+	});
+}
+const sentinelMark = "
";
+function evaluateLegacyObject(object, rootPath) {
+	const leaves = [];
+	const visit = (current, currentPath) => {
+		const value = {};
+		for (const property of current.getProperties()) {
+			if (Node.isSpreadAssignment(property)) {
+				return {
+					value: null,
+					fatal: `spread "${compact(property.getText())}" hides legacy condition entries`
+				};
+			}
+			if (!Node.isPropertyAssignment(property)) {
+				return {
+					value: null,
+					fatal: `property "${compact(property.getText())}" is not a static assignment`
+				};
+			}
+			const nameNode = property.getNameNode();
+			if (Node.isComputedPropertyName(nameNode)) {
+				return {
+					value: null,
+					fatal: `computed property "${compact(nameNode.getText())}" hides the affected style property`
+				};
+			}
+			const name = propertyName(nameNode);
+			if (name === null) {
+				return {
+					value: null,
+					fatal: `property name "${compact(nameNode.getText())}" is not statically known`
+				};
+			}
+			const path = `${currentPath}.${name}`;
+			const initializer = unwrapExpression(property.getInitializerOrThrow());
+			if (Node.isObjectLiteralExpression(initializer)) {
+				const nested = visit(initializer, path);
+				if (nested.fatal) return nested;
+				value[name] = nested.value;
+				continue;
+			}
+			const leaf = staticLeafValue(initializer);
+			if (leaf) {
+				value[name] = leaf.value;
+				continue;
+			}
+			value[name] = `${sentinelMark}${leaves.length}${sentinelMark}`;
+			leaves.push({
+				path,
+				prop: name,
+				expression: initializer
+			});
+		}
+		return {
+			value,
+			fatal: null
+		};
+	};
+	const result = visit(object, rootPath);
+	return {
+		...result,
+		leaves
+	};
+}
+function conditionProperties(value) {
+	const properties = /* @__PURE__ */ new Set();
+	const visit = (object) => {
+		for (const key in object) {
+			const child = object[key];
+			if (child !== null && typeof child === "object" && isLegacyConditionName(key)) {
+				visit(child);
+				continue;
+			}
+			if (!styleProps.has(key)) continue;
+			for (const property of expandToLonghands(key, shorthands)) properties.add(property);
+		}
+	};
+	visit(value);
+	return properties;
+}
+function pushLegacy(site, name, text, initializer, node) {
+	const index = site.index++;
+	site.legacy = true;
+	const keep = (properties2) => {
+		site.members.push({
+			type: "legacy",
+			index,
+			name,
+			text,
+			contributions: [],
+			properties: properties2,
+			failed: true
+		});
+	};
+	if (initializer === null || !Node.isObjectLiteralExpression(initializer)) {
+		addFlag(site.flags, "dynamic-legacy-condition", `"${name}" is not an inline object literal, so its entries are not statically known`);
+		keep(null);
+		return;
+	}
+	const evaluated = evaluateLegacyObject(initializer, name);
+	if (evaluated.fatal || evaluated.value === null) {
+		addFlag(site.flags, "dynamic-legacy-condition", evaluated.fatal ?? "unresolved");
+		keep(null);
+		return;
+	}
+	const properties = conditionProperties(evaluated.value);
+	const eligibilityStack = [{
+		object: evaluated.value,
+		path: name
+	}];
+	let hasRejectedProperty = false;
+	while (eligibilityStack.length > 0) {
+		const current = eligibilityStack.pop();
+		for (const prop in current.object) {
+			const value = current.object[prop];
+			const targetProp = resolveProp(prop);
+			if (styleProps.has(targetProp) && !isLegacyConditionName(prop)) {
+				const assessment = assessFlatConversion({
+					property: targetProp,
+					targets: site.targets,
+					host: site.host
+				}, site.registry);
+				if (assessment.verdict === "ineligible") {
+					addAssessment(site, targetProp, assessment);
+					hasRejectedProperty = true;
+				}
+				continue;
+			}
+			if (value !== null && typeof value === "object" && !Array.isArray(value) && isLegacyConditionName(prop)) {
+				eligibilityStack.push({
+					object: value,
+					path: `${current.path}.${prop}`
+				});
+			}
+		}
+	}
+	if (hasRejectedProperty) {
+		keep(properties);
+		return;
+	}
+	const unresolved = site.containers.unresolved.get(node);
+	if (unresolved !== void 0) {
+		addFlag(site.flags, unresolved.code, unresolved.detail);
+		keep(properties);
+		return;
+	}
+	const resolution = resolveLegacyName(name, site.registry);
+	if (!resolution.ok) {
+		addFlag(site.flags, resolution.code, resolution.message);
+		keep(properties);
+		return;
+	}
+	const payloads = /* @__PURE__ */ new Map();
+	let failed = false;
+	for (let index2 = 0; index2 < evaluated.leaves.length; index2++) {
+		const leaf = evaluated.leaves[index2];
+		const classified = classifyDynamic(leaf.prop, leaf.expression, site.registry);
+		for (const warning of classified.warnings) {
+			addFlag(site.warnings, warning.code, `${leaf.path}: ${warning.detail}`);
+		}
+		if (classified.payload === null) {
+			const flag = classified.problem ?? classified.blocked;
+			addFlag(site.flags, flag?.code ?? "dynamic-condition-value", `${leaf.path}: ${flag?.detail ?? "the value is not statically known"}`);
+			failed = true;
+			continue;
+		}
+		payloads.set(`${sentinelMark}${index2}${sentinelMark}`, classified.payload);
+	}
+	if (failed) {
+		keep(properties);
+		return;
+	}
+	const { canonical, replaceRoot } = resolution.resolved;
+	const converted2 = convertLegacyConditionProp(canonical, evaluated.value, { registry: site.registry });
+	if (converted2 === null) {
+		addFlag(site.flags, "unknown-legacy-condition", `"${name}" is not a registered legacy condition spelling`);
+		keep(properties);
+		return;
+	}
+	for (const error of converted2.errors) {
+		const path = error.path.startsWith(canonical) ? `${name}${error.path.slice(canonical.length)}` : error.path;
+		addFlag(site.flags, error.code, `${path}: ${error.message}`);
+		failed = true;
+	}
+	const contributions = [];
+	for (const contribution of converted2.contributions) {
+		if (!styleProps.has(contribution.prop)) {
+			addFlag(site.flags, "non-style-condition-entry", `${name}.${contribution.prop} is not a style property, so a flat value cannot carry it`);
+			failed = true;
+			continue;
+		}
+		const modifiers = replaceRoot ? [...replaceRoot, ...contribution.clause.modifiers.slice(1)] : contribution.clause.modifiers;
+		const dynamicPayload = payloads.get(contribution.clause.payload);
+		contributions.push({
+			prop: contribution.prop,
+			clause: {
+				modifiers,
+				payload: dynamicPayload ?? contribution.clause.payload
+			},
+			dynamic: dynamicPayload !== void 0
+		});
+		if (!assessProgram(site, contribution.prop, modifiers)) failed = true;
+	}
+	if (failed) {
+		keep(properties);
+		return;
+	}
+	site.members.push({
+		type: "legacy",
+		index,
+		name,
+		text,
+		contributions,
+		properties,
+		failed: false
+	});
+}
+function activationName(prop) {
+	return resolveProp(prop);
+}
+const noProperties = /* @__PURE__ */ new Set();
+const legacyStatePriorities = Object.freeze({
+	hover: 2,
+	press: 3,
+	active: 3,
+	focus: 4,
+	"focus-visible": 4,
+	"focus-within": 4,
+	enter: 4,
+	disabled: 5,
+	exit: 5
+});
+function legacyStatePriority(modifiers) {
+	let priority = null;
+	for (const modifier of modifiers) {
+		const candidate = legacyStatePriorities[modifier];
+		if (candidate !== void 0 && (priority === null || candidate > priority)) {
+			priority = candidate;
+		}
+	}
+	return priority;
+}
+function orderedEntries(site) {
+	const ordered = [];
+	for (const member of site.members) {
+		if (member.type === "authored") {
+			if (!member.activated || member.payload === null) continue;
+			ordered.push({
+				prop: member.prop,
+				value: {
+					base: member.payload,
+					clauses: []
+				},
+				dynamic: member.dynamic,
+				index: member.index,
+				base: true,
+				from: null,
+				legacyStatePriority: null
+			});
+			continue;
+		}
+		if (member.type !== "legacy" || member.failed) continue;
+		for (const contribution of member.contributions) {
+			ordered.push({
+				prop: contribution.prop,
+				value: {
+					base: null,
+					clauses: [contribution.clause]
+				},
+				dynamic: contribution.dynamic,
+				index: member.index,
+				base: false,
+				from: member,
+				legacyStatePriority: legacyStatePriority(contribution.clause.modifiers)
+			});
+		}
+	}
+	const ranked = ordered.filter((entry) => entry.legacyStatePriority !== null).sort((left, right) => left.legacyStatePriority - right.legacyStatePriority || left.index - right.index);
+	if (ranked.length < 2) return ordered;
+	let rankedIndex = 0;
+	return ordered.map((entry) => entry.legacyStatePriority === null ? entry : ranked[rankedIndex++]);
+}
+function buildSlots(ordered) {
+	const slots = /* @__PURE__ */ new Map();
+	for (const entry of ordered) {
+		for (const property of expandToLonghands(entry.prop, shorthands)) {
+			const previous = slots.get(property);
+			const value = previous ? mergeProgramValues(previous.value, entry.value) : entry.value;
+			slots.delete(property);
+			slots.set(property, {
+				property,
+				sourceProp: entry.prop,
+				value,
+				anchor: previous ? Math.min(previous.anchor, entry.index) : entry.index,
+				last: previous ? Math.max(previous.last, entry.index) : entry.index,
+				dynamic: (previous?.dynamic ?? false) || entry.dynamic
+			});
+		}
+	}
+	return slots;
+}
+function barriers(site) {
+	const list = [];
+	for (const member of site.members) {
+		if (member.type === "spread") {
+			list.push({
+				index: member.index,
+				source: member.text,
+				bases: null,
+				clauses: null
+			});
+			continue;
+		}
+		if (member.type === "authored" && !member.activated) {
+			list.push({
+				index: member.index,
+				source: member.text,
+				bases: new Set(expandToLonghands(member.prop, shorthands)),
+				clauses: noProperties
+			});
+			continue;
+		}
+		if (member.type === "legacy" && member.failed) {
+			list.push({
+				index: member.index,
+				source: member.name,
+				bases: noProperties,
+				clauses: member.properties
+			});
+		}
+	}
+	return list;
+}
+function resolveBarriers(site, ordered, slots) {
+	let changed = false;
+	for (const slot of slots.values()) {
+		const contributions = ordered.filter((entry) => expandToLonghands(entry.prop, shorthands).includes(slot.property));
+		for (const barrier of barriers(site)) {
+			if (barrier.index <= slot.anchor || barrier.index >= slot.last) continue;
+			if (barrier.clauses === null || barrier.clauses.has(slot.property)) {
+				for (const entry of contributions) {
+					if (entry.base || entry.index < barrier.index || !entry.from) continue;
+					addFlag(site.flags, "condition-order-not-preservable", `"${compact(barrier.source)}" can set "${slot.property}" between the values contributing to it, so "${entry.from.name}" stays authored instead of merging`);
+					entry.from.failed = true;
+					changed = true;
+				}
+			}
+			if (barrier.bases === null || barrier.bases.has(slot.property)) {
+				for (const entry of contributions) {
+					if (!entry.base || entry.index < barrier.index) continue;
+					const authored = site.members.find((member) => member.type === "authored" && member.index === entry.index && member.activated);
+					if (authored && authored.type === "authored") {
+						authored.payload = null;
+						authored.blocked = {
+							code: "base-order-not-preservable",
+							detail: `"${compact(barrier.source)}" can set "${slot.property}" between the values contributing to it, so this base cannot move`
+						};
+						changed = true;
+						continue;
+					}
+					addFlag(site.flags, "base-order-not-preservable", `"${compact(barrier.source)}" can set "${slot.property}" between the values contributing to it, so the merged base may win where it did not before`);
+				}
+			}
+		}
+	}
+	return changed;
+}
+function assemble(site) {
+	let slots = /* @__PURE__ */ new Map();
+	for (;;) {
+		let changed = false;
+		const contributed = /* @__PURE__ */ new Set();
+		for (const member of site.members) {
+			if (member.type !== "legacy" || member.failed) continue;
+			for (const contribution of member.contributions) {
+				contributed.add(activationName(contribution.prop));
+			}
+		}
+		for (const member of site.members) {
+			if (member.type !== "authored") continue;
+			const name = activationName(member.prop);
+			member.activated = member.token && member.payload !== null || contributed.has(name);
+			if (!member.activated || member.payload !== null) continue;
+			const blocked = member.blocked;
+			addFlag(site.flags, blocked?.code ?? "unprovable-dynamic-value", `a legacy condition targets "${member.prop}": ${blocked?.detail ?? `its base value "${compact(member.text)}" cannot join a program`}`);
+			member.activated = false;
+			for (const other of site.members) {
+				if (other.type !== "legacy" || other.failed) continue;
+				if (other.contributions.some((one) => activationName(one.prop) === name)) {
+					other.failed = true;
+					changed = true;
+				}
+			}
+		}
+		if (changed) continue;
+		const ordered = orderedEntries(site);
+		slots = buildSlots(ordered);
+		if (!resolveBarriers(site, ordered, slots)) break;
+	}
+	const entries = [];
+	for (const member of site.members) {
+		if (member.type === "authored" && member.activated) continue;
+		if (member.type === "legacy" && !member.failed) continue;
+		entries.push({
+			index: member.index,
+			text: member.text
+		});
+	}
+	const printed = printSlots(site, slots);
+	entries.push(...printed.output);
+	entries.push(...site.extras);
+	entries.sort((left, right) => left.index - right.index);
+	return {
+		entries,
+		programs: printed.programs
+	};
+}
+function printSlots(site, slots) {
+	const printed = /* @__PURE__ */ new Set();
+	const output = [];
+	const programs = [];
+	const outputCommentRanges = [];
+	for (const [property, slot] of slots) {
+		if (printed.has(property)) continue;
+		const serialized = printProgram(slot.value);
+		const expansion = expandToLonghands(slot.sourceProp, shorthands);
+		const collapses = expansion.length > 0 && expansion.every((expanded) => {
+			const candidate = slots.get(expanded);
+			return candidate !== void 0 && candidate.sourceProp === slot.sourceProp && candidate.anchor === slot.anchor && candidate.dynamic === slot.dynamic && printProgram(candidate.value) === serialized;
+		});
+		const name = collapses ? slot.sourceProp : property;
+		if (collapses) for (const expanded of expansion) printed.add(expanded);
+		else printed.add(property);
+		const value = slot.dynamic ? `\`${serialized}\`` : JSON.stringify(serialized);
+		programs.push({
+			name,
+			value: serialized,
+			dynamic: slot.dynamic
+		});
+		const propertyText = site.kind === "styled" ? `${name}: ${value}` : `${name}=${slot.dynamic ? `{${value}}` : value}`;
+		output.push({
+			index: slot.anchor,
+			text: propertyText
+		});
+		outputCommentRanges.push({
+			outputIndex: output.length - 1,
+			first: slot.anchor,
+			last: slot.last
+		});
+	}
+	verify(site, slots, [...output].sort((left, right) => left.index - right.index));
+	if (site.kind === "styled") {
+		const commentedIndexes = /* @__PURE__ */ new Set();
+		for (const range of outputCommentRanges) {
+			const comments = [];
+			for (const [index, texts] of site.comments) {
+				if (index < range.first || index > range.last || commentedIndexes.has(index)) {
+					continue;
+				}
+				comments.push(...texts);
+				commentedIndexes.add(index);
+			}
+			if (comments.length) {
+				output[range.outputIndex].text = `${comments.join("\n")}
+${output[range.outputIndex].text}`;
+			}
+		}
+	}
+	return {
+		output,
+		programs
+	};
+}
+function sanitize(text) {
+	let result = "";
+	for (let index = 0; index < text.length; index++) {
+		if (text[index] !== "$" || text[index + 1] !== "{") {
+			result += text[index];
+			continue;
+		}
+		let depth = 0;
+		let end = index + 1;
+		for (; end < text.length; end++) {
+			if (text[end] === "{") depth++;
+			else if (text[end] === "}" && --depth === 0) break;
+		}
+		result += "zz";
+		index = end;
+	}
+	return result;
+}
+function verify(site, slots, output) {
+	const separator = site.kind === "styled" ? ": " : "=";
+	const reparsed = /* @__PURE__ */ new Map();
+	for (const entry of output) {
+		const split = entry.text.indexOf(separator);
+		const prop = entry.text.slice(0, split);
+		let raw = entry.text.slice(split + separator.length);
+		if (raw.startsWith("{")) raw = raw.slice(1, -1);
+		const text = sanitize(raw.slice(1, -1));
+		const parsed = parseValue(text, site.registry);
+		if (!parsed.ok) {
+			addFlag(site.flags, "emitted-value-invalid", `"${prop}=${text}" does not parse: ${parsed.errors.map((error) => error.message).join("; ")}`);
+			return;
+		}
+		for (const property of expandToLonghands(prop, shorthands)) {
+			const previous = reparsed.get(property);
+			reparsed.set(property, previous ? mergeProgramValues(previous, parsed.value) : parsed.value);
+		}
+	}
+	for (const [property, slot] of slots) {
+		const actual = reparsed.get(property);
+		const expected = sanitize(printProgram(slot.value));
+		if (actual === void 0 || sanitize(printProgram(actual)) !== expected) {
+			addFlag(site.flags, "emitted-program-mismatch", `"${property}" reads back as "${actual ? sanitize(printProgram(actual)) : "(missing)"}" instead of "${expected}"`);
+		}
+	}
+}
+function propertyName(node) {
+	if (Node.isIdentifier(node) || Node.isStringLiteral(node) || Node.isNumericLiteral(node)) {
+		return node.getText().replace(/^['"]|['"]$/g, "");
+	}
+	return null;
+}
+function jsxAttributeName(attribute) {
+	const name = attribute.getNameNode();
+	return Node.isIdentifier(name) ? name.getText() : null;
+}
+function jsxLiteralString(attribute) {
+	const initializer = attribute.getInitializer();
+	if (Node.isStringLiteral(initializer)) return initializer.getLiteralValue();
+	const expression = jsxExpression(attribute);
+	if (expression && (Node.isStringLiteral(expression) || Node.isNoSubstitutionTemplateLiteral(expression))) {
+		return expression.getLiteralValue();
+	}
+	return null;
+}
+function jsxExpression(attribute) {
+	const initializer = attribute.getInitializer();
+	if (!Node.isJsxExpression(initializer)) return null;
+	const expression = initializer.getExpression();
+	return expression ? unwrapExpression(expression) : null;
+}
+function isConvertedJsxAttribute(attribute) {
+	if (Node.isJsxSpreadAttribute(attribute)) return true;
+	if (!Node.isJsxAttribute(attribute)) return false;
+	const name = jsxAttributeName(attribute);
+	return !!name && isConvertedName(name);
+}
+function rewriteJsxSite(opening, entries) {
+	const attributes = opening.getAttributes();
+	const rendered = [];
+	let inserted = false;
+	for (const attribute of attributes) {
+		if (isConvertedJsxAttribute(attribute)) {
+			if (!inserted) {
+				rendered.push(...entries.map((entry) => entry.text));
+				inserted = true;
+			}
+		} else {
+			rendered.push(attribute.getText());
+		}
+	}
+	const source = opening.getText();
+	const start = opening.getStart();
+	const first = attributes[0];
+	const last = attributes[attributes.length - 1];
+	const prefix = source.slice(0, first.getStart() - start);
+	const suffix = source.slice(last.getEnd() - start);
+	const authoredMultiline = prefix.includes("\n") || source.slice(first.getStart() - start, last.getEnd() - start).includes("\n");
+	opening.replaceWithText(authoredMultiline ? `${prefix.replace(/[ \t]+$/, "")}${rendered.map((text) => `  ${text}`).join("\n")}${suffix.replace(/\n[ \t]+/, "\n")}` : `${prefix}${rendered.join(" ")}${suffix}`);
+}
+function containerExtras(site, declaration, index) {
+	const target = site.containers.targets.get(declaration);
+	if (target === void 0) return;
+	const name = target.named && target.group !== "" ? target.group : null;
+	const text = site.kind === "styled" ? name === null ? "container: true" : `container: ${JSON.stringify(name)}` : name === null ? "container" : `container=${JSON.stringify(name)}`;
+	site.legacy = true;
+	site.extras.push({
+		index,
+		text
+	});
+	if (target.flag !== null) addFlag(site.flags, target.flag.code, target.flag.detail);
+	addNote(site, `a descendant uses a legacy container-size condition on this group, so it declares a query container`);
+}
+function convertJsxSite(opening, registry, containers, targets, host, write = false) {
+	const site = createSite("jsx", registry, containers, targets, host);
+	const before = [];
+	for (const attribute of opening.getAttributes()) {
+		if (Node.isJsxSpreadAttribute(attribute)) {
+			const expression = unwrapExpression(attribute.getExpression());
+			if (Node.isObjectLiteralExpression(expression)) {
+				before.push(compact(attribute.getText()));
+				for (const property of expression.getProperties()) {
+					if (Node.isPropertyAssignment(property)) {
+						const name2 = propertyName(property.getNameNode());
+						if (name2 !== null) {
+							if (isConvertedName(name2)) {
+								pushStyledProperty(site, name2, property, `${name2}={${property.getInitializerOrThrow().getText()}}`);
+							} else {
+								site.members.push({
+									type: "passthrough",
+									index: site.index++,
+									text: `${name2}={${property.getInitializerOrThrow().getText()}}`
+								});
+							}
+							continue;
+						}
+					}
+					pushSpread(site, property, Node.isSpreadAssignment(property) ? `{${property.getText()}}` : `{...{ ${property.getText()} }}`);
+				}
+				continue;
+			}
+			before.push(compact(attribute.getText()));
+			pushSpread(site, expression, attribute.getText());
+			continue;
+		}
+		const name = jsxAttributeName(attribute);
+		if (!name) continue;
+		const text = compact(attribute.getText());
+		if (name === "group") {
+			before.push(text);
+			containerExtras(site, attribute, site.index);
+			site.members.push({
+				type: "passthrough",
+				index: site.index++,
+				text
+			});
+			continue;
+		}
+		if (isLegacyConditionName(name)) {
+			before.push(text);
+			pushLegacy(site, name, text, jsxExpression(attribute), attribute);
+			continue;
+		}
+		if (tokenVariantProps.has(name)) {
+			if (pushTokenVariant(site, name, attribute, text)) before.push(text);
+			continue;
+		}
+		if (!styleProps.has(name)) continue;
+		before.push(text);
+		const literal = jsxLiteralString(attribute);
+		pushBase(site, name, text, literal === null ? jsxExpression(attribute) : null, literal);
+	}
+	if (!site.legacy) return null;
+	const { entries, programs } = assemble(site);
+	const sourceFile = opening.getSourceFile();
+	const report = {
+		kind: "jsx",
+		label: `<${opening.getTagNameNode().getText()}>`,
+		line: sourceFile.getLineAndColumnAtPos(opening.getStart()).line,
+		before: before.join(" "),
+		after: entries.map((entry) => entry.text).join(" ") || "(no style props left)",
+		programs: [...programs, ...site.respelled],
+		assessments: site.assessments,
+		assessmentVerdict: assessmentVerdict(site.assessments),
+		warnings: site.warnings,
+		flags: site.flags,
+		inventory: site.inventory,
+		pending: site.pending,
+		notes: site.notes,
+		legacyLeft: legacyLeft(site)
+	};
+	if (write && converted(site, report) && !site.flags.some((flag) => flag.code === "emitted-program-mismatch" || flag.code === "emitted-value-invalid")) {
+		rewriteJsxSite(opening, entries);
+	}
+	return report;
+}
+function pushStyledProperty(site, name, property, authoredText) {
+	const comments = allCommentTexts(property);
+	if (comments.length) site.comments.set(site.index, comments);
+	const text = authoredText ?? textWithOuterComments(property);
+	const initializer = unwrapExpression(property.getInitializerOrThrow());
+	if (name === "group") {
+		containerExtras(site, property, site.index);
+		site.members.push({
+			type: "passthrough",
+			index: site.index++,
+			text
+		});
+		return;
+	}
+	if (isLegacyConditionName(name)) {
+		pushLegacy(site, name, text, initializer, property);
+		return;
+	}
+	if (tokenVariantProps.has(name)) {
+		pushTokenVariant(site, name, property, text);
+		return;
+	}
+	if (!styleProps.has(name)) return;
+	const literal = Node.isStringLiteral(initializer) || Node.isNoSubstitutionTemplateLiteral(initializer) ? initializer.getLiteralValue() : null;
+	pushBase(site, name, text, literal === null ? initializer : null, literal);
+}
+function pushTokenVariant(site, name, node, text) {
+	const index = site.index++;
+	const initializer = node.getInitializer();
+	const value = initializer !== void 0 && Node.isJsxExpression(initializer) ? initializer.getExpression() : initializer;
+	const literals = value === void 0 ? [] : [value, ...value.getDescendants()].filter((candidate) => (Node.isStringLiteral(candidate) || Node.isNoSubstitutionTemplateLiteral(candidate)) && candidate.getLiteralValue().startsWith("$"));
+	if (value === void 0 || literals.length === 0) {
+		site.members.push({
+			type: "passthrough",
+			index,
+			text
+		});
+		return false;
+	}
+	const source = value.getText();
+	const start = value.getStart();
+	let rewritten = "";
+	let cursor = start;
+	for (const literal of literals) {
+		let replacement = "true";
+		if (literal.getLiteralValue() !== "$true") {
+			const flat = flatStringValue(literal.getLiteralValue(), site.registry);
+			if (flat.text === null) {
+				site.legacy = true;
+				addFlag(site.flags, flat.error?.code ?? "unsupported-legacy-value", `${name}: ${flat.error?.message ?? `${literal.getText()} has no flat spelling`}`);
+				site.members.push({
+					type: "passthrough",
+					index,
+					text
+				});
+				return true;
+			}
+			const quote = literal.getText()[0];
+			replacement = `${quote}${flat.text}${quote}`;
+		}
+		rewritten += source.slice(cursor - start, literal.getStart() - start);
+		rewritten += replacement;
+		cursor = literal.getEnd();
+	}
+	rewritten += source.slice(cursor - start);
+	site.legacy = true;
+	const output = Node.isJsxAttribute(node) ? Node.isStringLiteral(initializer) ? rewritten === "true" ? name : `${name}=${rewritten}` : `${name}={${rewritten}}` : site.kind === "jsx" ? `${name}={${rewritten}}` : textWithOuterComments(node, `${node.getNameNode().getText()}: ${rewritten}`);
+	site.members.push({
+		type: "passthrough",
+		index,
+		text: output
+	});
+	site.respelled.push({
+		name,
+		value: rewritten,
+		dynamic: literals.length !== 1 || literals[0] !== value
+	});
+	return true;
+}
+function convertStyleObject(object, kind, label, registry, containers, targets, host, write = false) {
+	const site = createSite(kind, registry, containers, targets, host);
+	const before = [];
+	for (const property of object.getProperties()) {
+		if (Node.isSpreadAssignment(property)) {
+			const expression = unwrapExpression(property.getExpression());
+			before.push(compact(property.getText()));
+			if (Node.isObjectLiteralExpression(expression)) {
+				for (const nested of expression.getProperties()) {
+					if (Node.isPropertyAssignment(nested)) {
+						const name2 = propertyName(nested.getNameNode());
+						if (name2 !== null) {
+							if (isConvertedName(name2)) {
+								pushStyledProperty(site, name2, nested);
+							} else {
+								site.members.push({
+									type: "passthrough",
+									index: site.index++,
+									text: compact(nested.getText())
+								});
+							}
+							continue;
+						}
+					}
+					pushSpread(site, nested, compact(nested.getText()));
+				}
+				continue;
+			}
+			pushSpread(site, expression, compact(property.getText()));
+			continue;
+		}
+		if (!Node.isPropertyAssignment(property)) continue;
+		const nameNode = property.getNameNode();
+		if (Node.isComputedPropertyName(nameNode)) {
+			addFlag(site.flags, "computed-property", `"${compact(nameNode.getText())}" hides the affected style property`);
+			continue;
+		}
+		const name = propertyName(nameNode);
+		if (name === null) continue;
+		if (!isConvertedName(name)) continue;
+		before.push(compact(property.getText()));
+		pushStyledProperty(site, name, property);
+	}
+	if (!site.legacy) return null;
+	const { entries, programs } = assemble(site);
+	const sourceFile = object.getSourceFile();
+	const report = {
+		kind,
+		label,
+		line: sourceFile.getLineAndColumnAtPos(object.getStart()).line,
+		before: before.join(", "),
+		after: entries.map((entry) => entry.text).join(", ") || "(no style props left)",
+		programs: [...programs, ...site.respelled],
+		assessments: site.assessments,
+		assessmentVerdict: assessmentVerdict(site.assessments),
+		warnings: site.warnings,
+		flags: site.flags,
+		inventory: site.inventory,
+		pending: site.pending,
+		notes: site.notes,
+		legacyLeft: legacyLeft(site)
+	};
+	if (write && converted(site, report) && !site.flags.some((flag) => flag.code === "emitted-program-mismatch" || flag.code === "emitted-value-invalid")) {
+		rewriteStyleObject(object, entries);
+	}
+	return report;
+}
+function isConvertedStyledProperty(property) {
+	if (Node.isSpreadAssignment(property)) return true;
+	if (!Node.isPropertyAssignment(property)) return false;
+	const nameNode = property.getNameNode();
+	if (Node.isComputedPropertyName(nameNode)) return false;
+	const name = propertyName(nameNode);
+	return !!name && isConvertedName(name);
+}
+function allCommentTexts(node) {
+	const comments = /* @__PURE__ */ new Map();
+	for (const current of [node, ...node.getDescendants()]) {
+		for (const range of [...current.getLeadingCommentRanges(), ...current.getTrailingCommentRanges()]) {
+			comments.set(range.getPos(), range.getText());
+		}
+	}
+	return [...comments.entries()].sort((left, right) => left[0] - right[0]).map((entry) => entry[1]);
+}
+function textWithOuterComments(node, text = node.getText()) {
+	const comments = /* @__PURE__ */ new Map();
+	for (const range of [...node.getLeadingCommentRanges(), ...node.getTrailingCommentRanges()]) {
+		comments.set(range.getPos(), range.getText());
+	}
+	const prefix = [...comments.entries()].sort((left, right) => left[0] - right[0]).map((entry) => entry[1]);
+	return [...prefix, text].join("\n  ");
+}
+function rewriteStyleObject(object, entries) {
+	const rendered = [];
+	let inserted = false;
+	for (const property of object.getProperties()) {
+		if (isConvertedStyledProperty(property)) {
+			if (!inserted) {
+				rendered.push(...entries.map((entry) => entry.text));
+				inserted = true;
+			}
+		} else {
+			rendered.push(textWithOuterComments(property));
+		}
+	}
+	if (rendered.length === 0) {
+		object.replaceWithText("{}");
+		return;
+	}
+	object.replaceWithText(`{
+${rendered.map((text) => `  ${text}`).join(",\n")}
+}`);
+}
+
+export { convertJsxSite, convertStyleObject, sanitize };
+//# sourceMappingURL=convert.mjs.map