{"version":3,"file":"index.mjs","sources":["../src/utils.ts","../src/properties.ts","../src/rules.ts","../src/selectors.ts"],"sourcesContent":["/**\n * A type-safe wrapper around Object.keys that preserves the object's key types.\n *\n * @returns a typed array of keys of the object\n */\nexport const unsafeKeys = Object.keys as (object: T) => Array;\n\n/**\n * A generator function that yields keys of an object that pass an optional validation function.\n *\n * Iterates through all own properties of the given object and yields\n * each key that passes the optional validation function.\n *\n * @param object - The object to iterate over\n * @param valid - Optional validation function that determines which keys to yield\n * @returns A generator of valid keys from the object\n */\nexport function* keys(object: T, valid?: (key: keyof T) => boolean): Generator {\n for (const key of unsafeKeys(object)) {\n if (typeof key === 'string' && Object.prototype.hasOwnProperty.call(object, key) && (valid?.(key) ?? true)) {\n yield key as K;\n }\n }\n}\n\n/**\n * Validates if a key-value pair meets default criteria.\n *\n * A key-value pair is considered valid when:\n * - The value is neither null nor undefined\n * - The key doesn't contain spaces\n * - The key doesn't start with an underscore (_)\n *\n * @param key - The key to validate\n * @param value - The value to validate\n * @returns true if the key-value pair is valid, false otherwise\n *\n */\nexport function defaultValidPair(key: K, value: T): boolean {\n return value !== null\n && value !== undefined\n && !key.includes(' ')\n && !key.startsWith('_');\n}\n\n/**\n * A generator function that yields valid key-value pairs from an object.\n *\n * Iterates through all own properties of the given object and yields\n * each key-value pair that passes the validation function.\n *\n * @param object - The object to iterate over\n * @param valid - Optional validation function that determines which key-value pairs to yield\n * @returns A generator of valid key-value pairs from the object\n */\nexport function* pairs(\n object: Record,\n valid?: (k: K, v: T) => boolean,\n): Generator<[K, T]> {\n for (const key of keys(object)) {\n const value = object[key];\n if (valid?.(key, value) ?? defaultValidPair(key, value))\n yield [key, value];\n }\n}\n\n/*\n * Converts a given string to kebab-case.\n *\n * Transforms various string formats (camelCase, PascalCase, snake_case)\n * into a lowercase string with words separated by hyphens.\n * Adds leading hyphen to recognized vendor prefixes.\n *\n * @param s - The input string to convert\n * @returns A kebab-case representation of the input string\n *\n * @example\n * kebabCase('XMLHttpRequest') // returns 'xml-http-request'\n * kebabCase('camelCase') // returns 'camel-case'\n * kebabCase('snake_case') // returns 'snake-case'\n * kebabCase('WebkitTransition') // returns '-webkit-transition'\n */\nexport function kebabCase(s: string): string {\n // Apply standard kebab-case transformations\n const kebabbed = s\n .trim()\n // handle multiple uppercase letters (e.g., XMLHttpRequest -> xml-http-request)\n .replaceAll(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')\n // handle camelCase\n .replaceAll(/([a-z])([A-Z])/g, '$1-$2')\n // handle snakeCase\n .replaceAll(/[\\s_]+/g, '-')\n .toLowerCase();\n\n // Check for vendor prefixes using a regex and add leading hyphen if needed\n if (vendorPrefixPattern.test(kebabbed)) {\n return `-${kebabbed}`;\n }\n\n return kebabbed;\n}\n\nconst vendorPrefixPattern = /^(webkit|moz|ms|o|khtml)-/;\n\n/**\n * Converts a given string to camelCase.\n *\n * Transforms various string formats (kebab-case, PascalCase, snake_case)\n * into a camelCase string. Properly handles vendor prefixes and internal\n * capitalization patterns.\n *\n * @param s - The input string to convert\n * @returns A camelCase representation of the input string\n *\n * @example\n * camelCase('xml-http-request') // returns 'xmlHttpRequest'\n * camelCase('PascalCase') // returns 'pascalCase'\n * camelCase('snake_case') // returns 'snakeCase'\n * camelCase('-webkit-transition') // returns 'webkitTransition'\n * camelCase('BGColor') // returns 'bgColor'\n * camelCase('HTMLElement') // returns 'htmlElement'\n */\nexport function camelCase(s: string): string {\n // Handle empty strings and single delimiters\n if (!s || s === '-' || s === '_') {\n return '';\n }\n\n // Remove leading hyphens (for vendor prefixes) and trim\n let result = s.trim().replace(/^-/, '');\n\n // Handle explicit delimiter-separated words (kebab-case, snake_case, spaces)\n result = result.replaceAll(/[-_\\s]+([\\w])/g, (_, c) => c.toUpperCase());\n\n // Handle internal capitalization patterns like \"BGColor\" -> \"bgColor\"\n // Look for uppercase letters that are preceded by lowercase or are the start\n // of a capital sequence followed by lowercase (like in \"BGColor\" or \"HTMLElement\")\n result = result\n // First handle patterns like \"BGColor\" by preserving the capital letter after\n // a sequence of capitals\n .replaceAll(/([A-Z]+)([A-Z][a-z])/g, (_, g1, g2) => g1.toLowerCase() + g2)\n // Then ensure the first letter is lowercase (handling both PascalCase and\n // cases like \"BG\" at the start)\n .replaceAll(/^[A-Z]+/g, match => match.toLowerCase());\n\n return result;\n}\n","import {\n kebabCase,\n pairs,\n} from './utils';\n\nexport type CSSProperties = Record;\nexport type CSSValue = string | number | boolean | (string | number | boolean)[];\n\n/**\n * Configuration options for CSS properties stringification.\n */\nexport type CSSPropertiesOptions = {\n /** Indentation string, defaults to two spaces. */\n indent?: string\n /** Prefix string added before each line, defaults to empty string. */\n prefix?: string\n /** New line character, defaults to LF. */\n newLine?: string\n /** Whether to format output on a single line, defaults to false. */\n inline?: boolean\n /** Maximum number of properties to format on a single line, defaults to 1. */\n singleLineThreshold?: number\n};\n\n/**\n * Converts a CSSProperties object into a formatted CSS string representation.\n *\n * @param object - The CSSProperties object to stringify.\n * @param options - Configuration options for string formatting.\n * @returns A string representing the CSS properties enclosed in curly braces.\n * @remarks no newLine at the end to aid composition.\n */\nexport function stringifyCSSProperties(\n object: CSSProperties,\n options?: CSSPropertiesOptions,\n): string {\n const {\n indent = ' ',\n prefix = '',\n newLine = '\\n',\n inline = false,\n singleLineThreshold = 1,\n } = options || {};\n\n const lines = formatCSSProperties(object);\n\n // Handle empty blocks with a simple format\n if (lines.length === 0) {\n return '{}';\n }\n\n // Handle inline mode or when property count is below threshold\n if (inline || lines.length <= singleLineThreshold) {\n return `{ ${lines.join('; ')} }`;\n }\n\n // Standard multiline format\n return `{${newLine}${prefix}${indent}${lines.join(`;${newLine}${prefix}${indent}`)}${newLine}${prefix}}`;\n}\n\n/**\n * Formats a CSSProperties object into an array of CSS property strings.\n *\n * @param object - The CSSProperties object to format.\n * @returns An array of strings, where each string is a CSS property in the format \"key: value;\".\n */\nexport function formatCSSProperties(object: CSSProperties): string[] {\n const propertyMap = new Map();\n for (const [key, value] of properties(object)) {\n const kebabKey = kebabCase(key);\n const useComma = !spaceDelimitedProperties.has(kebabKey);\n const formattedValue = formatCSSValue(value, useComma);\n propertyMap.set(kebabKey, formattedValue);\n }\n\n const lines: string[] = [];\n for (const [key, value] of propertyMap) {\n lines.push(`${key}: ${value}`);\n }\n return lines;\n}\n\n/**\n * Formats a CSS value into a string representation.\n *\n * @param value - The CSS value to format, which can be a single value or an array of values.\n * @param useComma - Flag to determine whether array values should be comma-separated (true)\n * or space-separated (false). Defaults to true.\n * @returns A formatted string representation of the CSS value.\n * @remarks\n\n * - For array values, elements are joined with commas or spaces based on the useComma parameter.\n * - The choice between commas and spaces depends on the CSS property being formatted.\n * - Properties like 'font-family' use commas while properties like 'margin' use spaces.\n */\nexport function formatCSSValue(value: CSSValue, useComma = true): string {\n if (Array.isArray(value)) {\n return value.map(v => quoted(v)).join(useComma ? ', ' : ' ');\n }\n return quoted(value);\n}\n\n/**\n * Encloses a CSS value in double quotes if it is a string containing spaces,\n * except for CSS functions which should not be quoted.\n *\n * @param v - The CSS value to process.\n * @returns The processed CSS value as a string.\n * @example\n * quoted('Open Sans') // Returns \"\\\"Open Sans\\\"\"\n * quoted('rgb(255, 0, 0)') // Returns \"rgb(255, 0, 0)\" (no quotes - CSS function)\n * quoted(16) // Returns \"16\"\n * quoted(true) // Returns \"true\"\n */\nexport function quoted(v: CSSValue): string {\n if (typeof v === 'boolean') {\n return v ? 'true' : 'false';\n } else if (typeof v === 'string') {\n // Check if this is a CSS function (contains parentheses)\n const isCssFunction = /^[a-zA-Z-]+\\(.*\\)$/.test(v.trim());\n\n // Only quote strings with spaces that are not CSS functions\n if (v.includes(' ') && !isCssFunction) {\n return `\"${v}\"`;\n }\n }\n return String(v);\n}\n\n/**\n * Generates a sequence of valid CSS property key-value pairs from a CSSProperties object.\n *\n * @param object - The object containing CSS properties.\n * @returns A generator of valid key-value CSS property pairs.\n * @remarks Filters out invalid or empty CSS property values, returning only valid entries.\n */\nexport function* properties(object: CSSProperties): Generator<[K, CSSValue]> {\n for (const [key, value] of pairs(object)) {\n if (Array.isArray(value) ? (value.length > 0 && value.every(v => isValidValue(v))) : isValidValue(value)) {\n yield [key, value as CSSValue];\n }\n }\n}\n\n/**\n * Checks if a CSS value is valid.\n * A value is considered valid if it is a non-empty string or a number.\n *\n * @param value - The value to check.\n * @returns True if the value is valid, false otherwise.\n */\nfunction isValidValue(value: unknown): boolean {\n if (typeof value === 'string')\n return value !== '';\n return typeof value === 'number';\n}\n\n/**\n * A set of CSS properties that typically have space-delimited values.\n * These properties often require multiple values to be specified in a single declaration.\n *\n * @remarks\n * When formatting CSS values for these properties, values are space-separated rather than comma-separated.\n * For example:\n * - margin: 10px 20px 30px 40px (spaces between values)\n * - padding: 5px 10px (spaces between values)\n * - font: bold 16px Arial (spaces between values)\n *\n * This differs from comma-separated properties like font-family:\n * - font-family: Arial, Helvetica, sans-serif (commas between values)\n */\nexport const spaceDelimitedProperties: ReadonlySet = new Set([\n 'animation',\n 'background',\n 'box-shadow',\n 'flex',\n 'font',\n 'grid-auto-columns',\n 'grid-auto-flow',\n 'grid-auto-rows',\n 'grid-gap',\n 'grid-template-areas',\n 'grid-template-columns',\n 'grid-template-rows',\n 'list-style',\n 'margin',\n 'padding',\n 'text-decoration',\n 'text-shadow',\n 'transform',\n 'transition',\n]);\n","import { defu } from 'defu';\nimport { pairs, kebabCase } from './utils';\n\nimport {\n formatCSSValue,\n spaceDelimitedProperties,\n} from './properties';\n\n/**\n * Represents a structured CSS rule set that can contain nested rules.\n *\n * This type allows for representing complex CSS structures including:\n * - Simple property/value pairs\n * - At-rules (like `@media`, `@keyframes`)\n * - Nested rule sets\n * - Arrays of values or rule sets\n *\n * @example\n * ```\n * // Example CSS rule structure\n * const rules = {\n * body: {\n * color: 'red',\n * fontSize: '16px',\n * '@media (max-width: 768px)': {\n * fontSize: '14px'\n * }\n * }\n * };\n * ```\n */\nexport type CSSRules = {\n [name: string]: null | string | string[] | CSSRules | CSSRules[]\n};\n\n/**\n * Represents the possible value types that can be assigned to a CSS rule.\n *\n * This is a type alias for the union of all possible values in a CSSRules\n * object.\n */\nexport type CSSRulesValue = CSSRules[string];\n\n/**\n * Configuration options for formatting CSS rules.\n */\nexport interface CSSRulesFormatOptions {\n /**\n * Indentation string to use for each level of nesting.\n * @defaultValue `' '` (two spaces)\n */\n indent?: string\n\n /**\n * Prefix string added before each line.\n * @defaultValue `''` (empty string)\n */\n prefix?: string\n\n /**\n * Optional validation function to determine which rules to include.\n * @param key - The rule name/selector\n * @param value - The rule value\n * @returns `true` if the rule should be included, `false` otherwise\n */\n valid?: (key: string, value: CSSRulesValue) => boolean\n\n /**\n * Whether to normalize CSS property names from camelCase to kebab-case.\n * Only applies to property names, not selectors.\n * @defaultValue `false`\n */\n normalizeProperties?: boolean\n}\n\n/**\n * A subset of CSSRules that is compatible with tailwindcss plugin API.\n *\n * This type is more restrictive than CSSRules:\n * - It doesn't allow null values\n * - It uses itself for nested rules rather than the broader CSSRules type\n */\nexport type CSSRuleObject = {\n [key: string]: string | string[] | CSSRuleObject\n};\n\n/**\n * Converts a CSS rule object into a formatted string representation.\n *\n * This function takes a CSS rule object and returns a formatted string with\n * proper indentation and nesting.\n *\n * @param rules - The CSS rules to stringify\n * @param options - Configuration options for string formatting\n * @returns A string representing the CSS rules with proper formatting\n * @remarks a newLine is not appended at the end to aid composition.\n *\n * @example\n * ```\n * // Simple example of converting CSS rules to string format\n * const rules = {\n * 'body': {\n * 'color': 'red',\n * 'font-size': '16px'\n * }\n * };\n *\n * const result = stringifyCSSRules(rules);\n * // Result will be:\n * // body {\n * // color: red;\n * // font-size: 16px;\n * // };\n * ```\n */\nexport function stringifyCSSRules(\n rules: CSSRules | CSSRuleObject = {},\n options: CSSRulesFormatOptions & {\n /**\n * Character(s) to use for line breaks.\n * @defaultValue `'\\n'`\n */\n newLine?: string\n } = {},\n): string {\n const {\n newLine = '\\n',\n } = options;\n\n return formatCSSRules(rules, options).join(newLine);\n}\n\n/**\n * Formats CSS rule objects into an array of formatted lines.\n *\n * This function processes a CSS rule object and returns an array of strings,\n * where each string represents a line in the formatted CSS output. It\n * handles various value types including strings, numbers, arrays, and nested\n * objects.\n *\n * @param rules - The CSS rules to format\n * @param options - Configuration options for formatting\n * @returns An array of strings, each representing a line in the formatted\n * CSS\n *\n * @example\n * ```\n * const rules = {\n * 'body': {\n * 'color': 'red'\n * }\n * };\n *\n * const lines = formatCSSRules(rules);\n * // Returns: ['body {', ' color: red;', '}']\n * ```\n */\nexport function formatCSSRules(\n rules: CSSRules | CSSRuleObject = {},\n options: CSSRulesFormatOptions = {},\n): string[] {\n return [...generateCSSRules(rules, options)];\n}\n\n/**\n * Formats an array of CSS rules into an array of formatted string lines.\n *\n * This function processes various CSS rule representations recursively and\n * converts them into strings representing CSS code with proper formatting.\n * It handles:\n *\n * - String values (treated as direct CSS with semicolons added)\n * - Empty strings (converted to blank lines for spacing if appropriate)\n * - CSS rule objects (recursively processed with formatCSSRules)\n * - Empty rule objects (possibly generating blank lines)\n *\n * The function maintains proper whitespace by tracking whether the last\n * inserted item was a blank line to avoid consecutive empty lines.\n *\n * @param rules - The array of CSS rules to format (strings or rule objects)\n * @param options - Configuration options for formatting\n * @returns An array of strings, each representing a line in the formatted\n * CSS\n *\n * @example\n * ```\n * // Mixed strings and objects\n * formatCSSRulesArray([\n * 'display: block',\n * { color: 'red' },\n * '',\n * { fontSize: '16px' }\n * ]);\n * // Returns: ['display: block;', 'color: red;', '', 'fontSize: 16px;']\n * ```\n */\nexport function formatCSSRulesArray(\n rules: (string | CSSRules | CSSRuleObject)[] = [],\n options: CSSRulesFormatOptions = {},\n): string[] {\n return [...generateCSSRulesArray(rules, options)];\n}\n\n/**\n * Default validation function for CSS rules.\n *\n * Determines if a CSS rule key-value pair should be included in the output.\n * By default, a rule is valid if:\n * - The key is not an empty string\n * - The value is neither undefined nor null\n *\n * @param key - The rule key/selector to validate\n * @param value - The rule value to validate\n * @returns `true` if the rule should be included, `false` otherwise\n */\nexport function defaultValidCSSRule(\n key: string,\n value: CSSRulesValue,\n): boolean {\n if (key === '' || value === undefined || value === null) {\n return false;\n }\n return true;\n}\n\n/**\n * Special handling for CSS at-rules with empty content.\n *\n * At-rules (rules starting with `@`) with empty content are treated\n * differently:\n * - Empty at-rules (like `@import`, `@charset`) are rendered as a single\n * line with semicolon\n * - Normal CSS rules with empty content would be omitted entirely\n *\n * @example\n * `@supports (display: grid) {}` becomes `@supports (display: grid);`\n */\nfunction atRuleException(key: string, value: CSSRulesValue): boolean {\n if (!key.startsWith('@') || value === null) {\n return false;\n } else if (Array.isArray(value)) {\n return value.length === 0;\n } else if (typeof value === 'object') {\n return Object.keys(value).length === 0;\n } else {\n return false;\n }\n}\n\n/**\n * Generator version of formatCSSRulesArray that yields lines as they're\n * generated. This avoids building arrays in memory and is more efficient for\n * large files.\n *\n * @param rules - The array of CSS rules to format\n * @param options - Configuration options for formatting\n * @returns Generator that yields individual CSS lines without line\n * endings\n */\nexport function* generateCSSRulesArray(\n rules: (string | CSSRules | CSSRuleObject)[] = [],\n options: CSSRulesFormatOptions = {},\n): Generator {\n // Track if the last item was a blank line to avoid consecutive empty lines\n let wasBlankLine = true;\n\n for (const value of rules) {\n if (typeof value === 'string') {\n // String rule, preserve empty for whitespace\n if (value) {\n yield `${value};`;\n wasBlankLine = false;\n } else if (!wasBlankLine) {\n yield '';\n wasBlankLine = true;\n }\n } else if (value !== null && value !== undefined) {\n // Object rule\n let hasContent = false;\n const innerLines: string[] = [];\n\n // Collect to check if empty (we need to peek ahead)\n for (const line of generateCSSRules(value, options)) {\n innerLines.push(line);\n hasContent = true;\n }\n\n if (hasContent) {\n for (const line of innerLines) {\n yield line;\n }\n wasBlankLine = false;\n } else if (!wasBlankLine) {\n yield '';\n wasBlankLine = true;\n }\n }\n }\n}\n\n/**\n * Generator version of formatCSSRules that yields lines as they're\n * generated.\n *\n * @param rules - The CSS rules to format\n * @param options - Configuration options for formatting\n * @returns Generator that yields individual CSS lines without line\n * endings\n */\nexport function* generateCSSRules(\n rules: CSSRules | CSSRuleObject = {},\n options: CSSRulesFormatOptions = {},\n): Generator {\n const {\n indent = ' ',\n prefix = '',\n valid = defaultValidCSSRule,\n normalizeProperties = false,\n } = options;\n\n const nextOptions: CSSRulesFormatOptions = {\n ...options,\n prefix: prefix + indent,\n };\n\n // Helper to normalize key if appropriate (property vs selector/at-rule)\n const mayNormalize = (key: string): string => {\n if (!normalizeProperties) return key;\n // Don't normalize selectors or at-rules\n if (key.startsWith('.') || key.startsWith('#')\n || key.startsWith('@') || key.startsWith(':')\n || key.includes(' ')) {\n return key;\n }\n return kebabCase(key);\n };\n\n for (const [key, value] of pairs(rules, valid)) {\n if (atRuleException(key, value)) {\n // at-function\n yield `${prefix}${key};`;\n } else if (typeof value === 'string') {\n // string, omit empty\n if (value) {\n // Apply kebab-case conversion only to properties, like formatCSSProperties\n yield `${prefix}${mayNormalize(key)}: ${value};`;\n }\n } else if (Array.isArray(value)) {\n if (value.length === 0) {\n // Skip empty arrays\n } else if (typeof value[0] === 'string') {\n // multi-value - follow formatCSSProperties pattern\n const normalizedKey = mayNormalize(key);\n const useComma = !spaceDelimitedProperties.has(normalizedKey);\n const inner = formatCSSValue(value as string[], useComma);\n if (inner) {\n yield `${prefix}${normalizedKey}: ${inner};`;\n }\n } else {\n // nested rules array\n let hasContent = false;\n const innerLines: string[] = [];\n\n // Collect to check if empty\n for (const line of generateCSSRulesArray(value, nextOptions)) {\n innerLines.push(line);\n hasContent = true;\n }\n\n if (hasContent) {\n yield `${prefix}${key} {`;\n for (const line of innerLines) {\n yield line;\n }\n yield `${prefix}}`;\n }\n }\n } else if (value) {\n // nested rules object\n let hasContent = false;\n const innerLines: string[] = [];\n\n // Collect to check if empty\n for (const line of generateCSSRules(value, nextOptions)) {\n innerLines.push(line);\n hasContent = true;\n }\n\n if (hasContent) {\n yield `${prefix}${key} {`;\n for (const line of innerLines) {\n yield line;\n }\n yield `${prefix}}`;\n }\n }\n }\n}\n\n/**\n * Interleaves an array of CSS rule objects with empty objects.\n *\n * @param rules - An array of CSS rule objects to be interleaved\n * @returns An array with the original rules spaced out with empty objects\n *\n * @example\n * ```\n * // Input: [{ color: 'red' }, { background: 'blue' }]\n * // Output: [{ color: 'red' }, {}, { background: 'blue' }]\n * ```\n */\nexport function interleavedRules(rules: CSSRules[]): CSSRules[] {\n if (rules.length === 0) return [];\n\n const size = rules.length * 2 - 1;\n const out: Array = Array.from({ length: size }, () => ({}));\n\n let i = 0;\n for (const entry of rules) {\n out[i] = entry;\n i += 2;\n }\n\n return out;\n}\n\n/**\n * Renames the keys in a CSS rules object using the provided function.\n *\n * @param rules - The CSS rules object whose keys should be renamed\n * @param fn - A function that takes an original key name and returns a new\n * key name (or falsy value to skip)\n * @returns A new CSS rules object with renamed keys\n *\n * @example\n * ```\n * // Input: { '.button': { color: 'blue' } }, key => `@utility\n * // ${key.slice(1)}`\n * // Output: { '@utility button': { color: 'blue' } }\n * ```\n */\nexport function renameRules(\n rules: CSSRules,\n fn: (name: string) => string,\n): CSSRules {\n if (!fn) return rules;\n\n const map = new Map();\n for (const [key, value] of pairs(rules)) {\n const k2 = fn(key);\n if (k2) map.set(k2, value);\n }\n\n return Object.fromEntries(map);\n}\n\n/**\n * Sets a CSS rule object at a specified path within a target object,\n * merging with existing objects and creating intermediate objects as needed.\n *\n * This function allows for deep setting of CSS rules in a nested object\n * structure. It can handle both string paths for top-level assignments and\n * array paths for nested assignments. When the target path already contains\n * an object, the new object is merged with the existing one, with new values\n * taking precedence.\n *\n * The function is overloaded to provide type safety for both general\n * `CSSRules` objects and TailwindCSS-compatible `CSSRuleObject` types.\n *\n * @param target - The target CSS rules object to modify\n * @param path - Either a string key for direct assignment or an array of\n * string keys for nested assignment\n * @param object - The CSS rule object to set at the specified path\n * @returns The modified target object (same type as input)\n * @remarks The target object is modified in place, returned reference is\n * only a convenience.\n *\n * @example\n * ```\n * // Direct assignment\n * setDeepRule(rules, 'button', { color: 'blue' });\n * // Result: { button: { color: 'blue' } }\n *\n * // Nested assignment\n * setDeepRule(rules, ['components', 'button'], { color: 'blue' });\n * // Result: { components: { button: { color: 'blue' } } }\n *\n * // Merging with existing object (new values take precedence)\n * const rules = { button: { color: 'red', margin: '5px' } };\n * setDeepRule(rules, 'button', { color: 'blue', padding: '10px' });\n * // Result: { button: { color: 'blue', margin: '5px', padding: '10px' } }\n * ```\n */\nexport function setDeepRule(\n target: CSSRuleObject,\n path: string | string[],\n object: CSSRuleObject,\n): CSSRuleObject;\nexport function setDeepRule(\n target: CSSRules,\n path: string | string[],\n object: CSSRules,\n): CSSRules;\nexport function setDeepRule(\n target: CSSRules,\n path: string | string[],\n object: CSSRules,\n): CSSRules {\n let p: CSSRules = target;\n let lastKey = '';\n\n if (Array.isArray(path)) {\n if (path.length === 0) return target;\n\n // Create nested objects for all but the last path segment\n for (let i = 0; i < path.length - 1; i++) {\n const k = path[i];\n if (p[k] === undefined) {\n p[k] = {} as CSSRules;\n } else if (typeof p[k] !== 'object' || p[k] === null) {\n throw new Error(\n `Invalid path at segment ${i}: \"${k}\" in path: `\n + `${path.join('.')}: ${typeof p[k]}`,\n );\n }\n\n p = p[k] as CSSRules;\n }\n\n // Assign the obj to the last path segment\n lastKey = path.at(-1) as string;\n } else {\n lastKey = path;\n }\n\n p[lastKey] = defu(object, p[lastKey] ?? {} as typeof object);\n\n return target;\n}\n\n/**\n * Retrieves a CSS rule value from a specified path within a target object.\n *\n * This function allows for deep retrieval of CSS rules from a nested object\n * structure. It can handle both string paths for top-level access and array\n * paths for nested access.\n *\n * The function is overloaded to provide type safety for both general\n * `CSSRules` objects and TailwindCSS-compatible `CSSRuleObject` types.\n *\n * @param target - The target CSS rules object to search within\n * @param path - Either a string key for direct access or an array of\n * string keys for nested access\n * @returns The value at the specified path, or `undefined` if the path\n * does not exist\n *\n * @example\n * ```\n * const rules = {\n * components: { button: { color: 'blue' } },\n * utils: ['clearfix', 'sr-only']\n * };\n *\n * // Direct access\n * getDeepRule(rules, 'utils');\n * // Result: ['clearfix', 'sr-only']\n *\n * // Nested access\n * getDeepRule(rules, ['components', 'button', 'color']);\n * // Result: 'blue'\n *\n * // Non-existent path\n * getDeepRule(rules, ['components', 'header']);\n * // Result: undefined\n *\n * // Root access (empty array)\n * getDeepRule(rules, []);\n * // Result: { components: { ... }, utils: [...] }\n * ```\n */\nexport function getDeepRule(\n target: CSSRuleObject,\n path: string | string[],\n): CSSRuleObject | undefined;\nexport function getDeepRule(\n target: CSSRules,\n path: string | string[],\n): CSSRulesValue | undefined;\nexport function getDeepRule(\n target: CSSRules,\n path: string | string[],\n): CSSRulesValue | undefined {\n const segments = typeof path === 'string' ? [path] : path;\n\n if (segments.length === 0) {\n // Empty path returns the target object itself\n return target;\n }\n\n let current: CSSRulesValue = target;\n for (const key of segments) {\n if (typeof current !== 'object' || current === null\n || !Object.prototype.hasOwnProperty.call(current, key)) {\n return undefined;\n }\n current = (current as CSSRules)[key];\n }\n\n return current;\n}\n","/**\n * Default selector aliases that expand simple names into complex at-rules\n */\nconst DEFAULT_SELECTOR_ALIASES: Record = {\n media: '@media (prefers-color-scheme: dark)',\n dark: '@media (prefers-color-scheme: dark)',\n light: '@media (prefers-color-scheme: light)',\n mobile: '@media (max-width: 768px)',\n tablet: '@media (min-width: 769px) and (max-width: 1024px)',\n desktop: '@media (min-width: 1025px)',\n};\n\n/**\n * Expands selector aliases into their full forms\n * @param selector - The selector to potentially expand\n * @param aliases - Custom aliases to use (defaults to built-in ones)\n * @returns Expanded selector or original if no alias found\n */\nexport function expandSelectorAlias(\n selector: string,\n aliases: Record = DEFAULT_SELECTOR_ALIASES,\n): string {\n const trimmed = selector.trim();\n return aliases[trimmed] || trimmed;\n}\n\nexport interface ProcessCSSSelectorOptions {\n /** Whether to add \"selector *\" variants to each selector */\n addStarVariants?: boolean\n /** Whether to allow comma-separated selectors to pass through */\n allowCommaPassthrough?: boolean\n /** Custom selector aliases to use for expansion */\n aliases?: Record\n}\n\n/**\n * Processes CSS selectors and at-rules, handling both strings and arrays.\n * Merges consecutive selectors with OR and adds * variants,\n * while keeping at-rules stacked separately.\n *\n * @param selectors - CSS selector(s) and at-rules\n * @param options - Processing options\n * @returns Array of processed selector strings or undefined\n */\nexport function processCSSSelectors(\n selectors: string | string[],\n options: ProcessCSSSelectorOptions = {},\n): string[] | undefined {\n const {\n addStarVariants = true,\n allowCommaPassthrough = true,\n aliases = DEFAULT_SELECTOR_ALIASES,\n } = options;\n\n // Convert string to array for unified processing\n const selectorArray = Array.isArray(selectors) ? selectors : [selectors];\n\n // Handle comma passthrough for single strings\n if (!Array.isArray(selectors) && allowCommaPassthrough && selectors.includes(',')) {\n const expanded = expandSelectorAlias(selectors, aliases);\n return [expanded];\n }\n\n const result: string[] = [];\n const currentSelectors: string[] = [];\n\n const flushSelectors = () => {\n if (currentSelectors.length > 0) {\n // Merge consecutive selectors with OR, optionally adding * variants\n const expandedSelectors: string[] = [];\n for (const selector of currentSelectors) {\n expandedSelectors.push(selector);\n if (addStarVariants) {\n expandedSelectors.push(`${selector} *`);\n }\n }\n result.push(expandedSelectors.join(', '));\n currentSelectors.length = 0;\n }\n };\n\n for (const s of selectorArray) {\n const expanded = expandSelectorAlias(s, aliases);\n const trimmed = expanded.trim();\n if (!trimmed) continue;\n\n if (trimmed.startsWith('@')) {\n // At-rule: flush current selectors and add at-rule separately\n flushSelectors();\n result.push(trimmed);\n } else {\n // Regular selector: add to current batch\n currentSelectors.push(trimmed);\n }\n }\n\n // Flush any remaining selectors\n flushSelectors();\n\n return result.length === 0 ? undefined : result;\n}\n"],"names":[],"mappings":"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"}