@tenphi/tasty 0.1.0 → 0.1.2

package/dist/pipeline/exclusive.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"exclusive.mjs","names":[],"sources":["../../src/pipeline/exclusive.ts"],"sourcesContent":["/**\n * Exclusive Condition Builder\n *\n * Transforms parsed style entries into exclusive conditions.\n * Each entry's condition is ANDed with the negation of all higher-priority conditions,\n * ensuring exactly one condition matches at any given time.\n */\n\nimport type { StyleValue } from '../utils/styles';\n\nimport type {\n  ConditionNode} from './conditions';\nimport {\n  and,\n  isCompoundCondition,\n  not,\n  trueCondition,\n} from './conditions';\nimport { simplifyCondition } from './simplify';\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/**\n * Parsed style entry with condition\n */\nexport interface ParsedStyleEntry {\n  styleKey: string; // e.g., 'padding', 'fill'\n  stateKey: string; // Original key: '', 'compact', '@media(w < 768px)'\n  value: StyleValue; // The style value (before handler processing)\n  condition: ConditionNode; // Parsed condition tree\n  priority: number; // Order in original object (higher = higher priority)\n}\n\n/**\n * Style entry with exclusive condition\n */\nexport interface ExclusiveStyleEntry extends ParsedStyleEntry {\n  exclusiveCondition: ConditionNode; // condition & !higherPriorityConditions\n}\n\n// ============================================================================\n// Main Function\n// ============================================================================\n\n/**\n * Build exclusive conditions for a list of parsed style entries.\n *\n * The entries should be ordered by priority (highest priority first).\n *\n * For each entry, we compute:\n *   exclusiveCondition = condition & !prior[0] & !prior[1] & ...\n *\n * This ensures exactly one condition matches at any time.\n *\n * Example:\n *   Input (ordered highest to lowest priority):\n *     A: value1 (priority 2)\n *     B: value2 (priority 1)\n *     C: value3 (priority 0)\n *\n *   Output:\n *     A: A\n *     B: B & !A\n *     C: C & !A & !B\n *\n * @param entries Parsed style entries ordered by priority (highest first)\n * @returns Entries with exclusive conditions, filtered to remove impossible ones\n */\nexport function buildExclusiveConditions(\n  entries: ParsedStyleEntry[],\n): ExclusiveStyleEntry[] {\n  const result: ExclusiveStyleEntry[] = [];\n  const priorConditions: ConditionNode[] = [];\n\n  for (const entry of entries) {\n    // Build: condition & !prior[0] & !prior[1] & ...\n    let exclusive: ConditionNode = entry.condition;\n\n    for (const prior of priorConditions) {\n      // Skip negating \"always true\" (default state) - it would become \"always false\"\n      if (prior.kind !== 'true') {\n        exclusive = and(exclusive, not(prior));\n      }\n    }\n\n    // Simplify the exclusive condition\n    const simplified = simplifyCondition(exclusive);\n\n    // Skip impossible conditions (simplified to FALSE)\n    if (simplified.kind === 'false') {\n      continue;\n    }\n\n    result.push({\n      ...entry,\n      exclusiveCondition: simplified,\n    });\n\n    // Add non-default conditions to prior list for subsequent entries\n    if (entry.condition.kind !== 'true') {\n      priorConditions.push(entry.condition);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Parse style entries from a value mapping object.\n *\n * @param styleKey The style key (e.g., 'padding')\n * @param valueMap The value mapping { '': '2x', 'compact': '1x', '@media(w < 768px)': '0.5x' }\n * @param parseCondition Function to parse state keys into conditions\n * @returns Parsed entries ordered by priority (highest first)\n */\nexport function parseStyleEntries(\n  styleKey: string,\n  valueMap: Record<string, StyleValue>,\n  parseCondition: (stateKey: string) => ConditionNode,\n): ParsedStyleEntry[] {\n  const entries: ParsedStyleEntry[] = [];\n  const keys = Object.keys(valueMap);\n\n  keys.forEach((stateKey, index) => {\n    const value = valueMap[stateKey];\n    const condition =\n      stateKey === '' ? trueCondition() : parseCondition(stateKey);\n\n    entries.push({\n      styleKey,\n      stateKey,\n      value,\n      condition,\n      priority: index,\n    });\n  });\n\n  // Reverse so highest priority (last in object) comes first for exclusive building\n  // buildExclusiveConditions expects highest priority first\n  entries.reverse();\n\n  return entries;\n}\n\n/**\n * Check if a value is a style value mapping (object with state keys)\n */\nexport function isValueMapping(\n  value: StyleValue | Record<string, StyleValue>,\n): value is Record<string, StyleValue> {\n  return (\n    value !== null &&\n    typeof value === 'object' &&\n    !Array.isArray(value) &&\n    !(value instanceof Date)\n  );\n}\n\n// ============================================================================\n// OR Expansion\n// ============================================================================\n\n/**\n * Expand OR conditions in parsed entries into multiple exclusive entries.\n *\n * For an entry with condition `A | B | C`, this creates 3 entries:\n *   - condition: A\n *   - condition: B & !A\n *   - condition: C & !A & !B\n *\n * This ensures OR branches are mutually exclusive BEFORE the main\n * exclusive condition building pass.\n *\n * @param entries Parsed entries (may contain OR conditions)\n * @returns Expanded entries with OR branches made exclusive\n */\nexport function expandOrConditions(\n  entries: ParsedStyleEntry[],\n): ParsedStyleEntry[] {\n  const result: ParsedStyleEntry[] = [];\n\n  for (const entry of entries) {\n    const expanded = expandSingleEntry(entry);\n    result.push(...expanded);\n  }\n\n  return result;\n}\n\n/**\n * Expand a single entry's OR condition into multiple exclusive entries\n */\nfunction expandSingleEntry(entry: ParsedStyleEntry): ParsedStyleEntry[] {\n  const orBranches = collectOrBranches(entry.condition);\n\n  // If no OR (single branch), return as-is\n  if (orBranches.length <= 1) {\n    return [entry];\n  }\n\n  // Make each OR branch exclusive from prior branches\n  const result: ParsedStyleEntry[] = [];\n  const priorBranches: ConditionNode[] = [];\n\n  for (let i = 0; i < orBranches.length; i++) {\n    const branch = orBranches[i];\n\n    // Build: branch & !prior[0] & !prior[1] & ...\n    let exclusiveBranch: ConditionNode = branch;\n    for (const prior of priorBranches) {\n      exclusiveBranch = and(exclusiveBranch, not(prior));\n    }\n\n    // Simplify to detect impossible combinations\n    const simplified = simplifyCondition(exclusiveBranch);\n\n    // Skip impossible branches\n    if (simplified.kind === 'false') {\n      priorBranches.push(branch);\n      continue;\n    }\n\n    result.push({\n      ...entry,\n      stateKey: `${entry.stateKey}[${i}]`, // Mark as expanded branch\n      condition: simplified,\n      // Keep same priority - all branches from same entry have same priority\n    });\n\n    priorBranches.push(branch);\n  }\n\n  return result;\n}\n\n/**\n * Collect top-level OR branches from a condition.\n *\n * For `A | B | C`, returns [A, B, C]\n * For `A & B`, returns [A & B] (single branch)\n * For `A | (B & C)`, returns [A, B & C]\n */\nfunction collectOrBranches(condition: ConditionNode): ConditionNode[] {\n  if (condition.kind === 'true' || condition.kind === 'false') {\n    return [condition];\n  }\n\n  if (isCompoundCondition(condition) && condition.operator === 'OR') {\n    // Flatten nested ORs\n    const branches: ConditionNode[] = [];\n    for (const child of condition.children) {\n      branches.push(...collectOrBranches(child));\n    }\n    return branches;\n  }\n\n  // Not an OR - return as single branch\n  return [condition];\n}\n\n// ============================================================================\n// Post-Build OR Expansion (for De Morgan ORs)\n// ============================================================================\n\n/**\n * Expand OR conditions in exclusive entries AFTER buildExclusiveConditions.\n *\n * This handles ORs that arise from De Morgan expansion during negation:\n *   !(A & B) = !A | !B\n *\n * These ORs need to be made exclusive to avoid overlapping CSS rules:\n *   !A | !B  →  !A | (A & !B)\n *\n * This is logically equivalent but ensures each branch has proper context.\n *\n * Example:\n *   Input: { \"\": V1, \"@supports(...) & :has()\": V2 }\n *   V2's exclusive = @supports & :has\n *   V1's exclusive = !(@supports & :has) = !@supports | !:has\n *\n *   Without this fix: V1 gets two rules:\n *     - @supports (not ...) → V1  ✓\n *     - :not(:has()) → V1  ✗ (missing @supports context!)\n *\n *   With this fix: V1 gets two exclusive rules:\n *     - @supports (not ...) → V1  ✓\n *     - @supports (...) { :not(:has()) } → V1  ✓ (proper context!)\n */\nexport function expandExclusiveOrs(\n  entries: ExclusiveStyleEntry[],\n): ExclusiveStyleEntry[] {\n  const result: ExclusiveStyleEntry[] = [];\n\n  for (const entry of entries) {\n    const expanded = expandExclusiveConditionOrs(entry);\n    result.push(...expanded);\n  }\n\n  return result;\n}\n\n/**\n * Check if a condition involves at-rules (media, container, supports, starting)\n */\nfunction hasAtRuleContext(node: ConditionNode): boolean {\n  if (node.kind === 'true' || node.kind === 'false') {\n    return false;\n  }\n\n  if (node.kind === 'state') {\n    // These condition types generate at-rules\n    return (\n      node.type === 'media' ||\n      node.type === 'container' ||\n      node.type === 'supports' ||\n      node.type === 'starting'\n    );\n  }\n\n  if (node.kind === 'compound') {\n    return node.children.some(hasAtRuleContext);\n  }\n\n  return false;\n}\n\n/**\n * Sort OR branches to prioritize at-rule conditions first.\n *\n * This is critical for correct CSS generation. For `!A | !B` where A is at-rule\n * and B is modifier, we want:\n *   - Branch 0: !A (at-rule negation - covers \"no @supports/media\" case)\n *   - Branch 1: A & !B (modifier negation with at-rule context)\n *\n * If we process in wrong order (!B first), we'd get:\n *   - Branch 0: !B (modifier negation WITHOUT at-rule context - WRONG!)\n *   - Branch 1: B & !A (at-rule negation with modifier - incomplete coverage)\n */\nfunction sortOrBranchesForExpansion(\n  branches: ConditionNode[],\n): ConditionNode[] {\n  return [...branches].sort((a, b) => {\n    const aHasAtRule = hasAtRuleContext(a);\n    const bHasAtRule = hasAtRuleContext(b);\n\n    // At-rule conditions come first\n    if (aHasAtRule && !bHasAtRule) return -1;\n    if (!aHasAtRule && bHasAtRule) return 1;\n\n    // Same type - keep original order (stable sort)\n    return 0;\n  });\n}\n\n/**\n * Expand ORs in a single entry's exclusive condition\n */\nfunction expandExclusiveConditionOrs(\n  entry: ExclusiveStyleEntry,\n): ExclusiveStyleEntry[] {\n  let orBranches = collectOrBranches(entry.exclusiveCondition);\n\n  // If no OR (single branch), return as-is\n  if (orBranches.length <= 1) {\n    return [entry];\n  }\n\n  // Sort branches so at-rule conditions come first\n  // This ensures proper context inheritance during expansion\n  orBranches = sortOrBranchesForExpansion(orBranches);\n\n  // Make each OR branch exclusive from prior branches\n  const result: ExclusiveStyleEntry[] = [];\n  const priorBranches: ConditionNode[] = [];\n\n  for (let i = 0; i < orBranches.length; i++) {\n    const branch = orBranches[i];\n\n    // Build: branch & !prior[0] & !prior[1] & ...\n    // This transforms: !A | !B  →  !A, !B & !!A  =  !A, (A & !B)\n    let exclusiveBranch: ConditionNode = branch;\n    for (const prior of priorBranches) {\n      exclusiveBranch = and(exclusiveBranch, not(prior));\n    }\n\n    // Simplify to detect impossible combinations and clean up double negations\n    const simplified = simplifyCondition(exclusiveBranch);\n\n    // Skip impossible branches\n    if (simplified.kind === 'false') {\n      priorBranches.push(branch);\n      continue;\n    }\n\n    result.push({\n      ...entry,\n      stateKey: `${entry.stateKey}[or:${i}]`, // Mark as expanded OR branch\n      exclusiveCondition: simplified,\n    });\n\n    priorBranches.push(branch);\n  }\n\n  return result;\n}\n"],"mappings":"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"}

package/dist/pipeline/index.mjs

@@ -1,635 +0,0 @@
-import { Lru } from "../parser/lru.mjs";
-import { stringifyStyles } from "../utils/styles.mjs";
-import { createStyle } from "../styles/createStyle.mjs";
-import { STYLE_HANDLER_MAP } from "../styles/index.mjs";
-import { createStateParserContext, extractLocalPredefinedStates } from "../states/index.mjs";
-import { and, falseCondition, not, or, trueCondition } from "./conditions.mjs";
-import { simplifyCondition } from "./simplify.mjs";
-import { buildExclusiveConditions, expandExclusiveOrs, expandOrConditions, isValueMapping, parseStyleEntries } from "./exclusive.mjs";
-import { buildAtRulesFromVariant, conditionToCSS, modifierToCSS, pseudoToCSS, rootConditionsToCSS } from "./materialize.mjs";
-import { parseStateKey } from "./parseStateKey.mjs";
-
-//#region src/pipeline/index.ts
-/**
-* Tasty Style Rendering Pipeline
-*
-* This is the main entrypoint for the new pipeline implementation.
-* It implements the complete flow from style objects to CSS rules.
-*
-* Pipeline stages:
-* 1. PARSE CONDITIONS - Parse state keys into ConditionNode trees
-* 2. BUILD EXCLUSIVE CONDITIONS - AND with negation of higher-priority conditions
-* 3. SIMPLIFY CONDITIONS - Apply boolean algebra, detect contradictions
-* 4. GROUP BY HANDLER - Collect styles per handler, compute combinations
-* 5. COMPUTE CSS VALUES - Call handlers to get CSS declarations
-* 6. MERGE BY VALUE - Merge rules with identical CSS output
-* 7. MATERIALIZE CSS - Convert conditions to CSS selectors + at-rules
-*/
-const pipelineCache = new Lru(5e3);
-function runPipeline(styles, parserContext) {
-	const allRules = [];
-	processStyles(styles, "", parserContext, allRules);
-	const seen = /* @__PURE__ */ new Set();
-	return allRules.filter((rule) => {
-		const key = `${rule.selector}|${rule.declarations}|${JSON.stringify(rule.atRules || [])}|${rule.rootPrefix || ""}`;
-		if (seen.has(key)) return false;
-		seen.add(key);
-		return true;
-	});
-}
-/**
-* Process styles at a given nesting level
-*/
-function processStyles(styles, selectorSuffix, parserContext, allRules) {
-	const keys = Object.keys(styles);
-	const selectorKeys = keys.filter((key) => isSelector(key));
-	const styleKeys = keys.filter((key) => !isSelector(key) && !key.startsWith("@"));
-	for (const key of selectorKeys) {
-		const nestedStyles = styles[key];
-		if (!nestedStyles || typeof nestedStyles !== "object") continue;
-		const suffixes = getAllSelectors(key, nestedStyles);
-		if (!suffixes) continue;
-		const { $: _$, ...cleanedStyles } = nestedStyles;
-		const subLocalStates = extractLocalPredefinedStates(cleanedStyles);
-		const hasSubStates = Object.keys(subLocalStates).length > 0;
-		const subContext = {
-			...parserContext,
-			isSubElement: true,
-			localPredefinedStates: hasSubStates ? {
-				...parserContext.localPredefinedStates,
-				...subLocalStates
-			} : parserContext.localPredefinedStates
-		};
-		for (const suffix of suffixes) processStyles(cleanedStyles, selectorSuffix + suffix, subContext, allRules);
-	}
-	const handlerQueue = buildHandlerQueue(styleKeys, styles);
-	for (const { handler, styleMap } of handlerQueue) {
-		const lookupStyles = handler.__lookupStyles;
-		const exclusiveByStyle = /* @__PURE__ */ new Map();
-		for (const styleName of lookupStyles) {
-			const value = styleMap[styleName];
-			if (value === void 0) continue;
-			if (isValueMapping(value)) {
-				const fullyExpanded = expandExclusiveOrs(buildExclusiveConditions(expandOrConditions(parseStyleEntries(styleName, value, (stateKey) => parseStateKey(stateKey, { context: parserContext })))));
-				exclusiveByStyle.set(styleName, fullyExpanded);
-			} else exclusiveByStyle.set(styleName, [{
-				styleKey: styleName,
-				stateKey: "",
-				value,
-				condition: trueCondition(),
-				priority: 0,
-				exclusiveCondition: trueCondition()
-			}]);
-		}
-		const stateSnapshots = computeStateCombinations(exclusiveByStyle, lookupStyles);
-		const computedRules = [];
-		for (const snapshot of stateSnapshots) {
-			const result = handler(snapshot.values);
-			if (!result) continue;
-			const results = Array.isArray(result) ? result : [result];
-			for (const r of results) {
-				if (!r || typeof r !== "object") continue;
-				const { $, ...styleProps } = r;
-				const declarations = {};
-				for (const [prop, val] of Object.entries(styleProps)) if (val != null && val !== "") declarations[prop] = String(val);
-				if (Object.keys(declarations).length === 0) continue;
-				const suffixes = $ ? (Array.isArray($) ? $ : [$]).map((s) => selectorSuffix + normalizeSelectorSuffix(String(s))) : [selectorSuffix];
-				for (const suffix of suffixes) computedRules.push({
-					condition: snapshot.condition,
-					declarations,
-					selectorSuffix: suffix
-				});
-			}
-		}
-		const mergedRules = mergeByValue(computedRules);
-		for (const rule of mergedRules) {
-			const cssRules = materializeComputedRule(rule);
-			allRules.push(...cssRules);
-		}
-	}
-}
-/**
-* Check if a key is a CSS selector
-*/
-function isSelector(key) {
-	return key.startsWith("&") || key.startsWith(".") || /^[A-Z]/.test(key);
-}
-/**
-* Get all selector suffixes for a sub-element key.
-*
-* Handles three types of selector keys:
-* - `&` prefix: Raw selector suffix (e.g., `&:hover` → `:hover`)
-* - `.` prefix: Class selector (e.g., `.active` → ` .active`)
-* - Uppercase: Sub-element with optional `$` affix pattern
-*
-* @param key - The sub-element key (e.g., 'Label', '&:hover', '.active')
-* @param styles - The styles object, may contain `$` property for selector affix
-* @returns Array of selector suffixes, or null if invalid (with console warning)
-*
-* @example
-* getAllSelectors('Label', {})
-* // → [' [data-element="Label"]']
-*
-* getAllSelectors('Cell', { $: '>, >Body>' })
-* // → ['> [data-element="Cell"]', ' [data-element="Body"] > [data-element="Cell"]']
-*/
-function getAllSelectors(key, styles) {
-	if (key.startsWith("&")) return [key.slice(1)];
-	if (key.startsWith(".")) return [` ${key}`];
-	if (/^[A-Z]/.test(key)) {
-		const affix = styles?.$;
-		if (affix !== void 0) {
-			const result = processAffix(String(affix), key);
-			if (!result.valid) {
-				console.warn(`[Tasty] ${result.reason}`);
-				return null;
-			}
-			return result.selectors;
-		}
-		return [` [data-element="${key}"]`];
-	}
-	return null;
-}
-/**
-* Process selector affix pattern and return selector(s)
-*
-* Supports:
-* - Direct child: '>'
-* - Chained elements: '>Body>Row>'
-* - HTML tags: 'a', '>ul>li', 'button:hover'
-* - Pseudo-elements on root: '::before'
-* - Pseudo on sub-element: '@::before', '>@:hover'
-* - Classes: '.active', '>@.active'
-* - Multiple selectors: '>, >Body>'
-* - Sibling combinators (after element): '>Item+', '>Item~'
-*/
-function processAffix(affix, key) {
-	const trimmed = affix.trim();
-	if (!trimmed) return {
-		valid: true,
-		selectors: [` [data-element="${key}"]`]
-	};
-	const patterns = trimmed.split(",").map((p) => p.trim());
-	const selectors = [];
-	for (const pattern of patterns) {
-		const validation = validatePattern(pattern);
-		if (!validation.valid) return validation;
-		const selector = processSinglePattern(pattern, key);
-		selectors.push(selector);
-	}
-	return {
-		valid: true,
-		selectors
-	};
-}
-/**
-* Recognized token patterns for selector affix validation.
-*
-* These patterns are used to tokenize and validate `$` affix strings.
-* Order matters: more specific patterns must come first to avoid
-* partial matches (e.g., `::before` must match before `:` alone).
-*
-* Unrecognized tokens (like `#id`, `*`, or numbers) will cause validation to fail.
-*/
-const VALID_TOKEN_PATTERNS = [
-	/^[>+~]/,
-	/^[A-Z][a-zA-Z0-9]*/,
-	/^@/,
-	/^::?[a-z][a-z0-9-]*(?:\([^)]*\))?/,
-	/^\.[a-zA-Z_-][a-zA-Z0-9_-]*/,
-	/^\[[^\]]+\]/,
-	/^[a-z][a-z0-9-]*/,
-	/^\s+/,
-	/^&/
-];
-/**
-* Scan a pattern for unrecognized tokens.
-*
-* Iterates through the pattern, consuming recognized tokens until
-* either the pattern is fully consumed (valid) or an unrecognized
-* character sequence is found (invalid).
-*
-* @param pattern - The selector pattern to validate
-* @returns The first unrecognized token found, or null if all tokens are valid
-*
-* @example
-* findUnrecognizedTokens('>Body>Row>') // → null (valid)
-* findUnrecognizedTokens('123')         // → '123' (invalid)
-* findUnrecognizedTokens('#myId')       // → '#' (invalid)
-*/
-function findUnrecognizedTokens(pattern) {
-	let remaining = pattern;
-	while (remaining.length > 0) {
-		let matched = false;
-		for (const regex of VALID_TOKEN_PATTERNS) {
-			const match = remaining.match(regex);
-			if (match) {
-				remaining = remaining.slice(match[0].length);
-				matched = true;
-				break;
-			}
-		}
-		if (!matched) {
-			const unrecognized = remaining.match(/^[^\s>+~@.:[\]A-Z]+/);
-			return unrecognized ? unrecognized[0] : remaining[0];
-		}
-	}
-	return null;
-}
-/**
-* Validate a selector pattern for structural correctness.
-*
-* Checks for:
-* 1. Out-of-scope selectors: Patterns starting with `+` or `~` target siblings
-*    of the root element, which is outside the component's DOM scope.
-* 2. Consecutive combinators: Patterns like `>>` or `>+` are malformed CSS.
-* 3. Unrecognized tokens: Characters/sequences not matching valid CSS selectors.
-*
-* @param pattern - A single selector pattern (already split by comma)
-* @returns AffixResult indicating validity and error reason if invalid
-*
-* @example
-* validatePattern('>Body>Row>')  // → { valid: true, selectors: [] }
-* validatePattern('+')           // → { valid: false, reason: '...outside root scope...' }
-* validatePattern('>>')          // → { valid: false, reason: '...consecutive combinators...' }
-*/
-function validatePattern(pattern) {
-	const trimmed = pattern.trim();
-	if (/^[+~]/.test(trimmed)) return {
-		valid: false,
-		reason: `Selector affix "${pattern}" targets elements outside the root scope. Sibling selectors (+, ~) must be preceded by an element inside the root. Use ">Element+" or ">Element~" instead.`
-	};
-	if (/[>+~]{2,}/.test(trimmed.replace(/\s+/g, ""))) return {
-		valid: false,
-		reason: `Selector affix "${pattern}" contains consecutive combinators.`
-	};
-	const unrecognized = findUnrecognizedTokens(trimmed);
-	if (unrecognized) return {
-		valid: false,
-		reason: `Selector affix "${pattern}" contains unrecognized token "${unrecognized}". Valid tokens: combinators (>, +, ~), element names (Uppercase), @ placeholder, pseudo (:hover, ::before), class (.name), attribute ([attr]).`
-	};
-	return {
-		valid: true,
-		selectors: []
-	};
-}
-/**
-* Process a single selector pattern into a CSS selector suffix.
-*
-* This is the main transformation function that converts a `$` affix pattern
-* into a valid CSS selector suffix. It handles:
-*
-* 1. `@` placeholder replacement with `[data-element="key"]`
-* 2. Key injection based on pattern ending (see `shouldInjectKey`)
-* 3. Proper spacing for descendant vs direct child selectors
-*
-* @param pattern - A single validated selector pattern
-* @param key - The sub-element key to inject (e.g., 'Label', 'Cell')
-* @returns CSS selector suffix ready to append to the root selector
-*
-* @example
-* processSinglePattern('>', 'Row')
-* // → '> [data-element="Row"]'
-*
-* processSinglePattern('>Body>Row>', 'Cell')
-* // → '> [data-element="Body"] > [data-element="Row"] > [data-element="Cell"]'
-*
-* processSinglePattern('::before', 'Before')
-* // → '::before' (no key injection for pseudo on root)
-*
-* processSinglePattern('>@:hover', 'Item')
-* // → '> [data-element="Item"]:hover'
-*/
-function processSinglePattern(pattern, key) {
-	const normalized = pattern.replace(/^&/, "").trim();
-	if (!normalized) return ` [data-element="${key}"]`;
-	const startsWithPseudo = /^::?[a-z]/.test(normalized);
-	let result = transformPattern(normalized);
-	if (result.includes("@")) {
-		result = result.replace(/@ (?=[.:])/g, "@");
-		result = result.replace(/@/g, `[data-element="${key}"]`);
-		if (!startsWithPseudo && !result.startsWith(" ")) result = " " + result;
-		return result;
-	}
-	if (shouldInjectKey(normalized)) result = result + ` [data-element="${key}"]`;
-	if (!startsWithPseudo && !result.startsWith(" ")) result = " " + result;
-	return result;
-}
-/**
-* Transform a selector pattern by converting element names and normalizing spacing.
-*
-* This is a character-by-character tokenizer that:
-* - Converts uppercase names to `[data-element="Name"]` selectors
-* - Adds proper spacing around combinators (>, +, ~)
-* - Preserves lowercase tags, classes, pseudos, and attributes as-is
-* - Keeps @ placeholder for later replacement
-*
-* The tokenizer handles these token types in order:
-* 1. Whitespace (skipped)
-* 2. Combinators: >, +, ~ (add surrounding spaces)
-* 3. Uppercase names: Body, Row (convert to [data-element="..."])
-* 4. @ placeholder (keep for later replacement)
-* 5. Pseudo: :hover, ::before (attach to previous token)
-* 6. Tags: a, div, button (keep as-is with spacing)
-* 7. Classes: .active (attach to previous element/tag/placeholder)
-* 8. Attributes: [type="text"] (keep as-is)
-*
-* @param pattern - The raw selector pattern to transform
-* @returns Transformed pattern with proper CSS selector syntax
-*
-* @example
-* transformPattern('>Body>Row>')
-* // → '> [data-element="Body"] > [data-element="Row"] >'
-*
-* transformPattern('button.primary:hover')
-* // → 'button.primary:hover'
-*/
-function transformPattern(pattern) {
-	let result = "";
-	let i = 0;
-	while (i < pattern.length) {
-		const char = pattern[i];
-		if (/\s/.test(char)) {
-			i++;
-			continue;
-		}
-		if (/[>+~]/.test(char)) {
-			if (result && !result.endsWith(" ")) result += " ";
-			result += char;
-			i++;
-			continue;
-		}
-		if (/[A-Z]/.test(char)) {
-			let name = "";
-			while (i < pattern.length && /[a-zA-Z0-9]/.test(pattern[i])) {
-				name += pattern[i];
-				i++;
-			}
-			if (result && !result.endsWith(" ")) result += " ";
-			result += `[data-element="${name}"]`;
-			continue;
-		}
-		if (char === "@") {
-			if (result && !result.endsWith(" ")) result += " ";
-			result += "@";
-			i++;
-			continue;
-		}
-		if (char === ":") {
-			let pseudo = "";
-			while (i < pattern.length && !/[\s>+~,@]/.test(pattern[i]) && !/[A-Z]/.test(pattern[i])) {
-				pseudo += pattern[i];
-				i++;
-			}
-			result += pseudo;
-			continue;
-		}
-		if (/[a-z]/.test(char)) {
-			let tag = "";
-			while (i < pattern.length && /[a-z0-9-]/.test(pattern[i])) {
-				tag += pattern[i];
-				i++;
-			}
-			if (result && !result.endsWith(" ")) result += " ";
-			result += tag;
-			continue;
-		}
-		if (char === ".") {
-			const lastNonSpace = result.replace(/\s+$/, "").slice(-1);
-			const attachToLast = lastNonSpace === "]" || lastNonSpace === "@" || /[a-zA-Z0-9-]/.test(lastNonSpace);
-			if (result && !attachToLast && !result.endsWith(" ")) result += " ";
-			let cls = ".";
-			i++;
-			while (i < pattern.length && /[a-zA-Z0-9_-]/.test(pattern[i])) {
-				cls += pattern[i];
-				i++;
-			}
-			result += cls;
-			continue;
-		}
-		if (char === "[") {
-			const lastNonSpace = result.replace(/\s+$/, "").slice(-1);
-			const attachToLast = lastNonSpace === "]" || lastNonSpace === "@" || /[a-zA-Z0-9-]/.test(lastNonSpace);
-			if (result && !attachToLast && !result.endsWith(" ")) result += " ";
-			let attr = "";
-			let depth = 0;
-			while (i < pattern.length) {
-				attr += pattern[i];
-				if (pattern[i] === "[") depth++;
-				if (pattern[i] === "]") depth--;
-				i++;
-				if (depth === 0) break;
-			}
-			result += attr;
-			continue;
-		}
-		result += char;
-		i++;
-	}
-	return result;
-}
-/**
-* Determine if the sub-element key should be auto-injected based on pattern ending.
-*
-* Key injection rules (when no @ placeholder is present):
-*
-* | Pattern Ending | Inject Key? | Example | Result |
-* |----------------|-------------|---------|--------|
-* | Combinator (>, +, ~) | Yes | `'>Body>'` | `> [data-element="Body"] > [el]` |
-* | Uppercase element | Yes | `'>Body>Row'` | `> [el1] > [el2] [key]` |
-* | Lowercase tag | Yes | `'>ul>li'` | `> ul > li [key]` |
-* | Pseudo (:hover, ::before) | No | `'::before'` | `::before` |
-* | Class (.active) | No | `'.active'` | `.active` |
-* | Attribute ([type]) | No | `'[type="text"]'` | `[type="text"]` |
-*
-* @param pattern - The normalized pattern (after stripping &)
-* @returns true if key should be injected, false otherwise
-*
-* @example
-* shouldInjectKey('>')           // → true (trailing combinator)
-* shouldInjectKey('>Body>Row')   // → true (ends with element)
-* shouldInjectKey('>ul>li')      // → true (ends with tag)
-* shouldInjectKey('::before')    // → false (ends with pseudo)
-* shouldInjectKey('.active')     // → false (ends with class)
-* shouldInjectKey('a:hover')     // → false (ends with pseudo)
-* shouldInjectKey('button.primary') // → false (ends with class)
-*/
-function shouldInjectKey(pattern) {
-	const trimmed = pattern.trim();
-	if (/[>+~]$/.test(trimmed)) return true;
-	if (/(?:^|[\s>+~\]:])[A-Z][a-zA-Z0-9]*$/.test(trimmed)) return true;
-	if (/(?<![:.])(?:^|[\s>+~])[a-z][a-z0-9-]*$/.test(trimmed)) return true;
-	return false;
-}
-/**
-* Normalize selector suffix from $ property
-*/
-function normalizeSelectorSuffix(suffix) {
-	if (!suffix) return "";
-	return suffix.startsWith("&") ? suffix.slice(1) : suffix;
-}
-/**
-* Build handler queue from style keys
-*/
-function buildHandlerQueue(styleKeys, styles) {
-	const queue = [];
-	const seenHandlers = /* @__PURE__ */ new Set();
-	for (const styleName of styleKeys) {
-		let handlers = STYLE_HANDLER_MAP[styleName];
-		if (!handlers) handlers = STYLE_HANDLER_MAP[styleName] = [createStyle(styleName)];
-		for (const handler of handlers) {
-			if (seenHandlers.has(handler)) continue;
-			seenHandlers.add(handler);
-			const lookupStyles = handler.__lookupStyles;
-			const styleMap = {};
-			for (const name of lookupStyles) {
-				const val = styles[name];
-				if (val !== void 0) styleMap[name] = val;
-			}
-			queue.push({
-				handler,
-				styleMap
-			});
-		}
-	}
-	return queue;
-}
-/**
-* Compute all valid state combinations for a handler's lookup styles
-*/
-function computeStateCombinations(exclusiveByStyle, lookupStyles) {
-	const combinations = cartesianProduct(lookupStyles.map((style) => exclusiveByStyle.get(style) || []));
-	const snapshots = [];
-	for (const combo of combinations) {
-		const simplified = simplifyCondition(and(...combo.map((e) => e.exclusiveCondition)));
-		if (simplified.kind === "false") continue;
-		const values = {};
-		for (const entry of combo) values[entry.styleKey] = entry.value;
-		snapshots.push({
-			condition: simplified,
-			values
-		});
-	}
-	return snapshots;
-}
-/**
-* Cartesian product of arrays
-*/
-function cartesianProduct(arrays) {
-	if (arrays.length === 0) return [[]];
-	const nonEmpty = arrays.filter((a) => a.length > 0);
-	if (nonEmpty.length === 0) return [[]];
-	return nonEmpty.reduce((acc, arr) => acc.flatMap((combo) => arr.map((item) => [...combo, item])), [[]]);
-}
-/**
-* Merge rules with identical CSS output
-*/
-function mergeByValue(rules) {
-	const groups = /* @__PURE__ */ new Map();
-	for (const rule of rules) {
-		const key = `${rule.selectorSuffix}|${JSON.stringify(rule.declarations)}`;
-		if (!groups.has(key)) groups.set(key, []);
-		groups.get(key).push(rule);
-	}
-	const merged = [];
-	for (const [, groupRules] of groups) if (groupRules.length === 1) merged.push(groupRules[0]);
-	else {
-		const mergedCondition = simplifyCondition(or(...groupRules.map((r) => r.condition)));
-		merged.push({
-			condition: mergedCondition,
-			declarations: groupRules[0].declarations,
-			selectorSuffix: groupRules[0].selectorSuffix
-		});
-	}
-	return merged;
-}
-/**
-* Build selector fragment from a variant (without className prefix)
-*/
-function buildSelectorFromVariant(variant, selectorSuffix) {
-	let selector = "";
-	for (const mod of variant.modifierConditions) selector += modifierToCSS(mod);
-	for (const pseudo of variant.pseudoConditions) selector += pseudoToCSS(pseudo);
-	selector += selectorSuffix;
-	for (const own of variant.ownConditions) if ("attribute" in own) selector += modifierToCSS(own);
-	else selector += pseudoToCSS(own);
-	return selector;
-}
-/**
-* Materialize a computed rule to final CSS format
-*
-* Returns an array because OR conditions may generate multiple CSS rules
-* (when different branches have different at-rules)
-*/
-function materializeComputedRule(rule) {
-	const components = conditionToCSS(rule.condition);
-	if (components.isImpossible || components.variants.length === 0) return [];
-	const declarations = Object.entries(rule.declarations).map(([prop, value]) => `${prop}: ${value};`).join(" ");
-	const getRootPrefixKey = (variant) => {
-		return variant.rootConditions.map((r) => r.negated ? `!${r.selector}` : r.selector).sort().join("|");
-	};
-	const byAtRules = /* @__PURE__ */ new Map();
-	for (const variant of components.variants) {
-		const atRules = buildAtRulesFromVariant(variant);
-		const key = atRules.sort().join("|||") + "###" + getRootPrefixKey(variant);
-		const group = byAtRules.get(key);
-		if (group) group.variants.push(variant);
-		else byAtRules.set(key, {
-			variants: [variant],
-			atRules,
-			rootPrefix: rootConditionsToCSS(variant.rootConditions)
-		});
-	}
-	const rules = [];
-	for (const [, group] of byAtRules) {
-		const selectorFragments = group.variants.map((v) => buildSelectorFromVariant(v, rule.selectorSuffix));
-		const cssRule = {
-			selector: selectorFragments.length === 1 ? selectorFragments[0] : selectorFragments,
-			declarations
-		};
-		if (group.atRules.length > 0) cssRule.atRules = group.atRules;
-		if (group.rootPrefix) cssRule.rootPrefix = group.rootPrefix;
-		rules.push(cssRule);
-	}
-	return rules;
-}
-function renderStyles(styles, classNameOrSelector, options) {
-	const directSelector = !!classNameOrSelector;
-	if (!styles) return directSelector ? [] : { rules: [] };
-	const cacheKey = stringifyStyles(styles);
-	let rules = pipelineCache.get(cacheKey);
-	if (!rules) {
-		rules = runPipeline(styles, createStateParserContext(styles));
-		pipelineCache.set(cacheKey, rules);
-	}
-	if (directSelector) {
-		const shouldDouble = options?.doubleSelector ?? false;
-		return rules.map((rule) => {
-			const result = {
-				selector: (Array.isArray(rule.selector) ? rule.selector : rule.selector ? [rule.selector] : [""]).map((part) => {
-					let sel = part ? `${classNameOrSelector}${part}` : classNameOrSelector;
-					if (shouldDouble && sel.startsWith(".")) {
-						const classMatch = sel.match(/^\.[a-zA-Z_-][a-zA-Z0-9_-]*/);
-						if (classMatch) sel = classMatch[0] + sel;
-					}
-					if (rule.rootPrefix) sel = `${rule.rootPrefix} ${sel}`;
-					return sel;
-				}).join(", "),
-				declarations: rule.declarations
-			};
-			if (rule.atRules && rule.atRules.length > 0) result.atRules = rule.atRules;
-			return result;
-		});
-	}
-	return { rules: rules.map((r) => ({
-		selector: Array.isArray(r.selector) ? r.selector.join("|||") : r.selector,
-		declarations: r.declarations,
-		atRules: r.atRules,
-		needsClassName: true,
-		rootPrefix: r.rootPrefix
-	})) };
-}
-
-//#endregion
-export { isSelector, renderStyles };
-//# sourceMappingURL=index.mjs.map