boss-css 0.0.1 → 0.0.2

package/dist/compile/jsx.mjs

@@ -0,0 +1,800 @@
+import { createTokenVars } from "../use/token/vars.mjs";
+import { printSync } from "@swc/core";
+
+//#region src/compile/jsx.ts
+const preservedAttrs = new Set(["key", "ref"]);
+const fallbackSpan = {
+	start: 0,
+	end: 0,
+	ctxt: 0
+};
+const ensureSpan = (span) => {
+	if (!span) return fallbackSpan;
+	return typeof span.ctxt === "number" ? span : {
+		...span,
+		ctxt: 0
+	};
+};
+const getSpan = (node) => {
+	if (node && typeof node === "object" && "span" in node) return ensureSpan(node.span);
+	return fallbackSpan;
+};
+const createJsxAttribute = (name, value, span) => {
+	const safeSpan = ensureSpan(span);
+	return {
+		type: "JSXAttribute",
+		span: safeSpan,
+		name: {
+			type: "Identifier",
+			value: name,
+			span: safeSpan,
+			optional: false
+		},
+		value
+	};
+};
+const createJsxExpressionContainer = (expression, span) => {
+	return {
+		type: "JSXExpressionContainer",
+		span: ensureSpan(span),
+		expression
+	};
+};
+async function transformJsxElement(node, state, context) {
+	const opening = node.opening;
+	const name = opening.name;
+	const bossElement = getBossElement(name);
+	const classNameProp = state.classNameProp ?? "className";
+	if (!bossElement) return node;
+	let prepared = null;
+	if (bossElement.isPrepared) {
+		prepared = state.preparedLocal.get(bossElement.tagName) ?? state.preparedGlobal.get(bossElement.tagName) ?? null;
+		if (!prepared) {
+			state.needsRuntime = true;
+			return node;
+		}
+	}
+	if (opening.attributes.some((attr) => attr.type === "SpreadElement") && !state.compile.spread) {
+		state.needsRuntime = true;
+		return node;
+	}
+	const { tagName } = bossElement;
+	const fallbackTag = prepared ? "div" : tagName;
+	const { tag, asAttribute, asExpression } = resolveTagFromAs(opening.attributes, fallbackTag, prepared?.asExpression);
+	const { tree, passthroughAttributes, tokensProp } = buildPropTree(opening.attributes, asAttribute, state, classNameProp, prepared?.tree);
+	await state.api.trigger("onPropTree", {
+		input: state.api.propTreeToObject(tree),
+		tree,
+		preferVariables: true,
+		parser: "jsx",
+		file: { path: state.filename }
+	}, (plugin) => plugin.name === "token");
+	const cssTree = structuredClone(tree);
+	await state.api.trigger("onPropTree", {
+		input: state.api.propTreeToObject(cssTree),
+		tree: cssTree,
+		preferVariables: true,
+		parser: "jsx",
+		file: { path: state.filename }
+	});
+	const hasInlineFirst = state.api.plugins.some((plugin) => plugin.name === "inline-first");
+	const hasClassnameFirst = state.api.plugins.some((plugin) => plugin.name === "classname-first");
+	if (!hasInlineFirst && !hasClassnameFirst) throw new Error("compile: only inline-first or classname-first strategies are supported right now");
+	const { classNames, styleProps } = hasClassnameFirst ? buildClassnameFirstOutput(tree, tag, state) : buildInlineFirstOutput(tree, tag, state);
+	const classNameValue = Array.from(classNames).join(" ").trim();
+	const tagSpan = ensureSpan(opening.span);
+	const existingClassName = findAttribute(opening.attributes, classNameProp);
+	const existingStyle = findAttribute(opening.attributes, "style");
+	const tokensExpression = buildTokenVarsExpression(tokensProp, state, tagSpan);
+	const nextAttributes = [];
+	const passthroughSet = new Set(passthroughAttributes);
+	for (const attr of opening.attributes) {
+		if (attr.type === "SpreadElement") {
+			nextAttributes.push(attr);
+			continue;
+		}
+		if (attr.type !== "JSXAttribute") continue;
+		const attrName = attributeName(attr.name);
+		if (!attrName) continue;
+		if (attrName === "style" || attrName === "as") continue;
+		if (attrName === classNameProp) continue;
+		if (preservedAttrs.has(attrName) || passthroughSet.has(attr)) nextAttributes.push(attr);
+	}
+	const mergedClassName = mergeClassName(existingClassName, classNameValue, tagSpan, classNameProp);
+	if (mergedClassName) nextAttributes.push(mergedClassName);
+	const mergedStyle = mergeStyle(existingStyle, styleProps, tagSpan);
+	const finalStyle = tokensExpression ? appendStyle(mergedStyle, tokensExpression, tagSpan) : mergedStyle;
+	if (finalStyle) nextAttributes.push(finalStyle);
+	opening.attributes = nextAttributes;
+	opening.name = toJsxIdentifier(tag, tagSpan);
+	if (node.closing) node.closing.name = toJsxIdentifier(tag, ensureSpan(node.closing.span));
+	state.replacedElements += 1;
+	if (asExpression) return wrapDynamicAs(node, asExpression, tagSpan, context);
+	return node;
+}
+const getBossElement = (name) => {
+	if (name.type === "Identifier" && name.value === "$$") return {
+		tagName: "div",
+		isPrepared: false
+	};
+	if (name.type === "JSXMemberExpression" && name.object.type === "Identifier" && name.object.value === "$$") {
+		const tagName = name.property.value;
+		return {
+			tagName,
+			isPrepared: /^[A-Z]/.test(tagName)
+		};
+	}
+	return null;
+};
+const resolveTagFromAs = (attributes, fallback, preparedAs) => {
+	const asAttribute = findAttribute(attributes, "as");
+	if (!asAttribute && !preparedAs) return {
+		tag: fallback,
+		asAttribute: null,
+		asExpression: null
+	};
+	if (asAttribute) {
+		const attrValue = asAttribute.value;
+		if (!attrValue) return {
+			tag: fallback,
+			asAttribute,
+			asExpression: null
+		};
+		if (attrValue.type === "StringLiteral") return {
+			tag: attrValue.value,
+			asAttribute,
+			asExpression: null
+		};
+		if (attrValue.type === "JSXExpressionContainer") {
+			const expression = attrValue.expression;
+			if (expression.type === "StringLiteral") return {
+				tag: expression.value,
+				asAttribute,
+				asExpression: null
+			};
+			if (expression.type === "TemplateLiteral" && expression.expressions.length === 0) return {
+				tag: expression.quasis[0].cooked ?? "",
+				asAttribute,
+				asExpression: null
+			};
+			return {
+				tag: fallback,
+				asAttribute,
+				asExpression: expression
+			};
+		}
+	}
+	if (preparedAs) {
+		if (preparedAs.type === "StringLiteral") return {
+			tag: preparedAs.value,
+			asAttribute: null,
+			asExpression: null
+		};
+		if (preparedAs.type === "TemplateLiteral" && preparedAs.expressions.length === 0) return {
+			tag: preparedAs.quasis[0].cooked ?? "",
+			asAttribute: null,
+			asExpression: null
+		};
+		return {
+			tag: fallback,
+			asAttribute: null,
+			asExpression: preparedAs
+		};
+	}
+	return {
+		tag: fallback,
+		asAttribute: null,
+		asExpression: null
+	};
+};
+const buildPropTree = (attributes, asAttribute, state, classNameProp, baseTree) => {
+	const tree = baseTree ? structuredClone(baseTree) : {};
+	const passthroughAttributes = [];
+	let tokensProp = null;
+	for (const attr of attributes) {
+		if (attr.type !== "JSXAttribute") continue;
+		if (attr === asAttribute) continue;
+		const name = attributeName(attr.name);
+		if (!name) continue;
+		if (name === "style" || preservedAttrs.has(name) || name === classNameProp) continue;
+		if (name === "tokens") {
+			const parsed$1 = parseAttributeValue(attr.value);
+			if (parsed$1) tokensProp = tokensProp ? mergePropValues(tokensProp, parsed$1) : parsed$1;
+			continue;
+		}
+		if (!state.api.dictionary.resolve(name).descriptor) {
+			passthroughAttributes.push(attr);
+			continue;
+		}
+		const parsed = parseAttributeValue(attr.value);
+		if (!parsed) continue;
+		tree[name] = mergePropValues(tree[name], parsed);
+	}
+	return {
+		tree,
+		passthroughAttributes,
+		tokensProp
+	};
+};
+const parseAttributeValue = (value) => {
+	if (!value) return {
+		dynamic: false,
+		value: true
+	};
+	if (value.type === "StringLiteral") return {
+		dynamic: false,
+		value: value.value
+	};
+	if (value.type === "JSXExpressionContainer") return parseExpressionValue(value.expression);
+	return {
+		dynamic: true,
+		value: null
+	};
+};
+const mergePropValues = (base, next) => {
+	if (!base) return next;
+	const baseValue = base.value;
+	const nextValue = next.value;
+	const baseIsObject = isPropTreeValue(baseValue);
+	const nextIsObject = isPropTreeValue(nextValue);
+	if (baseIsObject && nextIsObject) return {
+		...base,
+		...next,
+		dynamic: base.dynamic || next.dynamic,
+		value: mergePropTrees(baseValue, nextValue)
+	};
+	return next;
+};
+const mergePropTrees = (base, next) => {
+	const merged = structuredClone(base);
+	for (const [key, value] of Object.entries(next)) merged[key] = mergePropValues(merged[key], value);
+	return merged;
+};
+const isPropTreeValue = (value) => {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+};
+const parseExpressionValue = (expression) => {
+	if (expression.type === "JSXEmptyExpression") return {
+		dynamic: true,
+		value: null
+	};
+	if (expression.type === "NumericLiteral") return {
+		dynamic: false,
+		value: expression.value
+	};
+	if (expression.type === "StringLiteral") return {
+		dynamic: false,
+		value: expression.value
+	};
+	if (expression.type === "BooleanLiteral") return {
+		dynamic: false,
+		value: expression.value
+	};
+	if (expression.type === "NullLiteral") return {
+		dynamic: false,
+		value: null
+	};
+	if (expression.type === "TemplateLiteral") {
+		if (expression.expressions.length === 0) return {
+			dynamic: false,
+			value: expression.quasis[0].cooked ?? ""
+		};
+		return {
+			dynamic: true,
+			value: null,
+			ast: structuredClone(expression),
+			code: printExpression(expression)
+		};
+	}
+	if (expression.type === "ArrowFunctionExpression" || expression.type === "FunctionExpression") return {
+		dynamic: true,
+		value: null,
+		ast: structuredClone(expression),
+		code: printExpression(expression),
+		isFn: true
+	};
+	if (expression.type === "ArrayExpression") {
+		const values = [];
+		let dynamic = false;
+		for (const entry of expression.elements) {
+			if (!entry) {
+				dynamic = true;
+				continue;
+			}
+			const parsed = parseExpressionValue(entry.expression);
+			dynamic = dynamic || parsed.dynamic;
+			values.push(parsed);
+		}
+		return {
+			dynamic,
+			value: values,
+			ast: dynamic ? structuredClone(expression) : void 0,
+			code: dynamic ? printExpression(expression) : void 0
+		};
+	}
+	if (expression.type === "ObjectExpression") {
+		const value = {};
+		let dynamic = false;
+		for (const prop of expression.properties) {
+			if (prop.type !== "KeyValueProperty") {
+				dynamic = true;
+				continue;
+			}
+			if (prop.key.type !== "Identifier" && prop.key.type !== "StringLiteral") {
+				dynamic = true;
+				continue;
+			}
+			const key = prop.key.type === "Identifier" ? prop.key.value : prop.key.value;
+			const parsed = parseExpressionValue(prop.value);
+			dynamic = dynamic || parsed.dynamic;
+			value[key] = parsed;
+		}
+		return {
+			dynamic,
+			value,
+			ast: dynamic ? structuredClone(expression) : void 0,
+			code: dynamic ? printExpression(expression) : void 0
+		};
+	}
+	return {
+		dynamic: true,
+		value: null,
+		ast: structuredClone(expression),
+		code: printExpression(expression)
+	};
+};
+const buildPreparedDefinition = (objectExpression) => {
+	const tree = {};
+	let asExpression = null;
+	const ignored = new Set([
+		"as",
+		"class",
+		"className",
+		"style",
+		"key",
+		"ref"
+	]);
+	for (const prop of objectExpression.properties) {
+		if (prop.type !== "KeyValueProperty") continue;
+		if (prop.key.type !== "Identifier" && prop.key.type !== "StringLiteral") continue;
+		const key = prop.key.type === "Identifier" ? prop.key.value : prop.key.value;
+		if (ignored.has(key)) {
+			if (key === "as") asExpression = prop.value;
+			continue;
+		}
+		tree[key] = parseExpressionValue(prop.value);
+	}
+	return {
+		asExpression,
+		tree
+	};
+};
+const isPreparedDefinitionStatic = (definition) => {
+	if (!isStaticAsExpression(definition.asExpression)) return false;
+	return isPropTreeStatic(definition.tree);
+};
+const buildInlineFirstOutput = (tree, tag, state) => {
+	const classNames = /* @__PURE__ */ new Set();
+	const styleProps = /* @__PURE__ */ new Map();
+	const walk = (node, contexts) => {
+		for (const [name, prop] of Object.entries(node)) {
+			const value = prop.value;
+			if (value && typeof value === "object" && !Array.isArray(value)) {
+				walk(value, [...contexts, name]);
+				continue;
+			}
+			const resolved = state.api.dictionary.resolve(name);
+			const isCssProp = Boolean(resolved.descriptor?.isCSSProp);
+			if (!isCssProp) continue;
+			const shouldInline = contexts.length === 0 && isCssProp;
+			const propName = resolved.name;
+			const expr = propToExpression(prop, propName, state);
+			if (!expr) continue;
+			if (shouldInline) styleProps.set(propName, expr);
+			else {
+				classNames.add(state.api.contextToClassName(propName, null, contexts, false, state.api.selectorPrefix));
+				styleProps.set(state.api.contextToCSSVariable(propName, null, contexts, state.api.selectorPrefix), expr);
+			}
+		}
+	};
+	walk(tree, []);
+	return {
+		classNames,
+		styleProps
+	};
+};
+const buildClassnameFirstOutput = (tree, tag, state) => {
+	const classNames = /* @__PURE__ */ new Set();
+	const styleProps = /* @__PURE__ */ new Map();
+	const resolveSelectorValue = (prop) => {
+		if (prop.selectorValue !== void 0) return prop.selectorValue;
+		if (Array.isArray(prop.value)) return prop.value.map((entry) => entry.value);
+		return prop.value;
+	};
+	const walk = (node, contexts) => {
+		for (const [name, prop] of Object.entries(node)) {
+			const value = prop.value;
+			if (value && typeof value === "object" && !Array.isArray(value)) {
+				walk(value, [...contexts, name]);
+				continue;
+			}
+			const resolved = state.api.dictionary.resolve(name);
+			if (!Boolean(resolved.descriptor?.isCSSProp)) continue;
+			if (prop.dynamic && !prop.isFn) {
+				console.warn(`[boss-css] compile skipped dynamic prop "${name}" in ${state.filename}. Use ${name}={() => value} with classname-first.`);
+				continue;
+			}
+			const isDynamicFn = prop.dynamic && prop.isFn;
+			const selectorValue = isDynamicFn ? null : resolveSelectorValue(prop);
+			const propName = resolved.name;
+			classNames.add(state.api.contextToClassName(propName, selectorValue, contexts, false, state.api.selectorPrefix));
+			if (!isDynamicFn) continue;
+			const expr = propToDynamicExpression(prop, propName, state);
+			if (!expr) continue;
+			styleProps.set(state.api.contextToCSSVariable(propName, null, contexts, state.api.selectorPrefix), expr);
+		}
+	};
+	walk(tree, []);
+	return {
+		classNames,
+		styleProps
+	};
+};
+const propToExpression = (prop, name, state) => {
+	const span = getSpan(prop.ast);
+	if (prop.dynamic) {
+		if (!prop.ast) return null;
+		state.needsValueHelper = true;
+		return {
+			type: "CallExpression",
+			span,
+			callee: {
+				type: "Identifier",
+				value: "__bossValue",
+				optional: false,
+				span
+			},
+			arguments: [{ expression: prop.ast }]
+		};
+	}
+	return literalExpression(resolveStaticValue(prop.value, name, state), span);
+};
+const propToDynamicExpression = (prop, name, state) => {
+	if (!prop.ast) return null;
+	const span = getSpan(prop.ast);
+	const callTarget = prop.isFn && prop.ast ? {
+		type: "ParenthesisExpression",
+		span,
+		expression: prop.ast
+	} : prop.ast;
+	const resolvedExpression = prop.isFn ? {
+		type: "CallExpression",
+		span,
+		callee: callTarget,
+		arguments: []
+	} : prop.ast;
+	state.needsValueHelper = true;
+	return {
+		type: "CallExpression",
+		span,
+		callee: {
+			type: "Identifier",
+			value: "__bossValue",
+			optional: false,
+			span
+		},
+		arguments: [{ expression: resolvedExpression }]
+	};
+};
+const resolveStaticValue = (value, name, state) => {
+	if (Array.isArray(value)) return state.api.dictionary.toValue(value.map((entry) => entry.value), name);
+	return state.api.dictionary.toValue(value, name);
+};
+const literalExpression = (value, span) => {
+	const safeSpan = ensureSpan(span);
+	if (typeof value === "number") return {
+		type: "NumericLiteral",
+		value,
+		span: safeSpan
+	};
+	if (typeof value === "boolean") return {
+		type: "BooleanLiteral",
+		value,
+		span: safeSpan
+	};
+	if (value === null) return {
+		type: "NullLiteral",
+		span: safeSpan
+	};
+	return {
+		type: "StringLiteral",
+		value: String(value),
+		span: safeSpan
+	};
+};
+const mergeClassName = (existing, addition, span, classNameProp) => {
+	if (!addition && !existing) return null;
+	if (!addition) return existing;
+	const safeSpan = ensureSpan(span);
+	if (!existing) return createJsxAttribute(classNameProp, {
+		type: "StringLiteral",
+		value: addition,
+		span: safeSpan
+	}, safeSpan);
+	const value = existing.value;
+	if (!value) return {
+		...existing,
+		value: {
+			type: "StringLiteral",
+			value: addition,
+			span: safeSpan
+		}
+	};
+	if (value.type === "StringLiteral") return {
+		...existing,
+		value: {
+			type: "StringLiteral",
+			value: `${value.value} ${addition}`.trim(),
+			span: safeSpan
+		}
+	};
+	if (value.type === "JSXExpressionContainer") return {
+		...existing,
+		value: createJsxExpressionContainer({
+			type: "BinaryExpression",
+			operator: "+",
+			span: safeSpan,
+			left: value.expression,
+			right: {
+				type: "StringLiteral",
+				value: ` ${addition}`,
+				span: safeSpan
+			}
+		}, safeSpan)
+	};
+	return existing;
+};
+const mergeStyle = (existing, styleProps, span) => {
+	if (!styleProps.size && !existing) return null;
+	if (!styleProps.size) return existing;
+	const safeSpan = ensureSpan(span);
+	const styleObject = toStyleObject(styleProps, safeSpan);
+	if (!existing) return createJsxAttribute("style", createJsxExpressionContainer(styleObject, safeSpan), safeSpan);
+	const value = existing.value;
+	if (value?.type === "JSXExpressionContainer" && value.expression.type === "ObjectExpression") return {
+		...existing,
+		value: createJsxExpressionContainer(mergeObjectExpressions(value.expression, styleObject), safeSpan)
+	};
+	return {
+		...existing,
+		value: createJsxExpressionContainer(createObjectAssignExpression(styleObject, valueExpression(value, safeSpan), safeSpan), safeSpan)
+	};
+};
+const appendStyle = (existing, extra, span) => {
+	const safeSpan = ensureSpan(span);
+	if (!existing) return createJsxAttribute("style", createJsxExpressionContainer(extra, safeSpan), safeSpan);
+	const value = existing.value;
+	if (value?.type === "JSXExpressionContainer") return {
+		...existing,
+		value: createJsxExpressionContainer(mergeStyleExpressions(value.expression, extra, safeSpan), safeSpan)
+	};
+	return existing;
+};
+const mergeStyleExpressions = (base, extra, span) => {
+	if (base.type === "ObjectExpression" && extra.type === "ObjectExpression") return mergeObjectExpressions(base, extra);
+	return createObjectAssignExpression(base, extra, span);
+};
+const createObjectAssignExpression = (base, extra, span) => {
+	const safeSpan = ensureSpan(span);
+	return {
+		type: "CallExpression",
+		span: safeSpan,
+		callee: {
+			type: "MemberExpression",
+			span: safeSpan,
+			object: {
+				type: "Identifier",
+				value: "Object",
+				optional: false,
+				span: safeSpan
+			},
+			property: {
+				type: "Identifier",
+				value: "assign",
+				optional: false,
+				span: safeSpan
+			}
+		},
+		arguments: [{ expression: base }, { expression: extra }]
+	};
+};
+const toStyleObject = (styleProps, span) => {
+	const safeSpan = ensureSpan(span);
+	return {
+		type: "ObjectExpression",
+		span: safeSpan,
+		properties: Array.from(styleProps.entries()).map(([key, value]) => {
+			return {
+				type: "KeyValueProperty",
+				span: safeSpan,
+				key: /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) && !key.includes("-") ? {
+					type: "Identifier",
+					value: key,
+					optional: false,
+					span: safeSpan
+				} : {
+					type: "StringLiteral",
+					value: key,
+					span: safeSpan
+				},
+				value
+			};
+		})
+	};
+};
+const mergeObjectExpressions = (target, source) => {
+	target.properties = [...target.properties, ...source.properties];
+	return target;
+};
+const valueExpression = (value, span) => {
+	const safeSpan = ensureSpan(span);
+	if (value && value.type === "JSXExpressionContainer") return value.expression;
+	if (value && value.type === "StringLiteral") return {
+		type: "StringLiteral",
+		value: value.value,
+		span: safeSpan
+	};
+	return {
+		type: "ObjectExpression",
+		span: safeSpan,
+		properties: []
+	};
+};
+const attributeName = (name) => {
+	if (name.type === "Identifier") return name.value;
+	return null;
+};
+const findAttribute = (attributes, name) => {
+	for (const attr of attributes) {
+		if (attr.type !== "JSXAttribute") continue;
+		if (attributeName(attr.name) === name) return attr;
+	}
+	return null;
+};
+const toJsxIdentifier = (value, span) => {
+	return {
+		type: "Identifier",
+		value,
+		optional: false,
+		span: ensureSpan(span)
+	};
+};
+const printExpression = (expression) => {
+	const safeSpan = getSpan(expression);
+	return printSync({
+		type: "Module",
+		body: [{
+			type: "ExpressionStatement",
+			expression,
+			span: safeSpan
+		}],
+		interpreter: "",
+		span: safeSpan
+	}).code.replace(/^#!.*\n/, "").replace(/;\s*$/, "");
+};
+const isPropTreeStatic = (tree) => {
+	for (const prop of Object.values(tree)) {
+		if (prop.dynamic) return false;
+		const value = prop.value;
+		if (value && typeof value === "object" && !Array.isArray(value)) {
+			if (!isPropTreeStatic(value)) return false;
+		}
+	}
+	return true;
+};
+const isStaticAsExpression = (expression) => {
+	if (!expression) return true;
+	if (expression.type === "StringLiteral") return true;
+	return expression.type === "TemplateLiteral" && expression.expressions.length === 0;
+};
+const buildTokenVarsExpression = (tokensProp, state, span) => {
+	if (!tokensProp) return null;
+	if (tokensProp.dynamic) {
+		if (!tokensProp.ast) return null;
+		const safeSpan = getSpan(tokensProp.ast);
+		const argExpression = tokensProp.isFn ? {
+			type: "CallExpression",
+			span: safeSpan,
+			callee: {
+				type: "ParenthesisExpression",
+				span: safeSpan,
+				expression: tokensProp.ast
+			},
+			arguments: []
+		} : tokensProp.ast;
+		state.needsTokenVarsHelper = true;
+		return {
+			type: "CallExpression",
+			span: safeSpan,
+			callee: {
+				type: "Identifier",
+				value: "__bossTokenVars",
+				optional: false,
+				span: safeSpan
+			},
+			arguments: [{ expression: argExpression }]
+		};
+	}
+	const overrides = propValueToRaw(tokensProp);
+	if (!overrides || typeof overrides !== "object" || Array.isArray(overrides)) return null;
+	const tokenVars = createTokenVars({
+		prefix: state.api.selectorPrefix ?? "",
+		toValue: (value, property) => state.api.dictionary.toValue(value, property)
+	})(overrides);
+	const entries = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(tokenVars)) entries.set(key, literalExpression(value, ensureSpan(span)));
+	if (!entries.size) return null;
+	return toStyleObject(entries, ensureSpan(span));
+};
+const propValueToRaw = (prop) => {
+	const value = prop.value;
+	if (Array.isArray(value)) return value.map((entry) => propValueToRaw(entry));
+	if (value && typeof value === "object") return Object.entries(value).reduce((acc, [key, entry]) => {
+		acc[key] = propValueToRaw(entry);
+		return acc;
+	}, {});
+	return value;
+};
+const wrapDynamicAs = (node, asExpression, span, context) => {
+	const safeSpan = ensureSpan(span);
+	const componentIdentifier = {
+		type: "Identifier",
+		value: "__BossCmp",
+		optional: false,
+		span: safeSpan
+	};
+	const element = structuredClone(node);
+	element.opening.name = componentIdentifier;
+	if (element.closing) element.closing.name = componentIdentifier;
+	const iife = {
+		type: "CallExpression",
+		span: safeSpan,
+		callee: {
+			type: "FunctionExpression",
+			span: safeSpan,
+			identifier: void 0,
+			params: [],
+			body: {
+				type: "BlockStatement",
+				span: safeSpan,
+				stmts: [{
+					type: "VariableDeclaration",
+					span: safeSpan,
+					kind: "const",
+					declarations: [{
+						type: "VariableDeclarator",
+						span: safeSpan,
+						id: componentIdentifier,
+						init: asExpression
+					}]
+				}, {
+					type: "ReturnStatement",
+					span: safeSpan,
+					argument: element
+				}]
+			},
+			generator: false,
+			async: false
+		},
+		arguments: []
+	};
+	if (context.inJsxChild) return {
+		type: "JSXExpressionContainer",
+		span: safeSpan,
+		expression: iife
+	};
+	return iife;
+};
+
+//#endregion
+export { buildPreparedDefinition, isPreparedDefinitionStatic, transformJsxElement };