@bamboocss/core 1.11.1 → 1.11.3

package/dist/index.cjs

@@ -0,0 +1,4055 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _bamboocss_logger = require("@bamboocss/logger");
+let outdent = require("outdent");
+let _bamboocss_shared = require("@bamboocss/shared");
+let postcss = require("postcss");
+postcss = __toESM(postcss);
+let _bamboocss_is_valid_prop = require("@bamboocss/is-valid-prop");
+let _bamboocss_token_dictionary = require("@bamboocss/token-dictionary");
+let lodash_merge = require("lodash.merge");
+lodash_merge = __toESM(lodash_merge);
+let _csstools_postcss_cascade_layers = require("@csstools/postcss-cascade-layers");
+_csstools_postcss_cascade_layers = __toESM(_csstools_postcss_cascade_layers);
+let postcss_nested = require("postcss-nested");
+postcss_nested = __toESM(postcss_nested);
+let postcss_discard_duplicates = require("postcss-discard-duplicates");
+postcss_discard_duplicates = __toESM(postcss_discard_duplicates);
+let postcss_discard_empty = require("postcss-discard-empty");
+postcss_discard_empty = __toESM(postcss_discard_empty);
+let postcss_minify_selectors = require("postcss-minify-selectors");
+postcss_minify_selectors = __toESM(postcss_minify_selectors);
+let postcss_normalize_whitespace = require("postcss-normalize-whitespace");
+postcss_normalize_whitespace = __toESM(postcss_normalize_whitespace);
+let ts_pattern = require("ts-pattern");
+let postcss_selector_parser = require("postcss-selector-parser");
+postcss_selector_parser = __toESM(postcss_selector_parser);
+//#region src/messages.ts
+var messages_exports = /* @__PURE__ */ __exportAll({
+	artifactsGenerated: () => artifactsGenerated,
+	buildComplete: () => buildComplete,
+	codegenComplete: () => codegenComplete,
+	configExists: () => configExists,
+	configWatch: () => configWatch,
+	cssArtifactComplete: () => cssArtifactComplete,
+	exclamation: () => exclamation,
+	getMessages: () => getMessages,
+	noExtract: () => noExtract,
+	thankYou: () => thankYou,
+	watch: () => watch
+});
+const tick = _bamboocss_logger.colors.green().bold("✔️");
+const artifactsGenerated = (ctx) => {
+	const { config: { outdir, themes }, recipes, patterns, tokens, jsx } = ctx;
+	return () => [
+		outdent.outdent`
+    ${tick} ${(0, _bamboocss_logger.quote)(outdir, "/css")}: the css function to author styles
+    `,
+		!tokens.isEmpty && outdent.outdent`
+    ${tick} ${(0, _bamboocss_logger.quote)(outdir, "/tokens")}: the css variables and js function to query your tokens
+    `,
+		!patterns.isEmpty() && !ctx.isTemplateLiteralSyntax && outdent.outdent`
+    ${tick} ${(0, _bamboocss_logger.quote)(outdir, "/patterns")}: functions to implement and apply common layout patterns
+    `,
+		!recipes.isEmpty() && outdent.outdent`
+      ${tick} ${(0, _bamboocss_logger.quote)(outdir, "/recipes")}: functions to create multi-variant styles
+      `,
+		jsx.framework && outdent.outdent`
+      ${tick} ${(0, _bamboocss_logger.quote)(outdir, "/jsx")}: styled jsx elements for ${jsx.framework}
+      `,
+		themes && outdent.outdent`
+    ${tick} ${(0, _bamboocss_logger.quote)(outdir, "/themes")}: theme variants for your design system
+    `,
+		"\n"
+	].filter(Boolean).join("\n");
+};
+const configExists = (cmd) => outdent.outdent`
+      \n
+      It looks like you already have bamboo created\`.
+
+      You can now run ${(0, _bamboocss_logger.quote)(cmd, " bamboo --watch")}.
+
+      `;
+const thankYou = () => outdent.outdent`
+
+  🚀 Thanks for choosing ${_bamboocss_logger.colors.cyan("Bamboo")})} to write your css.
+
+  You are set up to start using Bamboo!
+
+  `;
+const codegenComplete = () => outdent.outdent`
+
+  ${_bamboocss_logger.colors.bold().cyan("Next steps:")}
+
+  [1] Create a ${(0, _bamboocss_logger.quote)("index.css")} file in your project that contains:
+
+      @layer reset, base, tokens, recipes, utilities;
+
+
+  [2] Import the ${(0, _bamboocss_logger.quote)("index.css")} file at the root of your project.
+
+  `;
+const noExtract = () => outdent.outdent`
+  No style object or props were detected in your source files.
+  If this is unexpected, double-check the \`include\` options in your Bamboo config\n
+`;
+const watch = () => outdent.outdent`
+  Watching for file changes...
+  `;
+const configWatch = () => outdent.outdent`
+  Watching for config file changes...
+  `;
+const buildComplete = (count) => outdent.outdent`
+  Successfully extracted css from ${count} file(s) ✨
+  `;
+const randomWords = [
+	"Sweet",
+	"Divine",
+	"Bamboolicious",
+	"Super"
+];
+const pickRandom = (arr) => arr[Math.floor(Math.random() * arr.length)];
+const exclamation = () => `🎋 ${pickRandom(randomWords)}! ✨`;
+const cssArtifactComplete = (type) => `Successfully generated ${type} css artifact ✨`;
+const getMessages = (ctx) => ({
+	artifactsGenerated: artifactsGenerated(ctx),
+	configExists,
+	thankYou,
+	codegenComplete,
+	noExtract,
+	watch,
+	buildComplete,
+	configWatch,
+	cssArtifactComplete,
+	exclamation
+});
+//#endregion
+//#region src/breakpoints.ts
+var Breakpoints = class {
+	breakpoints;
+	sorted;
+	values;
+	keys;
+	ranges;
+	conditions;
+	constructor(breakpoints) {
+		this.breakpoints = breakpoints;
+		this.sorted = sortBreakpoints(breakpoints);
+		this.values = Object.fromEntries(this.sorted);
+		this.keys = ["base", ...Object.keys(this.values)];
+		this.ranges = this.getRanges();
+		this.conditions = this.getConditions();
+	}
+	get = (name) => {
+		return this.values[name];
+	};
+	build = ({ min, max }) => {
+		if (min == null && max == null) return "";
+		return [
+			"screen",
+			min && `(min-width: ${min})`,
+			max && `(max-width: ${max})`
+		].filter(Boolean).join(" and ");
+	};
+	only = (name) => {
+		const { min, max } = this.get(name);
+		return this.build({
+			min,
+			max
+		});
+	};
+	getRanges = () => {
+		const breakpoints = Object.keys(this.values);
+		const permuations = getPermutations(breakpoints);
+		const values = breakpoints.flatMap((name) => {
+			const value = this.get(name);
+			const down = [`${name}Down`, this.build({ max: adjust(value.min) })];
+			return [
+				[name, this.build({ min: value.min })],
+				[`${name}Only`, this.only(name)],
+				down
+			];
+		}).filter(([_, value]) => value !== "").concat(permuations.map(([min, max]) => {
+			const minValue = this.get(min);
+			const maxValue = this.get(max);
+			return [`${min}To${(0, _bamboocss_shared.capitalize)(max)}`, this.build({
+				min: minValue.min,
+				max: adjust(maxValue.min)
+			})];
+		}));
+		return Object.fromEntries(values);
+	};
+	getConditions = () => {
+		const values = Object.entries(this.ranges).map(([key, value]) => {
+			return [key, toCondition(key, value)];
+		});
+		return Object.fromEntries(values);
+	};
+	getCondition = (key) => {
+		return this.conditions[key];
+	};
+	expandScreenAtRule = (root) => {
+		root.walkAtRules("breakpoint", (rule) => {
+			const value = this.getCondition(rule.params);
+			if (!value) throw rule.error(`No \`${rule.params}\` screen found.`);
+			if (value.type !== "at-rule") throw rule.error(`\`${rule.params}\` is not a valid screen.`);
+			rule.name = "media";
+			rule.params = value.params;
+		});
+	};
+};
+function adjust(value) {
+	return (0, _bamboocss_shared.toRem)(`${parseFloat((0, _bamboocss_shared.toPx)(value) ?? "") - .04}px`);
+}
+function sortBreakpoints(breakpoints) {
+	return Object.entries(breakpoints).sort(([, minA], [, minB]) => {
+		return parseInt(minA, 10) < parseInt(minB, 10) ? -1 : 1;
+	}).map(([name, min], index, entries) => {
+		let max = null;
+		if (index <= entries.length - 1) max = entries[index + 1]?.[1];
+		if (max != null) max = adjust(max);
+		return [name, {
+			name,
+			min: (0, _bamboocss_shared.toRem)(min),
+			max
+		}];
+	});
+}
+const toCondition = (key, value) => ({
+	type: "at-rule",
+	name: "breakpoint",
+	value: key,
+	raw: `@media ${value}`,
+	params: value
+});
+function getPermutations(values) {
+	const result = [];
+	values.forEach((current, index) => {
+		let idx = index;
+		idx++;
+		let next = values[idx];
+		while (next) {
+			result.push([current, next]);
+			idx++;
+			next = values[idx];
+		}
+	});
+	return result;
+}
+//#endregion
+//#region src/safe-parse.ts
+function safeParse(str) {
+	try {
+		return postcss.default.parse(str);
+	} catch {
+		return postcss.default.root();
+	}
+}
+//#endregion
+//#region src/parse-condition.ts
+function parseAtRule(value) {
+	const rule = safeParse(value).nodes[0];
+	return {
+		type: "at-rule",
+		name: rule.name,
+		value: rule.params,
+		raw: value,
+		params: rule.params
+	};
+}
+/**
+* Parses an object condition with `@slot` markers into condition blocks.
+* Each path from root to `@slot` becomes an independent condition block.
+*
+* @example
+* ```ts
+* parseObjectCondition({
+*   "@media (hover: hover)": { "&:is(:hover, [data-hover])": "@slot" },
+*   "@media (hover: none)": { "&:is(:active, [data-active])": "@slot" },
+* })
+* ```
+*/
+function parseObjectCondition(obj) {
+	const blocks = [];
+	function traverse(node, path) {
+		for (const [key, value] of Object.entries(node)) if (value === "@slot") {
+			const parsed = parseCondition([...path, key]);
+			if (parsed && parsed.type === "mixed" && parsed.value.length > 0) blocks.push(parsed);
+		} else if (typeof value === "object" && value !== null) traverse(value, [...path, key]);
+	}
+	traverse(obj, []);
+	if (blocks.length === 0) return void 0;
+	if (blocks.length === 1) return blocks[0];
+	return {
+		type: "multi-block",
+		value: blocks,
+		raw: obj
+	};
+}
+function parseCondition(condition) {
+	if (Array.isArray(condition)) return {
+		type: "mixed",
+		raw: condition,
+		value: condition.map(parseCondition).filter(Boolean)
+	};
+	if (typeof condition === "object" && condition !== null) return parseObjectCondition(condition);
+	if (condition.startsWith("@")) return parseAtRule(condition);
+	let type;
+	if (condition.startsWith("&")) type = "self-nesting";
+	else if (condition.endsWith(" &")) type = "parent-nesting";
+	else if (condition.includes("&")) type = "combinator-nesting";
+	if (type) return {
+		type,
+		value: condition,
+		raw: condition
+	};
+}
+//#endregion
+//#region src/sort-at-rules.ts
+const minMaxWidth = /(!?\(\s*min(-device-)?-width)(.|\n)+\(\s*max(-device)?-width/i;
+const minWidth = /\(\s*min(-device)?-width/i;
+const maxMinWidth = /(!?\(\s*max(-device)?-width)(.|\n)+\(\s*min(-device)?-width/i;
+const maxWidth = /\(\s*max(-device)?-width/i;
+const isMinWidth = _testQuery(minMaxWidth, maxMinWidth, minWidth);
+const isMaxWidth = _testQuery(maxMinWidth, minMaxWidth, maxWidth);
+const minMaxHeight = /(!?\(\s*min(-device)?-height)(.|\n)+\(\s*max(-device)?-height/i;
+const minHeight = /\(\s*min(-device)?-height/i;
+const maxMinHeight = /(!?\(\s*max(-device)?-height)(.|\n)+\(\s*min(-device)?-height/i;
+const maxHeight = /\(\s*max(-device)?-height/i;
+const isMinHeight = _testQuery(minMaxHeight, maxMinHeight, minHeight);
+const isMaxHeight = _testQuery(maxMinHeight, minMaxHeight, maxHeight);
+const isPrint = /print/i;
+const isPrintOnly = /^print$/i;
+const maxValue = Number.MAX_VALUE;
+/**
+* Obtain the length of the media request in pixels.
+* Copy from original source `function inspectLength (length)`
+*/
+function getQueryLength(query) {
+	let length = /(-?\d*\.?\d+)(ch|em|ex|px|rem)/.exec(query);
+	if (length === null && (isMinWidth(query) || isMinHeight(query))) length = /(\d)/.exec(query);
+	if (length === "0") return 0;
+	if (length === null) return maxValue;
+	let number = length[1];
+	switch (length[2]) {
+		case "ch":
+			number = parseFloat(number) * 8.8984375;
+			break;
+		case "em":
+		case "rem":
+			number = parseFloat(number) * 16;
+			break;
+		case "ex":
+			number = parseFloat(number) * 8.296875;
+			break;
+		case "px":
+			number = parseFloat(number);
+			break;
+	}
+	return +number;
+}
+/**
+* Wrapper for creating test functions
+* @private
+* @param {RegExp} doubleTestTrue
+* @param {RegExp} doubleTestFalse
+* @param {RegExp} singleTest
+* @return {Function}
+*/
+function _testQuery(doubleTestTrue, doubleTestFalse, singleTest) {
+	/**
+	* @param {string} query
+	* @return {boolean}
+	*/
+	return function(query) {
+		if (doubleTestTrue.test(query)) return true;
+		else if (doubleTestFalse.test(query)) return false;
+		return singleTest.test(query);
+	};
+}
+/**
+* @private
+* @param {string} a
+* @param {string} b
+* @return {number|null}
+*/
+function _testIsPrint(a, b) {
+	const isPrintA = isPrint.test(a);
+	const isPrintOnlyA = isPrintOnly.test(a);
+	const isPrintB = isPrint.test(b);
+	const isPrintOnlyB = isPrintOnly.test(b);
+	if (isPrintA && isPrintB) {
+		if (!isPrintOnlyA && isPrintOnlyB) return 1;
+		if (isPrintOnlyA && !isPrintOnlyB) return -1;
+		return a.localeCompare(b);
+	}
+	if (isPrintA) return 1;
+	if (isPrintB) return -1;
+	return null;
+}
+function createSort(config = {}) {
+	const { unitlessMqAlwaysFirst } = config;
+	return function sortCSSmq(a, b) {
+		const testIsPrint = _testIsPrint(a, b);
+		if (testIsPrint !== null) return testIsPrint;
+		const minA = isMinWidth(a) || isMinHeight(a);
+		const maxA = isMaxWidth(a) || isMaxHeight(a);
+		const minB = isMinWidth(b) || isMinHeight(b);
+		const maxB = isMaxWidth(b) || isMaxHeight(b);
+		if (unitlessMqAlwaysFirst && (!minA && !maxA || !minB && !maxB)) {
+			if (!minA && !maxA && !minB && !maxB) return a.localeCompare(b);
+			return !minB && !maxB ? 1 : -1;
+		} else {
+			if (minA && maxB) return -1;
+			if (maxA && minB) return 1;
+			const lengthA = getQueryLength(a);
+			const lengthB = getQueryLength(b);
+			if (lengthA === maxValue && lengthB === maxValue) return a.localeCompare(b);
+			else if (lengthA === maxValue) return 1;
+			else if (lengthB === maxValue) return -1;
+			if (lengthA > lengthB) {
+				if (maxA) return -1;
+				return 1;
+			}
+			if (lengthA < lengthB) {
+				if (maxA) return 1;
+				return -1;
+			}
+			return a.localeCompare(b);
+		}
+	};
+}
+const sortAtRules = createSort();
+//#endregion
+//#region src/sort-style-rules.ts
+const hasAtRule = (conditions) => conditions.some((details) => details.type === "at-rule" || details.type === "mixed" || details.type === "multi-block");
+const styleOrder = [
+	":link",
+	":visited",
+	":focus-within",
+	":focus",
+	":focus-visible",
+	":hover",
+	":active"
+];
+const pseudoSelectorScore = (selector) => {
+	return styleOrder.findIndex((pseudoClass) => selector.includes(pseudoClass)) + 1;
+};
+const compareSelectors = (a, b) => {
+	const aConds = a.conditions;
+	const bConds = b.conditions;
+	if (aConds.length === bConds.length) {
+		const selector1 = aConds[0].value;
+		const selector2 = bConds[0].value;
+		return pseudoSelectorScore(selector1) - pseudoSelectorScore(selector2);
+	}
+	return aConds.length - bConds.length;
+};
+/**
+* Flatten mixed conditions to Array<AtRuleCondition | SelectorCondition>
+*/
+const flatten$1 = (conds) => conds.flatMap((cond) => {
+	if (cond.type === "mixed") return cond.value;
+	if (cond.type === "multi-block") return cond.value.flatMap((block) => block.value);
+	return cond;
+});
+/**
+* Compare 2 Array<AtRuleCondition | SelectorCondition>
+* - sort by condition length (shorter first)
+* - sort at-rules by predefined order (sort-mq postcss plugin order)
+* - sort selectors by predefined pseudo selector order
+* - return 0 if equal
+*
+* do this for item in the array against the same index in the other array
+* -> exit early if not equal
+* -> if all comparisons result in a score of 0, return 0
+*/
+const compareAtRuleOrMixed = (a, b) => {
+	const aConds = flatten$1(a.conditions);
+	const bConds = flatten$1(b.conditions);
+	let aCond, bCond;
+	const max = Math.max(aConds.length, bConds.length);
+	for (let i = 0; i < max; i++) {
+		aCond = aConds[i];
+		bCond = bConds[i];
+		if (!aCond) return -1;
+		if (!bCond) return 1;
+		if (aCond.type === "at-rule" && bCond.type.includes("nesting")) return 1;
+		if (aCond.type.includes("nesting") && bCond.type === "at-rule") return -1;
+		if (aCond.type === "at-rule" && bCond.type === "at-rule") {
+			const atRule1 = aCond.params ?? aCond.raw;
+			const atRule2 = bCond.params ?? bCond.raw;
+			if (!atRule1) return -1;
+			if (!atRule2) return 1;
+			const score = sortAtRules(atRule1, atRule2);
+			if (score !== 0) return score;
+			continue;
+		}
+		if (aCond.type.includes("nesting") && bCond.type.includes("nesting")) {
+			const nextACond = aConds[i + 1];
+			const nextBCond = bConds[i + 1];
+			if (Boolean(nextACond) === Boolean(nextBCond)) {
+				const score = pseudoSelectorScore(aCond.value) - pseudoSelectorScore(bCond.value);
+				if (score !== 0) return score;
+			}
+		}
+	}
+	return 0;
+};
+const sortByPropertyPriority = (a, b) => {
+	if (a.entry.prop === b.entry.prop) return 0;
+	return (0, _bamboocss_shared.getPropertyPriority)(a.entry.prop) - (0, _bamboocss_shared.getPropertyPriority)(b.entry.prop);
+};
+/**
+* Sort style rules by conditions
+* - with no conditions first
+* - with selectors only next
+* - with at-rules last
+*
+* for each of them:
+* - sort by condition length (shorter first, the more you nest the more specific it is)
+* - sort selectors by predefined pseudo selector order
+* - sort at-rules by predefined order (sort-mq postcss plugin order)
+* - sort by property priority (longhands first)
+*/
+const sortStyleRules = (styleRules) => {
+	const declarations = [];
+	const withSelectorsOnly = [];
+	const withAtRules = [];
+	for (const styleRule of styleRules) if (!styleRule.conditions?.length) declarations.push(styleRule);
+	else if (!hasAtRule(styleRule.conditions)) withSelectorsOnly.push(styleRule);
+	else withAtRules.push(styleRule);
+	withSelectorsOnly.sort((a, b) => {
+		const selectorDiff = compareSelectors(a, b);
+		if (selectorDiff !== 0) return selectorDiff;
+		return sortByPropertyPriority(a, b);
+	});
+	withAtRules.sort((a, b) => {
+		const conditionDiff = compareAtRuleOrMixed(a, b);
+		if (conditionDiff !== 0) return conditionDiff;
+		return sortByPropertyPriority(a, b);
+	});
+	const sorted = declarations.sort(sortByPropertyPriority);
+	sorted.push(...withSelectorsOnly, ...withAtRules);
+	return sorted;
+};
+//#endregion
+//#region src/conditions.ts
+/**
+* Checks if a condition is an at-rule type
+*/
+const isAtRule = (cond) => cond.type === "at-rule";
+/**
+* Matches pseudo-element selectors (::before, ::after, ::placeholder, etc.)
+* Pseudo-elements must appear at the end of CSS selector chains per the CSS spec.
+*/
+const pseudoElementRegex$1 = /::[\w-]/;
+const isPseudoElement = (cond) => typeof cond.raw === "string" && pseudoElementRegex$1.test(cond.raw);
+/**
+* Flattens a condition, extracting parts from mixed conditions.
+* Returns an array of { condition, originalIndex } to track source order.
+*/
+const flattenCondition = (cond, originalIndex) => {
+	if (cond.type === "mixed") return cond.value.map((part) => ({
+		cond: part,
+		originalIndex
+	}));
+	return [{
+		cond,
+		originalIndex
+	}];
+};
+const underscoreRegex = /^_/;
+const selectorRegex = /&|@/;
+var Conditions = class {
+	options;
+	values;
+	breakpoints;
+	constructor(options) {
+		this.options = options;
+		const { breakpoints: breakpointValues = {}, conditions = {} } = options;
+		const breakpoints = new Breakpoints(breakpointValues);
+		this.breakpoints = breakpoints;
+		const entries = Object.entries(conditions).map(([key, value]) => [`_${key}`, parseCondition(value)]);
+		const containers = this.setupContainers();
+		const themes = this.setupThemes();
+		this.values = {
+			...Object.fromEntries(entries),
+			...breakpoints.conditions,
+			...containers,
+			...themes
+		};
+	}
+	setupContainers = () => {
+		const { containerNames = [], containerSizes = {} } = this.options;
+		const containers = {};
+		containerNames.unshift("");
+		containerNames.forEach((name) => {
+			Object.entries(containerSizes).forEach(([size, value]) => {
+				const _value = (0, _bamboocss_shared.toRem)(value) ?? value;
+				containers[`@${name}/${size}`] = {
+					type: "at-rule",
+					name: "container",
+					value: _value,
+					raw: `@container ${name} (min-width: ${_value})`,
+					params: `${name} ${value}`
+				};
+			});
+		});
+		return containers;
+	};
+	setupThemes = () => {
+		const { themes = {} } = this.options;
+		const themeVariants = {};
+		Object.entries(themes).forEach(([theme, _themeVariant]) => {
+			const condName = this.getThemeName(theme);
+			const cond = parseCondition(this.getThemeSelector(theme) + " &");
+			if (!cond) return;
+			themeVariants[condName] = cond;
+		});
+		return themeVariants;
+	};
+	getThemeSelector = (name) => {
+		return `[data-bamboo-theme=${name}]`;
+	};
+	getThemeName = (theme) => {
+		return "_theme" + (0, _bamboocss_shared.capitalize)(theme);
+	};
+	finalize = (paths) => {
+		return paths.map((path) => {
+			if (this.has(path)) return path.replace(underscoreRegex, "");
+			if (selectorRegex.test(path)) return `[${(0, _bamboocss_shared.withoutSpace)(path.trim())}]`;
+			return path;
+		});
+	};
+	shift = (paths) => {
+		return paths.map((path) => path.trim()).sort((a, b) => {
+			const aIsCondition = this.isCondition(a);
+			const bIsCondition = this.isCondition(b);
+			if (aIsCondition && !bIsCondition) return 1;
+			if (!aIsCondition && bIsCondition) return -1;
+			if (!aIsCondition && !bIsCondition) return -1;
+			return 0;
+		});
+	};
+	segment = (paths) => {
+		const condition = [];
+		const selector = [];
+		for (const path of paths) if (this.isCondition(path)) condition.push(path);
+		else selector.push(path);
+		return {
+			condition,
+			selector
+		};
+	};
+	has = (key) => {
+		return Object.prototype.hasOwnProperty.call(this.values, key);
+	};
+	isCondition = (key) => {
+		return this.has(key) || !!this.getRaw(key) || (0, _bamboocss_shared.isBaseCondition)(key);
+	};
+	isEmpty = () => {
+		return Object.keys(this.values).length === 0;
+	};
+	get = (key) => {
+		return this.values[key]?.raw;
+	};
+	getRaw = (condNameOrQuery) => {
+		if (typeof condNameOrQuery === "string" && this.values[condNameOrQuery]) return this.values[condNameOrQuery];
+		try {
+			return parseCondition(condNameOrQuery);
+		} catch (error) {
+			const query = typeof condNameOrQuery === "string" ? condNameOrQuery : JSON.stringify(condNameOrQuery);
+			const message = error instanceof Error ? error.message : String(error);
+			_bamboocss_logger.logger.warn("core:condition", `Failed to parse condition "${query}": ${message}`);
+		}
+	};
+	sort = (conditions) => {
+		const flattened = conditions.map(this.getRaw).filter(Boolean).flatMap((cond, index) => flattenCondition(cond, index));
+		flattened.sort((a, b) => {
+			const aIsAtRule = isAtRule(a.cond);
+			const bIsAtRule = isAtRule(b.cond);
+			if (aIsAtRule && !bIsAtRule) return -1;
+			if (!aIsAtRule && bIsAtRule) return 1;
+			const aIsPseudo = isPseudoElement(a.cond);
+			if (aIsPseudo !== isPseudoElement(b.cond)) return aIsPseudo ? 1 : -1;
+			return a.originalIndex - b.originalIndex;
+		});
+		return flattened.map((item) => item.cond);
+	};
+	normalize = (condition) => {
+		return (0, _bamboocss_shared.isObject)(condition) ? condition : this.getRaw(condition);
+	};
+	keys = () => {
+		return Object.keys(this.values);
+	};
+	saveOne = (key, value) => {
+		const parsed = parseCondition(value);
+		if (!parsed) return;
+		this.values[`_${key}`] = parsed;
+	};
+	remove(key) {
+		delete this.values[`_${key}`];
+	}
+	getSortedKeys = () => {
+		return Object.keys(this.values).sort((a, b) => {
+			const aCondition = this.values[a];
+			const bCondition = this.values[b];
+			return compareAtRuleOrMixed({
+				entry: {},
+				conditions: [aCondition]
+			}, {
+				entry: {},
+				conditions: [bCondition]
+			});
+		});
+	};
+};
+//#endregion
+//#region src/file.ts
+var FileEngine = class {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	get forceConsistentTypeExtension() {
+		return this.context.config.forceConsistentTypeExtension || false;
+	}
+	get outExtension() {
+		return this.context.config.outExtension;
+	}
+	ext(file) {
+		return `${file}.${this.outExtension}`;
+	}
+	extDts(file) {
+		return `${file}.${this.outExtension === "mjs" && this.forceConsistentTypeExtension ? "d.mts" : "d.ts"}`;
+	}
+	__extDts(file) {
+		return this.forceConsistentTypeExtension ? this.extDts(file) : file;
+	}
+	import(mod, file) {
+		return `import { ${mod} } from '${this.ext(file)}';`;
+	}
+	importType(mod, file) {
+		return `import type { ${mod} } from '${this.__extDts(file)}';`;
+	}
+	exportType(mod, file) {
+		return `export type { ${mod} } from '${this.__extDts(file)}';`;
+	}
+	exportStar(file) {
+		return `export * from '${this.ext(file)}';`;
+	}
+	exportTypeStar(file) {
+		return `export * from '${this.__extDts(file)}';`;
+	}
+	isTypeFile(file) {
+		return file.endsWith(".d.ts") || file.endsWith(".d.mts");
+	}
+	jsDocComment(comment, options) {
+		const { deprecated, default: defaultValue } = options ?? {};
+		if (!comment && !deprecated && !defaultValue) return "";
+		const comments = ["/**"];
+		if (comment) comments.push(` * ${comment}`, "\n");
+		if (deprecated) {
+			const suffix = (0, _bamboocss_shared.isString)(deprecated) ? ` ${deprecated}` : "";
+			comments.push(` * @deprecated${suffix}`);
+		}
+		if (defaultValue) comments.push(` * @default ${defaultValue}`);
+		comments.push(" */");
+		return comments.filter((c) => c.trim().length).join("\n");
+	}
+	/**
+	* convert import type { CompositionStyleObject } from './system-types'
+	* to import type { CompositionStyleObject } from './system-types.d.ts'
+	*/
+	rewriteTypeImport(code) {
+		return code.replace(/import\s+type\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/g, this.importType("$1", "$2"));
+	}
+};
+//#endregion
+//#region src/unitless.ts
+const keys = {
+	animationIterationCount: true,
+	aspectRatio: true,
+	borderImageOutset: true,
+	borderImageSlice: true,
+	borderImageWidth: true,
+	boxFlex: true,
+	boxFlexGroup: true,
+	boxOrdinalGroup: true,
+	columnCount: true,
+	columns: true,
+	flex: true,
+	flexGrow: true,
+	flexPositive: true,
+	flexShrink: true,
+	flexNegative: true,
+	flexOrder: true,
+	gridRow: true,
+	gridRowEnd: true,
+	gridRowSpan: true,
+	gridRowStart: true,
+	gridColumn: true,
+	gridColumnEnd: true,
+	gridColumnSpan: true,
+	gridColumnStart: true,
+	msGridRow: true,
+	msGridRowSpan: true,
+	msGridColumn: true,
+	msGridColumnSpan: true,
+	fontWeight: true,
+	lineClamp: true,
+	lineHeight: true,
+	opacity: true,
+	order: true,
+	orphans: true,
+	scale: true,
+	tabSize: true,
+	widows: true,
+	zIndex: true,
+	zoom: true,
+	WebkitLineClamp: true,
+	fillOpacity: true,
+	floodOpacity: true,
+	stopOpacity: true,
+	strokeDasharray: true,
+	strokeDashoffset: true,
+	strokeMiterlimit: true,
+	strokeOpacity: true,
+	strokeWidth: true
+};
+const unitlessProperties = /* @__PURE__ */ new Set();
+Object.keys(keys).forEach((key) => {
+	unitlessProperties.add(key);
+	unitlessProperties.add((0, _bamboocss_shared.hypenateProperty)(key));
+});
+//#endregion
+//#region src/stringify.ts
+const toString = Object.prototype.toString;
+/** Returns a string of CSS from an object of CSS. */
+function stringify(value) {
+	/** Set used to manage the opened and closed state of rules. */
+	const used = /* @__PURE__ */ new WeakSet();
+	const write = (cssText, selectors, conditions, name, data, isAtRuleLike, isVariableLike) => {
+		if (data === false) return "";
+		for (let i = 0; i < conditions.length; ++i) if (!used.has(conditions[i])) {
+			used.add(conditions[i]);
+			cssText += `${conditions[i]} {`;
+		}
+		if (selectors.length && !used.has(selectors)) {
+			used.add(selectors);
+			cssText += `${selectors.map((s) => s.replace("& ", ""))} {`;
+		}
+		let value = data;
+		if (typeof value === "number") {
+			if (!(value === 0 || unitlessProperties.has(name) || isVariableLike)) value = `${value}px`;
+		}
+		if (isAtRuleLike) name = `${name} `;
+		else if (isVariableLike) name = `${name}: `;
+		else name = `${(0, _bamboocss_shared.hypenateProperty)(name)}: `;
+		cssText += `${name + String(value)};\n`;
+		return cssText;
+	};
+	const parse = (style, selectors, conditions) => {
+		let cssText = "";
+		for (const name in style) {
+			const isAtRuleLike = name[0] === "@";
+			const isVariableLike = !isAtRuleLike && name.startsWith("--");
+			const rules = isAtRuleLike && Array.isArray(style[name]) ? style[name] : [style[name]];
+			for (const data of rules) {
+				if (!(typeof data === "object" && data && data.toString === toString)) {
+					cssText = write(cssText, selectors, conditions, name, data, isAtRuleLike, isVariableLike);
+					continue;
+				}
+				if (used.has(selectors)) {
+					used.delete(selectors);
+					cssText += "}";
+				}
+				let usedName = Object(name);
+				let nextSelectors;
+				if (isAtRuleLike) {
+					if (selectors.length && name.includes("@scope") && name.includes("&")) {
+						const resolvedSelectors = getResolvedSelectors(selectors, parseSelectors(name));
+						usedName = Object(resolvedSelectors[0]);
+					}
+					nextSelectors = selectors;
+					cssText += parse(data, nextSelectors, conditions.concat(usedName));
+				} else {
+					const nestedSelectors = parseSelectors(name);
+					nextSelectors = selectors.length ? getResolvedSelectors(selectors, nestedSelectors) : nestedSelectors;
+					cssText += parse(data, nextSelectors, conditions);
+				}
+				if (used.has(usedName)) {
+					used.delete(usedName);
+					cssText += "}\n";
+				}
+				if (used.has(nextSelectors)) {
+					used.delete(nextSelectors);
+					cssText += "}\n";
+				}
+			}
+		}
+		return cssText;
+	};
+	return parse(value, [], []);
+}
+/**
+* Returns a list of separated selectors from a selector string.
+* @example
+* parseSelectors('a, button') // ['a', 'button']
+* parseSelectors('.switch:is(:checked, [data-checked]).dark, .dark .switch:is(:checked, [data-checked])') // ['.switch:is(:checked, [data-checked]).dark', '.dark .switch:is(:checked, [data-checked])']
+* parseSelectors('&:is(:disabled, [disabled], [data-disabled]), .another') // [':is(:disabled, [disabled], [data-disabled])', '.another']
+*/
+function parseSelectors(selector) {
+	const result = [];
+	let parenCount = 0;
+	let currentSelector = "";
+	let inEscape = false;
+	for (let i = 0; i < selector.length; i++) {
+		const char = selector[i];
+		if (char === "\\" && !inEscape) {
+			inEscape = true;
+			currentSelector += char;
+			continue;
+		}
+		if (inEscape) {
+			inEscape = false;
+			currentSelector += char;
+			continue;
+		}
+		if (char === "(") parenCount++;
+		else if (char === ")") parenCount--;
+		if (char === "," && parenCount === 0) {
+			result.push(currentSelector.trim());
+			currentSelector = "";
+		} else currentSelector += char;
+	}
+	if (currentSelector) result.push(currentSelector.trim());
+	return result;
+}
+const parentSelectorRegex = /&/g;
+const descendantSelectorRegex = /[ +>|~]/g;
+const surroundedRegex = /&.*&/g;
+/**
+* Returns selectors resolved from parent selectors and nested selectors.
+* @example
+* getResolvedSelectors(['a', 'button'], ['&:hover', '&:focus']) // ['a:hover', 'a:focus', 'button:hover', 'button:focus']
+* getResolvedSelectors(['.switch:is(:checked, [data-checked]).dark, .dark .switch:is(:checked, [data-checked])'], ['&:hover', '&:focus']) // ['.switch:is(:checked, [data-checked]).dark:hover', '.switch:is(:checked, [data-checked]).dark:focus', '.dark .switch:is(:checked, [data-checked]):hover', '.dark .switch:is(:checked, [data-checked]):focus']
+*
+*/
+const getResolvedSelectors = (parentSelectors, nestedSelectors) => {
+	const resolved = [];
+	parentSelectors.forEach((parentSelector) => {
+		resolved.push(...nestedSelectors.map((selector) => {
+			if (!selector.includes("&")) return parentSelector + " " + selector;
+			return selector.replace(parentSelectorRegex, descendantSelectorRegex.test(parentSelector) && surroundedRegex.test(selector) ? `:is(${parentSelector})` : parentSelector);
+		}));
+	});
+	return resolved;
+};
+//#endregion
+//#region src/global-fontface.ts
+var GlobalFontface = class {
+	options;
+	names;
+	constructor(options) {
+		this.options = options;
+		const { globalFontface = {} } = options;
+		this.names = Object.keys(globalFontface);
+	}
+	isEmpty() {
+		return this.names.length === 0;
+	}
+	toString() {
+		const { globalFontface = {} } = this.options;
+		return stringifyGlobalFontface(globalFontface);
+	}
+};
+const stringifyGlobalFontface = (globalFontface) => {
+	if (!globalFontface) return "";
+	const lines = [];
+	Object.entries(globalFontface).forEach(([key, value]) => {
+		(Array.isArray(value) ? value : [value]).forEach((v) => {
+			lines.push(stringifyFontface(key, v));
+		});
+	});
+	return lines.join("\n\n");
+};
+function stringifyFontface(fontFamily, config) {
+	return `@font-face {
+  font-family: ${fontFamily};
+  ${stringify(config)}
+}`;
+}
+//#endregion
+//#region src/global-position-try.ts
+var GlobalPositionTry = class {
+	opts;
+	names;
+	constructor(opts) {
+		this.opts = opts;
+		this.names = Object.keys(opts.globalPositionTry ?? {});
+	}
+	isEmpty() {
+		return this.names.length === 0;
+	}
+	toString() {
+		return stringifyGlobalPositionTry(this.opts.globalPositionTry ?? {});
+	}
+};
+const stringifyGlobalPositionTry = (dfns) => {
+	if (!dfns) return "";
+	const lines = [];
+	Object.entries(dfns).forEach(([key, value]) => {
+		(Array.isArray(value) ? value : [value]).forEach((v) => {
+			lines.push(stringifyPositionTry(key, v));
+		});
+	});
+	return lines.join("\n\n");
+};
+const ident = (key) => key.startsWith("--") ? key : `--${key}`;
+function stringifyPositionTry(key, config) {
+	return `@position-try ${ident(key)} {
+  ${stringify(config)}
+}`;
+}
+//#endregion
+//#region src/global-vars.ts
+var GlobalVars = class {
+	options;
+	keys;
+	vars;
+	names;
+	constructor(options) {
+		this.options = options;
+		const { globalVars = {} } = options;
+		this.keys = new Set(Object.keys(globalVars));
+		const arr = Array.from(this.keys);
+		this.names = arr.map((v) => `${v.slice(2)}`);
+		this.vars = arr.map((v) => `var(${v})`);
+	}
+	isEmpty() {
+		return this.keys.size === 0;
+	}
+	toString() {
+		const { globalVars = {}, cssVarRoot } = this.options;
+		return stringifyGlobalVars(globalVars, cssVarRoot);
+	}
+};
+const stringifyGlobalVars = (globalVars, cssVarRoot) => {
+	if (!globalVars) return "";
+	const decls = [];
+	const vars = { [cssVarRoot]: {} };
+	const base = vars[cssVarRoot];
+	Object.entries(globalVars).forEach(([key, value]) => {
+		if (typeof value === "string") {
+			base[key] = value;
+			return;
+		}
+		const css = stringifyProperty(key, value);
+		decls.push(css);
+	});
+	const lines = [];
+	lines.push(stringify(vars));
+	lines.push(...decls);
+	return lines.join("\n\n");
+};
+function stringifyProperty(key, config) {
+	return outdent.outdent`@property ${key} {
+    syntax: '${config.syntax}';
+    inherits: ${config.inherits};
+    initial-value: ${config.initialValue ?? "initial"};
+  }`;
+}
+//#endregion
+//#region src/rule-processor.ts
+var RuleProcessor = class {
+	context;
+	encoder;
+	decoder;
+	sheet;
+	constructor(context) {
+		this.context = context;
+		this.encoder = context.encoder;
+		this.decoder = context.decoder;
+		this.sheet = context.createSheet();
+	}
+	getParamsOrThrow() {
+		if (!Boolean(this.encoder && this.decoder && this.sheet)) throw new _bamboocss_shared.BambooError("MISSING_PARAMS", "RuleProcessor is missing params, please call `clone` first");
+		return {
+			encoder: this.encoder,
+			decoder: this.decoder,
+			sheet: this.sheet
+		};
+	}
+	clone() {
+		this.encoder = this.context.encoder.clone();
+		this.decoder = this.context.decoder.clone();
+		this.sheet = this.context.createSheet();
+		return this;
+	}
+	toCss(options) {
+		const { decoder, sheet } = this.getParamsOrThrow();
+		sheet.processDecoder(decoder);
+		return sheet.toCss(options);
+	}
+	css(styles) {
+		const { encoder, decoder } = this.getParamsOrThrow();
+		encoder.processAtomic(styles);
+		decoder.collect(encoder);
+		return {
+			styles,
+			getClassNames: () => Array.from(decoder.classNames.keys()),
+			toCss: this.toCss.bind(this)
+		};
+	}
+	grouped(styles) {
+		const { encoder, decoder } = this.getParamsOrThrow();
+		encoder.processGrouped(styles);
+		decoder.collect(encoder);
+		const groupedResults = Array.from(decoder.grouped);
+		return {
+			styles,
+			getClassNames: () => groupedResults.map((r) => r.className),
+			toCss: this.toCss.bind(this)
+		};
+	}
+	cva(recipeConfig) {
+		const { encoder, decoder } = this.getParamsOrThrow();
+		encoder.processAtomicRecipe(recipeConfig);
+		decoder.collect(encoder);
+		return {
+			config: recipeConfig,
+			getClassNames: () => Array.from(decoder.classNames.keys()),
+			toCss: this.toCss.bind(this)
+		};
+	}
+	sva(recipeConfig) {
+		const { encoder, decoder } = this;
+		this.getParamsOrThrow();
+		encoder.processAtomicSlotRecipe(recipeConfig);
+		decoder.collect(encoder);
+		return {
+			config: recipeConfig,
+			getClassNames: () => Array.from(decoder.classNames.keys()),
+			toCss: this.toCss.bind(this)
+		};
+	}
+	recipe(name, variants = {}) {
+		const { encoder, decoder } = this;
+		this.getParamsOrThrow();
+		encoder.processRecipe(name, variants);
+		decoder.collect(encoder);
+		return {
+			variants,
+			getClassNames: () => Array.from(decoder.classNames.keys()),
+			toCss: this.toCss.bind(this)
+		};
+	}
+};
+//#endregion
+//#region src/hooks-api.ts
+var HooksApi = class {
+	ctx;
+	processor;
+	constructor(ctx) {
+		this.ctx = ctx;
+		this.processor = new RuleProcessor(ctx);
+	}
+	get config() {
+		return this.ctx.conf.config;
+	}
+	get configPath() {
+		return this.ctx.conf.path;
+	}
+	get configDependencies() {
+		return this.ctx.conf.dependencies;
+	}
+	get classNames() {
+		return this.ctx.utility.classNames;
+	}
+	get generatedClassNames() {
+		return this.ctx.decoder.classNames;
+	}
+};
+//#endregion
+//#region src/file-matcher.ts
+const cssEntrypointFns = new Set([
+	"css",
+	"cva",
+	"sva"
+]);
+var FileMatcher = class {
+	context;
+	imports;
+	namespaces = /* @__PURE__ */ new Map();
+	importMap;
+	cssAliases = /* @__PURE__ */ new Set();
+	cvaAliases = /* @__PURE__ */ new Set();
+	svaAliases = /* @__PURE__ */ new Set();
+	tokenAliases = /* @__PURE__ */ new Set();
+	jsxFactoryAliases = /* @__PURE__ */ new Set();
+	recipeAliases = /* @__PURE__ */ new Set();
+	patternAliases = /* @__PURE__ */ new Set();
+	propertiesMap = /* @__PURE__ */ new Map();
+	functions = /* @__PURE__ */ new Map();
+	components = /* @__PURE__ */ new Map();
+	constructor(context, opts) {
+		this.context = context;
+		const { value, importMap } = opts;
+		this.importMap = importMap;
+		this.imports = value;
+		this.imports.forEach((result) => {
+			if (result.kind === "namespace") this.namespaces.set(result.name, result);
+		});
+		this.assignAliases();
+		this.assignProperties();
+	}
+	assignAliases() {
+		const isCssEntrypoint = this.createMatch(this.importMap.css, Array.from(cssEntrypointFns));
+		const isTokensEntrypoint = this.createMatch(this.importMap.tokens, ["token"]);
+		this.imports.forEach((result) => {
+			if (this.isValidRecipe(result.alias)) this.recipeAliases.add(result.alias);
+			if (this.isValidPattern(result.alias)) this.patternAliases.add(result.alias);
+			if (isCssEntrypoint(result.alias)) {
+				if (result.name === "css") this.cssAliases.add(result.alias);
+				if (result.name === "cva") this.cvaAliases.add(result.alias);
+				if (result.name === "sva") this.svaAliases.add(result.alias);
+			}
+			if (isTokensEntrypoint(result.alias)) {
+				if (result.name === "token") this.tokenAliases.add(result.alias);
+			}
+			if (result.name === this.context.jsx.factoryName) this.jsxFactoryAliases.add(result.alias);
+			if (result.kind === "namespace") {
+				if (this.importMap.pattern.some((m) => result.mod.includes(m))) this.context.patterns.keys.forEach((pattern) => {
+					this.patternAliases.add(pattern);
+				});
+				if (this.importMap.recipe.some((m) => result.mod.includes(m))) this.context.recipes.keys.forEach((recipe) => {
+					this.recipeAliases.add(recipe);
+				});
+			}
+		});
+	}
+	assignProperties() {
+		this.context.jsx.nodes.forEach((node) => {
+			this.getAliases(node.jsxName).forEach((alias) => {
+				node.props?.forEach((prop) => this.propertiesMap.set(prop, true));
+				this.functions.set(node.baseName, this.propertiesMap);
+				this.functions.set(alias, this.propertiesMap);
+				this.components.set(alias, this.propertiesMap);
+			});
+		});
+	}
+	isEmpty = () => {
+		return this.imports.length === 0;
+	};
+	toString = () => {
+		return this.imports.map((item) => item.alias).join(", ");
+	};
+	find = (id) => {
+		return this.imports.find((o) => o.alias === id);
+	};
+	createMatch = (mods, keys) => {
+		const matchingImports = this.imports.filter((o) => {
+			const isFromMod = mods.some((m) => o.mod.includes(m) || o.importMapValue?.includes(m));
+			const isOneOfKeys = o.kind === "namespace" ? true : keys.includes(o.name);
+			return isFromMod && isOneOfKeys;
+		});
+		return (0, _bamboocss_shared.memo)((id) => {
+			return !!matchingImports.find((mod) => {
+				if (mod.kind === "namespace") return keys.includes(id.replace(`${mod.alias}.`, ""));
+				return mod.alias === id || mod.name === id;
+			});
+		});
+	};
+	match = (id) => {
+		return !!this.find(id);
+	};
+	getName = (id) => {
+		return this.find(id)?.name || id;
+	};
+	getAliases = (id) => {
+		return this.imports.filter((o) => o.name === id).map((o) => o.alias || id);
+	};
+	_patternsMatcher;
+	isValidPattern = (id) => {
+		this._patternsMatcher ||= this.createMatch(this.importMap.pattern, this.context.patterns.keys);
+		return this._patternsMatcher(id);
+	};
+	_recipesMatcher;
+	isValidRecipe = (id) => {
+		this._recipesMatcher ||= this.createMatch(this.importMap.recipe, this.context.recipes.keys);
+		return this._recipesMatcher(id);
+	};
+	isRawFn = (fnName) => {
+		const name = fnName.split(".raw")[0] ?? "";
+		return name === "css" || this.cssAliases.has(name) || this.cvaAliases.has(name) || this.svaAliases.has(name) || this.isValidPattern(name) || this.isValidRecipe(name);
+	};
+	isNamespaced = (fnName) => {
+		return this.namespaces.has(fnName.split(".")[0]);
+	};
+	normalizeFnName = (fnName) => {
+		let name = fnName;
+		if (this.isNamespaced(fnName)) name = name.split(".").slice(1).join(".");
+		if (this.isRawFn(name)) return name.replace(".raw", "");
+		return name;
+	};
+	isAliasFnName = (0, _bamboocss_shared.memo)((fnName) => {
+		return this.cvaAliases.has(fnName) || this.cssAliases.has(fnName) || this.svaAliases.has(fnName) || this.tokenAliases.has(fnName) || this.isJsxFactory(fnName);
+	});
+	isTokenAlias = (fnName) => {
+		return this.tokenAliases.has(fnName);
+	};
+	matchFn = (0, _bamboocss_shared.memo)((fnName) => {
+		if (this.recipeAliases.has(fnName) || this.patternAliases.has(fnName)) return true;
+		if (this.isAliasFnName(fnName) || this.isRawFn(fnName)) return true;
+		if (this.functions.has(fnName)) return true;
+		const [namespace, identifier] = fnName.split(".");
+		const ns = this.namespaces.get(namespace);
+		if (ns) {
+			if (this.importMap.css.some((m) => ns.mod.includes(m)) && cssEntrypointFns.has(identifier)) return true;
+			if (this.importMap.tokens.some((m) => ns.mod.includes(m)) && identifier === "token") return true;
+			if (this.importMap.recipe.some((m) => ns.mod.includes(m)) && this.recipeAliases.has(identifier)) return true;
+			if (this.importMap.pattern.some((m) => ns.mod.includes(m)) && this.patternAliases.has(identifier)) return true;
+			return this.functions.has(identifier);
+		}
+		return false;
+	});
+	isJsxFactory = (0, _bamboocss_shared.memo)((tagName) => {
+		const { jsx } = this.context;
+		if (!jsx.isEnabled) return false;
+		for (const alias of this.jsxFactoryAliases) if (tagName.startsWith(alias)) return true;
+		const [namespace, identifier] = tagName.split(".");
+		const ns = this.namespaces.get(namespace);
+		if (ns && this.importMap.jsx.some((m) => ns.mod.includes(m)) && identifier === this.context.jsx.factoryName) return true;
+	});
+	isBambooComponent = (0, _bamboocss_shared.memo)((tagName) => {
+		if (!tagName) return false;
+		const { jsx } = this.context;
+		return this.components.has(tagName) || this.isJsxFactory(tagName) || jsx.isJsxTagRecipe(tagName) || jsx.isJsxTagPattern(tagName);
+	});
+	matchTag = (0, _bamboocss_shared.memo)((tagName) => {
+		return this.isBambooComponent(tagName) || isUpperCase(tagName);
+	});
+	matchTagProp = (0, _bamboocss_shared.memo)((tagName, propName) => {
+		const { jsx, isValidProperty } = this.context;
+		switch (jsx.styleProps) {
+			case "all": return Boolean(this.components.get(tagName)?.has(propName)) || isValidProperty(propName) || this.propertiesMap.has(propName) || jsx.isRecipeOrPatternProp(tagName, propName) || propName.endsWith("Css");
+			case "minimal": return propName === "css" || propName.endsWith("Css") || jsx.isRecipeOrPatternProp(tagName, propName);
+			case "none": return jsx.isRecipeOrPatternProp(tagName, propName);
+			default: return false;
+		}
+	});
+};
+const isUpperCase = (value) => value[0] === value[0]?.toUpperCase();
+//#endregion
+//#region src/import-map.ts
+var ImportMap = class {
+	context;
+	value;
+	matchers = {};
+	outdir;
+	constructor(context) {
+		this.context = context;
+		const { jsx } = this.context;
+		this.outdir = this.getOutdir();
+		const importMap = this.buildImportMap(context.config.importMap);
+		this.matchers.css = this.createMatcher(importMap.css, [
+			"css",
+			"cva",
+			"sva"
+		]);
+		this.matchers.tokens = this.createMatcher(importMap.tokens, ["token"]);
+		this.matchers.recipe = this.createMatcher(importMap.recipe);
+		this.matchers.pattern = this.createMatcher(importMap.pattern);
+		if (jsx.isEnabled) this.matchers.jsx = this.createMatcher(importMap.jsx, jsx.names);
+		this.value = importMap;
+	}
+	/**
+	* Normalize one/many import map inputs to a single import map output with absolute paths.
+	* @example
+	* ```ts
+	* importMap: '@acme/org'
+	* ```
+	*
+	* will be normalized to
+	* ```ts
+	* {
+	*   css: ['@acme/org/css'],
+	*   recipe: ['@acme/org/recipes'],
+	*   pattern: ['@acme/org/patterns'],
+	*   jsx: ['@acme/org/jsx'],
+	*   tokens: ['@acme/org/tokens'],
+	* }
+	* ```
+	*
+	* @exammple
+	* importMap: ['@acme/org', '@foo/org', '@bar/org']
+	* ```
+	*
+	* will be normalized to
+	* ```ts
+	* {
+	*   css: ['@acme/org/css', '@foo/org/css', '@bar/org/css'],
+	*   recipe: ['@acme/org/recipes', '@foo/org/recipes', '@bar/org/recipes'],
+	*   pattern: ['@acme/org/patterns', '@foo/org/patterns', '@bar/org/patterns'],
+	*   jsx: ['@acme/org/jsx', '@foo/org/jsx', '@bar/org/jsx'],
+	*   tokens: ['@acme/org/tokens', '@foo/org/tokens', '@bar/org/tokens'],
+	* }
+	* ```
+	*/
+	buildImportMap = (option) => {
+		const output = {
+			css: [],
+			recipe: [],
+			pattern: [],
+			jsx: [],
+			tokens: []
+		};
+		asArray(option).forEach((input) => {
+			const normalized = this.normalize(input);
+			output.css.push(...normalized.css);
+			output.recipe.push(...normalized.recipe);
+			output.pattern.push(...normalized.pattern);
+			output.tokens.push(...normalized.tokens);
+			if (normalized.jsx) output.jsx.push(...normalized.jsx);
+		});
+		return output;
+	};
+	fromString = (map) => {
+		return {
+			css: [[map, "css"].join("/")],
+			recipe: [[map, "recipes"].join("/")],
+			pattern: [[map, "patterns"].join("/")],
+			jsx: [[map, "jsx"].join("/")],
+			tokens: [[map, "tokens"].join("/")]
+		};
+	};
+	fromInput = (map) => {
+		const { css, recipes, patterns, jsx, tokens } = map ?? {};
+		return {
+			css: css ? asArray(css) : [[this.outdir, "css"].join("/")],
+			recipe: recipes ? asArray(recipes) : [[this.outdir, "recipes"].join("/")],
+			pattern: patterns ? asArray(patterns) : [[this.outdir, "patterns"].join("/")],
+			jsx: jsx ? asArray(jsx) : [[this.outdir, "jsx"].join("/")],
+			tokens: tokens ? asArray(tokens) : [[this.outdir, "tokens"].join("/")]
+		};
+	};
+	getOutdir = () => {
+		const { outdir } = this.context.config;
+		const split = outdir.split("/");
+		return split[split.length - 1];
+	};
+	normalize = (map) => {
+		if ((0, _bamboocss_shared.isString)(map)) return this.fromString(map);
+		return this.fromInput(map);
+	};
+	createMatcher = (mods, values) => {
+		const regex = values ? new RegExp(`^(${values.join("|")})$`) : /.*/;
+		const match = (value) => regex.test(value);
+		return {
+			mods,
+			regex,
+			match
+		};
+	};
+	match = (result, resolveTsPath) => {
+		if (!result) return false;
+		for (const { regex, mods } of Object.values(this.matchers)) {
+			if (result.kind !== "namespace" && !regex.test(result.name)) continue;
+			if (mods.some((m) => result.mod.includes(m))) return true;
+			const resolvedMod = resolveTsPath?.(result.mod);
+			for (const mod of mods) {
+				const absMod = [this.context.config.cwd, mod].join("/").replaceAll("\\", "/");
+				if (resolvedMod?.includes(absMod) || resolvedMod === mod) {
+					result.importMapValue = resolvedMod;
+					return true;
+				}
+			}
+		}
+		return false;
+	};
+	file = (results) => {
+		return new FileMatcher(this.context, {
+			importMap: this.value,
+			value: results
+		});
+	};
+};
+const asArray = (value) => Array.isArray(value) ? value : [value];
+//#endregion
+//#region src/jsx.ts
+var JsxEngine = class {
+	context;
+	nodes = [];
+	names = [];
+	recipeMatcher = {
+		string: /* @__PURE__ */ new Set(),
+		regex: []
+	};
+	recipePropertiesByJsxName = /* @__PURE__ */ new Map();
+	patternMatcher = {
+		string: /* @__PURE__ */ new Set(),
+		regex: []
+	};
+	patternPropertiesByJsxName = /* @__PURE__ */ new Map();
+	constructor(context) {
+		this.context = context;
+		this.nodes = [...context.patterns.details, ...context.recipes.details];
+		this.names = [this.factoryName, ...this.nodes.map((node) => node.jsxName)];
+		this.assignRecipeMatcher();
+		this.assignPatternMatcher();
+	}
+	assignRecipeMatcher() {
+		if (!this.isEnabled) return;
+		for (const recipe of this.context.recipes.details) {
+			this.recipePropertiesByJsxName.set(recipe.jsxName, new Set(recipe.props ?? []));
+			recipe.jsx.forEach((jsx) => {
+				if (typeof jsx === "string") this.recipeMatcher.string.add(jsx);
+				else this.recipeMatcher.regex.push(jsx);
+			});
+		}
+	}
+	assignPatternMatcher() {
+		if (!this.isEnabled) return;
+		for (const pattern of this.context.patterns.details) {
+			this.patternPropertiesByJsxName.set(pattern.jsxName, new Set(pattern.props ?? []));
+			pattern.jsx.forEach((jsx) => {
+				if (typeof jsx === "string") this.patternMatcher.string.add(jsx);
+				else this.patternMatcher.regex.push(jsx);
+			});
+		}
+	}
+	get jsxFactory() {
+		return this.context.config.jsxFactory ?? "styled";
+	}
+	get styleProps() {
+		return this.context.config.jsxStyleProps ?? "all";
+	}
+	get framework() {
+		return this.context.config.jsxFramework;
+	}
+	get isEnabled() {
+		return this.framework != null;
+	}
+	get factoryName() {
+		return this.jsxFactory;
+	}
+	get upperName() {
+		return (0, _bamboocss_shared.capitalize)(this.jsxFactory);
+	}
+	get typeName() {
+		return `HTML${(0, _bamboocss_shared.capitalize)(this.jsxFactory)}Props`;
+	}
+	get variantName() {
+		return `${(0, _bamboocss_shared.capitalize)(this.jsxFactory)}VariantProps`;
+	}
+	get componentName() {
+		return `${(0, _bamboocss_shared.capitalize)(this.jsxFactory)}Component`;
+	}
+	isJsxFactory = (name) => {
+		if (name === this.factoryName) return true;
+		const [_namespace, identifier] = name.split(".");
+		return identifier === this.factoryName;
+	};
+	isJsxTagRecipe = (0, _bamboocss_shared.memo)((tagName) => {
+		return this.recipeMatcher.string.has(tagName) || this.recipeMatcher.regex.some((regex) => regex.test(tagName));
+	});
+	isJsxTagPattern = (0, _bamboocss_shared.memo)((tagName) => {
+		return this.patternMatcher.string.has(tagName) || this.patternMatcher.regex.some((regex) => regex.test(tagName));
+	});
+	isRecipeOrPatternProp = (0, _bamboocss_shared.memo)((tagName, propName) => {
+		if (this.isJsxTagRecipe(tagName)) return this.context.recipes.filter(tagName).some((recipe) => this.recipePropertiesByJsxName.get(recipe.jsxName)?.has(propName));
+		if (this.isJsxTagPattern(tagName)) return this.context.patterns.filter(tagName).some((pattern) => this.patternPropertiesByJsxName.get(pattern.jsxName)?.has(propName));
+		return false;
+	});
+};
+//#endregion
+//#region src/layers.ts
+var Layers = class {
+	names;
+	root;
+	reset;
+	base;
+	tokens;
+	recipes;
+	recipes_base;
+	recipes_slots;
+	recipes_slots_base;
+	utilities;
+	compositions;
+	utilityRuleMap = /* @__PURE__ */ new Map();
+	constructor(names) {
+		this.names = names;
+		this.root = postcss.default.root();
+		this.reset = postcss.default.atRule({
+			name: "layer",
+			params: names.reset,
+			nodes: []
+		});
+		this.base = postcss.default.atRule({
+			name: "layer",
+			params: names.base,
+			nodes: []
+		});
+		this.tokens = postcss.default.atRule({
+			name: "layer",
+			params: names.tokens,
+			nodes: []
+		});
+		this.recipes = postcss.default.atRule({
+			name: "layer",
+			params: names.recipes,
+			nodes: []
+		});
+		this.recipes_base = postcss.default.atRule({
+			name: "layer",
+			params: "_base",
+			nodes: []
+		});
+		this.recipes_slots = postcss.default.atRule({
+			name: "layer",
+			params: names.recipes + ".slots",
+			nodes: []
+		});
+		this.recipes_slots_base = postcss.default.atRule({
+			name: "layer",
+			params: "_base",
+			nodes: []
+		});
+		this.utilities = postcss.default.atRule({
+			name: "layer",
+			params: names.utilities,
+			nodes: []
+		});
+		this.compositions = postcss.default.atRule({
+			name: "layer",
+			params: "compositions",
+			nodes: []
+		});
+	}
+	getLayerRoot(layer) {
+		const { reset, base, tokens, recipes, recipes_base, recipes_slots, recipes_slots_base, utilities, compositions } = this;
+		switch (layer) {
+			case "base": return base;
+			case "reset": return reset;
+			case "tokens": return tokens;
+			case "recipes": {
+				const recipeRoot = postcss.default.root();
+				if (recipes_base.nodes?.length) recipes.prepend(recipes_base);
+				if (recipes_slots_base.nodes?.length) recipes_slots.prepend(recipes_slots_base);
+				if (recipes.nodes?.length) recipeRoot.append(recipes);
+				if (recipes_slots.nodes?.length) recipeRoot.append(recipes_slots);
+				return recipeRoot;
+			}
+			case "utilities":
+				if (compositions.nodes?.length) utilities.prepend(compositions);
+				this.utilityRuleMap.forEach((rules) => {
+					if (rules.nodes?.length) utilities.append(rules);
+				});
+				return utilities;
+			default: throw new _bamboocss_shared.BambooError("INVALID_LAYER", `Unknown layer: ${layer}`);
+		}
+	}
+	insert() {
+		const { root } = this;
+		const reset = this.getLayerRoot("reset");
+		if (reset.nodes?.length) root.append(reset);
+		const base = this.getLayerRoot("base");
+		if (base.nodes?.length) root.append(base);
+		const tokens = this.getLayerRoot("tokens");
+		if (tokens.nodes?.length) root.append(tokens);
+		const recipes = this.getLayerRoot("recipes");
+		if (recipes.nodes?.length) root.append(recipes);
+		const utilities = this.getLayerRoot("utilities");
+		if (utilities.nodes?.length) root.append(utilities);
+		return root;
+	}
+	get layerNames() {
+		return Object.values(this.names);
+	}
+	get params() {
+		return `@layer ${this.layerNames.join(", ")};`;
+	}
+};
+//#endregion
+//#region src/path.ts
+var PathEngine = class {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	get cwd() {
+		return this.context.config.cwd;
+	}
+	get outdir() {
+		return this.context.config.outdir;
+	}
+	getFilePath(file) {
+		return [
+			this.cwd,
+			this.outdir,
+			file
+		].filter(Boolean);
+	}
+	get root() {
+		return this.getFilePath();
+	}
+	get css() {
+		return this.getFilePath("css");
+	}
+	get token() {
+		return this.getFilePath("tokens");
+	}
+	get types() {
+		return this.getFilePath("types");
+	}
+	get recipe() {
+		return this.getFilePath("recipes");
+	}
+	get pattern() {
+		return this.getFilePath("patterns");
+	}
+	get outCss() {
+		return this.getFilePath("styles.css");
+	}
+	get jsx() {
+		return this.getFilePath("jsx");
+	}
+	get themes() {
+		return this.getFilePath("themes");
+	}
+	get specs() {
+		return this.getFilePath("specs");
+	}
+};
+//#endregion
+//#region src/patterns.ts
+var Patterns = class {
+	options;
+	patterns;
+	details;
+	keys;
+	utility;
+	tokens;
+	deprecated = /* @__PURE__ */ new Set();
+	constructor(options) {
+		this.options = options;
+		this.patterns = options.config.patterns ?? {};
+		this.details = Object.entries(this.patterns).map(([name, pattern]) => this.createDetail(name, pattern));
+		this.keys = Object.keys(this.patterns);
+		this.utility = options.utility;
+		this.tokens = options.tokens;
+	}
+	createDetail(name, pattern) {
+		const names = this.getNames(name);
+		const jsx = (pattern.jsx ?? []).concat([names.jsxName]);
+		if (pattern.deprecated) this.deprecated.add(name);
+		return {
+			...names,
+			props: Object.keys(pattern?.properties ?? {}),
+			blocklistType: pattern?.blocklist ? `| '${pattern.blocklist.join("' | '")}'` : "",
+			config: pattern,
+			type: "pattern",
+			match: (0, _bamboocss_shared.createRegex)(jsx),
+			jsx
+		};
+	}
+	getConfig(name) {
+		return this.patterns[name];
+	}
+	transform(name, styles) {
+		const pattern = this.patterns[name];
+		const _styles = (0, _bamboocss_shared.getPatternStyles)(pattern, styles);
+		return pattern?.transform?.(_styles, this.options.helpers) ?? {};
+	}
+	getNames(name) {
+		const upperName = (0, _bamboocss_shared.capitalize)(name);
+		return {
+			upperName,
+			baseName: name,
+			dashName: (0, _bamboocss_shared.dashCase)(name),
+			styleFnName: `get${upperName}Style`,
+			jsxName: this.patterns[name]?.jsxName ?? upperName
+		};
+	}
+	find = (0, _bamboocss_shared.memo)((jsxName) => {
+		return this.details.find((node) => node.match.test(jsxName))?.baseName ?? (0, _bamboocss_shared.uncapitalize)(jsxName);
+	});
+	filter = (0, _bamboocss_shared.memo)((jsxName) => {
+		return this.details.filter((node) => node.match.test(jsxName));
+	});
+	isEmpty() {
+		return this.keys.length === 0;
+	}
+	isDeprecated(name) {
+		return this.deprecated.has(name);
+	}
+	saveOne(name, pattern) {
+		this.patterns[name] = pattern;
+		const detailIndex = this.details.findIndex((detail) => detail.baseName === name);
+		const updated = this.createDetail(name, pattern);
+		if (detailIndex > -1) this.details[detailIndex] = updated;
+		else this.details.push(updated);
+	}
+	remove(name) {
+		delete this.patterns[name];
+		const detailIndex = this.details.findIndex((detail) => detail.baseName === name);
+		if (detailIndex > -1) this.details.splice(detailIndex, 1);
+	}
+	filterDetails(filters) {
+		const patternDiffs = filters?.affecteds?.patterns;
+		return patternDiffs ? this.details.filter((pattern) => patternDiffs.includes(pattern.dashName)) : this.details;
+	}
+	getPropertyValues = (patternName, property) => {
+		const patternConfig = this.getConfig(patternName);
+		if (!patternConfig) return [];
+		const propType = patternConfig.properties?.[property];
+		if (!propType) return;
+		if (propType.type === "enum") return propType.value;
+		if (propType.type === "boolean") return ["true", "false"];
+		if (propType.type === "property") return this.utility.getPropertyKeys(propType.value || property);
+		if (propType.type === "token") {
+			const values = this.tokens.view.getCategoryValues(propType.value);
+			return Object.keys(values ?? {});
+		}
+	};
+	getPropertyType = (prop) => {
+		switch (prop.type) {
+			case "enum": return `ConditionalValue<${(0, _bamboocss_shared.unionType)(prop.value)}>`;
+			case "token": {
+				const tokenType = `Tokens["${prop.value}"]`;
+				if (prop.property) return `ConditionalValue<${tokenType} | Properties["${prop.property}"]>`;
+				return `ConditionalValue<${tokenType}>`;
+			}
+			case "property": return `SystemProperties["${prop.value}"]`;
+			case "string":
+			case "number":
+			case "boolean": return `ConditionalValue<${prop.type}>`;
+			default: return `ConditionalValue<${prop.type || "unknown"}>`;
+		}
+	};
+	static isValidNode = (node) => {
+		return (0, _bamboocss_shared.isObject)(node) && "type" in node && node.type === "recipe";
+	};
+};
+//#endregion
+//#region src/serialize.ts
+/**
+* Transform the style object (with conditions, shorthands, tokens) into a valid CSS (in JS) object
+*/
+function transformStyles(context, styleObj, key) {
+	const encoder = context.encoder.clone();
+	const decoder = context.decoder.clone();
+	const hashSet = /* @__PURE__ */ new Set();
+	encoder.hashStyleObject(hashSet, styleObj);
+	return decoder.getGroup(hashSet, key).result;
+}
+/**
+* Serialize the style object (with conditions, shorthands, tokens) into a valid CSS string
+*/
+function serializeStyles(context, groupedObject) {
+	const result = {};
+	for (const [scope, styles] of Object.entries(groupedObject)) {
+		result[scope] ||= {};
+		const styleObject = (0, _bamboocss_shared.walkObject)(styles, (value) => value, { getKey: (prop, value) => {
+			if ((0, _bamboocss_shared.isObject)(value) && !context.conditions.isCondition(prop) && !context.isValidProperty(prop)) return parseSelectors(prop).map((s) => "& " + s).join(", ");
+			return prop;
+		} });
+		(0, lodash_merge.default)(result[scope], transformStyles(context, styleObject, scope));
+	}
+	return result;
+}
+//#endregion
+//#region src/recipes.ts
+const sharedState = {
+	/**
+	* The map of recipe names to their resolved class names
+	*/
+	classNames: /* @__PURE__ */ new Map(),
+	/**
+	* The map of the property to their resolved styles
+	*/
+	styles: /* @__PURE__ */ new Map(),
+	/**
+	* The map of the recipes with their resolved styles
+	*/
+	nodes: /* @__PURE__ */ new Map(),
+	/**
+	* The map of recipe key to slot key + slot recipe
+	*/
+	slots: /* @__PURE__ */ new Map()
+};
+var Recipes = class Recipes {
+	recipes;
+	slotSeparator = "__";
+	keys = [];
+	deprecated = /* @__PURE__ */ new Set();
+	context;
+	get config() {
+		return this.recipes;
+	}
+	constructor(recipes = {}) {
+		this.recipes = recipes;
+		this.prune();
+	}
+	getPropKey = (recipe, variant, value) => {
+		return `${recipe} (${variant} = ${value})`;
+	};
+	get separator() {
+		return this.context.utility.separator ?? "_";
+	}
+	getClassName = (className, variant, value) => {
+		return `${className}--${variant}${this.separator}${value}`;
+	};
+	prune = () => {
+		const recipeNames = Object.keys(this.recipes);
+		Array.from(sharedState.nodes.keys()).filter((name) => !recipeNames.includes(name)).forEach((name) => {
+			this.remove(name);
+		});
+	};
+	save = (context) => {
+		this.context = context;
+		for (const [name, recipe] of Object.entries(this.recipes)) this.saveOne(name, recipe);
+		this.keys = Object.keys(this.recipes);
+	};
+	saveOne = (name, recipe) => {
+		if (Recipes.isSlotRecipeConfig(recipe)) {
+			const slots = (0, _bamboocss_shared.getSlotRecipes)(recipe);
+			const slotsMap = /* @__PURE__ */ new Map();
+			Object.entries(slots).forEach(([slot, slotRecipe]) => {
+				const slotName = this.getSlotKey(name, slot);
+				this.normalize(slotName, slotRecipe);
+				slotsMap.set(slotName, slotRecipe);
+			});
+			this.assignRecipe(name, recipe);
+			sharedState.slots.set(name, slotsMap);
+		} else this.assignRecipe(name, this.normalize(name, recipe));
+	};
+	remove(name) {
+		sharedState.nodes.delete(name);
+		sharedState.classNames.delete(name);
+		sharedState.styles.delete(name);
+	}
+	inferJsxSlots = (name, recipe) => {
+		const capitalized = (0, _bamboocss_shared.capitalize)(name);
+		const jsx = Array.from(recipe.jsx ?? [capitalized]);
+		const ROOT_SLOT = "root";
+		if (Recipes.isSlotRecipeConfig(recipe)) {
+			const jsxRootName = (0, _bamboocss_shared.capitalize)(ROOT_SLOT);
+			const rootNames = [`${capitalized}.${jsxRootName}`, `${capitalized}${jsxRootName}`];
+			jsx.push(...rootNames);
+		}
+		return jsx;
+	};
+	assignRecipe = (name, recipe) => {
+		if (recipe.deprecated) this.deprecated.add(name);
+		const variantKeys = Object.keys(recipe.variants ?? {});
+		const jsx = this.inferJsxSlots(name, recipe);
+		sharedState.nodes.set(name, {
+			...this.getNames(name),
+			className: recipe.className ?? name,
+			jsx,
+			type: "recipe",
+			variantKeys,
+			variantKeyMap: Object.fromEntries(Object.entries(recipe.variants ?? {}).map(([key, value]) => {
+				return [key, Object.keys(value)];
+			})),
+			match: (0, _bamboocss_shared.createRegex)(jsx),
+			config: recipe,
+			splitProps: (props) => {
+				return (0, _bamboocss_shared.splitProps)(props, variantKeys);
+			},
+			props: variantKeys
+		});
+	};
+	getSlotKey = (name, slot) => {
+		return `${name}${this.slotSeparator}${slot}`;
+	};
+	isEmpty = () => {
+		return sharedState.nodes.size === 0;
+	};
+	isDeprecated = (name) => {
+		return this.deprecated.has(name);
+	};
+	getNames = (0, _bamboocss_shared.memo)((name) => {
+		return {
+			baseName: name,
+			upperName: (0, _bamboocss_shared.capitalize)(name),
+			dashName: (0, _bamboocss_shared.dashCase)(name),
+			jsxName: (0, _bamboocss_shared.capitalize)(name)
+		};
+	});
+	getRecipe = (0, _bamboocss_shared.memo)((name) => {
+		return sharedState.nodes.get(name);
+	});
+	getConfig = (0, _bamboocss_shared.memo)((name) => {
+		return this.recipes[name];
+	});
+	getConfigOrThrow = (0, _bamboocss_shared.memo)((name) => {
+		const config = this.getConfig(name);
+		if (!config) throw new _bamboocss_shared.BambooError("UNKNOWN_RECIPE", `Recipe "${name}" not found`);
+		return config;
+	});
+	find = (0, _bamboocss_shared.memo)((jsxName) => {
+		return this.details.find((node) => node.match.test(jsxName));
+	});
+	filter = (0, _bamboocss_shared.memo)((jsxName) => {
+		return this.details.filter((node) => node.match.test(jsxName));
+	});
+	get details() {
+		return Array.from(sharedState.nodes.values());
+	}
+	splitProps = (recipeName, props) => {
+		const recipe = this.details.find((node) => node.baseName === recipeName);
+		if (!recipe) return [{}, props];
+		return recipe.splitProps(props);
+	};
+	isSlotRecipe = (name) => {
+		return sharedState.slots.has(name);
+	};
+	static isSlotRecipeConfig = (config) => {
+		return "slots" in config && Array.isArray(config.slots) && config.slots.length > 0;
+	};
+	normalize = (name, config) => {
+		const { jsx = [(0, _bamboocss_shared.capitalize)(name)], base = {}, variants = {}, defaultVariants = {}, description = "", compoundVariants = [], staticCss = [] } = config;
+		const className = config.className ?? name;
+		const recipe = {
+			...config,
+			deprecated: config.deprecated == null ? false : config.deprecated,
+			jsx,
+			className,
+			description,
+			base: {},
+			variants: {},
+			defaultVariants,
+			compoundVariants,
+			staticCss
+		};
+		recipe.base = transformStyles(this.context, base, name);
+		sharedState.styles.set(name, recipe.base);
+		sharedState.classNames.set(name, recipe.className);
+		for (const [key, variant] of Object.entries(variants)) for (const [variantKey, styles] of Object.entries(variant)) {
+			const propKey = this.getPropKey(name, key, variantKey);
+			const className = this.getClassName(recipe.className, key, variantKey);
+			const styleObject = transformStyles(this.context, styles, className);
+			sharedState.styles.set(propKey, styleObject);
+			sharedState.classNames.set(propKey, className);
+			(0, lodash_merge.default)(recipe.variants, { [key]: { [variantKey]: styleObject } });
+		}
+		return recipe;
+	};
+	getTransform = (name, slot) => {
+		return (variant, value) => {
+			if (value === "__ignore__") return {
+				layer: slot ? "recipes_slots_base" : "recipes_base",
+				className: sharedState.classNames.get(name),
+				styles: sharedState.styles.get(name) ?? {}
+			};
+			const propKey = this.getPropKey(name, variant, value);
+			return {
+				className: sharedState.classNames.get(propKey),
+				styles: sharedState.styles.get(propKey) ?? {}
+			};
+		};
+	};
+	filterDetails = (filters) => {
+		const recipeDiffs = filters?.affecteds?.recipes;
+		return recipeDiffs ? this.details.filter((recipe) => recipeDiffs.includes(recipe.dashName)) : this.details;
+	};
+	static inferSlots = (recipe) => {
+		const slots = /* @__PURE__ */ new Set();
+		Object.keys(recipe.base ?? {}).forEach((name) => {
+			slots.add(name);
+		});
+		Object.values(recipe.variants ?? {}).forEach((variants) => {
+			Object.keys(variants).forEach((name) => {
+				slots.add(name);
+			});
+		});
+		recipe.compoundVariants?.forEach((compoundVariant) => {
+			if (!compoundVariant) return;
+			Object.keys(compoundVariant.css ?? {}).forEach((name) => {
+				slots.add(name);
+			});
+		});
+		return Array.from(slots);
+	};
+	static isValidNode = (node) => {
+		return (0, _bamboocss_shared.isObject)(node) && "type" in node && node.type === "recipe";
+	};
+};
+//#endregion
+//#region package.json
+var version = "1.11.3";
+//#endregion
+//#region src/style-encoder.ts
+const urlRegex = /^https?:\/\//;
+var StyleEncoder = class StyleEncoder {
+	context;
+	static separator = "]___[";
+	static conditionSeparator = "<___>";
+	atomic = /* @__PURE__ */ new Set();
+	compound_variants = /* @__PURE__ */ new Set();
+	recipes = /* @__PURE__ */ new Map();
+	recipes_base = /* @__PURE__ */ new Map();
+	grouped = /* @__PURE__ */ new Map();
+	constructor(context) {
+		this.context = context;
+	}
+	filterStyleProps = (props) => {
+		if (this.context.isTemplateLiteralSyntax) return props;
+		return filterProps(this.context.isValidProperty, props);
+	};
+	clone = () => {
+		return new StyleEncoder(this.context);
+	};
+	isEmpty = () => {
+		return !this.atomic.size && !this.recipes.size && !this.compound_variants.size && !this.recipes_base.size && !this.grouped.size;
+	};
+	get results() {
+		return {
+			atomic: this.atomic,
+			recipes: this.recipes,
+			recipes_base: this.recipes_base,
+			grouped: this.grouped
+		};
+	}
+	/**
+	* Hashes a style object and adds the resulting hashes to a set.
+	* @param set - The set to add the resulting hashes to.
+	* @param obj - The style object to hash.
+	* @param baseEntry - An optional base style entry to use when hashing the style object.
+	*/
+	hashStyleObject = (set, obj, baseEntry) => {
+		const isCondition = this.context.conditions.isCondition;
+		const traverseOptions = { separator: StyleEncoder.conditionSeparator };
+		let prop = "";
+		let prevProp = "";
+		const isRecipe = !!baseEntry?.variants;
+		(0, _bamboocss_shared.traverse)((0, _bamboocss_shared.normalizeStyleObject)(obj, this.context, !isRecipe), ({ key, value: rawValue, path }) => {
+			if (rawValue === void 0) return;
+			if (urlRegex.test(rawValue)) return;
+			const value = Array.isArray(rawValue) ? (0, _bamboocss_shared.toResponsiveObject)(rawValue, this.context.conditions.breakpoints.keys) : rawValue;
+			prop = key;
+			if (isCondition(key)) {
+				if ((0, _bamboocss_shared.isObjectOrArray)(value)) return;
+				prop = prevProp;
+			} else if ((0, _bamboocss_shared.isObjectOrArray)(value)) {
+				prevProp = prop;
+				return;
+			}
+			const resolvedCondition = getResolvedCondition(path, isCondition);
+			const hashed = hashStyleEntry(Object.assign(baseEntry ?? {}, {
+				prop,
+				value,
+				cond: resolvedCondition
+			}));
+			set.add(hashed);
+			prevProp = prop;
+		}, traverseOptions);
+	};
+	processAtomic = (styles) => {
+		this.hashStyleObject(this.atomic, styles);
+	};
+	processGrouped = (styles) => {
+		const groupSet = /* @__PURE__ */ new Set();
+		this.hashStyleObject(groupSet, styles);
+		if (groupSet.size === 0) return;
+		const groupId = Array.from(groupSet).sort().join("|");
+		if (this.grouped.get(groupId)) return;
+		this.grouped.set(groupId, groupSet);
+	};
+	processStyleProps = (styleProps, grouped = false) => {
+		const processFn = grouped ? this.processGrouped : this.processAtomic;
+		const styles = this.filterStyleProps(styleProps);
+		const rest = {};
+		for (const [key, value] of Object.entries(styles)) if (key === "css" || key.endsWith("Css")) {
+			if (Array.isArray(value)) value.forEach((style) => processFn(style));
+			else if (value) processFn(value);
+		} else rest[key] = value;
+		processFn(rest);
+	};
+	processConfigSlotRecipeBase = (recipeName, config) => {
+		config.slots.forEach((slot) => {
+			const recipeKey = this.context.recipes.getSlotKey(recipeName, slot);
+			const slotBase = config.base?.[slot];
+			if (!slotBase || this.recipes_base.has(recipeKey)) return;
+			const base_set = (0, _bamboocss_shared.getOrCreateSet)(this.recipes_base, recipeKey);
+			this.hashStyleObject(base_set, slotBase, {
+				recipe: recipeName,
+				slot
+			});
+		});
+	};
+	processConfigSlotRecipe = (recipeName, variants) => {
+		const config = this.context.recipes.getConfig(recipeName);
+		if (!Recipes.isSlotRecipeConfig(config)) return;
+		this.processConfigSlotRecipeBase(recipeName, config);
+		const set = (0, _bamboocss_shared.getOrCreateSet)(this.recipes, recipeName);
+		const computedVariants = Object.assign({}, config.defaultVariants, variants);
+		this.hashStyleObject(set, computedVariants, {
+			recipe: recipeName,
+			variants: true
+		});
+		if (!config.compoundVariants || this.compound_variants.has(recipeName)) return;
+		this.compound_variants.add(recipeName);
+		config.compoundVariants.forEach((compoundVariant) => {
+			if (!compoundVariant) return;
+			Object.values(compoundVariant.css).forEach((values) => {
+				if (!values) return;
+				this.processAtomic(values);
+			});
+		});
+	};
+	processConfigRecipeBase = (recipeName, config) => {
+		if (!config.base || this.recipes_base.has(recipeName)) return;
+		const base_set = (0, _bamboocss_shared.getOrCreateSet)(this.recipes_base, recipeName);
+		this.hashStyleObject(base_set, config.base, { recipe: recipeName });
+	};
+	processConfigRecipe = (recipeName, variants) => {
+		const config = this.context.recipes.getConfig(recipeName);
+		if (!config) return;
+		this.processConfigRecipeBase(recipeName, config);
+		const set = (0, _bamboocss_shared.getOrCreateSet)(this.recipes, recipeName);
+		const computedVariants = Object.assign({}, config.defaultVariants, variants);
+		this.hashStyleObject(set, computedVariants, {
+			recipe: recipeName,
+			variants: true
+		});
+		if (!config.compoundVariants || this.compound_variants.has(recipeName)) return;
+		this.compound_variants.add(recipeName);
+		config.compoundVariants.forEach((compoundVariant) => {
+			if (!compoundVariant) return;
+			this.processAtomic(compoundVariant.css);
+		});
+	};
+	processRecipe = (recipeName, variants) => {
+		if (this.context.recipes.isSlotRecipe(recipeName)) this.processConfigSlotRecipe(recipeName, variants);
+		else this.processConfigRecipe(recipeName, variants);
+	};
+	processRecipeBase(recipeName) {
+		const config = this.context.recipes.getConfig(recipeName);
+		if (!config) return;
+		if (this.context.recipes.isSlotRecipe(recipeName)) this.processConfigSlotRecipeBase(recipeName, config);
+		else this.processConfigRecipeBase(recipeName, config);
+	}
+	processPattern = (name, patternProps, type, jsxName) => {
+		let fnName = name;
+		if (type === "jsx-pattern" && jsxName) fnName = this.context.patterns.find(jsxName);
+		const styleProps = this.context.patterns.transform(fnName, patternProps);
+		this.processStyleProps(styleProps);
+	};
+	processAtomicRecipe = (recipe) => {
+		const { base = {}, variants = {}, compoundVariants = [] } = recipe;
+		this.processAtomic(base);
+		for (const variant of Object.values(variants)) for (const styles of Object.values(variant)) this.processAtomic(styles);
+		compoundVariants.forEach((compoundVariant) => {
+			if (!compoundVariant) return;
+			this.processAtomic(compoundVariant.css);
+		});
+	};
+	processAtomicSlotRecipe = (recipe) => {
+		const inferredSlots = Recipes.inferSlots(recipe);
+		recipe.slots = (0, _bamboocss_shared.uniq)([...recipe.slots ?? [], ...inferredSlots].filter(Boolean));
+		const slots = (0, _bamboocss_shared.getSlotRecipes)(recipe);
+		for (const slotRecipe of Object.values(slots)) this.processAtomicRecipe(slotRecipe);
+	};
+	getConfigRecipeHash = (recipeName) => {
+		return {
+			atomic: this.atomic,
+			base: this.recipes_base.get(recipeName),
+			variants: this.recipes.get(recipeName)
+		};
+	};
+	getConfigSlotRecipeHash = (recipeName) => {
+		const recipeConfig = this.context.recipes.getConfigOrThrow(recipeName);
+		if (!Recipes.isSlotRecipeConfig(recipeConfig)) throw new _bamboocss_shared.BambooError("INVALID_RECIPE", `Recipe "${recipeName}" is not a slot recipe`);
+		const base = {};
+		recipeConfig.slots.map((slot) => {
+			const recipeKey = this.context.recipes.getSlotKey(recipeName, slot);
+			base[slot] = this.recipes_base.get(recipeKey);
+		});
+		return {
+			atomic: this.atomic,
+			base,
+			variants: this.recipes.get(recipeName)
+		};
+	};
+	getRecipeHash = (recipeName) => {
+		if (this.context.recipes.isSlotRecipe(recipeName)) return this.getConfigSlotRecipeHash(recipeName);
+		return this.getConfigRecipeHash(recipeName);
+	};
+	toJSON = () => {
+		const styles = {
+			atomic: Array.from(this.atomic),
+			recipes: Object.fromEntries(Array.from(this.recipes.entries()).map(([name, set]) => [name, Array.from(set)]))
+		};
+		if (this.grouped.size) styles.grouped = Object.fromEntries(Array.from(this.grouped.entries()).map(([id, set]) => [id, Array.from(set)]));
+		return {
+			schemaVersion: version,
+			styles
+		};
+	};
+	fromJSON = (json) => {
+		const { styles } = json;
+		styles.atomic?.forEach((hash) => this.atomic.add(hash));
+		Object.entries(styles.recipes ?? {}).forEach(([recipeName, hashes]) => {
+			this.processRecipeBase(recipeName);
+			const set = (0, _bamboocss_shared.getOrCreateSet)(this.recipes, recipeName);
+			hashes.forEach((hash) => set.add(hash));
+		});
+		Object.entries(styles.grouped ?? {}).forEach(([groupId, hashes]) => {
+			const set = (0, _bamboocss_shared.getOrCreateSet)(this.grouped, groupId);
+			hashes.forEach((hash) => set.add(hash));
+		});
+		return this;
+	};
+};
+const filterProps = (isValidProperty, props) => {
+	const clone = {};
+	for (const [key, value] of Object.entries(props)) if ((isValidProperty(key) || key === "css" || key.endsWith("Css")) && value !== void 0) clone[key] = value;
+	return clone;
+};
+const hashStyleEntry = (entry) => {
+	const parts = [`${entry.prop}${StyleEncoder.separator}value:${entry.value}`];
+	if (entry.cond) parts.push(`cond:${entry.cond}`);
+	if (entry.recipe) parts.push(`recipe:${entry.recipe}`);
+	if (entry.layer) parts.push(`layer:${entry.layer}`);
+	if (entry.slot) parts.push(`slot:${entry.slot}`);
+	return parts.join(StyleEncoder.separator);
+};
+/**
+* Returns the final condition string after filtering out irrelevant parts. ('base' and props)
+* @example
+* 'marginTop<___>md' => 'md'
+* 'marginTop<___>md<___>lg' => 'md<___>lg'
+* '_hover' => '_hover'
+* '& > p<___>base', => '& > p'
+* '@media base' => '@media base'
+* '_hover<___>base<___>_dark' => '_hover<___>_dark'
+*
+*/
+const getResolvedCondition = (cond, isCondition) => {
+	if (!cond) return "";
+	const parts = cond.split(StyleEncoder.conditionSeparator);
+	const relevantParts = parts.filter((part) => part !== "base" && isCondition(part));
+	if (parts.length !== relevantParts.length) return relevantParts.join(StyleEncoder.conditionSeparator);
+	return cond;
+};
+//#endregion
+//#region src/style-decoder.ts
+var StyleDecoder = class StyleDecoder {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	classNames = /* @__PURE__ */ new Map();
+	atomic_cache = /* @__PURE__ */ new Map();
+	group_cache = /* @__PURE__ */ new Map();
+	recipe_base_cache = /* @__PURE__ */ new Map();
+	atomic = /* @__PURE__ */ new Set();
+	grouped = /* @__PURE__ */ new Set();
+	recipes = /* @__PURE__ */ new Map();
+	recipes_base = /* @__PURE__ */ new Map();
+	clone = () => {
+		return new StyleDecoder(this.context);
+	};
+	isEmpty = () => {
+		return !this.atomic.size && !this.grouped.size && !this.recipes.size && !this.recipes_base.size;
+	};
+	get results() {
+		return {
+			atomic: this.atomic,
+			grouped: this.grouped,
+			recipes: this.recipes,
+			recipes_base: this.recipes_base
+		};
+	}
+	formatSelector = (conditions, className) => {
+		const { conditions: cond, hash, utility } = this.context;
+		const conds = cond.finalize(conditions);
+		let result;
+		if (hash.className) {
+			conds.push(className);
+			result = utility.formatClassName(utility.toHash(conds, utility.defaultHashFn));
+		} else {
+			conds.push(utility.formatClassName(className));
+			result = conds.join(":");
+		}
+		return (0, _bamboocss_shared.esc)(result);
+	};
+	getRecipeName = (hash) => {
+		const entry = getEntryFromHash(hash);
+		if (!entry.recipe) return;
+		return entry.slot ? this.context.recipes.getSlotKey(entry.recipe, entry.slot) : entry.recipe;
+	};
+	getTransformResult = (hash) => {
+		const entry = getEntryFromHash(hash);
+		const recipeName = this.getRecipeName(hash);
+		const transformed = (recipeName ? this.context.recipes.getTransform(recipeName) : this.context.utility.transform)(entry.prop, (0, _bamboocss_shared.withoutImportant)(entry.value));
+		if (!transformed.className) return;
+		const important = (0, _bamboocss_shared.isImportant)(entry.value);
+		const styles = important ? (0, _bamboocss_shared.markImportant)(transformed.styles) : transformed.styles;
+		const parts = entry.cond ? entry.cond.split(StyleEncoder.conditionSeparator) : [];
+		const className = this.formatSelector(parts, transformed.className);
+		return {
+			className,
+			classSelector: important ? `.${className}\\!` : `.${className}`,
+			styles,
+			transformed,
+			parts
+		};
+	};
+	resolveCondition = (condition) => {
+		if (condition.type === "multi-block") return [];
+		if (Array.isArray(condition.raw)) return condition.raw.map((c) => this.context.utility.tokens.resolveReference(c));
+		return this.context.utility.tokens.resolveReference(condition.raw);
+	};
+	/**
+	* Expands multi-block conditions into separate sets of conditions.
+	* Each block becomes an independent condition set that produces its own CSS block.
+	* When multiple multi-block conditions are stacked (e.g. two custom multi-block
+	* conditions used together), the cartesian product of all blocks is produced.
+	* Returns null if no multi-block condition is found.
+	*/
+	expandMultiBlock(conditions) {
+		if (!conditions.some((c) => c.type === "multi-block")) return null;
+		const alternatives = conditions.map((c) => {
+			if (c.type === "multi-block") return c.value.map((block) => block.value.filter(Boolean));
+			return [[c]];
+		});
+		let combos = [[]];
+		for (const slot of alternatives) {
+			const next = [];
+			for (const partial of combos) for (const choice of slot) next.push([...partial, ...choice]);
+			combos = next;
+		}
+		return combos.map((combo) => sortConditionDetails(combo));
+	}
+	getAtomic = (hash) => {
+		const cached = this.atomic_cache.get(hash);
+		if (cached) return cached;
+		const entry = getEntryFromHash(hash);
+		const transformResult = this.getTransformResult(hash);
+		if (!transformResult) return;
+		const { className, classSelector, styles, transformed, parts } = transformResult;
+		const basePath = [classSelector];
+		const obj = {};
+		let conditions;
+		if (entry.cond) {
+			conditions = this.context.conditions.sort(parts);
+			const expanded = this.expandMultiBlock(conditions);
+			if (expanded) for (const blockConditions of expanded) (0, _bamboocss_shared.deepSet)(obj, basePath.concat(blockConditions.flatMap((c) => this.resolveCondition(c))), styles);
+			else (0, _bamboocss_shared.deepSet)(obj, basePath.concat(conditions.flatMap((c) => this.resolveCondition(c))), styles);
+		} else (0, _bamboocss_shared.deepSet)(obj, basePath, styles);
+		const styleResult = {
+			result: obj,
+			entry,
+			hash,
+			conditions,
+			className,
+			layer: transformed.layer
+		};
+		this.atomic_cache.set(hash, styleResult);
+		return styleResult;
+	};
+	getGroup = (hashSet, key) => {
+		const cached = this.group_cache.get(key);
+		if (cached) return cached;
+		let obj = {};
+		const basePath = [];
+		const details = [];
+		const transform = this.context.utility.transform.bind(this.context.utility);
+		hashSet.forEach((hash) => {
+			const entry = getEntryFromHash(hash);
+			const transformed = transform(entry.prop, (0, _bamboocss_shared.withoutImportant)(entry.value));
+			if (!transformed.className) return;
+			const result = (0, _bamboocss_shared.isImportant)(entry.value) ? (0, _bamboocss_shared.markImportant)(transformed.styles) : transformed.styles;
+			const parts = entry.cond ? entry.cond.split(StyleEncoder.conditionSeparator) : [];
+			let conditions;
+			if (entry.cond) conditions = this.context.conditions.sort(parts);
+			details.push({
+				hash,
+				entry,
+				conditions,
+				result
+			});
+		});
+		sortStyleRules(details).forEach((value) => {
+			if (value.conditions) {
+				const expanded = this.expandMultiBlock(value.conditions);
+				if (expanded) for (const blockConditions of expanded) {
+					const path = basePath.concat(blockConditions.flatMap((c) => this.resolveCondition(c)));
+					obj = (0, _bamboocss_shared.deepSet)(obj, path, value.result);
+				}
+				else {
+					const path = basePath.concat(value.conditions.flatMap((c) => this.resolveCondition(c)));
+					obj = (0, _bamboocss_shared.deepSet)(obj, path, value.result);
+				}
+			} else obj = (0, _bamboocss_shared.deepSet)(obj, basePath, value.result);
+		});
+		const result = {
+			result: obj,
+			hashSet,
+			details,
+			className: key
+		};
+		this.group_cache.set(key, result);
+		return result;
+	};
+	getRecipeBase = (hashSet, recipeName, slot) => {
+		const recipeConfig = this.context.recipes.getConfig(recipeName);
+		if (!recipeConfig) return;
+		const recipeNode = this.context.recipes.getRecipe(recipeName);
+		if (!recipeNode) return;
+		const className = "slots" in recipeConfig && slot ? this.context.recipes.getSlotKey(recipeNode.className, slot) : recipeNode.className;
+		const cached = this.recipe_base_cache.get(className);
+		if (cached) return cached;
+		const selector = this.formatSelector([], className);
+		const style = this.getGroup(hashSet, className);
+		const result = Object.assign({}, style, {
+			result: { ["." + selector]: style.result },
+			recipe: recipeName,
+			className,
+			slot
+		});
+		this.recipe_base_cache.set(className, result);
+		return result;
+	};
+	collectAtomic = (encoder) => {
+		const atomic = [];
+		encoder.atomic.forEach((item) => {
+			const result = this.getAtomic(item);
+			if (!result) return;
+			atomic.push(result);
+		});
+		sortStyleRules(atomic).forEach((styleResult) => {
+			this.atomic.add(styleResult);
+			this.classNames.set(styleResult.className, styleResult);
+		});
+		return this;
+	};
+	processClassName = (recipeName, hash) => {
+		const result = this.getAtomic(hash);
+		if (!result) return;
+		(0, _bamboocss_shared.getOrCreateSet)(this.recipes, recipeName).add(result);
+		this.classNames.set(result.className, result);
+	};
+	collectRecipe = (encoder) => {
+		encoder.recipes.forEach((hashSet, recipeName) => {
+			const recipeConfig = this.context.recipes.getConfig(recipeName);
+			if (!recipeConfig) return;
+			hashSet.forEach((hash) => {
+				if ("slots" in recipeConfig) recipeConfig.slots.forEach((slot) => {
+					const slotHash = hash + StyleEncoder.separator + "slot:" + slot;
+					this.processClassName(recipeName, slotHash);
+				});
+				else this.processClassName(recipeName, hash);
+			});
+		});
+	};
+	collectRecipeBase = (encoder) => {
+		encoder.recipes_base.forEach((hashSet, recipeKey) => {
+			const [recipeName, slot] = recipeKey.split(this.context.recipes.slotSeparator);
+			if (!this.context.recipes.getConfig(recipeName)) return;
+			const result = this.getRecipeBase(hashSet, recipeName, slot);
+			if (!result) return;
+			(0, _bamboocss_shared.getOrCreateSet)(this.recipes_base, recipeKey).add(result);
+			this.classNames.set(result.className, result);
+		});
+	};
+	collectGrouped = (encoder) => {
+		encoder.grouped.forEach((hashSet, groupId) => {
+			const groupKey = "grouped:" + groupId;
+			const style = this.getGroup(hashSet, groupKey);
+			const shortHash = this.context.utility.toHash(["grouped", groupId], this.context.utility.defaultHashFn);
+			const className = this.formatSelector([], shortHash);
+			const result = {
+				...style,
+				className,
+				result: { ["." + className]: style.result }
+			};
+			this.grouped.add(result);
+			this.classNames.set(className, result);
+		});
+	};
+	/**
+	* Collect and re-create all styles and recipes objects from the style encoder
+	* So that we can just iterate over them and transform resulting CSS objects into CSS strings
+	*/
+	collect = (encoder) => {
+		this.collectAtomic(encoder);
+		this.collectGrouped(encoder);
+		this.collectRecipe(encoder);
+		this.collectRecipeBase(encoder);
+		return this;
+	};
+	getConfigRecipeResult = (recipeName) => {
+		return {
+			atomic: this.atomic,
+			base: this.recipes_base.get(recipeName),
+			variants: this.recipes.get(recipeName)
+		};
+	};
+	getConfigSlotRecipeResult = (recipeName) => {
+		const recipeConfig = this.context.recipes.getConfigOrThrow(recipeName);
+		if (!Recipes.isSlotRecipeConfig(recipeConfig)) throw new _bamboocss_shared.BambooError("UNKNOWN_RECIPE", `Recipe "${recipeName}" is not a slot recipe`);
+		const base = {};
+		recipeConfig.slots.map((slot) => {
+			const recipeKey = this.context.recipes.getSlotKey(recipeName, slot);
+			base[slot] = this.recipes_base.get(recipeKey);
+		});
+		return {
+			atomic: this.atomic,
+			base,
+			variants: this.recipes.get(recipeName)
+		};
+	};
+	getRecipeResult = (recipeName) => {
+		if (this.context.recipes.isSlotRecipe(recipeName)) return this.getConfigSlotRecipeResult(recipeName);
+		return this.getConfigRecipeResult(recipeName);
+	};
+};
+const entryKeys = [
+	"cond",
+	"recipe",
+	"layer",
+	"slot"
+];
+const getEntryFromHash = (hash) => {
+	const parts = hash.split(StyleEncoder.separator);
+	const entry = {
+		prop: parts[0],
+		value: parseValue(parts[1].replace("value:", ""))
+	};
+	parts.forEach((part) => {
+		const key = entryKeys.find((k) => part.startsWith(k));
+		if (key) entry[key] = part.slice(key.length + 1);
+	});
+	return entry;
+};
+const startsWithZero = /^0\d+$/;
+const parseValue = (value) => {
+	if (startsWithZero.test(value)) return value;
+	const asNumber = Number(value);
+	if (!Number.isNaN(asNumber)) return asNumber;
+	return castBoolean(value);
+};
+const castBoolean = (value) => {
+	if (value === "true") return true;
+	if (value === "false") return false;
+	return value;
+};
+const pseudoElementRegex = /::[\w-]/;
+/**
+* Sort flattened condition details (at-rules and selectors only):
+* at-rules first, pseudo-elements last, preserve relative order.
+*
+* Note: This only operates on individual at-rule and selector conditions
+* (not mixed or multi-block), so checking `raw` as string is sufficient
+* for pseudo-element detection.
+*/
+const sortConditionDetails = (conditions) => {
+	const indexed = conditions.map((cond, i) => ({
+		cond,
+		i
+	}));
+	indexed.sort((a, b) => {
+		const aIsAtRule = a.cond.type === "at-rule";
+		const bIsAtRule = b.cond.type === "at-rule";
+		if (aIsAtRule && !bIsAtRule) return -1;
+		if (!aIsAtRule && bIsAtRule) return 1;
+		const aIsPseudo = typeof a.cond.raw === "string" && pseudoElementRegex.test(a.cond.raw);
+		if (aIsPseudo !== (typeof b.cond.raw === "string" && pseudoElementRegex.test(b.cond.raw))) return aIsPseudo ? 1 : -1;
+		return a.i - b.i;
+	});
+	return indexed.map((item) => item.cond);
+};
+//#endregion
+//#region src/static-css.ts
+var StaticCss = class {
+	context;
+	encoder;
+	decoder;
+	breakpointKeys;
+	conditionKeys;
+	wildcardCache = /* @__PURE__ */ new Map();
+	constructor(context) {
+		this.context = context;
+		this.encoder = context.encoder;
+		this.decoder = context.decoder;
+		this.breakpointKeys = Object.keys(context.config.theme?.breakpoints ?? {});
+		this.conditionKeys = Object.keys(context.config.conditions ?? {});
+	}
+	clone() {
+		this.encoder = this.encoder.clone();
+		this.decoder = this.decoder.clone();
+		return this;
+	}
+	formatCondition = (condition) => {
+		return this.conditionKeys.includes(condition) ? `_${condition}` : condition;
+	};
+	getConditionalValues = (conditions, value) => {
+		return conditions.reduce((acc, key) => {
+			const cond = this.formatCondition(key);
+			return {
+				...acc,
+				[cond]: value
+			};
+		}, { base: value });
+	};
+	createRegex = () => {
+		const pattern = `(${Array.from(this.decoder.classNames.keys()).map((name) => (0, _bamboocss_shared.esc)(name)).join("|")})`;
+		return new RegExp(`\\b${pattern}\\b`, "g");
+	};
+	parse = (text) => {
+		const regex = this.createRegex();
+		const matches = text.match(regex);
+		if (!matches) return [];
+		return matches.map((match) => match.replace(".", ""));
+	};
+	/**
+	* Get property keys with memoization for wildcard expansion
+	* This is the main performance optimization - avoids redundant token lookups
+	*/
+	getCachedPropertyKeys = (property) => {
+		if (!this.wildcardCache.has(property)) {
+			const keys = this.context.utility.getPropertyKeys(property);
+			this.wildcardCache.set(property, keys);
+			_bamboocss_logger.logger.debug("static_css:wildcard", `${property} -> ${keys.length} values (memoized)`);
+		} else _bamboocss_logger.logger.debug("static_css:wildcard", `${property} (cache hit)`);
+		return this.wildcardCache.get(property);
+	};
+	/**
+	* Get pattern property values with memoization
+	*/
+	getCachedPatternPropertyValues = (patternName, property) => {
+		const cacheKey = `${patternName}:${property}`;
+		if (!this.wildcardCache.has(cacheKey)) {
+			const values = this.context.patterns.getPropertyValues(patternName, property) ?? [];
+			this.wildcardCache.set(cacheKey, values);
+			_bamboocss_logger.logger.debug("static_css:wildcard", `Pattern ${patternName}.${property} -> ${values.length} values (memoized)`);
+		} else _bamboocss_logger.logger.debug("static_css:wildcard", `Pattern ${patternName}.${property} (cache hit)`);
+		return this.wildcardCache.get(cacheKey);
+	};
+	getCssObjects = (entry, conditions) => {
+		const [property, values] = entry;
+		const propKeys = this.getCachedPropertyKeys(property);
+		return values.flatMap((value) => value === "*" ? propKeys : value).map((value) => ({ [property]: conditions.length ? this.getConditionalValues(conditions, value) : value }));
+	};
+	getCssRuleObjects = (rule) => {
+		const conditions = rule.conditions || [];
+		if (rule.responsive) conditions.push(...this.breakpointKeys);
+		return Object.entries(rule.properties).flatMap((entry) => this.getCssObjects(entry, conditions));
+	};
+	getPatternObjects = (name, entry, conditions) => {
+		const [property, values] = entry;
+		const propValues = this.getCachedPatternPropertyValues(name, property);
+		return values.flatMap((value) => value === "*" ? propValues : value).map((patternValue) => {
+			const value = this.context.patterns.transform(name, { [property]: patternValue });
+			const conditionalValues = this.getConditionalValues(conditions, value);
+			return conditions.length ? conditionalValues : value;
+		});
+	};
+	getPatternRuleObjects = (name, pattern) => {
+		const details = this.context.patterns.details.find((d) => d.baseName === name);
+		if (!details) return [];
+		const useAllKeys = pattern === "*";
+		let props = {};
+		if (useAllKeys) props = Object.fromEntries((details.props ?? []).map((key) => [key, ["*"]]));
+		const { conditions = [], responsive = false, properties = props } = useAllKeys ? {} : pattern;
+		if (responsive) conditions.push(...this.breakpointKeys);
+		return Object.entries(properties).flatMap((entry) => this.getPatternObjects(name, entry, conditions));
+	};
+	getRecipeNode = (name) => {
+		return this.context.recipes.details.find((detail) => detail.baseName === name);
+	};
+	getRecipeRuleObjects = (name, recipe, recipeNode) => {
+		const recipeKeys = recipeNode.variantKeyMap;
+		if (!recipeKeys) return [];
+		const { conditions = [], responsive, ...variants } = recipe === "*" ? recipeKeys : recipe;
+		if (responsive) conditions.push(...this.breakpointKeys);
+		return Object.entries(variants).flatMap(([variant, values]) => {
+			if (!Array.isArray(values)) return [];
+			return values.flatMap((value) => value === "*" ? recipeKeys[variant] : value).map((value) => {
+				const conditionalValues = this.getConditionalValues(conditions, value);
+				return { [name]: { [variant]: conditions.length ? conditionalValues : value } };
+			});
+		});
+	};
+	getRecipeCompoundVariantCssObjects = (recipeNode) => {
+		const cssRules = [];
+		const { compoundVariants } = recipeNode.config;
+		if (!compoundVariants) return cssRules;
+		compoundVariants.forEach((compoundVariant) => {
+			const css = compoundVariant.css;
+			if ("slots" in recipeNode.config && recipeNode.config.slots.length) Object.values(css).forEach((styles) => {
+				Object.entries(styles).forEach(([prop, value]) => {
+					cssRules.push({ [prop]: value });
+				});
+			});
+			else Object.entries(css).forEach(([prop, value]) => {
+				cssRules.push({ [prop]: value });
+			});
+		});
+		return cssRules;
+	};
+	/**
+	* This transforms a static css config into the same format as in the ParserResult,
+	* so that it can be processed by the same logic as styles found in app code.
+	*
+	* e.g.
+	* @example { css: [{ color: ['red', 'blue'] }] } => { css: [{ color: 'red }, { color: 'blue }] }
+	* @example { css: [{ color: ['red'], conditions: ['md'] }] } => { css: [{ color: { base: 'red', md: 'red' } }] }
+	*
+	*/
+	getStyleObjects(options) {
+		const { css = [], patterns = {} } = options;
+		const results = {
+			css: [],
+			recipes: [],
+			patterns: []
+		};
+		css.forEach((rule) => {
+			const cssObjects = this.getCssRuleObjects(rule);
+			results.css.push(...cssObjects);
+		});
+		const recipes = options.recipes ?? {};
+		Object.entries(recipes).forEach(([recipe, rules]) => {
+			const recipeNode = this.getRecipeNode(recipe);
+			if (!recipeNode) return;
+			results.recipes.push({ [recipe]: {} });
+			if (recipeNode.config.compoundVariants) results.css.push(...this.getRecipeCompoundVariantCssObjects(recipeNode));
+			rules.forEach((rule) => {
+				results.recipes.push(...this.getRecipeRuleObjects(recipe, rule, recipeNode));
+			});
+		});
+		Object.entries(patterns).forEach(([pattern, rules]) => {
+			rules.forEach((rule) => {
+				results.patterns.push(...this.getPatternRuleObjects(pattern, rule));
+			});
+		});
+		return results;
+	}
+	process = (options, stylesheet) => {
+		const { context } = this;
+		const sheet = stylesheet ?? context.createSheet();
+		const isClonedInstance = this.encoder !== context.encoder;
+		const encoder = isClonedInstance ? context.encoder.clone() : this.encoder;
+		const decoder = isClonedInstance ? context.decoder.clone() : this.decoder;
+		const staticCss = {
+			...options,
+			recipes: { ...typeof options.recipes === "string" ? {} : options.recipes }
+		};
+		const { theme = {} } = context.config;
+		const recipeConfigs = Object.assign({}, theme.recipes, theme.slotRecipes);
+		const useAllRecipes = options.recipes === "*";
+		Object.entries(recipeConfigs).forEach(([name, recipe]) => {
+			if (useAllRecipes) staticCss.recipes[name] = ["*"];
+			else if (recipe.staticCss) staticCss.recipes[name] = recipe.staticCss;
+		});
+		_bamboocss_logger.logger.debug("static_css:process", `Processing staticCss`);
+		const results = this.getStyleObjects(staticCss);
+		_bamboocss_logger.logger.debug("static_css:process", `Generated style objects: ${results.css.length} css, ${results.recipes.length} recipes, ${results.patterns.length} patterns`);
+		results.css.forEach((css) => {
+			encoder.hashStyleObject(encoder.atomic, css);
+		});
+		results.recipes.forEach((result) => {
+			Object.entries(result).forEach(([name, value]) => {
+				encoder.processRecipe(name, value);
+			});
+		});
+		results.patterns.forEach((result) => {
+			encoder.hashStyleObject(encoder.atomic, result);
+		});
+		sheet.processDecoder(decoder.collect(encoder));
+		return {
+			results,
+			sheet
+		};
+	};
+};
+//#endregion
+//#region src/plugins/merge-rules.ts
+const vendorPrefix = /-(ah|apple|atsc|epub|hp|khtml|moz|ms|o|rim|ro|tc|wap|webkit|xv)-/;
+const findMsInputPlaceholder = (selector) => ~selector.search(/-ms-input-placeholder/i);
+function filterPrefixes(selector) {
+	return selector.match(vendorPrefix);
+}
+function sameVendor(selectorsA, selectorsB) {
+	const same = (selectors) => selectors.map((s) => filterPrefixes(s)?.join() ?? "").join(",");
+	const findMsVendor = (selectors) => selectors.find((s) => findMsInputPlaceholder(s));
+	return same(selectorsA) === same(selectorsB) && !(findMsVendor(selectorsA) && findMsVendor(selectorsB));
+}
+function noVendor(selector) {
+	return !vendorPrefix.test(selector);
+}
+function checkMatch(nodeA, nodeB) {
+	if (nodeA.type === "atrule" && nodeB.type === "atrule") return nodeA.params === nodeB.params && nodeA.name?.toLowerCase() === nodeB.name?.toLowerCase();
+	return nodeA.type === nodeB.type;
+}
+function sameParent(nodeA, nodeB) {
+	if (!nodeA.parent) return !nodeB.parent;
+	if (!nodeB.parent) return false;
+	if (!checkMatch(nodeA.parent, nodeB.parent)) return false;
+	return sameParent(nodeA.parent, nodeB.parent);
+}
+function declarationIsEqual(a, b) {
+	return a.important === b.important && a.prop === b.prop && a.value === b.value;
+}
+function indexOfDeclaration(array, decl) {
+	return array.findIndex((d) => declarationIsEqual(d, decl));
+}
+function intersect(a, b, not = false) {
+	return a.filter((c) => {
+		const index = indexOfDeclaration(b, c) !== -1;
+		return not ? !index : index;
+	});
+}
+function sameDeclarationsAndOrder(a, b) {
+	if (a.length !== b.length) return false;
+	return a.every((d, index) => declarationIsEqual(d, b[index]));
+}
+function isRuleOrAtRule(node) {
+	return node.type === "rule" || node.type === "atrule";
+}
+function isDeclaration(node) {
+	return node.type === "decl";
+}
+function getDecls(rule) {
+	return rule.nodes.filter(isDeclaration);
+}
+const joinSelectors = (...rules) => rules.map((s) => s.selector).join(",");
+function ruleLength(...rules) {
+	return rules.map((r) => r.nodes.length ? String(r) : "").join("").length;
+}
+function splitProp(prop) {
+	const parts = prop.split("-");
+	if (prop[0] !== "-") return {
+		prefix: "",
+		base: parts[0],
+		rest: parts.slice(1)
+	};
+	if (prop[1] === "-") return {
+		prefix: null,
+		base: null,
+		rest: [prop]
+	};
+	return {
+		prefix: parts[1],
+		base: parts[2],
+		rest: parts.slice(3)
+	};
+}
+function isConflictingProp(propA, propB) {
+	if (propA === propB) return true;
+	const a = splitProp(propA);
+	const b = splitProp(propB);
+	if (!a.base && !b.base) return true;
+	if (a.base !== b.base && a.base !== "place" && b.base !== "place") return false;
+	if (a.rest.length !== b.rest.length) return true;
+	if (a.base === "border") {
+		const allRestProps = new Set([...a.rest, ...b.rest]);
+		if (allRestProps.has("image") || allRestProps.has("width") || allRestProps.has("color") || allRestProps.has("style")) return true;
+	}
+	return a.rest.every((s, index) => b.rest[index] === s);
+}
+function mergeParents(first, second) {
+	if (!first.parent || !second.parent) return false;
+	if (first.parent === second.parent) return false;
+	second.remove();
+	first.parent.append(second);
+	return true;
+}
+function canMerge(ruleA, ruleB) {
+	const a = ruleA.selectors;
+	const b = ruleB.selectors;
+	const selectors = a.concat(b);
+	const parent = sameParent(ruleA, ruleB);
+	if (parent && ruleA.parent && ruleA.parent.type === "atrule" && ruleA.parent.name?.includes("keyframes")) return false;
+	if (ruleA.some(isRuleOrAtRule) || ruleB.some(isRuleOrAtRule)) return false;
+	return parent && (selectors.every(noVendor) || sameVendor(a, b));
+}
+function partialMerge(first, second) {
+	let intersection = intersect(getDecls(first), getDecls(second));
+	if (intersection.length === 0) return second;
+	let nextRule = second.next();
+	if (!nextRule) nextRule = (second.parent?.next())?.nodes?.[0];
+	if (nextRule && nextRule.type === "rule" && canMerge(second, nextRule)) {
+		const nextIntersection = intersect(getDecls(second), getDecls(nextRule));
+		if (nextIntersection.length > intersection.length) {
+			mergeParents(second, nextRule);
+			first = second;
+			second = nextRule;
+			intersection = nextIntersection;
+		}
+	}
+	const firstDecls = getDecls(first);
+	intersection = intersection.filter((decl, intersectIndex) => {
+		const indexOfDecl = indexOfDeclaration(firstDecls, decl);
+		const nextConflictInFirst = firstDecls.slice(indexOfDecl + 1).filter((d) => isConflictingProp(d.prop, decl.prop));
+		if (nextConflictInFirst.length === 0) return true;
+		const nextConflictInIntersection = intersection.slice(intersectIndex + 1).filter((d) => isConflictingProp(d.prop, decl.prop));
+		if (nextConflictInFirst.length !== nextConflictInIntersection.length) return false;
+		return nextConflictInFirst.every((d, index) => declarationIsEqual(d, nextConflictInIntersection[index]));
+	});
+	const secondDecls = getDecls(second);
+	intersection = intersection.filter((decl) => {
+		const nextConflictIndex = secondDecls.findIndex((d) => isConflictingProp(d.prop, decl.prop));
+		if (nextConflictIndex === -1) return false;
+		if (!declarationIsEqual(secondDecls[nextConflictIndex], decl)) return false;
+		if (decl.prop.toLowerCase() !== "direction" && decl.prop.toLowerCase() !== "unicode-bidi" && secondDecls.some((d) => d.prop.toLowerCase() === "all")) return false;
+		secondDecls.splice(nextConflictIndex, 1);
+		return true;
+	});
+	if (intersection.length === 0) return second;
+	const receivingBlock = second.clone();
+	receivingBlock.selector = joinSelectors(first, second);
+	receivingBlock.nodes = [];
+	second.parent.insertBefore(second, receivingBlock);
+	const firstClone = first.clone();
+	const secondClone = second.clone();
+	function moveDecl(callback) {
+		return (decl) => {
+			if (indexOfDeclaration(intersection, decl) !== -1) callback(decl);
+		};
+	}
+	firstClone.walkDecls(moveDecl((decl) => {
+		decl.remove();
+		receivingBlock.append(decl);
+	}));
+	secondClone.walkDecls(moveDecl((decl) => decl.remove()));
+	if (ruleLength(firstClone, receivingBlock, secondClone) < ruleLength(first, second)) {
+		first.replaceWith(firstClone);
+		second.replaceWith(secondClone);
+		[
+			firstClone,
+			receivingBlock,
+			secondClone
+		].forEach((r) => {
+			if (r.nodes.length === 0) r.remove();
+		});
+		if (!secondClone.parent) return receivingBlock;
+		return secondClone;
+	} else {
+		receivingBlock.remove();
+		return second;
+	}
+}
+function selectorMerger() {
+	let cache = null;
+	return function(rule) {
+		if (!cache || !canMerge(rule, cache)) {
+			cache = rule;
+			return;
+		}
+		if (cache === rule) {
+			cache = rule;
+			return;
+		}
+		mergeParents(cache, rule);
+		if (sameDeclarationsAndOrder(getDecls(rule), getDecls(cache))) {
+			rule.selector = joinSelectors(cache, rule);
+			cache.remove();
+			cache = rule;
+			return;
+		}
+		if (cache.selector === rule.selector) {
+			const cached = getDecls(cache);
+			rule.walk((node) => {
+				if (node.type === "decl" && indexOfDeclaration(cached, node) !== -1) {
+					node.remove();
+					return;
+				}
+				cache.append(node);
+			});
+			rule.remove();
+			return;
+		}
+		cache = partialMerge(cache, rule);
+	};
+}
+function mergeRules() {
+	return {
+		postcssPlugin: "postcss-merge-rules",
+		OnceExit(css) {
+			css.walkRules(selectorMerger());
+		}
+	};
+}
+mergeRules.postcss = true;
+//#endregion
+//#region src/plugins/prettify.ts
+function prettifyNode(node, indent = 0) {
+	node.each && node.each((child, i) => {
+		if (!child.raws.before || !child.raws.before.trim() || child.raws.before.includes("\n")) child.raws.before = `\n${node.type !== "rule" && i > 0 ? "\n" : ""}${"  ".repeat(indent)}`;
+		prettifyNode(child, indent + 1);
+	});
+}
+function prettify() {
+	return (root) => {
+		prettifyNode(root);
+		if (root.first) root.first.raws.before = "";
+	};
+}
+prettify.postcssPlugin = "bamboo-prettify";
+//#endregion
+//#region src/plugins/optimize-postcss.ts
+function optimizePostCss(code, options = {}) {
+	const { minify = false } = options;
+	const plugins = [
+		(0, postcss_nested.default)(),
+		(0, postcss_discard_duplicates.default)(),
+		mergeRules(),
+		(0, postcss_discard_empty.default)()
+	];
+	if (minify) plugins.push((0, postcss_normalize_whitespace.default)(), (0, postcss_minify_selectors.default)());
+	else plugins.push(prettify());
+	const { css } = (0, postcss.default)(plugins).process(code);
+	return css;
+}
+//#endregion
+//#region src/optimize.ts
+function optimizeCss(code, options = {}) {
+	const { hooks } = options;
+	const css = typeof code === "string" ? code : code.toString();
+	if (hooks?.["css:optimize"]) {
+		const result = hooks["css:optimize"]({
+			css,
+			minify: options.minify,
+			browserslist: options.browserslist
+		});
+		if (result !== void 0) return result;
+	}
+	return optimizePostCss(code, options);
+}
+function expandNestedCss(code) {
+	const { css } = (0, postcss.default)([(0, postcss_nested.default)(), prettify()]).process(code);
+	return css;
+}
+//#endregion
+//#region src/plugins/sort-mq.ts
+const atRuleName = ts_pattern.P.union("media", "container");
+function sortMediaQueries() {
+	const inner = (root) => {
+		root.nodes?.sort((a, b) => {
+			return (0, ts_pattern.match)({
+				a,
+				b
+			}).with({
+				a: {
+					type: "atrule",
+					name: atRuleName
+				},
+				b: {
+					type: "atrule",
+					name: atRuleName
+				}
+			}, ({ a, b }) => {
+				return sortAtRules(a.params, b.params);
+			}).with({
+				a: {
+					type: "atrule",
+					name: atRuleName
+				},
+				b: ts_pattern.P.any
+			}, () => {
+				return 1;
+			}).with({
+				a: ts_pattern.P.any,
+				b: {
+					type: "atrule",
+					name: atRuleName
+				}
+			}, () => {
+				return -1;
+			}).otherwise(() => {
+				return 0;
+			});
+		});
+		root.nodes?.forEach((node) => {
+			if ("nodes" in node) inner(node);
+		});
+	};
+	return inner;
+}
+sortMediaQueries.postcssPlugin = "bamboo-sort-mq";
+//#endregion
+//#region src/stylesheet.ts
+var Stylesheet = class {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	get layers() {
+		return this.context.layers;
+	}
+	getLayer(layer) {
+		return this.context.layers[layer];
+	}
+	process(options) {
+		const layer = this.getLayer(options.layer);
+		if (!layer) return;
+		const { styles } = options;
+		if (typeof styles !== "object") return;
+		try {
+			layer.append(stringify(styles));
+		} catch (error) {
+			if (error instanceof postcss.CssSyntaxError) _bamboocss_logger.logger.error("sheet:process", error.showSourceCode(true));
+			else _bamboocss_logger.logger.caughtError("sheet:process", "Failed to process styles", error);
+		}
+	}
+	serialize = (styles) => {
+		return serializeStyles(this.context, styles);
+	};
+	processResetCss = (styles) => {
+		let css = stringify(this.serialize(styles));
+		if (this.context.hooks["cssgen:done"]) css = this.context.hooks["cssgen:done"]({
+			artifact: "reset",
+			content: css
+		}) ?? css;
+		this.context.layers.reset.append(css);
+	};
+	processGlobalCss = (styles) => {
+		let css = stringify(this.serialize(styles));
+		css += this.context.globalVars.toString();
+		css += this.context.globalFontface.toString();
+		css += this.context.globalPositionTry.toString();
+		if (this.context.hooks["cssgen:done"]) css = this.context.hooks["cssgen:done"]({
+			artifact: "global",
+			content: css
+		}) ?? css;
+		this.context.layers.base.append(css);
+	};
+	processCss = (styles, layer) => {
+		if (!styles) return;
+		this.process({
+			styles,
+			layer
+		});
+	};
+	processDecoder = (decoder) => {
+		sortStyleRules([...decoder.atomic]).forEach((css) => {
+			this.processCss(css.result, css.layer ?? "utilities");
+		});
+		decoder.grouped.forEach((grouped) => {
+			this.processCss(grouped.result, "utilities");
+		});
+		decoder.recipes.forEach((recipeSet) => {
+			recipeSet.forEach((recipe) => {
+				this.processCss(recipe.result, recipe.entry.slot ? "recipes_slots" : "recipes");
+			});
+		});
+		decoder.recipes_base.forEach((recipeSet) => {
+			recipeSet.forEach((recipe) => {
+				this.processCss(recipe.result, recipe.slot ? "recipes_slots_base" : "recipes_base");
+			});
+		});
+	};
+	/**
+	* Process only the styles for a specific recipe from the decoder
+	*/
+	processDecoderForRecipe = (decoder, recipeName) => {
+		const recipeSet = decoder.recipes.get(recipeName);
+		if (recipeSet) recipeSet.forEach((recipe) => {
+			this.processCss(recipe.result, recipe.entry.slot ? "recipes_slots" : "recipes");
+		});
+		decoder.recipes_base.forEach((baseSet, recipeKey) => {
+			const [baseRecipeName] = recipeKey.split("__");
+			if (baseRecipeName === recipeName) baseSet.forEach((recipe) => {
+				this.processCss(recipe.result, recipe.slot ? "recipes_slots_base" : "recipes_base");
+			});
+		});
+	};
+	getLayerCss = (...layers) => {
+		const breakpoints = this.context.conditions.breakpoints;
+		return optimizeCss(layers.map((layer) => {
+			const root = this.context.layers.getLayerRoot(layer);
+			breakpoints.expandScreenAtRule(root);
+			return root.toString();
+		}).join("\n"), {
+			minify: false,
+			browserslist: this.context.browserslist,
+			hooks: this.context.hooks
+		});
+	};
+	toCss = ({ minify } = {}) => {
+		try {
+			const breakpoints = this.context.conditions.breakpoints;
+			const root = this.context.layers.insert();
+			breakpoints.expandScreenAtRule(root);
+			const plugins = [sortMediaQueries()];
+			if (this.context.polyfill) plugins.push((0, _csstools_postcss_cascade_layers.default)());
+			return optimizeCss((0, postcss.default)(plugins).process(root).toString(), {
+				minify,
+				browserslist: this.context.browserslist,
+				hooks: this.context.hooks
+			});
+		} catch (error) {
+			if (error instanceof postcss.CssSyntaxError) _bamboocss_logger.logger.error("sheet:toCss", error.showSourceCode(true));
+			throw error;
+		}
+	};
+};
+//#endregion
+//#region src/color-mix.ts
+const colorMix = (value, token) => {
+	if (!value || typeof value !== "string") return {
+		invalid: true,
+		value
+	};
+	const [rawColor, rawOpacity] = value.split("/");
+	if (!rawColor || !rawOpacity) return {
+		invalid: true,
+		value: rawColor
+	};
+	const colorToken = token(`colors.${rawColor}`);
+	const opacityToken = token.raw(`opacity.${rawOpacity}`)?.value;
+	if (!opacityToken && isNaN(Number(rawOpacity))) return {
+		invalid: true,
+		value: rawColor
+	};
+	const percent = opacityToken ? Number(opacityToken) * 100 + "%" : `${rawOpacity}%`;
+	const color = colorToken ?? rawColor;
+	return {
+		invalid: false,
+		color,
+		value: `color-mix(in srgb, ${color} ${percent}, transparent)`
+	};
+};
+//#endregion
+//#region src/utility.ts
+var Utility = class {
+	options;
+	/**
+	* The token map or dictionary of tokens
+	*/
+	tokens;
+	/**
+	* [cache] The map of property names to their resolved class names
+	*/
+	classNames = /* @__PURE__ */ new Map();
+	/**
+	* [cache] The map of the property to their resolved styless
+	*/
+	styles = /* @__PURE__ */ new Map();
+	/**
+	* Map of shorthand properties to their longhand properties
+	*/
+	shorthands = /* @__PURE__ */ new Map();
+	/**
+	* The map of possible values for each property
+	*/
+	types = /* @__PURE__ */ new Map();
+	/**
+	* The map of the property keys
+	*/
+	propertyTypeKeys = /* @__PURE__ */ new Map();
+	/**
+	* The utility config
+	*/
+	config = {};
+	/**
+	* The map of property names to their transform functions
+	*/
+	transforms = /* @__PURE__ */ new Map();
+	/**
+	* The map of property names to their config
+	*/
+	configs = /* @__PURE__ */ new Map();
+	/**
+	* The map of deprecated properties
+	*/
+	deprecated = /* @__PURE__ */ new Set();
+	separator = "_";
+	prefix = "";
+	strictTokens = false;
+	constructor(options) {
+		this.options = options;
+		const { tokens, config = {}, separator, prefix, shorthands, strictTokens } = options;
+		this.tokens = tokens;
+		this.config = this.normalizeConfig(config);
+		if (separator) this.separator = separator;
+		if (prefix) this.prefix = prefix;
+		if (strictTokens) this.strictTokens = strictTokens;
+		if (shorthands) this.assignShorthands();
+		this.assignColorPaletteProperty();
+		this.assignProperties();
+		this.assignPropertyTypes();
+	}
+	defaultHashFn = _bamboocss_shared.toHash;
+	toHash = (path, hashFn) => hashFn(path.join(":"));
+	normalizeConfig(config) {
+		return Object.fromEntries(Object.entries(config).map(([property, propertyConfig]) => {
+			return [property, this.normalize(propertyConfig)];
+		}));
+	}
+	assignDeprecated = (property, config) => {
+		if (!config.deprecated) return;
+		this.deprecated.add(property);
+		if ((0, _bamboocss_shared.isString)(config.shorthand)) this.deprecated.add(config.shorthand);
+		if (Array.isArray(config.shorthand)) config.shorthand.forEach((shorthand) => this.deprecated.add(shorthand));
+	};
+	register = (property, config) => {
+		this.config[property] = this.normalize(config);
+		this.assignProperty(property, config);
+		this.assignPropertyType(property, config);
+	};
+	assignShorthands = () => {
+		for (const [property, config] of Object.entries(this.config)) {
+			const { shorthand } = config ?? {};
+			if (!shorthand) continue;
+			(Array.isArray(shorthand) ? shorthand : [shorthand]).forEach((shorthandName) => {
+				this.shorthands.set(shorthandName, property);
+			});
+		}
+	};
+	assignColorPaletteProperty = () => {
+		if (!this.tokens.view.colorPalettes.size) return;
+		const values = (0, _bamboocss_shared.mapToJson)(this.tokens.view.colorPalettes);
+		this.config.colorPalette = {
+			values: Object.keys(values),
+			transform(value) {
+				return values[value];
+			}
+		};
+	};
+	resolveShorthand = (prop) => {
+		return this.shorthands.get(prop) ?? prop;
+	};
+	get hasShorthand() {
+		return this.shorthands.size > 0;
+	}
+	get isEmpty() {
+		return Object.keys(this.config).length === 0;
+	}
+	entries = () => {
+		return Object.entries(this.config).filter(([, value]) => !!value?.className).map(([key, value]) => [key, value.className]);
+	};
+	getPropKey = (prop, value) => {
+		return `(${prop} = ${value})`;
+	};
+	hash = (prop, value) => {
+		return `${prop}${this.separator}${value}`;
+	};
+	/**
+	* Get all the possible values for the defined property
+	*/
+	getPropertyValues = (config, resolveFn) => {
+		const { values } = config;
+		const fn = (key) => {
+			const categoryValues = this.getTokenCategoryValues(key);
+			if (!categoryValues) return;
+			const prop = resolveFn?.(key);
+			if (!prop) return;
+			return { [prop]: categoryValues };
+		};
+		if ((0, _bamboocss_shared.isString)(values)) return fn?.(values) ?? this.tokens.view.getCategoryValues(values) ?? {};
+		if (Array.isArray(values)) return values.reduce((result, value) => {
+			result[value] = value;
+			return result;
+		}, {});
+		if ((0, _bamboocss_shared.isFunction)(values)) return values(resolveFn ? fn : this.getTokenCategoryValues.bind(this));
+		return values;
+	};
+	getPropertyRawValue(config, value) {
+		const { values } = config;
+		if (!values) return value;
+		if ((0, _bamboocss_shared.isString)(values)) return this.tokens.view.valuesByCategory.get(values)?.get(String(value)) || value;
+		if (Array.isArray(values)) return value;
+		if ((0, _bamboocss_shared.isFunction)(values)) return values(this.getTokenCategoryValues.bind(this))[value] || value;
+		if (values.type) return value;
+		return values[value] || value;
+	}
+	getToken = (path) => {
+		return this.tokens.view.getVar(path);
+	};
+	getTokenCategoryValues = (category) => {
+		return this.tokens.view.getCategoryValues(category);
+	};
+	/**
+	* Normalize the property config
+	*/
+	normalize = (propertyConfig) => {
+		const config = { ...propertyConfig };
+		if (config.values === "keyframes") config.values = Object.keys(this.options.keyframes ?? {});
+		if (config.shorthand && !config.className) config.className = Array.isArray(config.shorthand) ? config.shorthand[0] : config.shorthand;
+		return config;
+	};
+	assignProperty = (property, config) => {
+		this.setTransform(property, config?.transform);
+		this.assignDeprecated(property, config);
+		if (!config) return;
+		this.configs.set(property, config);
+	};
+	assignProperties = () => {
+		for (const [property, propertyConfig] of Object.entries(this.config)) {
+			if (!propertyConfig) continue;
+			this.assignProperty(property, propertyConfig);
+		}
+	};
+	assignPropertiesValues = () => {
+		for (const [property, propertyConfig] of Object.entries(this.config)) {
+			if (!propertyConfig) continue;
+			this.assignPropertyValues(property, propertyConfig);
+		}
+		return this;
+	};
+	assignPropertyValues = (property, config) => {
+		const values = this.getPropertyValues(config);
+		if (!values) return;
+		for (const [alias, raw] of Object.entries(values)) {
+			const propKey = this.getPropKey(property, alias);
+			this.setStyles(property, raw, alias, propKey);
+			this.getOrCreateClassName(property, alias);
+		}
+	};
+	getPropertyKeys = (prop) => {
+		const propConfig = this.config[prop];
+		if (!propConfig) return [];
+		const values = this.getPropertyValues(propConfig);
+		if (!values) return [];
+		return Object.keys(values);
+	};
+	getPropertyTypeKeys = (property) => {
+		const keys = this.propertyTypeKeys.get(property);
+		return keys ? Array.from(keys) : [];
+	};
+	assignPropertyType = (property, config) => {
+		if (!config) return;
+		const values = this.getPropertyValues(config, (key) => `type:Tokens["${key}"]`);
+		if (typeof values === "object" && values.type) {
+			this.types.set(property, new Set([`type:${values.type}`]));
+			return;
+		}
+		if (values) {
+			const keys = new Set(Object.keys(values));
+			this.types.set(property, keys);
+			this.propertyTypeKeys.set(property, keys);
+		}
+		const set = this.types.get(property) ?? /* @__PURE__ */ new Set();
+		if (!this.strictTokens && config.property) this.types.set(property, set.add(`CssProperties["${config.property}"]`));
+	};
+	assignPropertyTypes = () => {
+		for (const [property, propertyConfig] of Object.entries(this.config)) {
+			if (!propertyConfig) continue;
+			this.assignPropertyType(property, propertyConfig);
+		}
+	};
+	addPropertyType = (property, type) => {
+		const set = this.types.get(property) ?? /* @__PURE__ */ new Set();
+		this.types.set(property, new Set([...set, ...type]));
+	};
+	/**
+	* Returns the Typescript type for the define properties
+	*/
+	getTypes = () => {
+		const map = /* @__PURE__ */ new Map();
+		for (const [prop, tokens] of this.types.entries()) {
+			if (tokens.size === 0) continue;
+			const typeValues = Array.from(tokens).map((key) => {
+				if (key.startsWith("CssProperties")) return key;
+				if (key.startsWith("type:")) return key.replace("type:", "");
+				return JSON.stringify(key);
+			});
+			map.set(prop, typeValues);
+		}
+		return map;
+	};
+	defaultTransform = (0, _bamboocss_shared.memo)((value, prop) => {
+		if (prop.startsWith("--")) {
+			const tokenValue = this.tokens.view.getVar(value);
+			value = typeof tokenValue === "string" ? tokenValue : value;
+		}
+		return { [prop]: value };
+	});
+	setTransform = (property, transform) => {
+		const defaultTransform = (value) => this.defaultTransform(value, property);
+		const transformFn = transform ?? defaultTransform;
+		this.transforms.set(property, transformFn);
+		return this;
+	};
+	getTokenFn = () => {
+		return Object.assign(this.getToken.bind(this), { raw: (path) => this.tokens.getByName(path) });
+	};
+	resolveColorMix = (value) => {
+		return colorMix(value, this.getTokenFn());
+	};
+	getTransformArgs = (raw) => {
+		return {
+			token: this.getTokenFn(),
+			raw,
+			utils: { colorMix: this.resolveColorMix.bind(this) }
+		};
+	};
+	setStyles = (property, raw, alias, propKey) => {
+		propKey = propKey ?? this.getPropKey(property, raw);
+		const defaultTransform = (value) => this.defaultTransform(value, property);
+		const styles = (this.transforms.get(property) ?? defaultTransform)(raw, this.getTransformArgs(alias));
+		this.styles.set(propKey, styles ?? {});
+		return this;
+	};
+	formatClassName = (className) => {
+		return [this.prefix, className].filter(Boolean).join("-");
+	};
+	/**
+	* Returns the resolved className for a given property and value
+	*/
+	getClassName = (property, raw) => {
+		const config = this.configs.get(property);
+		if (!config || !config.className) return this.hash((0, _bamboocss_shared.hypenateProperty)(property), raw);
+		return this.hash(config.className, raw);
+	};
+	getOrCreateClassName = (property, raw) => {
+		const propKey = this.getPropKey(property, raw);
+		let className = this.classNames.get(propKey);
+		if (!className) {
+			className = this.getClassName(property, raw);
+			this.classNames.set(propKey, className);
+		}
+		return className;
+	};
+	/**
+	* Whether a given property exists in the config
+	*/
+	has = (prop) => {
+		return this.configs.has(prop);
+	};
+	/**
+	* Get or create the resolved styles for a given property and value
+	*/
+	getOrCreateStyle = (prop, value) => {
+		const propKey = this.getPropKey(prop, value);
+		const styles = this.styles.get(propKey);
+		if (styles) return styles;
+		const config = this.configs.get(prop);
+		const raw = config ? this.getPropertyRawValue(config, value) : value;
+		this.setStyles(prop, raw, value, propKey);
+		return this.styles.get(propKey);
+	};
+	/**
+	* Returns the resolved className and styles for a given property and value
+	*/
+	transform = (prop, value) => {
+		if (value == null) return {
+			className: "",
+			styles: {}
+		};
+		const key = this.resolveShorthand(prop);
+		let styleValue = (0, _bamboocss_shared.getArbitraryValue)(value);
+		if ((0, _bamboocss_shared.isString)(styleValue)) styleValue = this.tokens.expandReferenceInValue(styleValue);
+		return (0, _bamboocss_shared.compact)({
+			layer: this.configs.get(key)?.layer,
+			className: this.getOrCreateClassName(key, (0, _bamboocss_shared.withoutSpace)(value)),
+			styles: this.getOrCreateStyle(key, styleValue)
+		});
+	};
+	/**
+	* All keys including shorthand keys
+	*/
+	keys = () => {
+		const shorthands = Array.from(this.shorthands.keys());
+		const properties = Object.keys(this.config);
+		return [...shorthands, ...properties];
+	};
+	/**
+	* Returns a map of the property keys and their shorthands
+	*/
+	getPropShorthandsMap = () => {
+		const shorthandsByProp = /* @__PURE__ */ new Map();
+		this.shorthands.forEach((prop, shorthand) => {
+			const list = shorthandsByProp.get(prop) ?? [];
+			list.push(shorthand);
+			shorthandsByProp.set(prop, list);
+		});
+		return shorthandsByProp;
+	};
+	/**
+	* Returns the shorthands for a given property
+	*/
+	getPropShorthands = (prop) => {
+		return this.getPropShorthandsMap().get(prop) ?? [];
+	};
+	/**
+	* Whether a given property is deprecated
+	*/
+	isDeprecated = (prop) => {
+		return this.deprecated.has(prop);
+	};
+	/**
+	* Returns the token type for a given property
+	*/
+	getTokenType = (prop) => {
+		const set = this.types.get(prop);
+		if (!set) return;
+		for (const type of set) {
+			const match = type.match(TOKEN_TYPE_PATTERN);
+			if (match) return match[1];
+		}
+	};
+};
+const TOKEN_TYPE_PATTERN = /type:Tokens\["([^"]+)"\]/;
+//#endregion
+//#region src/context.ts
+const defaults = (config) => ({
+	cssVarRoot: ":where(:root, :host)",
+	jsxFactory: "styled",
+	jsxStyleProps: "all",
+	outExtension: "mjs",
+	shorthands: true,
+	syntax: "object-literal",
+	...config,
+	layers: {
+		reset: "reset",
+		base: "base",
+		tokens: "tokens",
+		recipes: "recipes",
+		utilities: "utilities",
+		...config.layers
+	}
+});
+var Context = class {
+	conf;
+	studio;
+	tokens;
+	utility;
+	recipes;
+	conditions;
+	patterns;
+	staticCss;
+	jsx;
+	imports;
+	paths;
+	file;
+	globalVars;
+	globalFontface;
+	globalPositionTry;
+	encoder;
+	decoder;
+	hooksApi;
+	properties;
+	isValidProperty;
+	messages;
+	parserOptions;
+	constructor(conf) {
+		this.conf = conf;
+		const config = defaults(conf.config);
+		const theme = config.theme ?? {};
+		conf.config = config;
+		this.tokens = this.createTokenDictionary(theme, config.themes);
+		this.hooks["tokens:created"]?.({ configure: (opts) => {
+			if (opts.formatTokenName) this.tokens.formatTokenName = opts.formatTokenName;
+			if (opts.formatCssVar) this.tokens.formatCssVar = opts.formatCssVar;
+		} });
+		this.tokens.init();
+		this.utility = this.createUtility(config);
+		this.hooks["utility:created"]?.({ configure: (opts) => {
+			if (opts.toHash) this.utility.toHash = opts.toHash;
+		} });
+		this.conditions = this.createConditions(config);
+		this.patterns = new Patterns({
+			config,
+			tokens: this.tokens,
+			utility: this.utility,
+			helpers: _bamboocss_shared.patternFns
+		});
+		this.studio = {
+			outdir: `${config.outdir}-studio`,
+			...conf.config.studio
+		};
+		this.setupProperties();
+		this.recipes = this.createRecipes(theme);
+		this.encoder = new StyleEncoder({
+			utility: this.utility,
+			recipes: this.recipes,
+			conditions: this.conditions,
+			patterns: this.patterns,
+			isTemplateLiteralSyntax: this.isTemplateLiteralSyntax,
+			isValidProperty: this.isValidProperty
+		});
+		this.decoder = new StyleDecoder({
+			conditions: this.conditions,
+			utility: this.utility,
+			recipes: this.recipes,
+			hash: this.hash
+		});
+		this.setupCompositions(theme);
+		this.registerAnimationName(theme);
+		this.registerFontFamily(config.globalFontface);
+		this.recipes.save(this.baseSheetContext);
+		this.staticCss = new StaticCss({
+			config,
+			utility: this.utility,
+			patterns: this.patterns,
+			recipes: this.recipes,
+			createSheet: this.createSheet,
+			encoder: this.encoder,
+			decoder: this.decoder
+		});
+		this.jsx = new JsxEngine({
+			patterns: this.patterns,
+			recipes: this.recipes,
+			config
+		});
+		this.imports = new ImportMap({
+			jsx: this.jsx,
+			conf: this.conf,
+			config: this.config,
+			patterns: this.patterns,
+			recipes: this.recipes,
+			isValidProperty: this.isValidProperty
+		});
+		this.paths = new PathEngine({ config: this.config });
+		this.file = new FileEngine({ config: this.config });
+		this.globalVars = new GlobalVars({
+			globalVars: this.config.globalVars,
+			cssVarRoot: this.config.cssVarRoot
+		});
+		this.globalFontface = new GlobalFontface({ globalFontface: this.config.globalFontface });
+		this.globalPositionTry = new GlobalPositionTry({ globalPositionTry: this.config.globalPositionTry });
+		this.messages = getMessages({
+			jsx: this.jsx,
+			config: this.config,
+			tokens: this.tokens,
+			recipes: this.recipes,
+			patterns: this.patterns,
+			isTemplateLiteralSyntax: this.isTemplateLiteralSyntax
+		});
+		this.parserOptions = {
+			hash: this.hash,
+			compilerOptions: this.conf.tsconfig?.compilerOptions ?? {},
+			recipes: this.recipes,
+			patterns: this.patterns,
+			jsx: this.jsx,
+			config: this.config,
+			tokens: this.tokens,
+			conditions: this.conditions,
+			utility: this.utility,
+			encoder: this.encoder,
+			tsOptions: this.conf.tsOptions,
+			join: (...paths) => paths.join("/"),
+			imports: this.imports
+		};
+		this.hooksApi = new HooksApi(this);
+		this.hooks["context:created"]?.({
+			ctx: this.hooksApi,
+			logger: _bamboocss_logger.logger
+		});
+	}
+	get config() {
+		return this.conf.config;
+	}
+	get hooks() {
+		return this.conf.hooks ?? {};
+	}
+	get isTemplateLiteralSyntax() {
+		return this.config.syntax === "template-literal";
+	}
+	get hash() {
+		return {
+			tokens: (0, _bamboocss_shared.isBoolean)(this.config.hash) ? this.config.hash : this.config.hash?.cssVar,
+			className: (0, _bamboocss_shared.isBoolean)(this.config.hash) ? this.config.hash : this.config.hash?.className
+		};
+	}
+	get prefix() {
+		return {
+			tokens: (0, _bamboocss_shared.isString)(this.config.prefix) ? this.config.prefix : this.config.prefix?.cssVar,
+			className: (0, _bamboocss_shared.isString)(this.config.prefix) ? this.config.prefix : this.config.prefix?.className
+		};
+	}
+	createTokenDictionary = (theme, themeVariants) => {
+		return new _bamboocss_token_dictionary.TokenDictionary({
+			breakpoints: theme.breakpoints,
+			tokens: theme.tokens,
+			semanticTokens: theme.semanticTokens,
+			themes: themeVariants,
+			prefix: this.prefix.tokens,
+			hash: this.hash.tokens,
+			colorPalette: theme.colorPalette
+		});
+	};
+	createUtility = (config) => {
+		return new Utility({
+			prefix: this.prefix.className,
+			tokens: this.tokens,
+			config: this.isTemplateLiteralSyntax ? {} : Object.assign({}, config.utilities),
+			separator: config.separator,
+			shorthands: config.shorthands,
+			strictTokens: config.strictTokens,
+			keyframes: config.theme?.keyframes
+		});
+	};
+	createConditions = (config) => {
+		return new Conditions({
+			conditions: config.conditions,
+			containerNames: config.theme?.containerNames,
+			containerSizes: config.theme?.containerSizes,
+			breakpoints: config.theme?.breakpoints,
+			themes: config.themes
+		});
+	};
+	createLayers = (layers) => {
+		return new Layers(layers);
+	};
+	setupCompositions = (theme) => {
+		const { textStyles, layerStyles, animationStyles } = theme;
+		const compositions = (0, _bamboocss_shared.compact)({
+			textStyle: textStyles,
+			layerStyle: layerStyles,
+			animationStyle: animationStyles
+		});
+		const stylesheetCtx = {
+			...this.baseSheetContext,
+			layers: this.createLayers(this.config.layers)
+		};
+		for (const [key, values] of Object.entries(compositions)) {
+			this.properties.add(key);
+			const flatValues = (0, _bamboocss_shared.flatten)(values ?? {});
+			const config = {
+				layer: "compositions",
+				className: key,
+				values: Object.keys(flatValues),
+				transform: (value) => {
+					return transformStyles(stylesheetCtx, flatValues[value], key + "." + value);
+				}
+			};
+			this.utility.register(key, config);
+		}
+	};
+	registerAnimationName = (theme) => {
+		this.utility.addPropertyType("animationName", Object.keys(theme.keyframes ?? {}));
+	};
+	registerFontFamily = (fontFaces) => {
+		this.utility.addPropertyType("fontFamily", Object.keys(fontFaces ?? {}));
+	};
+	setupProperties = () => {
+		this.properties = new Set([
+			"css",
+			...this.utility.keys(),
+			...this.conditions.keys()
+		]);
+		this.isValidProperty = (0, _bamboocss_shared.memo)((key) => this.properties.has(key) || (0, _bamboocss_is_valid_prop.isCssProperty)(key));
+	};
+	get baseSheetContext() {
+		return {
+			conditions: this.conditions,
+			utility: this.utility,
+			hash: this.hash.className,
+			encoder: this.encoder,
+			decoder: this.decoder,
+			hooks: this.hooks,
+			isValidProperty: this.isValidProperty,
+			browserslist: this.config.browserslist,
+			polyfill: this.config.polyfill,
+			cssVarRoot: this.config.cssVarRoot,
+			helpers: _bamboocss_shared.patternFns,
+			globalVars: this.globalVars,
+			globalFontface: this.globalFontface,
+			globalPositionTry: this.globalPositionTry
+		};
+	}
+	createSheet = () => {
+		return new Stylesheet({
+			...this.baseSheetContext,
+			layers: this.createLayers(this.config.layers)
+		});
+	};
+	createRecipes = (theme) => {
+		return new Recipes(Object.assign({}, theme.recipes ?? {}, theme.slotRecipes ?? {}));
+	};
+	isValidLayerParams = (params) => {
+		const names = new Set(params.split(",").map((name) => name.trim()));
+		return names.size >= 5 && Object.values(this.config.layers).every((name) => names.has(name));
+	};
+};
+//#endregion
+//#region src/selector.ts
+const parentNestingRegex = /\s&/g;
+function extractParentSelectors(selector) {
+	const result = /* @__PURE__ */ new Set();
+	(0, postcss_selector_parser.default)((selectors) => {
+		selectors.each((selector) => {
+			(0, ts_pattern.match)(parseCondition(selector.toString())).with({ type: "parent-nesting" }, () => {
+				result.add(selector.toString().replace(parentNestingRegex, "").trim());
+			}).otherwise(() => {});
+		});
+	}).processSync(selector);
+	const finalized = Array.from(result).join(", ").trim();
+	return result.size > 1 ? `:where(${finalized})` : finalized;
+}
+function extractTrailingPseudos(selector) {
+	const ast = (0, postcss_selector_parser.default)((selectors) => selectors).astSync(selector);
+	const matrix = [];
+	for (const [i, sel] of ast.nodes.entries()) for (const [j, child] of [...sel.nodes].reverse().entries()) {
+		if (child.type !== "pseudo" || !child.value.startsWith("::")) break;
+		matrix[j] = matrix[j] || [];
+		matrix[j][i] = child;
+	}
+	const trailingPseudos = postcss_selector_parser.default.selector({ value: "" });
+	for (const pseudos of matrix) {
+		if (!pseudos) continue;
+		if (new Set(pseudos.map((p) => p.value)).size > 1) break;
+		pseudos.forEach((pseudo) => pseudo.remove());
+		trailingPseudos.prepend(pseudos[0]);
+	}
+	if (trailingPseudos.nodes.length) return [trailingPseudos.toString(), ast.toString()];
+	return [null, selector];
+}
+//#endregion
+exports.Breakpoints = Breakpoints;
+exports.Conditions = Conditions;
+exports.Context = Context;
+exports.FileMatcher = FileMatcher;
+exports.ImportMap = ImportMap;
+exports.JsxEngine = JsxEngine;
+exports.Layers = Layers;
+exports.Patterns = Patterns;
+exports.Recipes = Recipes;
+exports.RuleProcessor = RuleProcessor;
+exports.StaticCss = StaticCss;
+exports.StyleDecoder = StyleDecoder;
+exports.StyleEncoder = StyleEncoder;
+exports.Stylesheet = Stylesheet;
+exports.Utility = Utility;
+exports.expandNestedCss = expandNestedCss;
+exports.extractParentSelectors = extractParentSelectors;
+exports.extractTrailingPseudos = extractTrailingPseudos;
+Object.defineProperty(exports, "messages", {
+	enumerable: true,
+	get: function() {
+		return messages_exports;
+	}
+});
+exports.optimizeCss = optimizeCss;
+exports.stringify = stringify;