boss-css 0.0.1 → 0.0.2

package/dist/native/styleTypes.mjs

@@ -0,0 +1,164 @@
+import { createRequire } from "node:module";
+import fs from "node:fs/promises";
+import path from "node:path";
+import fg from "fast-glob";
+
+//#region src/native/styleTypes.ts
+const interfaceNames = new Set([
+	"ViewStyle",
+	"TextStyle",
+	"ImageStyle"
+]);
+const normalizeType = (value) => value.replace(/\s+/g, " ").replace(/;$/, "").trim();
+const parseInterfaces = (source) => {
+	const interfaces = /* @__PURE__ */ new Map();
+	const lines = source.split("\n");
+	let current = null;
+	let comment = [];
+	let pendingProp = null;
+	const interfaceRegexp = /^\s*(?:export\s+)?interface\s+([A-Za-z0-9_]+)(?:\s+extends\s+([^ {]+(?:\s*,\s*[^ {]+)*))?\s*\{/;
+	const propRegexp = /^\s+(?:readonly\s+)?["']?([A-Za-z0-9_]+)["']?\??:\s*(.+)$/;
+	for (const line of lines) {
+		const interfaceMatch = line.match(interfaceRegexp);
+		if (interfaceMatch) {
+			const [, name, extendsRaw] = interfaceMatch;
+			const entry = {
+				name,
+				extends: extendsRaw ? extendsRaw.split(",").map((value) => value.trim()) : [],
+				props: /* @__PURE__ */ new Map()
+			};
+			interfaces.set(name, entry);
+			current = entry;
+			comment = [];
+			pendingProp = null;
+			continue;
+		}
+		if (current && line.trim() === "}") {
+			current = null;
+			comment = [];
+			pendingProp = null;
+			continue;
+		}
+		if (!current) continue;
+		if (line.trim().startsWith("/**")) {
+			const trimmed = line.trim().replace(/^\/\*\* ?/, "");
+			if (trimmed.includes("*/")) comment = [trimmed.replace(/\*\/$/, "").trim()];
+			else comment = [trimmed];
+			continue;
+		}
+		if (comment.length && line.trim().startsWith("*")) {
+			const trimmed = line.trim().replace(/^\* ?/, "");
+			if (!trimmed.endsWith("*/")) {
+				comment.push(trimmed);
+				continue;
+			}
+			comment.push(trimmed.replace(/\*\/$/, "").trim());
+			continue;
+		}
+		if (pendingProp) {
+			pendingProp.type += ` ${line.trim()}`;
+			if (line.includes(";")) {
+				const propType = normalizeType(pendingProp.type);
+				current.props.set(pendingProp.name, {
+					name: pendingProp.name,
+					type: propType,
+					description: comment.join("\n").trim() || void 0
+				});
+				pendingProp = null;
+				comment = [];
+			}
+			continue;
+		}
+		const propMatch = line.match(propRegexp);
+		if (!propMatch) continue;
+		const [, rawName, typeRaw] = propMatch;
+		if (rawName.startsWith("[")) continue;
+		const typeValue = typeRaw.trim();
+		if (!line.includes(";")) {
+			pendingProp = {
+				name: rawName,
+				type: typeValue
+			};
+			continue;
+		}
+		current.props.set(rawName, {
+			name: rawName,
+			type: normalizeType(typeValue),
+			description: comment.join("\n").trim() || void 0
+		});
+		comment = [];
+	}
+	return interfaces;
+};
+const mergeProps = (target, source) => {
+	for (const [name, prop] of source.entries()) {
+		const existing = target.get(name);
+		if (!existing) {
+			target.set(name, { ...prop });
+			continue;
+		}
+		if (existing.type !== prop.type) {
+			const types = new Set([existing.type, prop.type]);
+			existing.type = Array.from(types).join(" | ");
+		}
+		if (!existing.description && prop.description) existing.description = prop.description;
+	}
+};
+const collectProps = (name, interfaces, visited = /* @__PURE__ */ new Set()) => {
+	if (visited.has(name)) return /* @__PURE__ */ new Map();
+	visited.add(name);
+	const entry = interfaces.get(name);
+	if (!entry) return /* @__PURE__ */ new Map();
+	const merged = /* @__PURE__ */ new Map();
+	for (const parent of entry.extends) mergeProps(merged, collectProps(parent, interfaces, visited));
+	mergeProps(merged, entry.props);
+	return merged;
+};
+const resolveReactNativeRoot = async () => {
+	const require = createRequire(process.cwd() + "/package.json");
+	let packageJsonPath;
+	try {
+		packageJsonPath = require.resolve("react-native/package.json");
+	} catch (error) {
+		throw new Error("native: react-native is not installed in this project.");
+	}
+	const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf-8"));
+	return {
+		root: path.dirname(packageJsonPath),
+		typesEntry: packageJson.types || packageJson.typings
+	};
+};
+const findStyleSheetTypesFile = async (root, typesEntry) => {
+	const candidates = await fg(["**/StyleSheetTypes.d.ts", "**/StyleSheetTypes.ts"], {
+		cwd: root,
+		absolute: true,
+		suppressErrors: true
+	});
+	if (candidates.length) return candidates[0];
+	if (typesEntry) {
+		const entryPath = path.join(root, typesEntry);
+		if ((await fs.readFile(entryPath, "utf-8").catch(() => "")).includes("interface ViewStyle")) return entryPath;
+	}
+	const fallback = await fg(["**/*.d.ts"], {
+		cwd: root,
+		absolute: true,
+		suppressErrors: true
+	});
+	for (const file of fallback) if ((await fs.readFile(file, "utf-8").catch(() => "")).includes("interface ViewStyle")) return file;
+	return null;
+};
+const loadReactNativeStyleProps = async () => {
+	const { root, typesEntry } = await resolveReactNativeRoot();
+	const typesFile = await findStyleSheetTypesFile(root, typesEntry);
+	if (!typesFile) throw new Error("native: unable to locate React Native style type definitions.");
+	const interfaces = parseInterfaces(await fs.readFile(typesFile, "utf-8"));
+	const merged = /* @__PURE__ */ new Map();
+	for (const name of interfaceNames) mergeProps(merged, collectProps(name, interfaces));
+	return {
+		props: merged,
+		sourcePath: typesFile
+	};
+};
+
+//#endregion
+export { loadReactNativeStyleProps };

package/dist/parser/classname/server.cjs

@@ -0,0 +1,239 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+
+//#region src/parser/classname/server.ts
+var server_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	name: () => name,
+	onParse: () => onParse
+});
+const name = "classname";
+const onParse = async (api, input) => {
+	if (api.runtime?.only) return;
+	const log = api.log.child("parser").child("classname");
+	const { content } = input;
+	const { codes: extractedCodes } = extractCode(content);
+	const results = await Promise.all(extractedCodes.map((v) => extractPropTree(v, api)));
+	for (const [key, tree] of Object.entries(results)) {
+		if (!Object.keys(tree).length) continue;
+		log.log("onPropTree", tree);
+		await api.trigger("onPropTree", {
+			input: api.propTreeToObject(tree),
+			tree,
+			preferVariables: false,
+			file: input,
+			code: extractedCodes[key],
+			parser: "classname"
+		});
+	}
+};
+const templateRegexp = /`([\S\s]+?)`/g;
+const quoteRegexps = [
+	/"(.+?)"/g,
+	/'(.+?)'/g,
+	templateRegexp
+];
+const extractCode = (content) => {
+	const results = [];
+	for (const regexp of quoteRegexps) {
+		const matches = content.matchAll(regexp);
+		const isTemplate = regexp === templateRegexp;
+		for (const match of matches) {
+			const [, code] = match;
+			if (isTemplate && code.includes("${")) {
+				console.warn("[boss-css] classname parser skipped template literals with expressions. Classnames must be static.");
+				console.warn(code);
+				continue;
+			}
+			results.push(code);
+		}
+	}
+	return { codes: results };
+};
+const extractPropTree = async (string, api) => {
+	const tree = {};
+	const selectorTokens = /* @__PURE__ */ new Map();
+	const selectors = splitSelectors(string.replace(/[\n\r]/g, " "));
+	const resolveDescriptor = (fragment) => {
+		if (getChildSelector(fragment)) return api.dictionary.resolve("child");
+		return api.dictionary.resolve(fragment);
+	};
+	selectors.forEach((selector) => {
+		const grouped = parseGroupedSelector(selector);
+		if (grouped) {
+			const rawFragments$1 = splitFragments(grouped.prefix);
+			if (!resolveDescriptor(stripImportantSuffix(rawFragments$1[0])).descriptor || rawFragments$1.length === 0) return;
+			const fragments = expandFragments(rawFragments$1);
+			grouped.entries.forEach(({ name, rawValue }) => {
+				if (!resolveDescriptor(name).descriptor?.isCSSProp) return;
+				const { value: value$1, important: important$1 } = parseImportantValue(rawValue);
+				const prop = { value: value$1 };
+				if (important$1) prop.important = true;
+				const path$1 = [...fragments, name];
+				const key = pathKey(path$1);
+				createPropPath([...path$1], prop, tree);
+				selectorTokens.set(key, selector);
+			});
+			return;
+		}
+		const rawFragments = splitFragments(selector);
+		let value = null;
+		let important = false;
+		const path = [];
+		const descriptor = resolveDescriptor(rawFragments.length === 1 ? stripImportantSuffix(rawFragments[0]) : rawFragments[0]).descriptor;
+		if (!descriptor || rawFragments.length === 1 && !descriptor.single) return;
+		for (const [index, fragment] of Object.entries(rawFragments)) {
+			const isLast = rawFragments.length === +index + 1;
+			if (path.length && isLast) {
+				const parsed = parseImportantValue(fragment);
+				value = parsed.value;
+				important = parsed.important;
+			} else {
+				const cleanedFragment = stripImportantSuffix(fragment);
+				if (isLast && rawFragments.length === 1 && cleanedFragment !== fragment) important = true;
+				const childSelector = getChildSelector(cleanedFragment);
+				if (childSelector) path.push("child", childSelector);
+				else path.push(cleanedFragment);
+			}
+		}
+		if (path.length) {
+			const lastProp = path.at(-1);
+			if (!(lastProp ? resolveDescriptor(lastProp).descriptor : null)?.isCSSProp) return;
+			const key = pathKey(path);
+			const prop = { value };
+			if (important) {
+				prop.important = true;
+				prop.classToken = selector;
+			}
+			createPropPath([...path], prop, tree);
+			selectorTokens.delete(key);
+		}
+	});
+	applySelectorTokens(tree, selectorTokens);
+	return tree;
+};
+const splitSelectors = (string) => splitOutside(string, " ");
+const splitFragments = (selector) => splitOutside(selector, ":");
+const splitGroupedEntries = (body) => splitOutside(body, ";");
+const splitGroupedEntry = (entry) => splitOnceOutside(entry, ":");
+const parseGroupedSelector = (selector) => {
+	if (!selector.endsWith("}")) return null;
+	const groupStart = findGroupStart(selector);
+	if (groupStart === -1) return null;
+	const prefix = selector.slice(0, groupStart);
+	const entries = splitGroupedEntries(selector.slice(groupStart + 2, -1)).map((entry) => entry.trim()).filter(Boolean).map((entry) => {
+		const parts = splitGroupedEntry(entry);
+		if (!parts) return null;
+		const [name, rawValue] = parts;
+		return {
+			name: name.trim(),
+			rawValue: rawValue.trim()
+		};
+	}).filter((entry) => Boolean(entry));
+	if (!entries.length) return null;
+	return {
+		prefix,
+		entries
+	};
+};
+const splitOutside = (input, delimiter) => {
+	const results = [];
+	let current = "";
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	for (const char of input) {
+		if (char === "{") braceDepth += 1;
+		if (char === "}") braceDepth = Math.max(0, braceDepth - 1);
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (char === delimiter && braceDepth === 0 && bracketDepth === 0) {
+			if (current) results.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	if (current) results.push(current);
+	return results;
+};
+const splitOnceOutside = (input, delimiter) => {
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	for (let i = 0; i < input.length; i += 1) {
+		const char = input[i];
+		if (char === "{") braceDepth += 1;
+		if (char === "}") braceDepth = Math.max(0, braceDepth - 1);
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (char === delimiter && braceDepth === 0 && bracketDepth === 0) return [input.slice(0, i), input.slice(i + 1)];
+	}
+	return null;
+};
+const findGroupStart = (selector) => {
+	let bracketDepth = 0;
+	for (let i = 0; i < selector.length - 1; i += 1) {
+		const char = selector[i];
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (bracketDepth === 0 && selector[i] === ":" && selector[i + 1] === "{") return i;
+	}
+	return -1;
+};
+const getChildSelector = (fragment) => {
+	if (!fragment || !fragment.startsWith("[") || !fragment.endsWith("]")) return null;
+	return fragment.slice(1, -1);
+};
+const expandFragments = (fragments) => {
+	const path = [];
+	for (const fragment of fragments) {
+		const childSelector = getChildSelector(fragment);
+		if (childSelector) path.push("child", childSelector);
+		else path.push(fragment);
+	}
+	return path;
+};
+const parseValue = (rawValue) => {
+	return rawValue.includes("_") ? rawValue.split("_") : rawValue;
+};
+const parseImportantValue = (rawValue) => {
+	if (!rawValue) return {
+		value: rawValue,
+		important: false
+	};
+	const important = rawValue.endsWith("!");
+	return {
+		value: parseValue(important ? rawValue.slice(0, -1) : rawValue),
+		important
+	};
+};
+const stripImportantSuffix = (fragment) => {
+	return fragment && fragment.endsWith("!") ? fragment.slice(0, -1) : fragment;
+};
+const pathKey = (path) => path.join(">");
+const createPropPath = (path, prop, obj) => {
+	const last = path.pop();
+	if (!last) return;
+	for (const key of path) {
+		obj[key] = obj[key] || { value: {} };
+		const next = obj[key].value;
+		if (!next || typeof next !== "object" || Array.isArray(next)) return;
+		obj = next;
+	}
+	typeof obj === "object" && (obj[last] = prop);
+};
+const applySelectorTokens = (tree, selectorTokens, path = []) => {
+	Object.entries(tree).forEach(([name, prop]) => {
+		const nextPath = [...path, name];
+		const token = selectorTokens.get(pathKey(nextPath));
+		if (token) prop.classToken = token;
+		if (prop.value && typeof prop.value === "object" && !Array.isArray(prop.value)) applySelectorTokens(prop.value, selectorTokens, nextPath);
+	});
+};
+
+//#endregion
+exports.name = name;
+exports.onParse = onParse;
+Object.defineProperty(exports, 'server_exports', {
+  enumerable: true,
+  get: function () {
+    return server_exports;
+  }
+});

package/dist/parser/classname/server.mjs

@@ -0,0 +1,232 @@
+import { __exportAll } from "../../_virtual/rolldown_runtime.mjs";
+
+//#region src/parser/classname/server.ts
+var server_exports = /* @__PURE__ */ __exportAll({
+	name: () => name,
+	onParse: () => onParse
+});
+const name = "classname";
+const onParse = async (api, input) => {
+	if (api.runtime?.only) return;
+	const log = api.log.child("parser").child("classname");
+	const { content } = input;
+	const { codes: extractedCodes } = extractCode(content);
+	const results = await Promise.all(extractedCodes.map((v) => extractPropTree(v, api)));
+	for (const [key, tree] of Object.entries(results)) {
+		if (!Object.keys(tree).length) continue;
+		log.log("onPropTree", tree);
+		await api.trigger("onPropTree", {
+			input: api.propTreeToObject(tree),
+			tree,
+			preferVariables: false,
+			file: input,
+			code: extractedCodes[key],
+			parser: "classname"
+		});
+	}
+};
+const templateRegexp = /`([\S\s]+?)`/g;
+const quoteRegexps = [
+	/"(.+?)"/g,
+	/'(.+?)'/g,
+	templateRegexp
+];
+const extractCode = (content) => {
+	const results = [];
+	for (const regexp of quoteRegexps) {
+		const matches = content.matchAll(regexp);
+		const isTemplate = regexp === templateRegexp;
+		for (const match of matches) {
+			const [, code] = match;
+			if (isTemplate && code.includes("${")) {
+				console.warn("[boss-css] classname parser skipped template literals with expressions. Classnames must be static.");
+				console.warn(code);
+				continue;
+			}
+			results.push(code);
+		}
+	}
+	return { codes: results };
+};
+const extractPropTree = async (string, api) => {
+	const tree = {};
+	const selectorTokens = /* @__PURE__ */ new Map();
+	const selectors = splitSelectors(string.replace(/[\n\r]/g, " "));
+	const resolveDescriptor = (fragment) => {
+		if (getChildSelector(fragment)) return api.dictionary.resolve("child");
+		return api.dictionary.resolve(fragment);
+	};
+	selectors.forEach((selector) => {
+		const grouped = parseGroupedSelector(selector);
+		if (grouped) {
+			const rawFragments$1 = splitFragments(grouped.prefix);
+			if (!resolveDescriptor(stripImportantSuffix(rawFragments$1[0])).descriptor || rawFragments$1.length === 0) return;
+			const fragments = expandFragments(rawFragments$1);
+			grouped.entries.forEach(({ name, rawValue }) => {
+				if (!resolveDescriptor(name).descriptor?.isCSSProp) return;
+				const { value: value$1, important: important$1 } = parseImportantValue(rawValue);
+				const prop = { value: value$1 };
+				if (important$1) prop.important = true;
+				const path$1 = [...fragments, name];
+				const key = pathKey(path$1);
+				createPropPath([...path$1], prop, tree);
+				selectorTokens.set(key, selector);
+			});
+			return;
+		}
+		const rawFragments = splitFragments(selector);
+		let value = null;
+		let important = false;
+		const path = [];
+		const descriptor = resolveDescriptor(rawFragments.length === 1 ? stripImportantSuffix(rawFragments[0]) : rawFragments[0]).descriptor;
+		if (!descriptor || rawFragments.length === 1 && !descriptor.single) return;
+		for (const [index, fragment] of Object.entries(rawFragments)) {
+			const isLast = rawFragments.length === +index + 1;
+			if (path.length && isLast) {
+				const parsed = parseImportantValue(fragment);
+				value = parsed.value;
+				important = parsed.important;
+			} else {
+				const cleanedFragment = stripImportantSuffix(fragment);
+				if (isLast && rawFragments.length === 1 && cleanedFragment !== fragment) important = true;
+				const childSelector = getChildSelector(cleanedFragment);
+				if (childSelector) path.push("child", childSelector);
+				else path.push(cleanedFragment);
+			}
+		}
+		if (path.length) {
+			const lastProp = path.at(-1);
+			if (!(lastProp ? resolveDescriptor(lastProp).descriptor : null)?.isCSSProp) return;
+			const key = pathKey(path);
+			const prop = { value };
+			if (important) {
+				prop.important = true;
+				prop.classToken = selector;
+			}
+			createPropPath([...path], prop, tree);
+			selectorTokens.delete(key);
+		}
+	});
+	applySelectorTokens(tree, selectorTokens);
+	return tree;
+};
+const splitSelectors = (string) => splitOutside(string, " ");
+const splitFragments = (selector) => splitOutside(selector, ":");
+const splitGroupedEntries = (body) => splitOutside(body, ";");
+const splitGroupedEntry = (entry) => splitOnceOutside(entry, ":");
+const parseGroupedSelector = (selector) => {
+	if (!selector.endsWith("}")) return null;
+	const groupStart = findGroupStart(selector);
+	if (groupStart === -1) return null;
+	const prefix = selector.slice(0, groupStart);
+	const entries = splitGroupedEntries(selector.slice(groupStart + 2, -1)).map((entry) => entry.trim()).filter(Boolean).map((entry) => {
+		const parts = splitGroupedEntry(entry);
+		if (!parts) return null;
+		const [name, rawValue] = parts;
+		return {
+			name: name.trim(),
+			rawValue: rawValue.trim()
+		};
+	}).filter((entry) => Boolean(entry));
+	if (!entries.length) return null;
+	return {
+		prefix,
+		entries
+	};
+};
+const splitOutside = (input, delimiter) => {
+	const results = [];
+	let current = "";
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	for (const char of input) {
+		if (char === "{") braceDepth += 1;
+		if (char === "}") braceDepth = Math.max(0, braceDepth - 1);
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (char === delimiter && braceDepth === 0 && bracketDepth === 0) {
+			if (current) results.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	if (current) results.push(current);
+	return results;
+};
+const splitOnceOutside = (input, delimiter) => {
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	for (let i = 0; i < input.length; i += 1) {
+		const char = input[i];
+		if (char === "{") braceDepth += 1;
+		if (char === "}") braceDepth = Math.max(0, braceDepth - 1);
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (char === delimiter && braceDepth === 0 && bracketDepth === 0) return [input.slice(0, i), input.slice(i + 1)];
+	}
+	return null;
+};
+const findGroupStart = (selector) => {
+	let bracketDepth = 0;
+	for (let i = 0; i < selector.length - 1; i += 1) {
+		const char = selector[i];
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (bracketDepth === 0 && selector[i] === ":" && selector[i + 1] === "{") return i;
+	}
+	return -1;
+};
+const getChildSelector = (fragment) => {
+	if (!fragment || !fragment.startsWith("[") || !fragment.endsWith("]")) return null;
+	return fragment.slice(1, -1);
+};
+const expandFragments = (fragments) => {
+	const path = [];
+	for (const fragment of fragments) {
+		const childSelector = getChildSelector(fragment);
+		if (childSelector) path.push("child", childSelector);
+		else path.push(fragment);
+	}
+	return path;
+};
+const parseValue = (rawValue) => {
+	return rawValue.includes("_") ? rawValue.split("_") : rawValue;
+};
+const parseImportantValue = (rawValue) => {
+	if (!rawValue) return {
+		value: rawValue,
+		important: false
+	};
+	const important = rawValue.endsWith("!");
+	return {
+		value: parseValue(important ? rawValue.slice(0, -1) : rawValue),
+		important
+	};
+};
+const stripImportantSuffix = (fragment) => {
+	return fragment && fragment.endsWith("!") ? fragment.slice(0, -1) : fragment;
+};
+const pathKey = (path) => path.join(">");
+const createPropPath = (path, prop, obj) => {
+	const last = path.pop();
+	if (!last) return;
+	for (const key of path) {
+		obj[key] = obj[key] || { value: {} };
+		const next = obj[key].value;
+		if (!next || typeof next !== "object" || Array.isArray(next)) return;
+		obj = next;
+	}
+	typeof obj === "object" && (obj[last] = prop);
+};
+const applySelectorTokens = (tree, selectorTokens, path = []) => {
+	Object.entries(tree).forEach(([name, prop]) => {
+		const nextPath = [...path, name];
+		const token = selectorTokens.get(pathKey(nextPath));
+		if (token) prop.classToken = token;
+		if (prop.value && typeof prop.value === "object" && !Array.isArray(prop.value)) applySelectorTokens(prop.value, selectorTokens, nextPath);
+	});
+};
+
+//#endregion
+export { name, onParse, server_exports };

package/dist/parser/jsx/browser.cjs

@@ -0,0 +1,66 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_framework = require('../../shared/framework.cjs');
+const require_isDOMProp = require('./isDOMProp.cjs');
+const require_cx_index = require('../../cx/index.cjs');
+let _boss_css_is_css_prop = require("@boss-css/is-css-prop");
+_boss_css_is_css_prop = require_rolldown_runtime.__toESM(_boss_css_is_css_prop);
+
+//#region src/parser/jsx/browser.ts
+const ignoredProps = new Set([
+	"ref",
+	"children",
+	"dangerouslySetInnerHtml",
+	"key"
+]);
+const name = "jsx";
+const onBrowserObjectStart = (api, { input, tag = "div", contexts = [], output = {} }) => {
+	const log = api.log.child("runtime").child("jsx");
+	log.log("browserObject:start", input, output, contexts);
+	if (contexts.length) return;
+	const isClassnameFirst = api.strategy === "classname-first";
+	const classNameProp = require_framework.getClassNameProp(api.framework);
+	let tokenOverrides = null;
+	for (const prop in input) {
+		if (prop === "tokens") {
+			tokenOverrides = input[prop];
+			delete input[prop];
+			continue;
+		}
+		if (prop === classNameProp) {
+			output[classNameProp] = require_cx_index.cx(output[classNameProp], input[prop]);
+			delete input[prop];
+			continue;
+		}
+		if (prop === "style") {
+			const styleValue = input[prop];
+			if (styleValue && typeof styleValue === "object" && !Array.isArray(styleValue)) output.style = {
+				...output.style ?? {},
+				...styleValue
+			};
+			else if (styleValue !== void 0) output.style = styleValue;
+			delete input[prop];
+			continue;
+		}
+		if (ignoredProps.has(prop) || require_isDOMProp.default(tag, prop)) {
+			output[prop] = input[prop];
+			delete input[prop];
+			continue;
+		}
+		if (typeof input[prop] === "function") {
+			if (isClassnameFirst && (0, _boss_css_is_css_prop.default)(tag, prop)) continue;
+			input[prop] = input[prop]();
+		}
+	}
+	if (tokenOverrides && typeof api.tokenVars === "function") {
+		const resolved = typeof tokenOverrides === "function" ? tokenOverrides() : tokenOverrides;
+		if (resolved && typeof resolved === "object") output.style = {
+			...output.style ?? {},
+			...api.tokenVars(resolved)
+		};
+	}
+	log.log("browserObject:end", input, output);
+};
+
+//#endregion
+exports.name = name;
+exports.onBrowserObjectStart = onBrowserObjectStart;