{"version":3,"sources":["../src/internal/parsers.ts","../src/core/schema.ts","../src/internal/property-sorter.ts","../src/internal/is-time.ts","../src/internal/is-timing-function.ts","../src/internal/property-handler.ts","../src/internal/is-value-node.ts","../src/internal/layer-parser-utils.ts","../src/handlers/animation/animation-layers.ts","../src/handlers/animation/expand.ts","../src/internal/color-utils.ts","../src/internal/is-color.ts","../src/internal/is-length.ts","../src/internal/normalize-color.ts","../src/handlers/background/background-layers.ts","../src/handlers/background/expand.ts","../src/internal/position-parser.ts","../src/handlers/background-position/expand.ts","../src/handlers/background-position/index.ts","../src/internal/directional.ts","../src/handlers/border/expand.ts","../src/handlers/border-radius/expand.ts","../src/handlers/column-rule/expand.ts","../src/handlers/columns/expand.ts","../src/handlers/contain-intrinsic-size/expand.ts","../src/handlers/flex/expand.ts","../src/handlers/flex-flow/expand.ts","../src/handlers/font/expand.ts","../src/handlers/grid/expand.ts","../src/internal/grid-line.ts","../src/handlers/grid-area/expand.ts","../src/handlers/grid-column/expand.ts","../src/handlers/grid-row/expand.ts","../src/handlers/list-style/expand.ts","../src/handlers/mask/mask-layers.ts","../src/handlers/mask/expand.ts","../src/internal/is-angle.ts","../src/handlers/offset/expand.ts","../src/handlers/outline/expand.ts","../src/handlers/overflow/expand.ts","../src/internal/place-utils.ts","../src/handlers/place-content/expand.ts","../src/handlers/place-items/expand.ts","../src/handlers/place-self/expand.ts","../src/handlers/text-decoration/expand.ts","../src/handlers/text-emphasis/expand.ts","../src/handlers/transition/transition-layers.ts","../src/handlers/transition/expand.ts","../src/internal/shorthand-registry.ts","../src/core/validate.ts","../src/core/expand.ts","../src/internal/border-side-parser.ts","../src/handlers/border-block/expand.ts","../src/handlers/border-block/index.ts","../src/handlers/border-block-end/expand.ts","../src/handlers/border-block-end/index.ts","../src/handlers/border-block-start/expand.ts","../src/handlers/border-block-start/index.ts","../src/handlers/border-bottom/expand.ts","../src/handlers/border-bottom/index.ts","../src/internal/trbl-expander.ts","../src/handlers/border-color/expand.ts","../src/handlers/border-color/index.ts","../src/handlers/border-image/expand.ts","../src/handlers/border-image/index.ts","../src/handlers/border-inline/expand.ts","../src/handlers/border-inline/index.ts","../src/handlers/border-inline-end/expand.ts","../src/handlers/border-inline-end/index.ts","../src/handlers/border-inline-start/expand.ts","../src/handlers/border-inline-start/index.ts","../src/handlers/border-left/expand.ts","../src/handlers/border-left/index.ts","../src/handlers/border-right/expand.ts","../src/handlers/border-right/index.ts","../src/handlers/border-style/expand.ts","../src/handlers/border-style/index.ts","../src/handlers/border-top/expand.ts","../src/handlers/border-top/index.ts","../src/handlers/border-width/expand.ts","../src/handlers/border-width/index.ts","../src/handlers/container/expand.ts","../src/handlers/container/index.ts","../src/handlers/gap/expand.ts","../src/handlers/grid-template/expand.ts","../src/handlers/grid-template/index.ts","../src/handlers/inset/expand.ts","../src/handlers/inset/index.ts","../src/handlers/inset-block/expand.ts","../src/handlers/inset-block/index.ts","../src/handlers/inset-inline/expand.ts","../src/handlers/inset-inline/index.ts","../src/handlers/margin/expand.ts","../src/handlers/margin/index.ts","../src/handlers/mask-position/expand.ts","../src/handlers/mask-position/index.ts","../src/handlers/object-position/expand.ts","../src/handlers/object-position/index.ts","../src/handlers/padding/expand.ts","../src/handlers/padding/index.ts","../src/handlers/scroll-margin/expand.ts","../src/handlers/scroll-margin/index.ts","../src/handlers/scroll-padding/expand.ts","../src/handlers/scroll-padding/index.ts","../src/internal/handler-registry.ts"],"names":["stripComments","css","result","i","j","parseInputString","input","declarations","current","char","nextChar","quoteEnd","parenCount","parenEnd","bracketEnd","decl","parseCssDeclaration","declaration","trimmed","colonIndex","property","value","FORMAT_VALUES","PROPERTY_GROUPING_VALUES","FORMAT_CSS","FORMAT_JS","GROUPING_BY_PROPERTY","GROUPING_BY_SIDE","ExpandOptions","Format","PropertyGrouping","Separator","Indent","DEFAULT_EXPAND_OPTIONS","PROPERTY_ORDER_MAP","sortProperties","obj","grouping","sortPropertiesBySide","sortPropertiesByProperty","getPropertyMetadata","prop","parts","sides","side","p","sideIndex","base","sortedEntries","a","b","orderA","orderB","metaA","metaB","kebabToCamelCase","_","letter","objectToCss","indent","separator","propertyGrouping","indentStr","sorted","key","TIME","isTime","TIMING_KEYWORDS","TIMING_FUNCTIONS","hasBalancedParentheses","openCount","isTimingFunction","DEFAULT_PROPERTY_HANDLER_OPTIONS","createPropertyHandler","config","options","validatedOptions","COLOR_FUNCTIONS","IMAGE_FUNCTIONS","matchesType","node","types","typeArray","nodeType","funcName","isNumericValueNode","isPositionValueNode","keywords","isSizeValueNode","hasTopLevelCommas","detectFunctions","parenDepth","bracketDepth","hasFunctions","splitLayers","layers","currentLayer","parseLayersGeneric","parseSingleLayer","layerStrings","layerStr","parsedLayer","ANIMATION_DEFAULTS","needsAdvancedParser","parseAnimationLayers","layerValue","ast","children","child","processCssChildren","timeCount","matched","name","funcValue","timingValue","timeValue","numValue","identValue","reconstructLayers","properties","l","values","KEYWORD","ITERATION_COUNT","DIRECTION","FILL_MODE","PLAY_STATE","parseAnimationValue","layeredResult","tokens","token","animationHandler","animation","CSS_COLOR_NAMES","cssUrlRegex","hexColorRegex","opts","hslRegex","hslaRegex","rgbRegex","rgbaRegex","HEX","HSLA","HSL","RGB","RGBA","colorCache","MAX_CACHE_SIZE","isColor","cached","lowerValue","firstKey","LENGTH","ZERO","isLength","FUNCTIONS","normalizeColor","acc","func","match","BACKGROUND_DEFAULTS","isGradient","imageValue","parseBackgroundLayers","parsedLayers","globalColor","distributeLayerProperties","layer","layerProps","parseSingleLayerWithCssTree","S","hasPositionSize","funcNode","positionParts","sizeParts","currentChild","sizeChild","repeat","nextName","color","backgroundImages","index","ATTACHMENT","BOX","IMAGE","REPEAT_SINGLE","REPEAT_DOUBLE","POSITION_HORIZONTAL","POSITION_VERTICAL","SIZE_SINGLE","normalizeUrl","parseBackgroundValue","simpleBackgroundParser","group1","first","v","n","isHorizontal","isVertical","sizeV","sizeValue","sizeN","finalResult","backgroundHandler","background","POSITION_KEYWORDS","HORIZONTAL_KEYWORDS","VERTICAL_KEYWORDS","parsePosition","smartSplit","part","second","third","fourth","depth","expandBackgroundPosition","x","y","xValues","yValues","backgroundPositionHandler","directionalCache","directional","direction","WIDTH","STYLE","suffix","longhand","all","filtered","width","style","boxSizing","parseBorderValue","widthProps","styleProps","colorProps","borderHandler","border","expand_default","expandFourValues","borderRadiusHandler","slashIndex","horizontalPart","verticalPart","horizontalValues","verticalValues","horizontal","vertical","corners","expanded","columnRuleHandler","parsed","columnRule","columnsHandler","INTEGER","specificValues","autoValues","val","type","autoValue","containIntrinsicSizeHandler","parseValue","nextToken","widthValue","heightValue","flexHandler","numberPattern","flexBasisKeywordPattern","fitContentFn","classified","flexFlowHandler","directionPattern","wrapPattern","wrap","states","parse","state","buffer","c","parseFontValue","family","fontHandler","font","GRID_DEFAULTS","parseValueAndGetSegments","ne","slashIndices","slashCount","childrenArray","listToArray","leftSegment","rightSegment","detectGridForm","hasAutoFlowLeft","hasAutoFlowRight","list","arr","item","separateAreasAndTracks","segmentNodes","strings","tracks","areas","rows","s","columnCount","row","tracksStr","parseTrackList","validNodes","generatedParts","parseTemplateForm","templateAreas","templateRows","templateColumns","leftAreas","leftTracks","rightTracks","parseExplicitRowsForm","firstNonWhiteSpace","autoFlow","autoColumns","hasDense","autoColumnsStart","autoColumnsSegment","parseExplicitColumnsForm","autoRows","autoRowsStart","autoRowsSegment","parseGridValue","segments","gridHandler","isCustomIdent","isInteger","parseGridLine","rest","seenInt","seenIdent","getDefaultEnd","start","gridAreaHandler","rowStart","columnStart","rowEnd","columnEnd","gridColumnHandler","startValue","endValue","gridRowHandler","POSITION","COMMON_TYPE","IDENT","STRING_VALUE","listStyleHandler","normalizedValue","explicitlySet","listStyle","MASK_DEFAULTS","parseMaskLayers","hasUnrecognizedToken","parseMaskValue","trimmedValue","maskHandler","mask","ANGLE","isAngle","splitTopLevelSlash","inQuotes","quoteChar","main","anchor","tokenizeRespectingFunctions","isPositionKeyword","parsePath","parseDistance","parseRotate","parseAnchor","parseOffsetValue","slashSplit","positionResult","pathResult","distanceResult","rotateResult","parsedAnchor","offsetHandler","outlineHandler","outline","overflowHandler","validValues","consolidatePlaceTokens","nextTokenPattern","out","t","placeContentHandler","processedValues","validValuePattern","placeItemsHandler","isValidAlignItemsValue","isValidJustifyItemsValue","alignVal","justifyVal","placeSelfHandler","isValidAlignSelfValue","isValidJustifySelfValue","LINE","THICKNESS","textDecorationHandler","lines","hasStyle","hasColor","hasThickness","textDecoration","FILL","SHAPE","textEmphasisHandler","textEmphasis","TRANSITION_DEFAULTS","parseTransitionLayers","PROPERTY_KEYWORD","parseTransitionValue","transitionHandler","transition","prefix","shorthand","DEFAULT_MAX_LINE_WIDTH","LINE_NUMBER_PADDING","DEFAULT_CONTEXT_WINDOW_SIZE","containsVar","validate","errors","warnings","syntax","z","uniqueDecls","err","stack","id","suppressNoise","msg","LOG_LEVEL","QUIET","origWarn","origError","args","error","formattedWarnings","cssLines","warning","formattedError","formatErrorDisplay","calculateLineWindow","errorLine","totalLines","contextWindowSize","end","formatLineNumber","lineNum","maxLineNum","maxDigits","paddedNum","trimLine","line","spacesRemoved","calculateTruncationBounds","lineLength","errorColumn","maxWidth","availableWidth","halfWidth","startPos","needsStartEllipsis","endPos","needsEndEllipsis","applyTruncation","bounds","originalErrorColumn","content","adjustedColumn","formatContextLine","formatErrorLine","adjustedErrorColumn","trimmedBounds","createPointerLine","prefixLength","column","length","safeLength","safeColumn","pointerPrefix","dashes","carets","mismatchLength","lineIndex","currentLine","currentPrefix","pointerLine","formattedLine","expand","cleanedInput","format","validation","inputs","finalProperties","issues","normalized","nestedParse","nestedLonghand","camelCased","ok","allIssues","BORDER_STYLES","BORDER_WIDTHS","parseBorderSide","createBorderSideExpander","expandBorderBlock","borderBlockHandler","expandBorderBlockEnd","borderBlockEndHandler","expandBorderBlockStart","borderBlockStartHandler","expandBorderBottom","borderBottomHandler","expandTRBL","top","bottom","right","left","createTRBLExpander","expandBorderColor","borderColorHandler","REPEAT_KEYWORDS","expandBorderImage","source","slice","outset","slashParts","mainPart","sliceTokens","repeatTokens","borderImageHandler","expandBorderInline","borderInlineHandler","expandBorderInlineEnd","borderInlineEndHandler","expandBorderInlineStart","borderInlineStartHandler","expandBorderLeft","borderLeftHandler","expandBorderRight","borderRightHandler","expandBorderStyle","borderStyleHandler","expandBorderTop","borderTopHandler","expandBorderWidth","borderWidthHandler","expandContainer","containerHandler","parseGapValue","gapHandler","expandGridTemplate","columns","areaMatches","remaining","area","gridTemplateHandler","expandInset","insetHandler","expandInsetBlock","insetBlockHandler","expandInsetInline","insetInlineHandler","expandMargin","marginHandler","expandMaskPosition","maskPositionHandler","expandObjectPosition","objectPositionHandler","expandPadding","paddingHandler","expandScrollMargin","scrollMarginHandler","expandScrollPadding","scrollPaddingHandler","handlerMap","longhandToShorthandsMap","handler","existing","registry","category","h","expandProperty","validateProperty","isShorthandProperty"],"mappings":"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","file":"index.cjs","sourcesContent":["// b_path:: src/internal/parsers.ts\n\n/**\n * Internal parsing utilities for CSS declaration processing.\n * @internal\n */\n\n/**\n * Removes all CSS comments from the input string.\n * Uses a character-by-character scanning approach that safely handles multi-line comments.\n * @internal\n */\nexport function stripComments(css: string): string {\n  let result = \"\";\n  let i = 0;\n\n  while (i < css.length) {\n    if (css[i] === \"/\" && css[i + 1] === \"*\") {\n      let j = i + 2;\n      while (j < css.length) {\n        if (css[j] === \"*\" && css[j + 1] === \"/\") {\n          result += \" \";\n          i = j + 2;\n          break;\n        }\n        j++;\n      }\n      if (j >= css.length) {\n        i = css.length;\n      }\n    } else {\n      result += css[i];\n      i++;\n    }\n  }\n\n  return result;\n}\n\n/**\n * Parses CSS input string into individual declarations.\n * Handles quotes, parentheses, and brackets correctly.\n * @internal\n */\nexport function parseInputString(input: string): string[] {\n  const declarations: string[] = [];\n  let current = \"\";\n  let i = 0;\n\n  while (i < input.length) {\n    const char = input[i];\n    const nextChar = input[i + 1];\n\n    if (char === \"\\\\\" && nextChar) {\n      current += char + nextChar;\n      i += 2;\n      continue;\n    }\n\n    if (char === '\"' || char === \"'\") {\n      let quoteEnd = i + 1;\n      while (quoteEnd < input.length) {\n        if (input[quoteEnd] === char && input[quoteEnd - 1] !== \"\\\\\") {\n          break;\n        }\n        quoteEnd++;\n      }\n      if (quoteEnd < input.length) {\n        current += input.substring(i, quoteEnd + 1);\n        i = quoteEnd + 1;\n        continue;\n      }\n    }\n\n    if (char === \"(\") {\n      let parenCount = 1;\n      let parenEnd = i + 1;\n      while (parenEnd < input.length && parenCount > 0) {\n        if (input[parenEnd] === \"(\") parenCount++;\n        if (input[parenEnd] === \")\") parenCount--;\n        parenEnd++;\n      }\n      if (parenCount === 0) {\n        current += input.substring(i, parenEnd);\n        i = parenEnd;\n        continue;\n      }\n    }\n\n    if (char === \"[\") {\n      const bracketEnd = input.indexOf(\"]\", i + 1);\n      if (bracketEnd !== -1) {\n        current += input.substring(i, bracketEnd + 1);\n        i = bracketEnd + 1;\n        continue;\n      }\n    }\n\n    if (char === \";\") {\n      declarations.push(current.trim());\n      current = \"\";\n    } else {\n      current += char;\n    }\n\n    i++;\n  }\n\n  if (current.trim()) {\n    declarations.push(current.trim());\n  }\n\n  return declarations.filter((decl) => decl.length > 0);\n}\n\n/**\n * Parses a CSS declaration into property and value.\n * @internal\n */\nexport function parseCssDeclaration(\n  declaration: string\n): { property: string; value: string } | null {\n  const trimmed = declaration.trim();\n  const colonIndex = trimmed.indexOf(\":\");\n\n  if (colonIndex === -1) return null;\n\n  const property = trimmed.slice(0, colonIndex).trim();\n  const value = trimmed.slice(colonIndex + 1).trim();\n\n  if (!property || !value) return null;\n\n  return { property, value };\n}\n","// b_path:: src/core/schema.ts\n\n/**\n * Base CSS value types\n */\nexport type CssValue = string;\nexport type CssProperty = string;\nexport type CssDeclaration = string;\n\n/**\n * Output format enum\n * - 'css': Returns kebab-case CSS string (e.g., \"margin-top: 10px;\")\n * - 'js': Returns camelCase JavaScript object (e.g., { marginTop: '10px' })\n */\nexport const FORMAT_VALUES = [\"css\", \"js\"] as const;\nexport type Format = (typeof FORMAT_VALUES)[number];\n\n/**\n * Property grouping strategy enum\n * - 'by-property': Groups by property type (e.g., all margins, then all borders)\n * - 'by-side': Groups by directional side (e.g., all top properties, then all right properties)\n */\nexport const PROPERTY_GROUPING_VALUES = [\"by-property\", \"by-side\"] as const;\nexport type PropertyGrouping = (typeof PROPERTY_GROUPING_VALUES)[number];\n\n// Named constants for better readability\nexport const FORMAT_CSS = \"css\" as const;\nexport const FORMAT_JS = \"js\" as const;\nexport const GROUPING_BY_PROPERTY = \"by-property\" as const;\nexport const GROUPING_BY_SIDE = \"by-side\" as const;\n\n/**\n * Options for CSS shorthand expansion\n */\nexport interface ExpandOptions {\n  /** Output format: \"css\" (kebab-case string) or \"js\" (camelCase object). Default: \"css\" */\n  format?: Format;\n\n  /** Indentation spaces for CSS output (min: 0). Default: 0 */\n  indent?: number;\n\n  /** Separator between CSS declarations. Default: \"\\n\" */\n  separator?: string;\n\n  /**\n   * Property grouping strategy. Default: \"by-property\"\n   * - 'by-property': Groups by property type (e.g., all margins, then all borders)\n   * - 'by-side': Groups by directional side (e.g., all top properties, then all right properties)\n   */\n  propertyGrouping?: PropertyGrouping;\n}\n\n/**\n * Enum-style namespace for ExpandOptions values\n * Provides better autocomplete and discoverability\n *\n * @example\n * ```typescript\n * import * as b from 'b_short';\n *\n * b.expand('background: red', {\n *   format: b.ExpandOptions.Format.CSS,\n *   propertyGrouping: b.ExpandOptions.PropertyGrouping.BY_PROPERTY,\n *   separator: b.ExpandOptions.Separator.NEWLINE,\n *   indent: b.ExpandOptions.Indent.NONE\n * });\n * ```\n */\nexport namespace ExpandOptions {\n  /**\n   * Output format values\n   */\n  export enum Format {\n    /** CSS format: kebab-case strings like \"margin-top: 10px;\" */\n    CSS = \"css\",\n    /** JS format: camelCase objects like { marginTop: '10px' } */\n    JS = \"js\",\n  }\n\n  /**\n   * Property grouping strategy values\n   */\n  export enum PropertyGrouping {\n    /** Group by property type (all margins, then all borders) */\n    BY_PROPERTY = \"by-property\",\n    /** Group by directional side (all top properties, then all right) */\n    BY_SIDE = \"by-side\",\n  }\n\n  /**\n   * Common separator values\n   */\n  export enum Separator {\n    /** Newline separator (default) */\n    NEWLINE = \"\\n\",\n    /** Space separator */\n    SPACE = \" \",\n    /** Semicolon with space */\n    SEMICOLON = \"; \",\n    /** Empty string (compact) */\n    NONE = \"\",\n  }\n\n  /**\n   * Common indentation values\n   */\n  export enum Indent {\n    /** No indentation (default) */\n    NONE = 0,\n    /** 2 spaces */\n    TWO_SPACES = 2,\n    /** 4 spaces */\n    FOUR_SPACES = 4,\n    /** Tab character (8 spaces equivalent) */\n    TAB = 8,\n  }\n}\n\n/**\n * Default values for ExpandOptions\n * Users can spread this and override specific values\n *\n * @example\n * ```typescript\n * import { expand, DEFAULT_EXPAND_OPTIONS } from 'b_short';\n *\n * const myOptions = {\n *   ...DEFAULT_EXPAND_OPTIONS,\n *   indent: 2,\n *   format: 'js'\n * };\n *\n * expand('margin: 10px', myOptions);\n * ```\n */\nexport const DEFAULT_EXPAND_OPTIONS: Required<ExpandOptions> = {\n  format: \"css\",\n  indent: 0,\n  separator: \"\\n\",\n  propertyGrouping: \"by-property\",\n};\n\n/**\n * CSS Tree syntax parsing error\n */\nexport interface CssTreeSyntaxParseError {\n  name: string;\n  message: string;\n  line?: number;\n  column?: number;\n  property?: string;\n  offset?: number;\n  length?: number;\n}\n\n/**\n * Custom warning for CSS property validation\n */\nexport interface BStyleWarning {\n  /** CSS property that has the warning */\n  property: string;\n  /** Warning name/type */\n  name: string;\n  /** CSS syntax that caused the warning */\n  syntax?: string;\n  /** Formatted warning message for display */\n  formattedWarning?: string;\n}\n\n/**\n * Single layer in a multi-layer background\n */\nexport interface BackgroundLayer {\n  /** Background image (url, gradient, or none) */\n  image?: string;\n  /** Background position (e.g., '10px 20px') */\n  position?: string;\n  /** Background size (e.g., 'cover', '100px 200px') */\n  size?: string;\n  /** Background repeat (e.g., 'no-repeat', 'repeat-x') */\n  repeat?: string;\n  /** Background attachment (e.g., 'fixed', 'scroll') */\n  attachment?: string;\n  /** Background origin (e.g., 'padding-box', 'border-box') */\n  origin?: string;\n  /** Background clip (e.g., 'padding-box', 'border-box') */\n  clip?: string;\n}\n\n/**\n * Result of parsing multi-layer background declaration\n */\nexport interface BackgroundResult {\n  /** Array of background layers */\n  layers: BackgroundLayer[];\n  /** Global background color applied to all layers */\n  color?: string;\n}\n\n/**\n * Single layer in a multi-layer mask\n */\nexport interface MaskLayer {\n  /** Mask image (url, gradient, or none) */\n  image?: string;\n  /** Masking mode (e.g., 'alpha', 'luminance', 'match-source') */\n  mode?: string;\n  /** Mask position (e.g., '10px 20px', 'center') */\n  position?: string;\n  /** Mask size (e.g., 'cover', '100px 200px', 'auto') */\n  size?: string;\n  /** Mask repeat (e.g., 'no-repeat', 'repeat-x') */\n  repeat?: string;\n  /** Mask origin (e.g., 'padding-box', 'border-box', 'content-box') */\n  origin?: string;\n  /** Mask clip (e.g., 'padding-box', 'border-box', 'content-box', 'no-clip') */\n  clip?: string;\n  /** Mask composite (e.g., 'add', 'subtract', 'intersect', 'exclude') */\n  composite?: string;\n}\n\n/**\n * Result of parsing multi-layer mask declaration\n */\nexport interface MaskResult {\n  /** Array of mask layers */\n  layers: MaskLayer[];\n}\n\n/**\n * Single layer in a multi-layer transition\n */\nexport interface TransitionLayer {\n  /** Transition property (e.g., 'opacity', 'all', 'transform') */\n  property?: string;\n  /** Transition duration (e.g., '300ms', '0.5s') */\n  duration?: string;\n  /** Transition timing function (e.g., 'ease', 'cubic-bezier(0.4, 0, 0.2, 1)') */\n  timingFunction?: string;\n  /** Transition delay (e.g., '100ms', '0s') */\n  delay?: string;\n}\n\n/**\n * Result of parsing multi-layer transition declaration\n */\nexport interface TransitionResult {\n  /** Array of transition layers */\n  layers: TransitionLayer[];\n}\n\n/**\n * Single layer in a multi-layer animation\n */\nexport interface AnimationLayer {\n  /** Animation name (e.g., 'spin', 'none') */\n  name?: string;\n  /** Animation duration (e.g., '1s', '300ms') */\n  duration?: string;\n  /** Animation timing function (e.g., 'ease', 'cubic-bezier(0.4, 0, 0.2, 1)') */\n  timingFunction?: string;\n  /** Animation delay (e.g., '100ms', '0s') */\n  delay?: string;\n  /** Animation iteration count (e.g., '3', 'infinite') */\n  iterationCount?: string;\n  /** Animation direction (e.g., 'normal', 'reverse', 'alternate', 'alternate-reverse') */\n  direction?: string;\n  /** Animation fill mode (e.g., 'none', 'forwards', 'backwards', 'both') */\n  fillMode?: string;\n  /** Animation play state (e.g., 'running', 'paused') */\n  playState?: string;\n}\n\n/**\n * Result of parsing multi-layer animation declaration\n */\nexport interface AnimationResult {\n  /** Array of animation layers */\n  layers: AnimationLayer[];\n}\n\n/**\n * Result of CSS shorthand expansion\n */\nexport interface ExpandResult {\n  /** Whether expansion was successful (no syntax errors) */\n  ok: boolean;\n  /**\n   * The expanded CSS result\n   * - JavaScript object format (multiple declarations are merged, with later properties overriding earlier ones)\n   * - CSS string format (multiple declarations are joined)\n   * - undefined when input is empty or invalid\n   */\n  result?: Record<string, string> | string;\n  /** Array of syntax errors and validation warnings */\n  issues: Array<CssTreeSyntaxParseError | BStyleWarning>;\n}\n\n/**\n * Result of CSS stylesheet validation\n */\nexport interface StylesheetValidation {\n  /** Whether validation passed (no errors) */\n  ok: boolean;\n  /** Array of syntax parsing errors */\n  errors: CssTreeSyntaxParseError[];\n  /** Array of property validation warnings */\n  warnings: BStyleWarning[];\n}\n\n// ============================================================================\n// v2.0.0: Collapse types removed - Expansion only\n// ============================================================================\n","// b_path:: src/internal/property-sorter.ts\n\nimport type { PropertyGrouping } from \"../core/schema\";\nimport { GROUPING_BY_PROPERTY } from \"../core/schema\";\n\n/**\n * Internal property sorting utilities.\n * @internal\n */\n\n/**\n * CSS property ordering map - defines the canonical order of properties\n * @internal\n */\nexport const PROPERTY_ORDER_MAP: Record<string, number> = {\n  // Grid properties (indices 0-11)\n  \"grid-row-start\": 0,\n  \"grid-row-end\": 1,\n  \"grid-column-start\": 2,\n  \"grid-column-end\": 3,\n  \"grid-template-rows\": 4,\n  \"grid-template-columns\": 5,\n  \"grid-template-areas\": 6,\n  \"grid-auto-rows\": 7,\n  \"grid-auto-columns\": 8,\n  \"grid-auto-flow\": 9,\n  \"row-gap\": 10,\n  \"column-gap\": 11,\n\n  // Animation properties (indices 20-27)\n  \"animation-name\": 20,\n  \"animation-duration\": 21,\n  \"animation-timing-function\": 22,\n  \"animation-delay\": 23,\n  \"animation-iteration-count\": 24,\n  \"animation-direction\": 25,\n  \"animation-fill-mode\": 26,\n  \"animation-play-state\": 27,\n\n  // Transition properties (indices 30-33)\n  \"transition-property\": 30,\n  \"transition-duration\": 31,\n  \"transition-timing-function\": 32,\n  \"transition-delay\": 33,\n\n  // Background properties (indices 40-49)\n  \"background-image\": 40,\n  \"background-position\": 41,\n  \"background-position-x\": 42,\n  \"background-position-y\": 43,\n  \"background-size\": 44,\n  \"background-repeat\": 45,\n  \"background-attachment\": 46,\n  \"background-origin\": 47,\n  \"background-clip\": 48,\n  \"background-color\": 49,\n\n  // Font properties (indices 50-56)\n  \"font-style\": 50,\n  \"font-variant\": 51,\n  \"font-weight\": 52,\n  \"font-stretch\": 53,\n  \"font-size\": 54,\n  \"line-height\": 55,\n  \"font-family\": 56,\n\n  // Flex properties (indices 60-64)\n  \"flex-grow\": 60,\n  \"flex-shrink\": 61,\n  \"flex-basis\": 62,\n  \"flex-direction\": 63,\n  \"flex-wrap\": 64,\n\n  // Border directional properties (indices 70-84)\n  \"border-top-width\": 70,\n  \"border-top-style\": 71,\n  \"border-top-color\": 72,\n  \"border-right-width\": 73,\n  \"border-right-style\": 74,\n  \"border-right-color\": 75,\n  \"border-bottom-width\": 76,\n  \"border-bottom-style\": 77,\n  \"border-bottom-color\": 78,\n  \"border-left-width\": 79,\n  \"border-left-style\": 80,\n  \"border-left-color\": 81,\n  \"border-width\": 82,\n  \"border-style\": 83,\n  \"border-color\": 84,\n\n  // Border-radius properties (indices 90-93)\n  \"border-top-left-radius\": 90,\n  \"border-top-right-radius\": 91,\n  \"border-bottom-right-radius\": 92,\n  \"border-bottom-left-radius\": 93,\n\n  // Outline properties (indices 100-102)\n  \"outline-width\": 100,\n  \"outline-style\": 101,\n  \"outline-color\": 102,\n\n  // Column-rule properties (indices 110-112)\n  \"column-rule-width\": 110,\n  \"column-rule-style\": 111,\n  \"column-rule-color\": 112,\n\n  // Columns properties (indices 115-116)\n  \"column-width\": 115,\n  \"column-count\": 116,\n\n  // List-style properties (indices 120-122)\n  \"list-style-type\": 120,\n  \"list-style-position\": 121,\n  \"list-style-image\": 122,\n\n  // Text-decoration properties (indices 130-133)\n  \"text-decoration-line\": 130,\n  \"text-decoration-style\": 131,\n  \"text-decoration-color\": 132,\n  \"text-decoration-thickness\": 133,\n\n  // Overflow properties (indices 140-141)\n  \"overflow-x\": 140,\n  \"overflow-y\": 141,\n\n  // Place properties (indices 150-155)\n  \"align-items\": 150,\n  \"justify-items\": 151,\n  \"align-content\": 152,\n  \"justify-content\": 153,\n  \"align-self\": 154,\n  \"justify-self\": 155,\n\n  // Directional properties - margin (indices 200-203)\n  \"margin-top\": 200,\n  \"margin-right\": 201,\n  \"margin-bottom\": 202,\n  \"margin-left\": 203,\n\n  // Directional properties - padding (indices 210-213)\n  \"padding-top\": 210,\n  \"padding-right\": 211,\n  \"padding-bottom\": 212,\n  \"padding-left\": 213,\n\n  // Directional properties - inset (indices 220-223)\n  top: 220,\n  right: 221,\n  bottom: 222,\n  left: 223,\n\n  // Mask properties (indices 230-239)\n  \"mask-image\": 230,\n  \"mask-mode\": 231,\n  \"mask-position\": 232,\n  \"mask-position-x\": 233,\n  \"mask-position-y\": 234,\n  \"mask-size\": 235,\n  \"mask-repeat\": 236,\n  \"mask-origin\": 237,\n  \"mask-clip\": 238,\n  \"mask-composite\": 239,\n\n  // Object properties (indices 245-246)\n  \"object-position-x\": 245,\n  \"object-position-y\": 246,\n\n  // Offset properties (indices 240-244)\n  \"offset-position\": 240,\n  \"offset-path\": 241,\n  \"offset-distance\": 242,\n  \"offset-rotate\": 243,\n  \"offset-anchor\": 244,\n\n  // Text-emphasis properties (indices 250-252)\n  \"text-emphasis-style\": 250,\n  \"text-emphasis-color\": 251,\n  \"text-emphasis-position\": 252,\n\n  // Contain-intrinsic-size properties (indices 260-261)\n  \"contain-intrinsic-width\": 260,\n  \"contain-intrinsic-height\": 261,\n};\n\n/**\n * Sorts an object's properties according to CSS specification order.\n * @internal\n */\nexport function sortProperties(\n  obj: Record<string, string>,\n  grouping: PropertyGrouping = GROUPING_BY_PROPERTY\n): Record<string, string> {\n  if (grouping === \"by-side\") {\n    return sortPropertiesBySide(obj);\n  }\n  return sortPropertiesByProperty(obj);\n}\n\n/**\n * Helper to extract property metadata for directional grouping.\n * @internal\n */\nfunction getPropertyMetadata(prop: string): {\n  side: string | null;\n  sideIndex: number;\n  base: string;\n} {\n  const parts = prop.split(\"-\");\n  const sides = [\"top\", \"right\", \"bottom\", \"left\"];\n  const side = parts.find((p) => sides.includes(p)) || null;\n  const sideIndex = side ? sides.indexOf(side) : -1;\n  const base = parts[0];\n\n  return { side, sideIndex, base };\n}\n\n/**\n * Sort properties by property type (default CSS spec order).\n * @internal\n */\nfunction sortPropertiesByProperty(obj: Record<string, string>): Record<string, string> {\n  const sortedEntries = Object.entries(obj).sort(([a], [b]) => {\n    const orderA = PROPERTY_ORDER_MAP[a];\n    const orderB = PROPERTY_ORDER_MAP[b];\n\n    if (orderA !== undefined && orderB !== undefined) {\n      return orderA - orderB;\n    }\n    if (orderA !== undefined) return -1;\n    if (orderB !== undefined) return 1;\n    return a.localeCompare(b);\n  });\n\n  return Object.fromEntries(sortedEntries);\n}\n\n/**\n * Sort properties by directional side.\n * @internal\n */\nfunction sortPropertiesBySide(obj: Record<string, string>): Record<string, string> {\n  const sortedEntries = Object.entries(obj).sort(([a], [b]) => {\n    const metaA = getPropertyMetadata(a);\n    const metaB = getPropertyMetadata(b);\n\n    if (metaA.side && metaB.side) {\n      if (metaA.sideIndex !== metaB.sideIndex) {\n        return metaA.sideIndex - metaB.sideIndex;\n      }\n      const orderA = PROPERTY_ORDER_MAP[a] ?? 999999;\n      const orderB = PROPERTY_ORDER_MAP[b] ?? 999999;\n      return orderA - orderB;\n    }\n\n    if (!metaA.side && metaB.side) {\n      const orderA = PROPERTY_ORDER_MAP[a] ?? 999999;\n      if (orderA < 200) return -1;\n      return 1;\n    }\n    if (metaA.side && !metaB.side) {\n      const orderB = PROPERTY_ORDER_MAP[b] ?? 999999;\n      if (orderB < 200) return 1;\n      return -1;\n    }\n\n    const orderA = PROPERTY_ORDER_MAP[a] ?? 999999;\n    const orderB = PROPERTY_ORDER_MAP[b] ?? 999999;\n    if (orderA !== orderB) return orderA - orderB;\n    return a.localeCompare(b);\n  });\n\n  return Object.fromEntries(sortedEntries);\n}\n\n/**\n * Converts a kebab-case CSS property name to camelCase for JavaScript.\n * @internal\n */\nexport function kebabToCamelCase(property: string): string {\n  return property.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());\n}\n\n/**\n * Converts a CSS object to CSS string format.\n * @internal\n */\nexport function objectToCss(\n  obj: Record<string, string>,\n  indent: number,\n  separator: string,\n  propertyGrouping: PropertyGrouping = GROUPING_BY_PROPERTY\n): string {\n  const indentStr = \"  \".repeat(indent);\n  const sorted = sortProperties(obj, propertyGrouping);\n  const sortedEntries = Object.entries(sorted);\n  return sortedEntries.map(([key, value]) => `${indentStr}${key}: ${value};`).join(separator);\n}\n","// b_path:: src/internal/is-time.ts\n// Utility to detect CSS time values for transition-duration and transition-delay parsing\nconst TIME = /^[+-]?(\\d*\\.)?\\d+(m?s)$/i;\n\nexport default function isTime(value: string): boolean {\n  return TIME.test(value);\n}\n","// b_path:: src/internal/is-timing-function.ts\n// Utility to detect CSS timing function values for transition-timing-function parsing\nconst TIMING_KEYWORDS = /^(ease|linear|ease-in|ease-out|ease-in-out|step-start|step-end)$/i;\nconst TIMING_FUNCTIONS = /^(cubic-bezier|steps)\\s*\\(/i;\n\nfunction hasBalancedParentheses(value: string): boolean {\n  let openCount = 0;\n  for (const char of value) {\n    if (char === \"(\") {\n      openCount++;\n    } else if (char === \")\") {\n      openCount--;\n      if (openCount < 0) {\n        return false;\n      }\n    }\n  }\n  return openCount === 0;\n}\n\nexport default function isTimingFunction(value: string): boolean {\n  // Check for timing function keywords\n  if (TIMING_KEYWORDS.test(value)) {\n    return true;\n  }\n\n  // Check for timing function functions with balanced parentheses\n  if (TIMING_FUNCTIONS.test(value)) {\n    return hasBalancedParentheses(value);\n  }\n\n  return false;\n}\n","// b_path:: src/internal/property-handler.ts\n\n/**\n * Options for property handler behavior\n */\nexport interface PropertyHandlerOptions {\n  /** Enable strict validation mode (reject invalid values). Default: false */\n  strict?: boolean;\n  /** Preserve custom properties (CSS variables) in output. Default: true */\n  preserveCustomProperties?: boolean;\n}\n\n/**\n * Default values for PropertyHandlerOptions\n */\nexport const DEFAULT_PROPERTY_HANDLER_OPTIONS: Required<PropertyHandlerOptions> = {\n  strict: false,\n  preserveCustomProperties: true,\n};\n\n/**\n * Property category enumeration\n */\nexport const PROPERTY_CATEGORIES = [\n  \"box-model\",\n  \"visual\",\n  \"layout\",\n  \"animation\",\n  \"typography\",\n  \"border\",\n  \"grid\",\n  \"position\",\n  \"positioning\",\n  \"other\",\n] as const;\n\nexport type PropertyCategory = (typeof PROPERTY_CATEGORIES)[number];\n\n/**\n * Metadata describing a property handler\n */\nexport interface PropertyHandlerMetadata {\n  /** The shorthand property name (e.g., 'border') */\n  shorthand: string;\n  /** Array of longhand property names this shorthand expands to */\n  longhands: string[];\n  /** Default values for longhand properties when not specified */\n  defaults?: Record<string, string>;\n  /** Property category classification */\n  category: PropertyCategory;\n}\n\n/**\n * Property handler interface for CSS shorthand expansion\n *\n * All property handlers must implement this interface to ensure:\n * - Consistent API across all handlers\n * - Type-safe expansion logic\n * - Introspection capabilities\n * - Future extensibility (e.g., collapse API)\n */\nexport interface PropertyHandler {\n  /**\n   * Metadata describing the handler's properties\n   */\n  readonly meta: PropertyHandlerMetadata;\n\n  /**\n   * Expand a CSS shorthand value into its longhand properties\n   *\n   * @param value - The CSS value to expand\n   * @param options - Optional handler options\n   * @returns Object mapping longhand property names to values, or undefined if invalid\n   *\n   * @example\n   * ```typescript\n   * const handler = overflowHandler;\n   * handler.expand('hidden auto'); // { 'overflow-x': 'hidden', 'overflow-y': 'auto' }\n   * handler.expand('invalid'); // undefined\n   * ```\n   */\n  expand(value: string, options?: PropertyHandlerOptions): Record<string, string> | undefined;\n\n  /**\n   * Optional: Validate a CSS value without expanding it\n   *\n   * @param value - The CSS value to validate\n   * @returns true if valid, false otherwise\n   */\n  validate?(value: string): boolean;\n\n  /**\n   * Optional: Reconstruct a shorthand value from longhand properties (future feature)\n   *\n   * This method enables the \"collapse API\" - converting longhand properties back\n   * into their shorthand equivalent.\n   *\n   * @param properties - Object mapping longhand property names to values\n   * @returns The reconstructed shorthand value, or undefined if cannot be collapsed\n   *\n   * @example\n   * ```typescript\n   * const handler = overflowHandler;\n   * handler.reconstruct?.({ 'overflow-x': 'hidden', 'overflow-y': 'hidden' }); // 'hidden'\n   * handler.reconstruct?.({ 'overflow-x': 'hidden', 'overflow-y': 'auto' }); // 'hidden auto'\n   * ```\n   */\n  reconstruct?(properties: Record<string, string>): string | undefined;\n\n  /**\n   * Optional: Sub-handlers for related shorthands\n   *\n   * Some properties like 'border' have sub-properties (border-width, border-style, etc.)\n   * that are themselves shorthands. This allows hierarchical composition.\n   *\n   * @example\n   * ```typescript\n   * const borderHandler: PropertyHandler = {\n   *   meta: { shorthand: 'border', ... },\n   *   expand: (value) => { ... },\n   *   handlers: {\n   *     width: borderWidthHandler,\n   *     style: borderStyleHandler,\n   *     color: borderColorHandler,\n   *   }\n   * };\n   * ```\n   */\n  readonly handlers?: Readonly<Record<string, PropertyHandler>>;\n}\n\n/**\n * Factory function for creating property handlers with consistent behavior\n *\n * This factory wraps handler logic with:\n * - Option validation and defaults\n * - Error handling (returns undefined on exceptions)\n * - Consistent return types\n *\n * @param config - Property handler configuration\n * @returns A fully-formed PropertyHandler instance\n *\n * @example\n * ```typescript\n * export const overflowHandler = createPropertyHandler({\n *   meta: {\n *     shorthand: 'overflow',\n *     longhands: ['overflow-x', 'overflow-y'],\n *     category: 'visual',\n *   },\n *   expand: (value) => {\n *     // Handler implementation\n *   },\n * });\n * ```\n */\nexport function createPropertyHandler(config: PropertyHandler): PropertyHandler {\n  return {\n    ...config,\n    expand: (\n      value: string,\n      options?: PropertyHandlerOptions\n    ): Record<string, string> | undefined => {\n      try {\n        // Apply default options\n        const validatedOptions: Required<PropertyHandlerOptions> = {\n          ...DEFAULT_PROPERTY_HANDLER_OPTIONS,\n          ...options,\n        };\n\n        // Call the underlying expand function with validated options\n        return config.expand(value, validatedOptions);\n      } catch (_error) {\n        // Return undefined on any errors (invalid options, parsing failures, etc.)\n        return undefined;\n      }\n    },\n  };\n}\n","// b_path:: src/internal/is-value-node.ts\nimport type * as csstree from \"@eslint/css-tree\";\n\n/**\n * CSS functions that represent colors, not numeric values.\n * These should NOT be accepted as position/size values.\n */\nconst COLOR_FUNCTIONS = new Set([\n  \"rgb\",\n  \"rgba\",\n  \"hsl\",\n  \"hsla\",\n  \"hwb\",\n  \"lab\",\n  \"lch\",\n  \"oklab\",\n  \"oklch\",\n  \"color\",\n  \"color-mix\",\n  \"light-dark\",\n]);\n\n/**\n * CSS functions that represent images, not numeric values.\n * These should NOT be accepted as position/size values.\n */\nconst IMAGE_FUNCTIONS = new Set([\n  \"url\",\n  \"image\",\n  \"image-set\",\n  \"element\",\n  \"linear-gradient\",\n  \"radial-gradient\",\n  \"conic-gradient\",\n  \"repeating-linear-gradient\",\n  \"repeating-radial-gradient\",\n  \"repeating-conic-gradient\",\n  \"cross-fade\",\n  \"paint\",\n]);\n\n/**\n * Universal type checker that handles CSS functions intelligently.\n *\n * Use this instead of direct `node.type === \"Dimension\"` checks.\n * Automatically accepts calc(), var(), min(), max(), and all math functions.\n *\n * @example\n * // OLD: if (child.type === \"Dimension\" || child.type === \"Percentage\")\n * // NEW: if (matchesType(child, [\"Dimension\", \"Percentage\"]))\n *\n * @internal\n */\nexport function matchesType(node: csstree.CssNode | undefined, types: string | string[]): boolean {\n  if (!node) return false;\n\n  const typeArray = Array.isArray(types) ? types : [types];\n  const nodeType = node.type;\n\n  // Direct type match\n  if (typeArray.includes(nodeType)) {\n    return true;\n  }\n\n  // Function node: treat as numeric value unless it's a color/image function\n  if (\n    nodeType === \"Function\" &&\n    (typeArray.includes(\"Dimension\") ||\n      typeArray.includes(\"Percentage\") ||\n      typeArray.includes(\"Number\"))\n  ) {\n    const funcName = (node as csstree.FunctionNode).name.toLowerCase();\n    return !COLOR_FUNCTIONS.has(funcName) && !IMAGE_FUNCTIONS.has(funcName);\n  }\n\n  return false;\n}\n\n/**\n * Checks if a css-tree node is a valid numeric/dimensional value type.\n * Accepts: Dimension, Percentage, Number, Function (calc, var, etc.)\n * Rejects: Color functions (rgb, hsl), Image functions (url, gradient)\n *\n * Use this for properties that accept length, percentage, or calculated values.\n *\n * @internal\n */\nexport function isNumericValueNode(node: csstree.CssNode): boolean {\n  return matchesType(node, [\"Dimension\", \"Percentage\", \"Number\"]);\n}\n\n/**\n * Checks if a css-tree node is a valid position value type.\n * Accepts: Identifier (keywords), Dimension, Percentage, Number, Function\n *\n * Use this for properties like background-position, mask-position, etc.\n *\n * @param node - css-tree node to check\n * @param keywords - Optional array of valid identifier keywords (e.g., ['left', 'center', 'right'])\n * @internal\n */\nexport function isPositionValueNode(node: csstree.CssNode, keywords?: string[]): boolean {\n  if (isNumericValueNode(node)) {\n    return true;\n  }\n\n  if (node.type === \"Identifier\") {\n    if (!keywords) return true;\n    return keywords.includes((node as csstree.Identifier).name);\n  }\n\n  return false;\n}\n\n/**\n * Checks if a css-tree node is a valid size value type.\n * Accepts: Identifier (keywords), Dimension, Percentage, Number, Function\n *\n * Use this for properties like background-size, mask-size, width, height, etc.\n *\n * @param node - css-tree node to check\n * @param keywords - Optional array of valid identifier keywords (e.g., ['auto', 'cover', 'contain'])\n * @internal\n */\nexport function isSizeValueNode(node: csstree.CssNode, keywords?: string[]): boolean {\n  return isPositionValueNode(node, keywords);\n}\n","// b_path:: src/internal/layer-parser-utils.ts\nimport * as csstree from \"@eslint/css-tree\";\n\n/**\n * Shared utilities for parsing multi-layer CSS properties (background, mask, animation, transition).\n * Eliminates ~360 lines of duplication across layer-parsing modules.\n */\n\n/**\n * Detects if a CSS value contains top-level commas (indicating multiple layers).\n * Ignores commas inside parentheses/brackets (functions, rgba(), etc.).\n *\n * @param value - CSS value to analyze\n * @param detectFunctions - If true, also return true for values with function calls\n * @returns true if multi-layer parsing is needed\n *\n * @example\n * hasTopLevelCommas('url(a.png), url(b.png)') // → true (multiple layers)\n * hasTopLevelCommas('rgba(0,0,0,0.5)')        // → false (comma inside function)\n * hasTopLevelCommas('cubic-bezier(0,0,1,1)', true) // → true (has function)\n */\nexport function hasTopLevelCommas(value: string, detectFunctions = false): boolean {\n  let parenDepth = 0;\n  let bracketDepth = 0;\n  let hasFunctions = false;\n\n  for (let i = 0; i < value.length; i++) {\n    const char = value[i];\n\n    if (char === \"(\") {\n      parenDepth++;\n      hasFunctions = true;\n    } else if (char === \")\") {\n      parenDepth--;\n    } else if (char === \"[\") {\n      bracketDepth++;\n    } else if (char === \"]\") {\n      bracketDepth--;\n    } else if (char === \",\" && parenDepth === 0 && bracketDepth === 0) {\n      // Found a comma at the top level - this indicates multiple layers\n      return true;\n    }\n  }\n\n  // Optionally detect functions (for animation/transition timing functions)\n  return detectFunctions && hasFunctions;\n}\n\n/**\n * Splits a CSS value into layers at top-level commas, respecting nested functions.\n *\n * @param value - CSS value to split\n * @returns Array of layer strings (trimmed)\n *\n * @example\n * splitLayers('url(a.png) center, url(b.png) top')\n * // → ['url(a.png) center', 'url(b.png) top']\n *\n * splitLayers('rgba(0,0,0,0.5)')\n * // → ['rgba(0,0,0,0.5)']\n */\nexport function splitLayers(value: string): string[] {\n  const layers: string[] = [];\n  let currentLayer = \"\";\n  let parenDepth = 0;\n  let bracketDepth = 0;\n\n  for (let i = 0; i < value.length; i++) {\n    const char = value[i];\n\n    if (char === \"(\") {\n      parenDepth++;\n    } else if (char === \")\") {\n      parenDepth--;\n    } else if (char === \"[\") {\n      bracketDepth++;\n    } else if (char === \"]\") {\n      bracketDepth--;\n    } else if (char === \",\" && parenDepth === 0 && bracketDepth === 0) {\n      // Found a comma at the top level - this separates layers\n      layers.push(currentLayer.trim());\n      currentLayer = \"\";\n      continue;\n    }\n\n    currentLayer += char;\n  }\n\n  // Add the last layer\n  if (currentLayer.trim()) {\n    layers.push(currentLayer.trim());\n  }\n\n  return layers;\n}\n\n/**\n * Generic layer parsing factory for multi-layer CSS properties.\n * Handles splitting, parsing, and error handling uniformly.\n *\n * @param value - CSS value to parse\n * @param parseSingleLayer - Function to parse a single layer string\n * @returns Parsed layers or undefined on error\n *\n * @example\n * // Background parsing\n * parseLayersGeneric(\n *   'url(a.png) center, url(b.png) top',\n *   parseBackgroundLayer\n * )\n */\nexport function parseLayersGeneric<T>(\n  value: string,\n  parseSingleLayer: (layerValue: string) => T | undefined\n): T[] | undefined {\n  try {\n    // Split into layers\n    const layerStrings = splitLayers(value);\n    if (layerStrings.length === 0) {\n      return undefined;\n    }\n\n    // Parse each layer\n    const layers: T[] = [];\n    for (const layerStr of layerStrings) {\n      const parsedLayer = parseSingleLayer(layerStr);\n      if (!parsedLayer) {\n        return undefined; // Parsing failed for this layer\n      }\n      layers.push(parsedLayer);\n    }\n\n    return layers;\n  } catch (_error) {\n    // If parsing fails, return undefined to indicate invalid input\n    return undefined;\n  }\n}\n\n/**\n * Collects all child nodes from a css-tree AST Value node.\n * Common pattern across all multi-layer parsers.\n *\n * @param ast - css-tree AST (must contain Value nodes)\n * @returns Flattened array of child nodes\n */\nexport function collectCssTreeChildren(ast: csstree.CssNode): csstree.CssNode[] {\n  const children: csstree.CssNode[] = [];\n\n  // Type guard to ensure we have a valid css-tree node\n  if (!ast || typeof ast !== \"object\") {\n    return children;\n  }\n\n  // Walk the AST and collect children from Value nodes\n  csstree.walk(ast, {\n    visit: \"Value\",\n    enter: (node: csstree.CssNode) => {\n      if (node.type === \"Value\" && node.children) {\n        for (const child of node.children) {\n          children.push(child);\n        }\n      }\n    },\n  });\n\n  return children;\n}\n","// b_path:: src/handlers/animation/animation-layers.ts\n\nimport * as csstree from \"@eslint/css-tree\";\nimport type { AnimationLayer, AnimationResult } from \"@/core/schema\";\nimport isTime from \"@/internal/is-time\";\nimport isTimingFunction from \"@/internal/is-timing-function\";\nimport { matchesType } from \"@/internal/is-value-node\";\nimport { hasTopLevelCommas, parseLayersGeneric } from \"@/internal/layer-parser-utils\";\n\n// CSS default values for animation properties\nexport const ANIMATION_DEFAULTS = {\n  name: \"none\",\n  duration: \"0s\",\n  timingFunction: \"ease\",\n  delay: \"0s\",\n  iterationCount: \"1\",\n  direction: \"normal\",\n  fillMode: \"none\",\n  playState: \"running\",\n} as const;\n\n/**\n * Detects if an animation value needs advanced parsing (multi-layer animations or complex functions)\n */\nexport function needsAdvancedParser(value: string): boolean {\n  return hasTopLevelCommas(value, true);\n}\n\n/**\n * Parses a complex animation value using css-tree AST parsing\n */\nexport function parseAnimationLayers(value: string): AnimationResult | undefined {\n  const layers = parseLayersGeneric(value, parseSingleLayer);\n  return layers ? { layers } : undefined;\n}\n\n/**\n * Parses a single animation layer using css-tree AST parsing\n */\nfunction parseSingleLayer(layerValue: string): AnimationLayer | undefined {\n  const result: AnimationLayer = {};\n\n  const ast = csstree.parse(layerValue.trim(), { context: \"value\" });\n\n  // Collect all child nodes from the Value node\n  const children: csstree.CssNode[] = [];\n  csstree.walk(ast, {\n    visit: \"Value\",\n    enter: (node: csstree.CssNode) => {\n      if (node.type === \"Value\" && node.children) {\n        node.children.forEach((child) => {\n          children.push(child);\n        });\n      }\n    },\n  });\n\n  // Process children in order, handling animation property parsing\n  if (!processCssChildren(children, result)) {\n    return undefined; // Parsing failed due to invalid syntax\n  }\n\n  return result;\n}\n\n/**\n * Processes CSS AST children sequentially to extract animation properties\n *\n * This function handles the parsing of CSS animation layer syntax,\n * including animation names, time values, timing functions, iteration counts,\n * direction, fill mode, and play state.\n * CSS ordering rules: first time = duration, second time = delay\n *\n * Returns false if parsing should fail (e.g., too many time values, unrecognized tokens, duplicates)\n */\nfunction processCssChildren(children: csstree.CssNode[], result: AnimationLayer): boolean {\n  let timeCount = 0; // Track first vs second time value\n\n  for (const child of children) {\n    let matched = false; // Track if this token was recognized\n\n    // Skip whitespace and operators\n    if (child.type === \"WhiteSpace\" || child.type === \"Operator\") {\n      continue;\n    }\n\n    // Handle animation name first (can be any identifier including var() or quoted strings)\n    if (!result.name) {\n      if (child.type === \"Identifier\") {\n        const name = (child as csstree.Identifier).name;\n        if (name === \"none\") {\n          result.name = \"none\";\n          matched = true;\n        }\n        // Check if it looks like a valid animation name identifier\n        // Allow custom identifiers matching pattern, but exclude timing functions and other keywords\n        else if (\n          /^-?[a-zA-Z][a-zA-Z0-9-]*$/.test(name) &&\n          !isTimingFunction(name) &&\n          !/^(normal|reverse|alternate|alternate-reverse|none|forwards|backwards|both|running|paused|infinite)$/i.test(\n            name\n          )\n        ) {\n          result.name = name;\n          matched = true;\n        }\n      } else if (child.type === \"Function\") {\n        const funcValue = csstree.generate(child);\n        if (funcValue.startsWith(\"var(\")) {\n          result.name = funcValue;\n          matched = true;\n        }\n      } else if (child.type === \"String\") {\n        result.name = csstree.generate(child);\n        matched = true;\n      }\n\n      if (matched) continue;\n    }\n\n    // Handle timing functions FIRST (keywords and functions)\n    // Must check before time values to avoid cubic-bezier() being treated as time\n    if (!result.timingFunction) {\n      if (child.type === \"Identifier\") {\n        const timingValue = csstree.generate(child);\n        if (isTimingFunction(timingValue)) {\n          result.timingFunction = timingValue;\n          matched = true;\n        }\n      }\n\n      if (child.type === \"Function\") {\n        const funcValue = csstree.generate(child);\n        if (isTimingFunction(funcValue)) {\n          // Fix spacing in function calls (css-tree removes spaces after commas)\n          result.timingFunction = funcValue.replace(/,([^\\s])/g, \", $1\");\n          matched = true;\n        }\n      }\n    } else {\n      // Check for duplicates\n      if (child.type === \"Identifier\") {\n        const timingValue = csstree.generate(child);\n        if (isTimingFunction(timingValue)) {\n          return false; // Duplicate timing function\n        }\n      }\n      if (child.type === \"Function\") {\n        const funcValue = csstree.generate(child);\n        if (isTimingFunction(funcValue)) {\n          return false; // Duplicate timing function\n        }\n      }\n    }\n\n    // Handle time values (duration and delay)\n    // Accept: Dimensions with time units (1s, 500ms), or any Function (calc, var, etc.)\n    if (!matched && matchesType(child, [\"Dimension\", \"Function\"])) {\n      const timeValue = csstree.generate(child);\n\n      // For Dimensions, validate they have time units\n      // For Functions (var, calc), accept unconditionally (carry over as-is)\n      if (child.type === \"Function\" || isTime(timeValue)) {\n        if (timeCount >= 2) {\n          // More than 2 time values is invalid\n          return false;\n        }\n        if (timeCount === 0) {\n          result.duration = timeValue;\n        } else {\n          result.delay = timeValue;\n        }\n        timeCount++;\n        matched = true;\n      }\n    }\n\n    // Handle iteration count\n    // Accept: Number, \"infinite\" keyword, or any Function (calc, var, etc.)\n    if (!matched && !result.iterationCount) {\n      if (matchesType(child, [\"Number\", \"Function\"])) {\n        const numValue = csstree.generate(child);\n        result.iterationCount = numValue;\n        matched = true;\n      }\n      if (child.type === \"Identifier\") {\n        const identValue = csstree.generate(child);\n        if (identValue === \"infinite\") {\n          result.iterationCount = \"infinite\";\n          matched = true;\n        }\n      }\n    } else if (!matched) {\n      // Check for duplicates\n      if (matchesType(child, [\"Number\", \"Function\"])) {\n        return false; // Duplicate iteration count\n      }\n      if (child.type === \"Identifier\") {\n        const identValue = csstree.generate(child);\n        if (identValue === \"infinite\") {\n          return false; // Duplicate iteration count\n        }\n      }\n    }\n\n    // Handle direction keywords\n    if (!result.direction) {\n      if (child.type === \"Identifier\") {\n        const identValue = csstree.generate(child);\n        if (/^(normal|reverse|alternate|alternate-reverse)$/i.test(identValue)) {\n          result.direction = identValue;\n          matched = true;\n        }\n      }\n    } else {\n      // Check for duplicates\n      if (child.type === \"Identifier\") {\n        const identValue = csstree.generate(child);\n        if (/^(normal|reverse|alternate|alternate-reverse)$/i.test(identValue)) {\n          return false; // Duplicate direction\n        }\n      }\n    }\n\n    // Handle fill mode keywords\n    if (!result.fillMode) {\n      if (child.type === \"Identifier\") {\n        const identValue = csstree.generate(child);\n        if (/^(none|forwards|backwards|both)$/i.test(identValue)) {\n          result.fillMode = identValue;\n          matched = true;\n        }\n      }\n    } else {\n      // Check for duplicates\n      if (child.type === \"Identifier\") {\n        const identValue = csstree.generate(child);\n        if (/^(none|forwards|backwards|both)$/i.test(identValue)) {\n          return false; // Duplicate fill mode\n        }\n      }\n    }\n\n    // Handle play state keywords\n    if (!result.playState) {\n      if (child.type === \"Identifier\") {\n        const identValue = csstree.generate(child);\n        if (/^(running|paused)$/i.test(identValue)) {\n          result.playState = identValue;\n          matched = true;\n        }\n      }\n    } else {\n      // Check for duplicates\n      if (child.type === \"Identifier\") {\n        const identValue = csstree.generate(child);\n        if (/^(running|paused)$/i.test(identValue)) {\n          return false; // Duplicate play state\n        }\n      }\n    }\n\n    // If token was not matched by any category, it's unrecognized\n    if (!matched) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Reconstructs final CSS properties from layer objects\n */\nexport function reconstructLayers(layers: AnimationLayer[]): Record<string, string> {\n  const result: Record<string, string> = {};\n\n  // Collect all layer values for each property\n  const properties = {\n    \"animation-name\": layers.map((l) => l.name || ANIMATION_DEFAULTS.name),\n    \"animation-duration\": layers.map((l) => l.duration || ANIMATION_DEFAULTS.duration),\n    \"animation-timing-function\": layers.map(\n      (l) => l.timingFunction || ANIMATION_DEFAULTS.timingFunction\n    ),\n    \"animation-delay\": layers.map((l) => l.delay || ANIMATION_DEFAULTS.delay),\n    \"animation-iteration-count\": layers.map(\n      (l) => l.iterationCount || ANIMATION_DEFAULTS.iterationCount\n    ),\n    \"animation-direction\": layers.map((l) => l.direction || ANIMATION_DEFAULTS.direction),\n    \"animation-fill-mode\": layers.map((l) => l.fillMode || ANIMATION_DEFAULTS.fillMode),\n    \"animation-play-state\": layers.map((l) => l.playState || ANIMATION_DEFAULTS.playState),\n  };\n\n  // Join layer values with commas\n  Object.entries(properties).forEach(([property, values]) => {\n    result[property] = values.join(\", \");\n  });\n\n  return result;\n}\n","// b_path:: src/handlers/animation/expand.ts\n\n// NOTE: This handler contains complex multi-layer parsing logic that is a candidate\n// for future refactoring. The current implementation works correctly but could be\n// simplified with better abstractions for timing/iteration/direction parsing.\n\nimport isTime from \"@/internal/is-time\";\nimport isTimingFunction from \"@/internal/is-timing-function\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\nimport {\n  ANIMATION_DEFAULTS,\n  needsAdvancedParser,\n  parseAnimationLayers,\n  reconstructLayers,\n} from \"./animation-layers\";\n\nconst KEYWORD = /^(inherit|initial|unset|revert)$/i;\nconst ITERATION_COUNT = /^(infinite|[0-9]+(\\.[0-9]+)?)$/;\nconst DIRECTION = /^(normal|reverse|alternate|alternate-reverse)$/i;\nconst FILL_MODE = /^(none|forwards|backwards|both)$/i;\nconst PLAY_STATE = /^(running|paused)$/i;\n\nfunction parseAnimationValue(value: string): Record<string, string> | undefined {\n  // Handle global keywords first\n  if (KEYWORD.test(value.trim())) {\n    return {\n      \"animation-name\": value.trim(),\n      \"animation-duration\": value.trim(),\n      \"animation-timing-function\": value.trim(),\n      \"animation-delay\": value.trim(),\n      \"animation-iteration-count\": value.trim(),\n      \"animation-direction\": value.trim(),\n      \"animation-fill-mode\": value.trim(),\n      \"animation-play-state\": value.trim(),\n    };\n  }\n\n  // Check for multi-layer syntax\n  if (needsAdvancedParser(value)) {\n    const layeredResult = parseAnimationLayers(value);\n    if (layeredResult) {\n      return reconstructLayers(layeredResult.layers);\n    }\n    return undefined; // Advanced parsing failed\n  }\n\n  // Simple single-layer fallback parser\n  const result: Record<string, string> = {};\n  const tokens = value.trim().split(/\\s+/);\n  let timeCount = 0; // Track first vs second time value\n\n  for (const token of tokens) {\n    // Handle animation name first (can be any identifier including var() or quoted strings)\n    if (!result[\"animation-name\"]) {\n      if (token === \"none\") {\n        result[\"animation-name\"] = \"none\";\n        continue;\n      }\n      // Check if it looks like a valid animation name identifier\n      // Allow custom identifiers matching pattern, var() functions, quoted strings, but exclude timing functions and other keywords\n      if (\n        (/^-?[a-zA-Z][a-zA-Z0-9-]*$/.test(token) ||\n          token.startsWith(\"var(\") ||\n          (token.startsWith('\"') && token.endsWith('\"')) ||\n          (token.startsWith(\"'\") && token.endsWith(\"'\"))) &&\n        !isTimingFunction(token) &&\n        !DIRECTION.test(token) &&\n        !FILL_MODE.test(token) &&\n        !PLAY_STATE.test(token) &&\n        !ITERATION_COUNT.test(token)\n      ) {\n        result[\"animation-name\"] = token;\n        continue;\n      }\n    }\n\n    // Handle time values (duration and delay) - CSS allows flexible ordering\n    if (isTime(token)) {\n      if (timeCount === 0) {\n        result[\"animation-duration\"] = token;\n      } else if (timeCount === 1) {\n        result[\"animation-delay\"] = token;\n      } else {\n        // More than 2 time values is invalid\n        return undefined;\n      }\n      timeCount++;\n      continue;\n    }\n\n    // Handle timing functions\n    if (!result[\"animation-timing-function\"] && isTimingFunction(token)) {\n      result[\"animation-timing-function\"] = token;\n      continue;\n    }\n\n    // Handle iteration count\n    if (!result[\"animation-iteration-count\"] && ITERATION_COUNT.test(token)) {\n      result[\"animation-iteration-count\"] = token;\n      continue;\n    }\n\n    // Handle direction keywords\n    if (!result[\"animation-direction\"] && DIRECTION.test(token)) {\n      result[\"animation-direction\"] = token;\n      continue;\n    }\n\n    // Handle fill mode keywords\n    if (!result[\"animation-fill-mode\"] && FILL_MODE.test(token)) {\n      result[\"animation-fill-mode\"] = token;\n      continue;\n    }\n\n    // Handle play state keywords\n    if (!result[\"animation-play-state\"] && PLAY_STATE.test(token)) {\n      result[\"animation-play-state\"] = token;\n      continue;\n    }\n\n    // If token doesn't match any category, it's invalid\n    return undefined;\n  }\n\n  // Accept single-token property values - they will expand to defaults\n\n  // Build final result with defaults\n  return {\n    \"animation-name\": result[\"animation-name\"] || ANIMATION_DEFAULTS.name,\n    \"animation-duration\": result[\"animation-duration\"] || ANIMATION_DEFAULTS.duration,\n    \"animation-timing-function\":\n      result[\"animation-timing-function\"] || ANIMATION_DEFAULTS.timingFunction,\n    \"animation-delay\": result[\"animation-delay\"] || ANIMATION_DEFAULTS.delay,\n    \"animation-iteration-count\":\n      result[\"animation-iteration-count\"] || ANIMATION_DEFAULTS.iterationCount,\n    \"animation-direction\": result[\"animation-direction\"] || ANIMATION_DEFAULTS.direction,\n    \"animation-fill-mode\": result[\"animation-fill-mode\"] || ANIMATION_DEFAULTS.fillMode,\n    \"animation-play-state\": result[\"animation-play-state\"] || ANIMATION_DEFAULTS.playState,\n  };\n}\n\n/**\n * Property handler for the 'animation' CSS shorthand property\n *\n * Expands animation into animation-name, animation-duration, animation-timing-function,\n * animation-delay, animation-iteration-count, animation-direction, animation-fill-mode,\n * and animation-play-state.\n *\n * @example\n * ```typescript\n * animationHandler.expand('slide 300ms ease-in');\n * animationHandler.expand('bounce 1s infinite');\n * ```\n */\nexport const animationHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"animation\",\n    longhands: [\n      \"animation-name\",\n      \"animation-duration\",\n      \"animation-timing-function\",\n      \"animation-delay\",\n      \"animation-iteration-count\",\n      \"animation-direction\",\n      \"animation-fill-mode\",\n      \"animation-play-state\",\n    ],\n    defaults: {\n      \"animation-name\": ANIMATION_DEFAULTS.name,\n      \"animation-duration\": ANIMATION_DEFAULTS.duration,\n      \"animation-timing-function\": ANIMATION_DEFAULTS.timingFunction,\n      \"animation-delay\": ANIMATION_DEFAULTS.delay,\n      \"animation-iteration-count\": ANIMATION_DEFAULTS.iterationCount,\n      \"animation-direction\": ANIMATION_DEFAULTS.direction,\n      \"animation-fill-mode\": ANIMATION_DEFAULTS.fillMode,\n      \"animation-play-state\": ANIMATION_DEFAULTS.playState,\n    },\n    category: \"animation\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    return parseAnimationValue(value);\n  },\n\n  validate: (value: string): boolean => {\n    return animationHandler.expand(value) !== undefined;\n  },\n});\n\nexport default function animation(value: string): Record<string, string> | undefined {\n  return animationHandler.expand(value);\n}\n","// b_path:: src/internal/color-utils.ts\n// Color utility functions - replacing external dependencies for better self-containment\n\nexport const CSS_COLOR_NAMES: Record<string, string> = {\n  aliceblue: \"#F0F8FF\",\n  antiquewhite: \"#FAEBD7\",\n  aqua: \"#00FFFF\",\n  aquamarine: \"#7FFFD4\",\n  azure: \"#F0FFFF\",\n  beige: \"#F5F5DC\",\n  bisque: \"#FFE4C4\",\n  black: \"#000000\",\n  blanchedalmond: \"#FFEBCD\",\n  blue: \"#0000FF\",\n  blueviolet: \"#8A2BE2\",\n  brown: \"#A52A2A\",\n  burlywood: \"#DEB887\",\n  cadetblue: \"#5F9EA0\",\n  chartreuse: \"#7FFF00\",\n  chocolate: \"#D2691E\",\n  coral: \"#FF7F50\",\n  cornflowerblue: \"#6495ED\",\n  cornsilk: \"#FFF8DC\",\n  crimson: \"#DC143C\",\n  cyan: \"#00FFFF\",\n  darkblue: \"#00008B\",\n  darkcyan: \"#008B8B\",\n  darkgoldenrod: \"#B8860B\",\n  darkgray: \"#A9A9A9\",\n  darkgrey: \"#A9A9A9\",\n  darkgreen: \"#006400\",\n  darkkhaki: \"#BDB76B\",\n  darkmagenta: \"#8B008B\",\n  darkolivegreen: \"#556B2F\",\n  darkorange: \"#FF8C00\",\n  darkorchid: \"#9932CC\",\n  darkred: \"#8B0000\",\n  darksalmon: \"#E9967A\",\n  darkseagreen: \"#8FBC8F\",\n  darkslateblue: \"#483D8B\",\n  darkslategray: \"#2F4F4F\",\n  darkslategrey: \"#2F4F4F\",\n  darkturquoise: \"#00CED1\",\n  darkviolet: \"#9400D3\",\n  deeppink: \"#FF1493\",\n  deepskyblue: \"#00BFFF\",\n  dimgray: \"#696969\",\n  dimgrey: \"#696969\",\n  dodgerblue: \"#1E90FF\",\n  firebrick: \"#B22222\",\n  floralwhite: \"#FFFAF0\",\n  forestgreen: \"#228B22\",\n  fuchsia: \"#FF00FF\",\n  gainsboro: \"#DCDCDC\",\n  ghostwhite: \"#F8F8FF\",\n  gold: \"#FFD700\",\n  goldenrod: \"#DAA520\",\n  gray: \"#808080\",\n  grey: \"#808080\",\n  green: \"#008000\",\n  greenyellow: \"#ADFF2F\",\n  honeydew: \"#F0FFF0\",\n  hotpink: \"#FF69B4\",\n  indianred: \"#CD5C5C\",\n  indigo: \"#4B0082\",\n  ivory: \"#FFFFF0\",\n  khaki: \"#F0E68C\",\n  lavender: \"#E6E6FA\",\n  lavenderblush: \"#FFF0F5\",\n  lawngreen: \"#7CFC00\",\n  lemonchiffon: \"#FFFACD\",\n  lightblue: \"#ADD8E6\",\n  lightcoral: \"#F08080\",\n  lightcyan: \"#E0FFFF\",\n  lightgoldenrodyellow: \"#FAFAD2\",\n  lightgray: \"#D3D3D3\",\n  lightgrey: \"#D3D3D3\",\n  lightgreen: \"#90EE90\",\n  lightpink: \"#FFB6C1\",\n  lightsalmon: \"#FFA07A\",\n  lightseagreen: \"#20B2AA\",\n  lightskyblue: \"#87CEFA\",\n  lightslategray: \"#778899\",\n  lightslategrey: \"#778899\",\n  lightsteelblue: \"#B0C4DE\",\n  lightyellow: \"#FFFFE0\",\n  lime: \"#00FF00\",\n  limegreen: \"#32CD32\",\n  linen: \"#FAF0E6\",\n  magenta: \"#FF00FF\",\n  maroon: \"#800000\",\n  mediumaquamarine: \"#66CDAA\",\n  mediumblue: \"#0000CD\",\n  mediumorchid: \"#BA55D3\",\n  mediumpurple: \"#9370DB\",\n  mediumseagreen: \"#3CB371\",\n  mediumslateblue: \"#7B68EE\",\n  mediumspringgreen: \"#00FA9A\",\n  mediumturquoise: \"#48D1CC\",\n  mediumvioletred: \"#C71585\",\n  midnightblue: \"#191970\",\n  mintcream: \"#F5FFFA\",\n  mistyrose: \"#FFE4E1\",\n  moccasin: \"#FFE4B5\",\n  navajowhite: \"#FFDEAD\",\n  navy: \"#000080\",\n  oldlace: \"#FDF5E6\",\n  olive: \"#808000\",\n  olivedrab: \"#6B8E23\",\n  orange: \"#FFA500\",\n  orangered: \"#FF4500\",\n  orchid: \"#DA70D6\",\n  palegoldenrod: \"#EEE8AA\",\n  palegreen: \"#98FB98\",\n  paleturquoise: \"#AFEEEE\",\n  palevioletred: \"#DB7093\",\n  papayawhip: \"#FFEFD5\",\n  peachpuff: \"#FFDAB9\",\n  peru: \"#CD853F\",\n  pink: \"#FFC0CB\",\n  plum: \"#DDA0DD\",\n  powderblue: \"#B0E0E6\",\n  purple: \"#800080\",\n  rebeccapurple: \"#663399\",\n  red: \"#FF0000\",\n  rosybrown: \"#BC8F8F\",\n  royalblue: \"#4169E1\",\n  saddlebrown: \"#8B4513\",\n  salmon: \"#FA8072\",\n  sandybrown: \"#F4A460\",\n  seagreen: \"#2E8B57\",\n  seashell: \"#FFF5EE\",\n  sienna: \"#A0522D\",\n  silver: \"#C0C0C0\",\n  skyblue: \"#87CEEB\",\n  slateblue: \"#6A5ACD\",\n  slategray: \"#708090\",\n  slategrey: \"#708090\",\n  snow: \"#FFFAFA\",\n  springgreen: \"#00FF7F\",\n  steelblue: \"#4682B4\",\n  tan: \"#D2B48C\",\n  teal: \"#008080\",\n  thistle: \"#D8BFD8\",\n  tomato: \"#FF6347\",\n  turquoise: \"#40E0D0\",\n  violet: \"#EE82EE\",\n  wheat: \"#F5DEB3\",\n  white: \"#FFFFFF\",\n  whitesmoke: \"#F5F5F5\",\n  yellow: \"#FFFF00\",\n  yellowgreen: \"#9ACD32\",\n};\n\nexport function cssUrlRegex(): RegExp {\n  return /url\\((.*?)\\)/gi;\n}\n\nexport function hexColorRegex(opts?: { strict?: boolean }): RegExp {\n  opts = opts && typeof opts === \"object\" ? opts : {};\n  return opts.strict\n    ? /^#([a-f0-9]{3,4}|[a-f0-9]{4}(?:[a-f0-9]{2}){1,2})\\b$/i\n    : /#([a-f0-9]{3}|[a-f0-9]{4}(?:[a-f0-9]{2}){0,2})\\b/gi;\n}\n\nexport function hslRegex(options?: { exact?: boolean }): RegExp {\n  options = options || {};\n  return options.exact\n    ? /^hsl\\(\\s*(\\d+)\\s*[,\\s]?\\s*(\\d*(?:\\.\\d+)?%)\\s*[,\\s]?\\s*(\\d*(?:\\.\\d+)?%)(?:\\s*\\/?\\s*(\\d*(?:\\.\\d+)?%?))?\\s*\\)$/\n    : /hsl\\(\\s*(\\d+)\\s*[,\\s]?\\s*(\\d*(?:\\.\\d+)?%)\\s*[,\\s]?\\s*(\\d*(?:\\.\\d+)?%)(?:\\s*\\/?\\s*(\\d*(?:\\.\\d+)?%?))?\\s*\\)/gi;\n}\n\nexport function hslaRegex(options?: { exact?: boolean }): RegExp {\n  options = options || {};\n  return options.exact\n    ? /^hsla\\(\\s*(\\d+)\\s*[,\\s]?\\s*(\\d*(?:\\.\\d+)?%)\\s*[,\\s]?\\s*(\\d*(?:\\.\\d+)?%)\\s*[,/]?\\s*(\\d*(?:\\.\\d+)?%?)\\s*\\)$/\n    : /hsla\\(\\s*(\\d+)\\s*[,\\s]?\\s*(\\d*(?:\\.\\d+)?%)\\s*[,\\s]?\\s*(\\d*(?:\\.\\d+)?%)\\s*[,/]?\\s*(\\d*(?:\\.\\d+)?%?)\\s*\\)/gi;\n}\n\nexport function rgbRegex(options?: { exact?: boolean }): RegExp {\n  options = options || {};\n  return options.exact\n    ? /^rgb\\(\\s*(\\d{1,3})\\s*[,\\s]?\\s*(\\d{1,3})\\s*[,\\s]?\\s*(\\d{1,3})(?:\\s*\\/?\\s*(\\d*(?:\\.\\d+)?%?))?\\s*\\)$/\n    : /rgb\\(\\s*(\\d{1,3})\\s*[,\\s]?\\s*(\\d{1,3})\\s*[,\\s]?\\s*(\\d{1,3})(?:\\s*\\/?\\s*(\\d*(?:\\.\\d+)?%?))?\\s*\\)/gi;\n}\n\nexport function rgbaRegex(options?: { exact?: boolean }): RegExp {\n  options = options || {};\n  return options.exact\n    ? /^rgba\\(\\s*(\\d{1,3})\\s*[,\\s]?\\s*(\\d{1,3})\\s*[,\\s]?\\s*(\\d{1,3})\\s*[,/]?\\s*(\\d*(?:\\.\\d+)?%?)\\s*\\)$/\n    : /rgba\\(\\s*(\\d{1,3})\\s*[,\\s]?\\s*(\\d{1,3})\\s*[,\\s]?\\s*(\\d{1,3})\\s*[,/]?\\s*(\\d*(?:\\.\\d+)?%?)\\s*\\)/gi;\n}\n","// b_path:: src/internal/is-color.ts\nimport {\n  CSS_COLOR_NAMES,\n  hexColorRegex,\n  hslaRegex,\n  hslRegex,\n  rgbaRegex,\n  rgbRegex,\n} from \"./color-utils\";\n\nconst HEX = new RegExp(`^${hexColorRegex().source}$`, \"i\");\nconst HSLA = hslaRegex({ exact: true });\nconst HSL = hslRegex({ exact: true });\nconst RGB = rgbRegex({ exact: true });\nconst RGBA = rgbaRegex({ exact: true });\n\n/**\n * Cache for color validation results.\n * Improves performance for repeated color checks.\n */\nconst colorCache = new Map<string, boolean>();\nconst MAX_CACHE_SIZE = 500;\n\n/**\n * Checks if a string value represents a valid CSS color.\n * Supports named colors, hex, rgb, rgba, hsl, hsla, and CSS custom properties.\n * Results are cached for performance.\n *\n * @param value - The CSS value to check\n * @returns true if the value is a valid color, false otherwise\n *\n * @example\n * isColor('red') // true\n * isColor('#ff0000') // true\n * isColor('rgb(255, 0, 0)') // true\n * isColor('var(--primary-color)') // true\n * isColor('10px') // false\n */\nexport default function isColor(value: string): boolean {\n  // Check cache first\n  const cached = colorCache.get(value);\n  if (cached !== undefined) return cached;\n\n  const lowerValue = value.toLowerCase();\n\n  // Support CSS custom property (var name)\n  if (/^var\\(\\s*--[a-zA-Z0-9-_]+\\s*\\)$/.test(lowerValue)) {\n    colorCache.set(value, true);\n    return true;\n  }\n\n  const result =\n    !!CSS_COLOR_NAMES[lowerValue] ||\n    lowerValue === \"currentcolor\" ||\n    lowerValue === \"transparent\" ||\n    HEX.test(lowerValue) ||\n    HSLA.test(lowerValue) ||\n    HSL.test(lowerValue) ||\n    RGB.test(lowerValue) ||\n    RGBA.test(lowerValue);\n\n  // Cache result with size limit\n  if (colorCache.size >= MAX_CACHE_SIZE) {\n    const firstKey = colorCache.keys().next().value;\n    if (firstKey !== undefined) {\n      colorCache.delete(firstKey);\n    }\n  }\n  colorCache.set(value, result);\n\n  return result;\n}\n","// b_path:: src/internal/is-length.ts\nconst LENGTH = /^(\\+|-)?([0-9]*\\.)?[0-9]+(em|ex|ch|rem|vh|vw|vmin|vmax|px|mm|cm|in|pt|pc|%)$/i;\nconst ZERO = /^(\\+|-)?(0*\\.)?0+$/;\n\nexport default function isLength(value: string): boolean {\n  return LENGTH.test(value) || ZERO.test(value);\n}\n","// b_path:: src/internal/normalize-color.ts\nimport { hslaRegex, hslRegex, rgbaRegex, rgbRegex } from \"./color-utils\";\n\nconst FUNCTIONS = [hslaRegex(), hslRegex(), rgbRegex(), rgbaRegex()];\n\nexport default function normalizeColor(value: string): string {\n  return FUNCTIONS.reduce((acc: string, func: RegExp) => {\n    return acc.replace(func, (match: string) => {\n      // Normalize both modern (space-separated) and legacy (comma-separated) syntax\n      // Convert space-separated to comma-separated for consistent handling\n      return match\n        .replace(/\\(\\s+/g, \"(\") // Remove space after opening paren\n        .replace(/\\s+\\)/g, \")\") // Remove space before closing paren\n        .replace(/\\s*,\\s*/g, \",\") // Normalize commas (remove spaces around them)\n        .replace(/\\s*\\/\\s*/g, \"/\") // Normalize slash (remove spaces around it)\n        .replace(/\\s+/g, \",\"); // Convert remaining spaces (separators) to commas\n    });\n  }, value);\n}\n","// b_path:: src/handlers/background/background-layers.ts\n\nimport * as csstree from \"@eslint/css-tree\";\nimport type { BackgroundLayer, BackgroundResult } from \"@/core/schema\";\nimport isColor from \"@/internal/is-color\";\nimport { isPositionValueNode, isSizeValueNode } from \"@/internal/is-value-node\";\nimport { hasTopLevelCommas, splitLayers } from \"@/internal/layer-parser-utils\";\n\n// CSS default values for background properties\nexport const BACKGROUND_DEFAULTS = {\n  image: \"none\",\n  position: \"0% 0%\",\n  size: \"auto auto\",\n  repeat: \"repeat\",\n  attachment: \"scroll\",\n  origin: \"padding-box\",\n  clip: \"border-box\",\n} as const;\n\n/**\n * Checks if a background-image value is a gradient.\n * Per CSS spec, gradients default to `no-repeat` instead of `repeat`.\n */\nfunction isGradient(imageValue: string): boolean {\n  const gradientPattern =\n    /^(?:linear-gradient|radial-gradient|conic-gradient|repeating-linear-gradient|repeating-radial-gradient|repeating-conic-gradient)\\(/i;\n  return gradientPattern.test(imageValue.trim());\n}\n\n/**\n * Detects if a background value needs advanced parsing (multi-layer backgrounds)\n */\nexport function needsAdvancedParser(value: string): boolean {\n  return hasTopLevelCommas(value);\n}\n\n/**\n * Parses a complex background value using css-tree AST parsing\n */\nexport function parseBackgroundLayers(value: string): BackgroundResult | undefined {\n  try {\n    // Split into layers\n    const layerStrings = splitLayers(value);\n    if (layerStrings.length === 0) {\n      return undefined;\n    }\n\n    // Parse each layer to extract all properties\n    const parsedLayers: Array<BackgroundLayer & { color?: string }> = [];\n    let globalColor: string | undefined;\n\n    for (const layerStr of layerStrings) {\n      const parsedLayer = parseSingleLayer(layerStr);\n\n      // Extract color from the last layer that has one\n      if (parsedLayer.color) {\n        globalColor = parsedLayer.color;\n      }\n\n      parsedLayers.push(parsedLayer);\n    }\n\n    // Now distribute properties across layers according to CSS rules\n    const layers = distributeLayerProperties(parsedLayers);\n\n    return {\n      layers,\n      color: globalColor,\n    };\n  } catch (_error) {\n    // If parsing fails, return undefined to indicate invalid input\n    return undefined;\n  }\n}\n\n/**\n * Distributes properties across layers according to CSS background rules\n */\nfunction distributeLayerProperties(\n  parsedLayers: Array<BackgroundLayer & { color?: string }>\n): BackgroundLayer[] {\n  // For CSS backgrounds, properties are NOT distributed across layers.\n  // Each layer only gets the properties that were explicitly specified for it.\n  // Unspecified properties remain undefined and get default values during reconstruction.\n\n  const result: BackgroundLayer[] = [];\n\n  // Just copy the parsed properties - no distribution needed\n  for (const layer of parsedLayers) {\n    const { color: _, ...layerProps } = layer;\n    result.push(layerProps);\n  }\n\n  // Special handling for origin/clip: if a layer specifies only one box value,\n  // it applies to both origin and clip\n  result.forEach((layer) => {\n    if (layer.origin !== undefined && layer.clip === undefined) {\n      layer.clip = layer.origin;\n    }\n  });\n\n  return result;\n}\n\n/**\n * Parses a single background layer using css-tree AST parsing\n */\nfunction parseSingleLayerWithCssTree(layerValue: string): BackgroundLayer & { color?: string } {\n  const result: BackgroundLayer & { color?: string } = {};\n\n  const ast = csstree.parse(layerValue.trim(), { context: \"value\" });\n\n  // Collect all child nodes from the Value node\n  const children: csstree.CssNode[] = [];\n  csstree.walk(ast, {\n    visit: \"Value\",\n    enter: (node: csstree.CssNode) => {\n      if (node.type === \"Value\" && node.children) {\n        node.children.forEach((child) => {\n          children.push(child);\n        });\n      }\n    },\n  });\n\n  // Process children in order, handling position/size parsing\n  processCssChildren(children, result);\n\n  return result;\n}\n\n/**\n * Processes CSS AST children sequentially to extract background properties\n *\n * This function handles the complex parsing of CSS background layer syntax,\n * including position/size combinations separated by \"/\", various keyword types,\n * and proper ordering according to CSS specifications.\n */\nfunction processCssChildren(\n  children: csstree.CssNode[],\n  result: BackgroundLayer & { color?: string }\n): void {\n  let i = 0;\n  let hasPositionSize = false;\n\n  while (i < children.length) {\n    const child = children[i];\n\n    // Skip whitespace and operators (except \"/\")\n    if (child.type === \"WhiteSpace\") {\n      i++;\n      continue;\n    }\n\n    if (child.type === \"Operator\" && (child as csstree.Operator).value !== \"/\") {\n      i++;\n      continue;\n    }\n\n    // Handle background-image (url(), none, or image functions like gradients)\n    if (child.type === \"Url\" && !result.image) {\n      result.image = `url(${(child as csstree.Url).value})`;\n      i++;\n      continue;\n    }\n\n    if (child.type === \"Function\") {\n      const funcNode = child as csstree.FunctionNode;\n      if (\n        [\n          \"linear-gradient\",\n          \"radial-gradient\",\n          \"conic-gradient\",\n          \"repeating-linear-gradient\",\n          \"repeating-radial-gradient\",\n          \"repeating-conic-gradient\",\n          \"image\",\n          \"element\",\n        ].includes(funcNode.name)\n      ) {\n        if (!result.image) {\n          result.image = csstree.generate(child);\n        }\n        i++;\n        continue;\n      }\n    }\n\n    if (\n      child.type === \"Identifier\" &&\n      (child as csstree.Identifier).name === \"none\" &&\n      !result.image\n    ) {\n      result.image = \"none\";\n      i++;\n      continue;\n    }\n\n    // Handle position and size (complex parsing needed)\n    if (\n      !hasPositionSize &&\n      ((child.type === \"Operator\" && (child as csstree.Operator).value === \"/\") ||\n        isPositionValueNode(child, [\"left\", \"center\", \"right\", \"top\", \"bottom\"]))\n    ) {\n      const positionParts: string[] = [];\n      const sizeParts: string[] = [];\n      let _hasSlash = false;\n\n      // Check if we start with \"/\"\n      if (child.type === \"Operator\" && (child as csstree.Operator).value === \"/\") {\n        _hasSlash = true;\n        i++; // skip \"/\"\n\n        // Collect size parts\n        while (i < children.length) {\n          const currentChild = children[i];\n          if (currentChild.type === \"WhiteSpace\") {\n            i++;\n            continue;\n          }\n          if (isSizeValueNode(currentChild, [\"auto\", \"cover\", \"contain\"])) {\n            sizeParts.push(csstree.generate(currentChild));\n            i++;\n          } else {\n            break;\n          }\n        }\n      } else {\n        // Collect position parts until we hit \"/\" or a non-position node\n        while (i < children.length) {\n          const currentChild = children[i];\n          if (currentChild.type === \"WhiteSpace\") {\n            i++;\n            continue;\n          }\n\n          if (\n            currentChild.type === \"Operator\" &&\n            (currentChild as csstree.Operator).value === \"/\"\n          ) {\n            _hasSlash = true;\n            i++; // skip \"/\"\n\n            // Collect size parts\n            while (i < children.length) {\n              const sizeChild = children[i];\n              if (sizeChild.type === \"WhiteSpace\") {\n                i++;\n                continue;\n              }\n              if (isSizeValueNode(sizeChild, [\"auto\", \"cover\", \"contain\"])) {\n                sizeParts.push(csstree.generate(sizeChild));\n                i++;\n              } else {\n                break;\n              }\n            }\n            break;\n          } else if (\n            isPositionValueNode(currentChild, [\"left\", \"center\", \"right\", \"top\", \"bottom\"])\n          ) {\n            positionParts.push(csstree.generate(currentChild));\n            i++;\n          } else {\n            break;\n          }\n        }\n      }\n\n      if (positionParts.length > 0) {\n        result.position = positionParts.join(\" \");\n      }\n      if (sizeParts.length > 0) {\n        result.size = sizeParts.join(\" \");\n      }\n\n      hasPositionSize = true;\n      continue;\n    }\n\n    // Handle repeat values\n    if (child.type === \"Identifier\") {\n      const name = (child as csstree.Identifier).name;\n      if ([\"repeat\", \"repeat-x\", \"repeat-y\", \"space\", \"round\", \"no-repeat\"].includes(name)) {\n        if (!result.repeat) {\n          let repeat = name;\n          i++;\n\n          // Check for second repeat value\n          if (i < children.length && children[i].type === \"Identifier\") {\n            const nextName = (children[i] as csstree.Identifier).name;\n            if (\n              [\"repeat\", \"repeat-x\", \"repeat-y\", \"space\", \"round\", \"no-repeat\"].includes(nextName)\n            ) {\n              repeat += ` ${nextName}`;\n              i++;\n            }\n          }\n\n          result.repeat = repeat;\n        } else {\n          i++;\n        }\n        continue;\n      }\n    }\n\n    // Handle attachment\n    if (child.type === \"Identifier\") {\n      const name = (child as csstree.Identifier).name;\n      if ([\"fixed\", \"local\", \"scroll\"].includes(name)) {\n        if (!result.attachment) {\n          result.attachment = name;\n        }\n        i++;\n        continue;\n      }\n    }\n\n    // Handle box values (origin/clip)\n    if (child.type === \"Identifier\") {\n      const name = (child as csstree.Identifier).name;\n      if ([\"border-box\", \"padding-box\", \"content-box\"].includes(name)) {\n        if (!result.origin) {\n          result.origin = name;\n        } else if (!result.clip) {\n          result.clip = name;\n        }\n        i++;\n        continue;\n      }\n    }\n\n    // Handle colors\n    if (child.type === \"Identifier\" || child.type === \"Function\" || child.type === \"Hash\") {\n      const value = csstree.generate(child);\n      if (isColor(value)) {\n        result.color = value;\n        i++;\n        continue;\n      }\n    }\n\n    // Skip unrecognized nodes\n    i++;\n  }\n}\n\n/**\n * Parses a single background layer using css-tree AST parsing\n *\n * This function now uses css-tree for robust CSS parsing instead of\n * the previous custom tokenizer approach.\n */\nfunction parseSingleLayer(layerValue: string): BackgroundLayer & { color?: string } {\n  return parseSingleLayerWithCssTree(layerValue);\n}\n\n/**\n * Distributes property values across layers according to CSS rules\n */\nexport function distributeProperties(\n  layers: BackgroundLayer[],\n  properties: Record<string, string[]>\n): BackgroundLayer[] {\n  const result = layers.map((layer) => ({ ...layer }));\n\n  // Apply property distribution for each property type\n  Object.entries(properties).forEach(([property, values]) => {\n    const distributedValues = distributeValues(values, layers.length);\n\n    distributedValues.forEach((value, index) => {\n      if (result[index]) {\n        (result[index] as BackgroundLayer)[property as keyof BackgroundLayer] = value;\n      }\n    });\n  });\n\n  return result;\n}\n\n/**\n * Distributes values across layers using CSS repetition rules\n */\nexport function distributeValues(values: string[], layerCount: number): string[] {\n  if (values.length === 0) return [];\n\n  const result: string[] = [];\n\n  for (let i = 0; i < layerCount; i++) {\n    // CSS rule: repeat values cyclically if fewer than layers\n    result.push(values[i % values.length]);\n  }\n\n  return result;\n}\n\n/**\n * Reconstructs final CSS properties from layer objects\n */\nexport function reconstructLayers(\n  layers: BackgroundLayer[],\n  color?: string\n): Record<string, string> {\n  const result: Record<string, string> = {};\n\n  // Collect all layer values for each property\n  const backgroundImages = layers.map((l) => l.image || BACKGROUND_DEFAULTS.image);\n\n  const properties = {\n    \"background-image\": backgroundImages,\n    \"background-position\": layers.map((l) => l.position || BACKGROUND_DEFAULTS.position),\n    \"background-size\": layers.map((l) => l.size || BACKGROUND_DEFAULTS.size),\n    \"background-repeat\": layers.map((l, index) => {\n      // If repeat was explicitly set, use it\n      if (l.repeat) return l.repeat;\n\n      // Otherwise, check if the background-image is a gradient\n      // Per CSS spec: gradients default to no-repeat, not repeat\n      const imageValue = backgroundImages[index];\n      return isGradient(imageValue) ? \"no-repeat\" : BACKGROUND_DEFAULTS.repeat;\n    }),\n    \"background-attachment\": layers.map((l) => l.attachment || BACKGROUND_DEFAULTS.attachment),\n    \"background-origin\": layers.map((l) => l.origin || BACKGROUND_DEFAULTS.origin),\n    \"background-clip\": layers.map((l) => l.clip || BACKGROUND_DEFAULTS.clip),\n  };\n\n  // Join layer values with commas\n  Object.entries(properties).forEach(([property, values]) => {\n    result[property] = values.join(\", \");\n  });\n\n  // Add color (defaults to transparent if not specified)\n  result[\"background-color\"] = color || \"transparent\";\n\n  return result;\n}\n","// b_path:: src/handlers/background/expand.ts\n\n// NOTE: This handler contains complex multi-layer parsing logic that is a candidate\n// for future refactoring. The position/size parsing could be simplified with better\n// abstractions for coordinate and dimension handling.\n\nimport { cssUrlRegex } from \"@/internal/color-utils\";\nimport isColor from \"@/internal/is-color\";\nimport isLength from \"@/internal/is-length\";\nimport normalizeColor from \"@/internal/normalize-color\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\nimport { parseBackgroundLayers, reconstructLayers } from \"./background-layers\";\n\nconst ATTACHMENT = /^(fixed|local|scroll)$/;\nconst BOX = /^(border-box|padding-box|content-box)$/;\nconst IMAGE = new RegExp(`^(none|${cssUrlRegex().source})$`, \"i\");\nconst REPEAT_SINGLE = /^(repeat-x|repeat-y)$/i;\nconst REPEAT_DOUBLE = /^(repeat|space|round|no-repeat)$/i;\nconst POSITION_HORIZONTAL = /^(left|center|right)$/;\nconst POSITION_VERTICAL = /^(top|center|bottom)$/;\nconst SIZE_SINGLE = /^(cover|contain)$/;\nconst KEYWORD = /^(inherit|initial)$/i;\n\ninterface BackgroundResult {\n  attachment?: string;\n  clip?: string;\n  image?: string;\n  repeat?: string;\n  color?: string;\n  position?: string;\n  size?: string;\n}\n\nconst normalizeUrl = (value: string): string =>\n  value.replace(cssUrlRegex(), (match: string) =>\n    match.replace(/^url\\(\\s+/, \"url(\").replace(/\\s+\\)$/, \")\")\n  );\n\nfunction parseBackgroundValue(value: string): Record<string, string> | undefined {\n  // Use advanced parsing for all cases - it handles both simple and complex syntax better\n  const layeredResult = parseBackgroundLayers(value);\n  if (layeredResult) {\n    return reconstructLayers(layeredResult.layers, layeredResult.color);\n  }\n\n  // Fallback to simple parsing if advanced parsing fails\n  return simpleBackgroundParser(value);\n}\n\nfunction simpleBackgroundParser(value: string): Record<string, string> | undefined {\n  // Use existing single-layer parsing logic as fallback\n  const result: BackgroundResult = {};\n  const values = normalizeUrl(normalizeColor(value))\n    .replace(/\\(.*\\/.*\\)|(\\/)+/g, (match: string, group1: string) => (!group1 ? match : \" / \"))\n    .split(/\\s+/);\n\n  const first = values[0];\n\n  if (values.length === 1 && KEYWORD.test(first)) {\n    return {\n      \"background-attachment\": first,\n      \"background-clip\": first,\n      \"background-image\": first,\n      \"background-repeat\": first,\n      \"background-color\": first,\n      \"background-position\": first,\n      \"background-size\": first,\n    };\n  }\n\n  for (let i = 0; i < values.length; i++) {\n    let v = values[i];\n\n    if (ATTACHMENT.test(v)) {\n      if (result.attachment) return;\n      result.attachment = v;\n    } else if (BOX.test(v)) {\n      if (result.clip) return;\n      result.clip = v;\n    } else if (IMAGE.test(v)) {\n      if (result.image) return;\n      result.image = v;\n    } else if (REPEAT_SINGLE.test(v)) {\n      if (result.repeat) return;\n      result.repeat = v;\n    } else if (REPEAT_DOUBLE.test(v)) {\n      if (result.repeat) return;\n\n      const n = values[i + 1];\n\n      if (n && REPEAT_DOUBLE.test(n)) {\n        v += ` ${n}`;\n        i++;\n      }\n\n      result.repeat = v;\n    } else if (isColor(v)) {\n      if (result.color) return;\n      result.color = v;\n    } else if (POSITION_HORIZONTAL.test(v) || POSITION_VERTICAL.test(v) || isLength(v)) {\n      if (result.position) return;\n\n      const n = values[i + 1];\n      const isHorizontal = POSITION_HORIZONTAL.test(v) || isLength(v);\n      const isVertical = n && (POSITION_VERTICAL.test(n) || isLength(n));\n\n      if (isHorizontal && isVertical) {\n        result.position = `${v} ${n}`;\n        i++;\n      } else {\n        result.position = v;\n      }\n\n      const nextV = values[i + 1];\n\n      if (nextV === \"/\") {\n        i += 2;\n        const sizeV = values[i];\n\n        if (SIZE_SINGLE.test(sizeV)) {\n          result.size = sizeV;\n        } else if (sizeV === \"auto\" || isLength(sizeV)) {\n          let sizeValue = sizeV;\n          const sizeN = values[i + 1];\n\n          if (sizeN === \"auto\" || isLength(sizeN)) {\n            sizeValue += ` ${sizeN}`;\n            i++;\n          }\n\n          result.size = sizeValue;\n        } else {\n          return;\n        }\n      }\n    } else {\n      return;\n    }\n  }\n\n  const finalResult: Record<string, string> = {};\n  for (const key in result) {\n    if (result[key as keyof BackgroundResult]) {\n      finalResult[`background-${key}`] = result[key as keyof BackgroundResult] as string;\n    }\n  }\n  return finalResult;\n}\n\n/**\n * Property handler for the 'background' CSS shorthand property\n *\n * Expands background into background-image, background-position, background-size,\n * background-repeat, background-attachment, background-origin, background-clip,\n * and background-color.\n *\n * @example\n * ```typescript\n * backgroundHandler.expand('red');\n * backgroundHandler.expand('url(bg.png) center / cover no-repeat');\n * ```\n */\nexport const backgroundHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"background\",\n    longhands: [\n      \"background-image\",\n      \"background-position\",\n      \"background-size\",\n      \"background-repeat\",\n      \"background-attachment\",\n      \"background-clip\",\n      \"background-color\",\n    ],\n    category: \"visual\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    return parseBackgroundValue(value);\n  },\n\n  validate: (value: string): boolean => {\n    return backgroundHandler.expand(value) !== undefined;\n  },\n});\n\nexport default function background(value: string): Record<string, string> | undefined {\n  return backgroundHandler.expand(value);\n}\n","// b_path:: src/internal/position-parser.ts\n\n/**\n * Position parser utility for CSS position shorthands\n *\n * Handles: background-position, mask-position, object-position\n * Grammar: [ left | center | right | top | bottom | <length-percentage> ]\n * or [ [ left | center | right ] [ top | center | bottom ] ]\n * or [ [ left | center | right | <length-percentage> ] [ top | center | bottom | <length-percentage> ] ]\n */\n\nexport interface PositionResult {\n  x: string;\n  y: string;\n}\n\nconst POSITION_KEYWORDS = new Set([\"left\", \"center\", \"right\", \"top\", \"bottom\"]);\nconst HORIZONTAL_KEYWORDS = new Set([\"left\", \"center\", \"right\"]);\nconst VERTICAL_KEYWORDS = new Set([\"top\", \"center\", \"bottom\"]);\n\n/**\n * Parse a CSS position value into x and y components\n */\nexport function parsePosition(value: string): PositionResult {\n  const trimmed = value.trim();\n\n  // Empty string defaults to 0% 0%\n  if (!trimmed) {\n    return { x: \"0%\", y: \"0%\" };\n  }\n\n  // Handle global keywords\n  if (\n    trimmed === \"initial\" ||\n    trimmed === \"inherit\" ||\n    trimmed === \"unset\" ||\n    trimmed === \"revert\"\n  ) {\n    return { x: trimmed, y: trimmed };\n  }\n\n  // Split by whitespace (but preserve calc(), var(), etc.)\n  const parts = smartSplit(trimmed);\n\n  if (parts.length === 0) {\n    return { x: \"0%\", y: \"0%\" };\n  }\n\n  // 1-value syntax\n  if (parts.length === 1) {\n    const part = parts[0];\n\n    // If it's a vertical keyword, treat as y-only\n    if (VERTICAL_KEYWORDS.has(part)) {\n      return { x: \"center\", y: part };\n    }\n\n    // If it's a horizontal keyword or length, treat as x-only\n    if (HORIZONTAL_KEYWORDS.has(part) || !POSITION_KEYWORDS.has(part)) {\n      return { x: part, y: \"center\" };\n    }\n\n    // Unknown keyword\n    return { x: part, y: \"center\" };\n  }\n\n  // 2-value syntax\n  if (parts.length === 2) {\n    const [first, second] = parts;\n\n    // Both are keywords\n    if (POSITION_KEYWORDS.has(first) && POSITION_KEYWORDS.has(second)) {\n      // Check if they're swapped (top/bottom first)\n      if (VERTICAL_KEYWORDS.has(first) && HORIZONTAL_KEYWORDS.has(second)) {\n        return { x: second, y: first };\n      }\n      return { x: first, y: second };\n    }\n\n    // Standard case: x y\n    return { x: first, y: second };\n  }\n\n  // 3-value syntax: side offset center (edge-offset syntax)\n  if (parts.length === 3) {\n    const [first, second, third] = parts;\n\n    // Pattern: left 10px center → x: left 10px, y: center\n    if (HORIZONTAL_KEYWORDS.has(first) && !POSITION_KEYWORDS.has(second)) {\n      return { x: `${first} ${second}`, y: third };\n    }\n\n    // Pattern: center top 10px → x: center, y: top 10px\n    if (VERTICAL_KEYWORDS.has(second) && !POSITION_KEYWORDS.has(third)) {\n      return { x: first, y: `${second} ${third}` };\n    }\n\n    // Pattern: center bottom 10px → x: center, y: bottom 10px\n    if (!POSITION_KEYWORDS.has(first) && VERTICAL_KEYWORDS.has(second)) {\n      return { x: first, y: `${second} ${third}` };\n    }\n\n    // Fallback: first is keyword, second is offset\n    if (HORIZONTAL_KEYWORDS.has(first)) {\n      return { x: `${first} ${second}`, y: third };\n    }\n\n    return { x: first, y: `${second} ${third}` };\n  }\n\n  // 4-value syntax: side offset side offset\n  if (parts.length === 4) {\n    const [first, second, third, fourth] = parts;\n\n    // Determine which pair is horizontal vs vertical based on first keyword\n    if (HORIZONTAL_KEYWORDS.has(first)) {\n      // first+second is horizontal, third+fourth is vertical\n      return { x: `${first} ${second}`, y: `${third} ${fourth}` };\n    }\n    // first+second is vertical, third+fourth is horizontal\n    return { x: `${third} ${fourth}`, y: `${first} ${second}` };\n  }\n\n  // Fallback for complex cases\n  return { x: parts[0], y: parts[1] || \"center\" };\n}\n\n/**\n * Smart split that preserves function calls like calc(), var()\n */\nfunction smartSplit(value: string): string[] {\n  const result: string[] = [];\n  let current = \"\";\n  let depth = 0;\n\n  for (let i = 0; i < value.length; i++) {\n    const char = value[i];\n\n    if (char === \"(\") {\n      depth++;\n      current += char;\n    } else if (char === \")\") {\n      depth--;\n      current += char;\n    } else if (char === \" \" && depth === 0) {\n      if (current.trim()) {\n        result.push(current.trim());\n        current = \"\";\n      }\n    } else {\n      current += char;\n    }\n  }\n\n  if (current.trim()) {\n    result.push(current.trim());\n  }\n\n  return result;\n}\n","// b_path:: src/handlers/background-position/expand.ts\n\nimport { splitLayers } from \"../../internal/layer-parser-utils\";\nimport { parsePosition } from \"../../internal/position-parser\";\n\n/**\n * Expand background-position shorthand to longhand properties\n *\n * background-position → background-position-x, background-position-y\n *\n * Handles both single and multi-layer values:\n * - \"center\" → { x: \"center\", y: \"center\" }\n * - \"center, left top\" → { x: \"center, left\", y: \"center, top\" }\n */\nexport function expandBackgroundPosition(value: string): Record<string, string> {\n  // Check if we have multiple layers (comma-separated)\n  const layers = splitLayers(value);\n\n  if (layers.length === 1) {\n    // Single layer - simple case\n    const { x, y } = parsePosition(value);\n    return {\n      \"background-position-x\": x,\n      \"background-position-y\": y,\n    };\n  }\n\n  // Multi-layer - expand each layer and rejoin\n  const xValues: string[] = [];\n  const yValues: string[] = [];\n\n  for (const layer of layers) {\n    const { x, y } = parsePosition(layer);\n    xValues.push(x);\n    yValues.push(y);\n  }\n\n  return {\n    \"background-position-x\": xValues.join(\", \"),\n    \"background-position-y\": yValues.join(\", \"),\n  };\n}\n","// b_path:: src/handlers/background-position/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandBackgroundPosition } from \"./expand\";\n\nexport const backgroundPositionHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"background-position\",\n    longhands: [\"background-position-x\", \"background-position-y\"],\n    category: \"position\",\n  },\n  expand: (value) => expandBackgroundPosition(value),\n};\n\nexport { expandBackgroundPosition };\n","// b_path:: src/internal/directional.ts\n\n/**\n * Cache for directional property expansion results.\n * Improves performance for repeated calls with same values.\n */\nconst directionalCache = new Map<string, Record<string, string>>();\nconst MAX_CACHE_SIZE = 1000;\n\n/**\n * Expands directional values (top, right, bottom, left) from CSS shorthand notation.\n * Supports 1-4 value syntax and caches results for performance.\n *\n * @param value - CSS value string with 1-4 space-separated values\n * @returns Object with top, right, bottom, left properties, or undefined if invalid\n *\n * @example\n * directional('10px') // { top: '10px', right: '10px', bottom: '10px', left: '10px' }\n * directional('10px 20px') // { top: '10px', right: '20px', bottom: '10px', left: '20px' }\n * directional('10px 20px 30px') // { top: '10px', right: '20px', bottom: '30px', left: '20px' }\n * directional('10px 20px 30px 40px') // { top: '10px', right: '20px', bottom: '30px', left: '40px' }\n */\nexport default function directional(value: string): Record<string, string> | undefined {\n  // Check cache first\n  const cached = directionalCache.get(value);\n  if (cached) return cached;\n\n  const values = value.split(/\\s+/);\n\n  if (values.length === 1) values.splice(0, 1, ...Array.from({ length: 4 }, () => values[0]));\n  else if (values.length === 2) values.push(...values);\n  else if (values.length === 3) values.push(values[1]);\n  else if (values.length > 4) return;\n\n  const result = [\"top\", \"right\", \"bottom\", \"left\"].reduce(\n    (acc: Record<string, string>, direction: string, i: number) => {\n      acc[direction] = values[i];\n      return acc;\n    },\n    {}\n  );\n\n  // Cache result with size limit\n  if (directionalCache.size >= MAX_CACHE_SIZE) {\n    // Remove oldest entry (first key)\n    const firstKey = directionalCache.keys().next().value;\n    if (firstKey !== undefined) {\n      directionalCache.delete(firstKey);\n    }\n  }\n  directionalCache.set(value, result);\n\n  return result;\n}\n","// b_path:: src/handlers/border/expand.ts\n\n// NOTE: This handler contains complex hierarchical logic with sub-handlers that is a\n// candidate for future refactoring. The border property expands to multiple directions\n// (top/right/bottom/left) and properties (width/style/color), plus a box-sizing edge case.\n\nimport directional from \"@/internal/directional\";\nimport isColor from \"@/internal/is-color\";\nimport isLength from \"@/internal/is-length\";\nimport normalizeColor from \"@/internal/normalize-color\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\nimport { sortProperties } from \"@/internal/property-sorter\";\n\nconst WIDTH = /^(thin|medium|thick)$/;\nconst STYLE = /^(none|hidden|dotted|dashed|solid|double|groove|ridge|inset|outset)$/i;\nconst KEYWORD = /^(inherit|initial|unset|revert)$/i;\n\ninterface BorderProperties {\n  width?: string;\n  style?: string;\n  color?: string;\n}\n\ninterface BorderResult extends BorderProperties {\n  boxSizing?: string;\n}\n\ntype BorderFunction = {\n  (value: string): Record<string, string> | undefined;\n  width: (value: string) => Record<string, string> | undefined;\n  style: (value: string) => Record<string, string> | undefined;\n  color: (value: string) => Record<string, string> | undefined;\n  top: (value: string) => Record<string, string> | undefined;\n  right: (value: string) => Record<string, string> | undefined;\n  bottom: (value: string) => Record<string, string> | undefined;\n  left: (value: string) => Record<string, string> | undefined;\n};\n\nconst suffix =\n  (suffix: string) =>\n  (value: string): Record<string, string> | undefined => {\n    const longhand = directional(value);\n\n    if (!longhand) return;\n\n    const result: Record<string, string> = {};\n    for (const key in longhand) {\n      result[`border-${key}-${suffix}`] = longhand[key];\n    }\n    return sortProperties(result);\n  };\n\nconst direction =\n  (direction: string) =>\n  (value: string): Record<string, string> | undefined => {\n    const longhand = all(value);\n\n    if (!longhand) return;\n\n    const filtered: Record<string, string> = {};\n    for (const key in longhand) {\n      if (key === \"boxSizing\" && longhand[key]) {\n        filtered[key] = longhand[key];\n      } else if (longhand[key as keyof BorderProperties]) {\n        filtered[`border-${direction}-${key}`] = longhand[key as keyof BorderProperties] as string;\n      }\n    }\n    return sortProperties(filtered);\n  };\n\nconst all = (value: string): BorderResult | undefined => {\n  const values = normalizeColor(value).split(/\\s+/);\n  const first = values[0];\n\n  // Handle special case: border values with box-sizing\n  if (values.length === 4) {\n    const [width, style, color, boxSizing] = values;\n\n    // Check if first 3 values are valid border values and 4th is valid box-sizing\n    if (\n      (WIDTH.test(width) || isLength(width)) &&\n      STYLE.test(style) &&\n      isColor(color) &&\n      (boxSizing === \"border-box\" || boxSizing === \"content-box\")\n    ) {\n      return {\n        width,\n        style,\n        color,\n        boxSizing,\n      };\n    }\n  }\n\n  if (values.length > 3) return;\n  if (values.length === 1 && KEYWORD.test(first)) {\n    return {\n      width: first,\n      style: first,\n      color: first,\n    };\n  }\n\n  const result: BorderProperties = {};\n  for (let i = 0; i < values.length; i++) {\n    const v = values[i];\n\n    if (WIDTH.test(v) || isLength(v)) {\n      if (result.width) return;\n      result.width = v;\n    } else if (STYLE.test(v)) {\n      if (result.style) return;\n      result.style = v;\n    } else if (isColor(v)) {\n      if (result.color) return;\n      result.color = v;\n    } else {\n      return;\n    }\n  }\n\n  return result;\n};\n\nfunction parseBorderValue(value: string): Record<string, string> | undefined {\n  const longhand = all(value);\n\n  if (!longhand) return;\n\n  const result: Record<string, string> = {};\n\n  // Handle box-sizing separately\n  if (longhand.boxSizing) {\n    result[\"box-sizing\"] = longhand.boxSizing;\n  }\n\n  // Use defaults for missing properties\n  // Per CSS spec, the default values for border shorthand are:\n  //   width: 'medium', style: 'none', color: 'currentcolor'\n  // See: https://drafts.csswg.org/css-backgrounds-3/#border-shorthand\n  const width = longhand.width || \"medium\";\n  const style = longhand.style || \"none\";\n  const color = longhand.color || \"currentcolor\";\n\n  // Expand all three border properties\n  const widthProps = suffix(\"width\")(width);\n  const styleProps = suffix(\"style\")(style);\n  const colorProps = suffix(\"color\")(color);\n\n  if (widthProps) Object.assign(result, widthProps);\n  if (styleProps) Object.assign(result, styleProps);\n  if (colorProps) Object.assign(result, colorProps);\n\n  return sortProperties(result);\n}\n\nexport const borderHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"border\",\n    longhands: [\n      \"border-top-width\",\n      \"border-right-width\",\n      \"border-bottom-width\",\n      \"border-left-width\",\n      \"border-top-style\",\n      \"border-right-style\",\n      \"border-bottom-style\",\n      \"border-left-style\",\n      \"border-top-color\",\n      \"border-right-color\",\n      \"border-bottom-color\",\n      \"border-left-color\",\n    ],\n    defaults: {\n      \"border-top-width\": \"medium\",\n      \"border-right-width\": \"medium\",\n      \"border-bottom-width\": \"medium\",\n      \"border-left-width\": \"medium\",\n      \"border-top-style\": \"none\",\n      \"border-right-style\": \"none\",\n      \"border-bottom-style\": \"none\",\n      \"border-left-style\": \"none\",\n      \"border-top-color\": \"currentcolor\",\n      \"border-right-color\": \"currentcolor\",\n      \"border-bottom-color\": \"currentcolor\",\n      \"border-left-color\": \"currentcolor\",\n    },\n    category: \"box-model\",\n  },\n\n  expand: (value: string) => parseBorderValue(value),\n\n  validate: (value: string) => borderHandler.expand(value) !== undefined,\n});\n\nconst border: BorderFunction = (value: string): Record<string, string> | undefined => {\n  return borderHandler.expand(value);\n};\n\nborder.width = suffix(\"width\");\nborder.style = suffix(\"style\");\nborder.color = suffix(\"color\");\nborder.top = direction(\"top\");\nborder.right = direction(\"right\");\nborder.bottom = direction(\"bottom\");\nborder.left = direction(\"left\");\n\nexport default border;\n","// b_path:: src/handlers/border-radius/expand.ts\n\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\n\n/**\n * Expand 1-4 values following CSS box model (top-left, top-right, bottom-right, bottom-left)\n */\nconst expandFourValues = (values: string[]): string[] => {\n  if (values.length === 1) return [values[0], values[0], values[0], values[0]];\n  if (values.length === 2) return [values[0], values[1], values[0], values[1]];\n  if (values.length === 3) return [values[0], values[1], values[2], values[1]];\n  if (values.length === 4) return values;\n  return []; // Invalid\n};\n\n/**\n * Property handler for the 'border-radius' CSS shorthand property\n *\n * Expands border-radius into individual corner radius properties.\n * Supports both uniform radii and horizontal/vertical radii with slash syntax.\n *\n * @example\n * ```typescript\n * borderRadiusHandler.expand('10px'); // All corners: 10px\n * borderRadiusHandler.expand('10px 20px'); // TL/BR: 10px, TR/BL: 20px\n * borderRadiusHandler.expand('10px / 20px'); // Horizontal: 10px, Vertical: 20px\n * ```\n */\nexport const borderRadiusHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"border-radius\",\n    longhands: [\n      \"border-top-left-radius\",\n      \"border-top-right-radius\",\n      \"border-bottom-right-radius\",\n      \"border-bottom-left-radius\",\n    ],\n    category: \"visual\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    // Check if there's a slash separator for horizontal/vertical radii\n    const slashIndex = value.indexOf(\"/\");\n\n    if (slashIndex !== -1) {\n      // Split horizontal and vertical radii\n      const horizontalPart = value.slice(0, slashIndex).trim();\n      const verticalPart = value.slice(slashIndex + 1).trim();\n\n      const horizontalValues = horizontalPart.split(/\\s+/).filter((v) => v);\n      const verticalValues = verticalPart.split(/\\s+/).filter((v) => v);\n\n      // Expand both sets to 4 values\n      const horizontal = expandFourValues(horizontalValues);\n      const vertical = expandFourValues(verticalValues);\n\n      if (horizontal.length === 0 || vertical.length === 0) return;\n\n      // Combine into corner-specific values\n      const corners = [\"top-left\", \"top-right\", \"bottom-right\", \"bottom-left\"];\n      const result: Record<string, string> = {};\n\n      for (let i = 0; i < 4; i++) {\n        result[`border-${corners[i]}-radius`] = `${horizontal[i]} ${vertical[i]}`;\n      }\n\n      return result;\n    }\n\n    // No slash - simple case with uniform horizontal and vertical radii\n    const values = value.split(/\\s+/).filter((v) => v);\n    const expanded = expandFourValues(values);\n\n    if (expanded.length === 0) return;\n\n    const corners = [\"top-left\", \"top-right\", \"bottom-right\", \"bottom-left\"];\n    const result: Record<string, string> = {};\n\n    for (let i = 0; i < 4; i++) {\n      result[`border-${corners[i]}-radius`] = expanded[i];\n    }\n\n    return result;\n  },\n\n  validate: (value: string): boolean => {\n    return borderRadiusHandler.expand(value) !== undefined;\n  },\n});\n\nexport default (value: string): Record<string, string> | undefined => {\n  return borderRadiusHandler.expand(value);\n};\n","// b_path:: src/handlers/column-rule/expand.ts\n\nimport isColor from \"@/internal/is-color\";\nimport isLength from \"@/internal/is-length\";\nimport normalizeColor from \"@/internal/normalize-color\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\nimport { sortProperties } from \"@/internal/property-sorter\";\n\nconst WIDTH = /^(thin|medium|thick)$/;\nconst STYLE = /^(none|hidden|dotted|dashed|solid|double|groove|ridge|inset|outset)$/i;\nconst KEYWORD = /^(inherit|initial|unset|revert)$/i;\n\n/**\n * Property handler for the 'column-rule' CSS shorthand property\n *\n * Expands column-rule into column-rule-width, column-rule-style, and column-rule-color.\n *\n * @example\n * ```typescript\n * columnRuleHandler.expand('medium'); // { 'column-rule-width': 'medium', 'column-rule-style': 'none', 'column-rule-color': 'currentcolor' }\n * columnRuleHandler.expand('3px solid red'); // { 'column-rule-width': '3px', 'column-rule-style': 'solid', 'column-rule-color': 'red' }\n * columnRuleHandler.expand('dotted blue'); // { 'column-rule-width': 'medium', 'column-rule-style': 'dotted', 'column-rule-color': 'blue' }\n * ```\n */\nexport const columnRuleHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"column-rule\",\n    longhands: [\"column-rule-width\", \"column-rule-style\", \"column-rule-color\"],\n    defaults: {\n      \"column-rule-width\": \"medium\",\n      \"column-rule-style\": \"none\",\n      \"column-rule-color\": \"currentcolor\",\n    },\n    category: \"visual\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    const values = normalizeColor(value).split(/\\s+/);\n\n    if (values.length > 3) return;\n    if (values.length === 1 && KEYWORD.test(values[0])) {\n      return sortProperties({\n        \"column-rule-width\": values[0],\n        \"column-rule-style\": values[0],\n        \"column-rule-color\": values[0],\n      });\n    }\n\n    const parsed: { width?: string; style?: string; color?: string } = {};\n    for (let i = 0; i < values.length; i++) {\n      const v = values[i];\n\n      if (isLength(v) || WIDTH.test(v)) {\n        if (parsed.width) return;\n        parsed.width = v;\n      } else if (STYLE.test(v)) {\n        if (parsed.style) return;\n        parsed.style = v;\n      } else if (isColor(v)) {\n        if (parsed.color) return;\n        parsed.color = v;\n      } else {\n        return;\n      }\n    }\n\n    // Use defaults for missing properties\n    // Per CSS spec, the default values for column-rule shorthand are:\n    //   width: 'medium', style: 'none', color: 'currentcolor'\n    // See: https://drafts.csswg.org/css-multicol-1/#propdef-column-rule\n    return sortProperties({\n      \"column-rule-width\": parsed.width || \"medium\",\n      \"column-rule-style\": parsed.style || \"none\",\n      \"column-rule-color\": parsed.color || \"currentcolor\",\n    });\n  },\n\n  validate: (value: string): boolean => {\n    return columnRuleHandler.expand(value) !== undefined;\n  },\n});\n\n// Export default for backward compatibility with existing code\nexport default function columnRule(value: string): Record<string, string> | undefined {\n  return columnRuleHandler.expand(value);\n}\n","// b_path:: src/handlers/columns/expand.ts\n\nimport isLength from \"@/internal/is-length\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\nimport { sortProperties } from \"@/internal/property-sorter\";\n\n/**\n * Property handler for the 'columns' CSS shorthand property\n *\n * Expands columns into column-width and column-count.\n *\n * @example\n * ```typescript\n * columnsHandler.expand('auto'); // { 'column-width': 'auto', 'column-count': 'auto' }\n * columnsHandler.expand('12em'); // { 'column-width': '12em', 'column-count': 'auto' }\n * columnsHandler.expand('auto 12'); // { 'column-width': 'auto', 'column-count': '12' }\n * columnsHandler.expand('12em 5'); // { 'column-width': '12em', 'column-count': '5' }\n * ```\n */\nexport const columnsHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"columns\",\n    longhands: [\"column-width\", \"column-count\"],\n    category: \"layout\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    // Handle global CSS keywords\n    if (/^(inherit|initial|unset|revert)$/i.test(value)) {\n      return sortProperties({\n        \"column-width\": value,\n        \"column-count\": value,\n      });\n    }\n\n    // Split values on whitespace\n    const values = value.trim().split(/\\s+/);\n\n    // Validate value count - max 2 values\n    if (values.length > 2) {\n      return undefined;\n    }\n\n    // Regex patterns for type detection\n    const INTEGER = /^[0-9]+$/;\n    const KEYWORD = /^(auto)$/i;\n\n    const result: Record<string, string> = {};\n\n    // Separate specific values from auto values\n    const specificValues: Array<{ value: string; type: \"width\" | \"count\" }> = [];\n    const autoValues: string[] = [];\n\n    for (const val of values) {\n      if (KEYWORD.test(val)) {\n        autoValues.push(val);\n      } else if (isLength(val)) {\n        specificValues.push({ value: val, type: \"width\" });\n      } else if (INTEGER.test(val)) {\n        specificValues.push({ value: val, type: \"count\" });\n      } else {\n        return undefined; // Invalid value\n      }\n    }\n\n    // Check for conflicts in specific values\n    if (\n      specificValues.filter((v) => v.type === \"width\").length > 1 ||\n      specificValues.filter((v) => v.type === \"count\").length > 1\n    ) {\n      return undefined; // Multiple values for same property\n    }\n\n    // Assign specific values first\n    for (const { value, type } of specificValues) {\n      result[`column-${type}`] = value;\n    }\n\n    // Assign auto values to remaining properties\n    for (const autoValue of autoValues) {\n      if (!result[\"column-width\"]) {\n        result[\"column-width\"] = autoValue;\n      } else if (!result[\"column-count\"]) {\n        result[\"column-count\"] = autoValue;\n      } else {\n        return undefined; // No available property for auto\n      }\n    }\n\n    return sortProperties(result);\n  },\n\n  validate: (value: string): boolean => {\n    return columnsHandler.expand(value) !== undefined;\n  },\n});\n\n// Export default for backward compatibility with existing code\nexport default (value: string): Record<string, string> | undefined => {\n  return columnsHandler.expand(value);\n};\n","// b_path:: src/handlers/contain-intrinsic-size/expand.ts\n\nimport isLength from \"@/internal/is-length\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\n\n/**\n * Property handler for the 'contain-intrinsic-size' CSS shorthand property\n *\n * Expands contain-intrinsic-size into contain-intrinsic-width and contain-intrinsic-height.\n *\n * @example\n * ```typescript\n * containIntrinsicSizeHandler.expand('auto 100px'); // { 'contain-intrinsic-width': 'auto 100px', 'contain-intrinsic-height': 'auto 100px' }\n * containIntrinsicSizeHandler.expand('100px auto 200px'); // { 'contain-intrinsic-width': '100px', 'contain-intrinsic-height': 'auto 200px' }\n * containIntrinsicSizeHandler.expand('none'); // { 'contain-intrinsic-width': 'none', 'contain-intrinsic-height': 'none' }\n * ```\n */\nexport const containIntrinsicSizeHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"contain-intrinsic-size\",\n    longhands: [\"contain-intrinsic-width\", \"contain-intrinsic-height\"],\n    category: \"layout\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    // Handle global CSS keywords\n    if (/^(inherit|initial|unset|revert)$/i.test(value)) {\n      return {\n        \"contain-intrinsic-width\": value,\n        \"contain-intrinsic-height\": value,\n      };\n    }\n\n    // Split values on whitespace\n    const tokens = value.trim().split(/\\s+/);\n\n    // Validate token count - max 4 tokens (for two auto pairs)\n    if (tokens.length > 4 || tokens.length === 0) {\n      return undefined;\n    }\n\n    const result: Record<string, string> = {};\n\n    // Parse tokens into width and height values\n    let i = 0;\n    const parseValue = (): string | undefined => {\n      if (i >= tokens.length) return undefined;\n\n      const token = tokens[i++];\n      if (token.toLowerCase() === \"auto\") {\n        if (i >= tokens.length) return undefined; // auto must be followed by something\n        const nextToken = tokens[i++];\n        if (nextToken.toLowerCase() === \"none\") {\n          return \"auto none\";\n        } else if (isLength(nextToken)) {\n          return `auto ${nextToken}`;\n        } else {\n          return undefined; // invalid after auto\n        }\n      } else if (token.toLowerCase() === \"none\") {\n        return \"none\";\n      } else if (isLength(token)) {\n        return token;\n      } else {\n        return undefined; // invalid token\n      }\n    };\n\n    // Parse width value\n    const widthValue = parseValue();\n    if (widthValue === undefined) return undefined;\n\n    // Parse height value (if present)\n    const heightValue = parseValue();\n\n    // If only one value provided, apply to both\n    if (heightValue === undefined) {\n      result[\"contain-intrinsic-width\"] = widthValue;\n      result[\"contain-intrinsic-height\"] = widthValue;\n    } else {\n      // Two values provided\n      result[\"contain-intrinsic-width\"] = widthValue;\n      result[\"contain-intrinsic-height\"] = heightValue;\n    }\n\n    // Ensure no extra tokens\n    if (i !== tokens.length) return undefined;\n\n    return result;\n  },\n\n  validate: (value: string): boolean => {\n    return containIntrinsicSizeHandler.expand(value) !== undefined;\n  },\n});\n\n// Export default for backward compatibility with existing code\nexport default (value: string): Record<string, string> | undefined => {\n  return containIntrinsicSizeHandler.expand(value);\n};\n","// b_path:: src/handlers/flex/expand.ts\n\nimport isLength from \"@/internal/is-length\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\n\n/**\n * Property handler for the 'flex' CSS shorthand property\n *\n * Expands flex into flex-grow, flex-shrink, and flex-basis.\n *\n * @example\n * ```typescript\n * flexHandler.expand('1'); // { 'flex-grow': '1', 'flex-shrink': '1', 'flex-basis': '0%' }\n * flexHandler.expand('auto'); // { 'flex-grow': '1', 'flex-shrink': '1', 'flex-basis': 'auto' }\n * flexHandler.expand('1 1 200px'); // { 'flex-grow': '1', 'flex-shrink': '1', 'flex-basis': '200px' }\n * ```\n */\nexport const flexHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"flex\",\n    longhands: [\"flex-grow\", \"flex-shrink\", \"flex-basis\"],\n    defaults: {\n      \"flex-grow\": \"0\",\n      \"flex-shrink\": \"1\",\n      \"flex-basis\": \"auto\",\n    },\n    category: \"layout\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    // Handle global CSS keywords\n    if (/^(inherit|unset|revert)$/i.test(value)) {\n      return {\n        \"flex-grow\": value,\n        \"flex-shrink\": value,\n        \"flex-basis\": value,\n      };\n    }\n\n    // Special case for initial\n    if (value === \"initial\") {\n      return {\n        \"flex-grow\": \"0\",\n        \"flex-shrink\": \"1\",\n        \"flex-basis\": \"auto\",\n      };\n    }\n\n    // Handle special keyword values\n    if (value === \"none\") {\n      return {\n        \"flex-grow\": \"0\",\n        \"flex-shrink\": \"0\",\n        \"flex-basis\": \"auto\",\n      };\n    }\n\n    if (value === \"auto\") {\n      return {\n        \"flex-grow\": \"1\",\n        \"flex-shrink\": \"1\",\n        \"flex-basis\": \"auto\",\n      };\n    }\n\n    // Parse normal values\n    const parts = value.trim().split(/\\s+/);\n    if (parts.length > 3 || parts.length === 0) return undefined;\n\n    // Define value type detection patterns\n    const numberPattern = /^[+-]?([0-9]*\\.)?[0-9]+$/;\n    const flexBasisKeywordPattern = /^(auto|content|max-content|min-content|fit-content)$/i;\n    const fitContentFn = /^fit-content\\(\\s*[^)]+\\s*\\)$/i;\n\n    // Classify each value by type\n    const classified: Array<{ value: string; type: \"number\" | \"basis\" }> = [];\n    for (const part of parts) {\n      if (numberPattern.test(part)) {\n        classified.push({ value: part, type: \"number\" });\n      } else if (flexBasisKeywordPattern.test(part) || isLength(part) || fitContentFn.test(part)) {\n        classified.push({ value: part, type: \"basis\" });\n      } else {\n        return undefined;\n      }\n    }\n\n    // Handle unitless zero as basis in three-value form\n    if (\n      classified.length === 3 &&\n      classified[2].type === \"number\" &&\n      isLength(classified[2].value)\n    ) {\n      classified[2] = { type: \"basis\", value: classified[2].value };\n    }\n\n    // Apply expansion rules based on value count\n    if (classified.length === 1) {\n      const [val] = classified;\n      if (val.type === \"number\") {\n        return {\n          \"flex-grow\": val.value,\n          \"flex-shrink\": \"1\",\n          \"flex-basis\": \"0%\",\n        };\n      } else {\n        return {\n          \"flex-grow\": \"1\",\n          \"flex-shrink\": \"1\",\n          \"flex-basis\": val.value,\n        };\n      }\n    } else if (classified.length === 2) {\n      const [first, second] = classified;\n      if (first.type === \"number\" && second.type === \"number\") {\n        return {\n          \"flex-grow\": first.value,\n          \"flex-shrink\": second.value,\n          \"flex-basis\": \"0%\",\n        };\n      } else if (first.type === \"number\" && second.type === \"basis\") {\n        return {\n          \"flex-grow\": first.value,\n          \"flex-shrink\": \"1\",\n          \"flex-basis\": second.value,\n        };\n      } else if (first.type === \"basis\" && second.type === \"number\") {\n        return {\n          \"flex-grow\": second.value,\n          \"flex-shrink\": \"1\",\n          \"flex-basis\": first.value,\n        };\n      } else {\n        return undefined;\n      }\n    } else if (classified.length === 3) {\n      const [first, second, third] = classified;\n      if (first.type === \"number\" && second.type === \"number\" && third.type === \"basis\") {\n        return {\n          \"flex-grow\": first.value,\n          \"flex-shrink\": second.value,\n          \"flex-basis\": third.value,\n        };\n      } else {\n        return undefined;\n      }\n    }\n\n    return undefined;\n  },\n\n  validate: (value: string): boolean => {\n    return flexHandler.expand(value) !== undefined;\n  },\n});\n\nexport default function (value: string): Record<string, string> | undefined {\n  return flexHandler.expand(value);\n}\n","// b_path:: src/handlers/flex-flow/expand.ts\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\n\n/**\n * Property handler for the 'flex-flow' CSS shorthand property\n *\n * Expands flex-flow into flex-direction and flex-wrap.\n *\n * @example\n * ```typescript\n * flexFlowHandler.expand('row wrap'); // { 'flex-direction': 'row', 'flex-wrap': 'wrap' }\n * flexFlowHandler.expand('column'); // { 'flex-direction': 'column' }\n * ```\n */\nexport const flexFlowHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"flex-flow\",\n    longhands: [\"flex-direction\", \"flex-wrap\"],\n    defaults: {\n      \"flex-direction\": \"row\",\n      \"flex-wrap\": \"nowrap\",\n    },\n    category: \"layout\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    // Handle global CSS keywords first\n    if (/^(inherit|initial|unset|revert)$/i.test(value)) {\n      return {\n        \"flex-direction\": value,\n        \"flex-wrap\": value,\n      };\n    }\n\n    // Parse normal values\n    const parts = value.trim().split(/\\s+/);\n    if (parts.length > 2) return undefined;\n\n    // Define keyword patterns\n    const directionPattern = /^(row|row-reverse|column|column-reverse)$/i;\n    const wrapPattern = /^(nowrap|wrap|wrap-reverse)$/i;\n\n    // Value classification logic\n    let direction: string | undefined;\n    let wrap: string | undefined;\n\n    for (const part of parts) {\n      if (directionPattern.test(part)) {\n        if (direction !== undefined) return undefined; // duplicate\n        direction = part;\n      } else if (wrapPattern.test(part)) {\n        if (wrap !== undefined) return undefined; // duplicate\n        wrap = part;\n      } else {\n        return undefined; // invalid\n      }\n    }\n\n    // Return result\n    const result: Record<string, string> = {};\n    if (direction) result[\"flex-direction\"] = direction;\n    if (wrap) result[\"flex-wrap\"] = wrap;\n    return Object.keys(result).length > 0 ? result : undefined;\n  },\n\n  validate: (value: string): boolean => {\n    const result = flexFlowHandler.expand(value);\n    return result !== undefined;\n  },\n});\n\n// Export default for backward compatibility with existing code\nexport default function (value: string): Record<string, string> | undefined {\n  return flexFlowHandler.expand(value);\n}\n","// b_path:: src/handlers/font/expand.ts\n\n// NOTE: This handler contains complex state machine parsing logic from css-font-parser\n// that is a candidate for future refactoring. The order-dependent parsing and font-family\n// handling with quotes and commas adds significant complexity.\n\n/**\n * Copied from https://github.com/bramstein/css-font-parser\n */\n\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\nimport { sortProperties } from \"@/internal/property-sorter\";\n\n/**\n * @enum {number}\n */\nconst states = {\n  VARIATION: 1,\n  LINE_HEIGHT: 2,\n  FONT_FAMILY: 3,\n};\n\ninterface FontResult {\n  \"font-family\": string[];\n  \"font-size\"?: string;\n  \"line-height\"?: string;\n  \"font-style\"?: string;\n  \"font-weight\"?: string;\n  \"font-variant\"?: string;\n  \"font-stretch\"?: string;\n}\n\nfunction parse(input: string): FontResult | null {\n  let state = states.VARIATION;\n  let buffer = \"\";\n  const result: FontResult = {\n    \"font-family\": [],\n  };\n\n  for (let i = 0; i < input.length; i += 1) {\n    const c = input.charAt(i);\n    if (state === states.FONT_FAMILY && (c === '\"' || c === \"'\")) {\n      let index = i + 1;\n\n      // consume the entire string\n      do {\n        index = input.indexOf(c, index) + 1;\n        if (!index) {\n          // If a string is not closed by a ' or \" return null.\n          // TODO: Check to see if this is correct.\n          return null;\n        }\n      } while (input.charAt(index - 2) === \"\\\\\");\n\n      result[\"font-family\"].push(input.slice(i + 1, index - 1).replace(/\\\\('|\")/g, \"$1\"));\n\n      i = index - 1;\n      buffer = \"\";\n    } else if (state === states.FONT_FAMILY && c === \",\") {\n      if (!/^\\s*$/.test(buffer)) {\n        result[\"font-family\"].push(buffer.replace(/^\\s+|\\s+$/, \"\").replace(/\\s+/g, \" \"));\n        buffer = \"\";\n      }\n    } else if (state === states.VARIATION && (c === \" \" || c === \"/\")) {\n      if (\n        /^((xx|x)-large|(xx|s)-small|small|large|medium)$/.test(buffer) ||\n        /^(larg|small)er$/.test(buffer) ||\n        /^(\\+|-)?([0-9]*\\.)?[0-9]+(em|ex|ch|rem|vh|vw|vmin|vmax|px|mm|cm|in|pt|pc|%)$/.test(buffer)\n      ) {\n        state = c === \"/\" ? states.LINE_HEIGHT : states.FONT_FAMILY;\n        result[\"font-size\"] = buffer;\n      } else if (/^(italic|oblique)$/.test(buffer)) {\n        result[\"font-style\"] = buffer;\n      } else if (/^small-caps$/.test(buffer)) {\n        result[\"font-variant\"] = buffer;\n      } else if (/^(bold(er)?|lighter|normal|[1-9]00)$/.test(buffer)) {\n        result[\"font-weight\"] = buffer;\n      } else if (/^((ultra|extra|semi)-)?(condensed|expanded)$/.test(buffer)) {\n        result[\"font-stretch\"] = buffer;\n      }\n      buffer = \"\";\n    } else if (state === states.LINE_HEIGHT && c === \" \") {\n      if (\n        /^(\\+|-)?([0-9]*\\.)?[0-9]+(em|ex|ch|rem|vh|vw|vmin|vmax|px|mm|cm|in|pt|pc|%)?$/.test(buffer)\n      ) {\n        result[\"line-height\"] = buffer;\n      }\n      state = states.FONT_FAMILY;\n      buffer = \"\";\n    } else {\n      buffer += c;\n    }\n  }\n\n  if (state === states.FONT_FAMILY && !/^\\s*$/.test(buffer)) {\n    result[\"font-family\"].push(buffer.replace(/^\\s+|\\s+$/, \"\").replace(/\\s+/g, \" \"));\n  }\n\n  if (result[\"font-size\"] && result[\"font-family\"].length) {\n    return result;\n  } else {\n    return null;\n  }\n}\n\nfunction parseFontValue(input: string): Record<string, string> | undefined {\n  if (/^(inherit|initial)$/.test(input)) {\n    return sortProperties({\n      \"font-size\": input,\n      \"line-height\": input,\n      \"font-style\": input,\n      \"font-weight\": input,\n      \"font-variant\": input,\n      \"font-stretch\": input,\n      \"font-family\": input,\n    });\n  }\n\n  input = input.replace(/\\s*\\/\\s*/, \"/\");\n  const result = parse(input);\n\n  if (result) {\n    const finalResult: Record<string, string> = {};\n\n    // Set defaults for properties that should always be present\n    // Per CSS spec, font shorthand resets these to initial values if not specified\n    const defaults = {\n      \"font-style\": \"normal\",\n      \"font-variant\": \"normal\",\n      \"font-weight\": \"normal\",\n      \"font-stretch\": \"normal\",\n    };\n\n    // Apply defaults first\n    Object.assign(finalResult, defaults);\n\n    // Then override with parsed values\n    for (const key in result) {\n      if (key === \"font-family\") {\n        finalResult[key] = result[key]\n          .map((family: string) =>\n            /^(serif|sans-serif|monospace|cursive|fantasy)$/.test(family) ? family : `\"${family}\"`\n          )\n          .join(\", \");\n      } else if (result[key as keyof FontResult]) {\n        finalResult[key] = result[key as keyof FontResult] as string;\n      }\n    }\n    return sortProperties(finalResult);\n  }\n\n  return undefined;\n}\n\n/**\n * Property handler for the 'font' CSS shorthand property\n *\n * Expands font into font-style, font-variant, font-weight, font-stretch,\n * font-size, line-height, and font-family.\n *\n * @example\n * ```typescript\n * fontHandler.expand('italic bold 16px/1.5 Arial, sans-serif');\n * fontHandler.expand('12px \"Helvetica Neue\", Helvetica');\n * ```\n */\nexport const fontHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"font\",\n    longhands: [\n      \"font-style\",\n      \"font-variant\",\n      \"font-weight\",\n      \"font-stretch\",\n      \"font-size\",\n      \"line-height\",\n      \"font-family\",\n    ],\n    category: \"typography\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    return parseFontValue(value);\n  },\n\n  validate: (value: string): boolean => {\n    return fontHandler.expand(value) !== undefined;\n  },\n});\n\nexport default function font(value: string): Record<string, string> | undefined {\n  return fontHandler.expand(value);\n}\n","// b_path:: src/handlers/grid/expand.ts\n\n// NOTE: This handler contains extremely complex grid template syntax parsing logic\n// (~446 lines) that is a candidate for future refactoring. The implementation handles\n// named grid lines, track sizes, repeat() notation, area names, and multiple syntaxes\n// (template form, explicit-rows, explicit-columns). The parsing logic is preserved as-is.\n\nimport * as csstree from \"@eslint/css-tree\";\nimport { matchesType } from \"@/internal/is-value-node\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\n\n// CSS default values for grid properties\n// NOTE: row-gap and column-gap are NOT part of grid shorthand\nexport const GRID_DEFAULTS = {\n  \"grid-template-rows\": \"none\",\n  \"grid-template-columns\": \"none\",\n  \"grid-template-areas\": \"none\",\n  \"grid-auto-rows\": \"auto\",\n  \"grid-auto-columns\": \"auto\",\n  \"grid-auto-flow\": \"row\",\n} as const;\n\n/**\n * Parses value and returns segments and slash count\n */\nfunction parseValueAndGetSegments(\n  value: string\n): { leftSegment: csstree.CssNode[]; rightSegment: csstree.CssNode[]; slashCount: number } | null {\n  try {\n    const ast = csstree.parse(value.trim(), { context: \"value\" }) as csstree.Value;\n\n    // Find top-level / operator positions\n    const slashIndices: number[] = [];\n\n    csstree.walk(ast, {\n      visit: \"Value\",\n      enter: (node: csstree.CssNode) => {\n        if (node.type === \"Value\" && node.children) {\n          let index = 0;\n          node.children.forEach((child) => {\n            if (child.type === \"Operator\" && (child as csstree.Operator).value === \"/\") {\n              slashIndices.push(index);\n            }\n            index++;\n          });\n        }\n      },\n    });\n\n    const slashCount = slashIndices.length;\n    if (slashCount > 1) {\n      return null; // Multiple slashes not allowed\n    }\n\n    const childrenArray = listToArray(ast.children);\n    if (slashCount === 0) {\n      return { leftSegment: childrenArray, rightSegment: [], slashCount: 0 };\n    }\n\n    const slashIndex = slashIndices[0];\n    const leftSegment = childrenArray.slice(0, slashIndex);\n    const rightSegment = childrenArray.slice(slashIndex + 1);\n\n    return { leftSegment, rightSegment, slashCount };\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Detects which grid shorthand form is being used\n */\nfunction detectGridForm(\n  leftSegment: csstree.CssNode[],\n  rightSegment: csstree.CssNode[]\n): \"template\" | \"explicit-rows\" | \"explicit-columns\" | null {\n  if (rightSegment.length === 0) {\n    // No slash, check if it's valid track list or ASCII art\n    return \"template\";\n  }\n\n  // Check for auto-flow in each segment\n  let hasAutoFlowLeft = false;\n  let hasAutoFlowRight = false;\n\n  for (const node of leftSegment) {\n    if (node.type === \"Identifier\" && (node as csstree.Identifier).name === \"auto-flow\") {\n      hasAutoFlowLeft = true;\n      break;\n    }\n  }\n\n  for (const node of rightSegment) {\n    if (node.type === \"Identifier\" && (node as csstree.Identifier).name === \"auto-flow\") {\n      hasAutoFlowRight = true;\n      break;\n    }\n  }\n\n  if (hasAutoFlowRight) {\n    return \"explicit-rows\";\n  } else if (hasAutoFlowLeft) {\n    return \"explicit-columns\";\n  } else {\n    return \"template\";\n  }\n}\n\n/**\n * Helper to convert List to array\n */\nfunction listToArray<T>(list: csstree.List<T>): T[] {\n  const arr: T[] = [];\n  for (const item of list) {\n    arr.push(item);\n  }\n  return arr;\n}\n\n/**\n * Separates areas (strings) and tracks (other nodes) from a segment\n */\nfunction separateAreasAndTracks(segmentNodes: csstree.CssNode[]): {\n  areas: string | undefined;\n  tracks: string | undefined;\n} {\n  const strings: string[] = [];\n  const tracks: csstree.CssNode[] = [];\n\n  for (const node of segmentNodes) {\n    if (node.type === \"String\") {\n      strings.push((node as csstree.StringNode).value);\n    } else if (node.type !== \"WhiteSpace\") {\n      tracks.push(node);\n    }\n  }\n\n  let areas: string | undefined;\n  if (strings.length > 0) {\n    // Validate that all rows have the same number of columns\n    const rows = strings.map((s) => s.trim().split(/\\s+/));\n    const columnCount = rows[0]?.length || 0;\n    if (columnCount === 0 || !rows.every((row) => row.length === columnCount)) {\n      return { areas: undefined, tracks: undefined }; // Invalid\n    }\n    areas = strings.map((s) => `\"${s.trim()}\"`).join(\" \");\n  }\n\n  let tracksStr: string | undefined;\n  if (tracks.length > 0) {\n    tracksStr = parseTrackList(tracks);\n  }\n\n  return { areas, tracks: tracksStr };\n}\n\n/**\n * Parses track list (rows or columns) into CSS string\n */\nfunction parseTrackList(segmentNodes: csstree.CssNode[]): string | undefined {\n  const validNodes: csstree.CssNode[] = [];\n\n  for (const node of segmentNodes) {\n    if (\n      node.type === \"Identifier\" &&\n      [\"auto\", \"min-content\", \"max-content\"].includes((node as csstree.Identifier).name)\n    ) {\n      validNodes.push(node);\n    } else if (matchesType(node, [\"Dimension\", \"Percentage\", \"Number\"])) {\n      validNodes.push(node);\n    } else if (\n      node.type === \"Function\" &&\n      [\"repeat\", \"minmax\", \"fit-content\"].includes((node as csstree.FunctionNode).name)\n    ) {\n      validNodes.push(node);\n    } else if (node.type === \"Parentheses\") {\n      // Named grid lines like [line1]\n      validNodes.push(node);\n    }\n  }\n\n  if (validNodes.length === 0) {\n    return undefined;\n  }\n\n  // Generate CSS from the valid nodes\n  const generatedParts: string[] = [];\n  for (const node of validNodes) {\n    generatedParts.push(csstree.generate(node));\n  }\n\n  return generatedParts.join(\" \");\n}\n\n/**\n * Parses template form: <grid-template>\n */\nfunction parseTemplateForm(\n  leftSegment: csstree.CssNode[],\n  rightSegment: csstree.CssNode[]\n): Record<string, string> | undefined {\n  let templateAreas: string | undefined;\n  let templateRows: string | undefined;\n  let templateColumns: string | undefined;\n\n  if (rightSegment.length === 0) {\n    // No slash - could be just rows, but not areas\n    const { areas, tracks } = separateAreasAndTracks(leftSegment);\n    if (areas) {\n      return undefined; // Strings without slash not supported\n    }\n    templateRows = tracks;\n    if (!templateRows) {\n      return undefined; // Invalid\n    }\n  } else {\n    const { areas: leftAreas, tracks: leftTracks } = separateAreasAndTracks(leftSegment);\n    const { tracks: rightTracks } = separateAreasAndTracks(rightSegment);\n\n    // Template form logic:\n    // - If left has areas, then left areas + left tracks (as rows) + right columns\n    // - If left has tracks but no areas, then left rows + right columns\n    // - If no slash and left has areas, then just areas\n    // - If no slash and left has tracks, then just rows\n\n    if (leftAreas) {\n      templateAreas = leftAreas;\n      templateRows = leftTracks; // Interleaved track sizes become rows\n      templateColumns = rightTracks;\n      if (!templateColumns) {\n        return undefined;\n      }\n    } else if (leftTracks) {\n      templateRows = leftTracks;\n      templateColumns = rightTracks;\n      if (!templateColumns) {\n        return undefined;\n      }\n    } else {\n      return undefined; // Invalid\n    }\n  }\n\n  return {\n    \"grid-template-rows\": templateRows || GRID_DEFAULTS[\"grid-template-rows\"],\n    \"grid-template-columns\": templateColumns || GRID_DEFAULTS[\"grid-template-columns\"],\n    \"grid-template-areas\": templateAreas || GRID_DEFAULTS[\"grid-template-areas\"],\n    \"grid-auto-rows\": GRID_DEFAULTS[\"grid-auto-rows\"],\n    \"grid-auto-columns\": GRID_DEFAULTS[\"grid-auto-columns\"],\n    \"grid-auto-flow\": GRID_DEFAULTS[\"grid-auto-flow\"],\n  };\n}\n\n/**\n * Parses explicit rows form: <rows> / auto-flow [dense] [<auto-columns>]\n */\nfunction parseExplicitRowsForm(\n  leftSegment: csstree.CssNode[],\n  rightSegment: csstree.CssNode[]\n): Record<string, string> | undefined {\n  // Check if right segment starts with auto-flow\n  let firstNonWhiteSpace: csstree.CssNode | undefined;\n  for (const node of rightSegment) {\n    if (node.type !== \"WhiteSpace\") {\n      firstNonWhiteSpace = node;\n      break;\n    }\n  }\n  if (\n    !firstNonWhiteSpace ||\n    firstNonWhiteSpace.type !== \"Identifier\" ||\n    (firstNonWhiteSpace as csstree.Identifier).name !== \"auto-flow\"\n  ) {\n    return undefined;\n  }\n\n  // Left side: template rows\n  const templateRows = parseTrackList(leftSegment);\n  if (!templateRows) {\n    return undefined;\n  }\n\n  // Right side: auto-flow [dense] [auto-columns]\n  let autoFlow = \"column\";\n  let autoColumns: string | undefined;\n\n  // Find auto-flow and dense\n  let hasDense = false;\n  let autoColumnsStart = -1;\n\n  for (let i = 0; i < rightSegment.length; i++) {\n    const node = rightSegment[i];\n    if (node.type === \"Identifier\" && (node as csstree.Identifier).name === \"auto-flow\") {\n      // Next might be dense\n      if (\n        i + 1 < rightSegment.length &&\n        rightSegment[i + 1].type === \"Identifier\" &&\n        (rightSegment[i + 1] as csstree.Identifier).name === \"dense\"\n      ) {\n        hasDense = true;\n        autoColumnsStart = i + 2;\n      } else {\n        autoColumnsStart = i + 1;\n      }\n      break;\n    }\n  }\n\n  if (hasDense) {\n    autoFlow = \"column dense\";\n  }\n\n  // Parse auto-columns if present\n  if (autoColumnsStart >= 0 && autoColumnsStart < rightSegment.length) {\n    const autoColumnsSegment = rightSegment.slice(autoColumnsStart);\n    autoColumns = parseTrackList(autoColumnsSegment);\n  }\n\n  return {\n    \"grid-template-rows\": templateRows,\n    \"grid-template-columns\": GRID_DEFAULTS[\"grid-template-columns\"],\n    \"grid-template-areas\": GRID_DEFAULTS[\"grid-template-areas\"],\n    \"grid-auto-rows\": GRID_DEFAULTS[\"grid-auto-rows\"],\n    \"grid-auto-columns\": autoColumns || GRID_DEFAULTS[\"grid-auto-columns\"],\n    \"grid-auto-flow\": autoFlow,\n  };\n}\n\n/**\n * Parses explicit columns form: auto-flow [dense] [<auto-rows>] / <columns>\n */\nfunction parseExplicitColumnsForm(\n  leftSegment: csstree.CssNode[],\n  rightSegment: csstree.CssNode[]\n): Record<string, string> | undefined {\n  // Check if left segment starts with auto-flow\n  let firstNonWhiteSpace: csstree.CssNode | undefined;\n  for (const node of leftSegment) {\n    if (node.type !== \"WhiteSpace\") {\n      firstNonWhiteSpace = node;\n      break;\n    }\n  }\n  if (\n    !firstNonWhiteSpace ||\n    firstNonWhiteSpace.type !== \"Identifier\" ||\n    (firstNonWhiteSpace as csstree.Identifier).name !== \"auto-flow\"\n  ) {\n    return undefined;\n  }\n\n  // Right side: template columns\n  const templateColumns = parseTrackList(rightSegment);\n  if (!templateColumns) {\n    return undefined;\n  }\n\n  // Left side: auto-flow [dense] [auto-rows]\n  let autoFlow = \"row\";\n  let autoRows: string | undefined;\n\n  // Find auto-flow and dense\n  let hasDense = false;\n  let autoRowsStart = -1;\n\n  for (let i = 0; i < leftSegment.length; i++) {\n    const node = leftSegment[i];\n    if (node.type === \"Identifier\" && (node as csstree.Identifier).name === \"auto-flow\") {\n      // Next might be dense\n      if (\n        i + 1 < leftSegment.length &&\n        leftSegment[i + 1].type === \"Identifier\" &&\n        (leftSegment[i + 1] as csstree.Identifier).name === \"dense\"\n      ) {\n        hasDense = true;\n        autoRowsStart = i + 2;\n      } else {\n        autoRowsStart = i + 1;\n      }\n      break;\n    }\n  }\n\n  if (hasDense) {\n    autoFlow = \"row dense\";\n  }\n\n  // Parse auto-rows if present\n  if (autoRowsStart >= 0 && autoRowsStart < leftSegment.length) {\n    const autoRowsSegment = leftSegment.slice(autoRowsStart);\n    autoRows = parseTrackList(autoRowsSegment);\n  }\n\n  return {\n    \"grid-template-rows\": GRID_DEFAULTS[\"grid-template-rows\"],\n    \"grid-template-columns\": templateColumns,\n    \"grid-template-areas\": GRID_DEFAULTS[\"grid-template-areas\"],\n    \"grid-auto-rows\": autoRows || GRID_DEFAULTS[\"grid-auto-rows\"],\n    \"grid-auto-columns\": GRID_DEFAULTS[\"grid-auto-columns\"],\n    \"grid-auto-flow\": autoFlow,\n  };\n}\n\nfunction parseGridValue(value: string): Record<string, string> | undefined {\n  // Handle global CSS keywords\n  if (/^(inherit|initial|unset|revert)$/i.test(value)) {\n    return {\n      \"grid-template-rows\": value,\n      \"grid-template-columns\": value,\n      \"grid-template-areas\": value,\n      \"grid-auto-rows\": value,\n      \"grid-auto-columns\": value,\n      \"grid-auto-flow\": value,\n    };\n  }\n\n  // Handle none keyword\n  if (value.trim().toLowerCase() === \"none\") {\n    return { ...GRID_DEFAULTS };\n  }\n\n  // Parse value and get segments\n  const segments = parseValueAndGetSegments(value);\n  if (!segments) {\n    return undefined; // Invalid (e.g., multiple slashes)\n  }\n\n  // Detect form and parse accordingly\n  const form = detectGridForm(segments.leftSegment, segments.rightSegment);\n  switch (form) {\n    case \"template\":\n      return parseTemplateForm(segments.leftSegment, segments.rightSegment);\n    case \"explicit-rows\":\n      return parseExplicitRowsForm(segments.leftSegment, segments.rightSegment);\n    case \"explicit-columns\":\n      return parseExplicitColumnsForm(segments.leftSegment, segments.rightSegment);\n    default:\n      return undefined;\n  }\n}\n\nexport const gridHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"grid\",\n    longhands: [\n      \"grid-template-rows\",\n      \"grid-template-columns\",\n      \"grid-template-areas\",\n      \"grid-auto-rows\",\n      \"grid-auto-columns\",\n      \"grid-auto-flow\",\n      // NOTE: row-gap and column-gap are NOT part of grid shorthand\n      // They have their own 'gap' shorthand\n    ],\n    defaults: GRID_DEFAULTS,\n    category: \"layout\",\n  },\n\n  expand: (value: string) => parseGridValue(value),\n\n  validate: (value: string) => gridHandler.expand(value) !== undefined,\n});\n\nexport default (value: string): Record<string, string> | undefined => {\n  return gridHandler.expand(value);\n};\n","// b_path:: src/internal/grid-line.ts\n\nexport function isCustomIdent(s: string): boolean {\n  return /^[a-zA-Z_-][a-zA-Z0-9_-]*$/.test(s);\n}\n\nfunction isInteger(s: string): boolean {\n  return /^[+-]?[0-9]+$/.test(s) && Number(s) !== 0;\n}\n\nexport function parseGridLine(value: string): boolean {\n  const tokens = value.trim().split(/\\s+/);\n  if (tokens.length === 0) return false;\n\n  if (tokens[0] === \"span\") {\n    if (tokens.length < 2 || tokens.length > 3) return false;\n    const rest = tokens.slice(1);\n    let seenInt = false;\n    let seenIdent = false;\n    for (const token of rest) {\n      if (isInteger(token)) {\n        if (seenInt) return false;\n        seenInt = true;\n      } else if (isCustomIdent(token)) {\n        if (seenIdent) return false;\n        seenIdent = true;\n      } else {\n        return false;\n      }\n    }\n    return seenInt || seenIdent;\n  } else {\n    if (tokens.length > 2) return false;\n    let seenInt = false;\n    let seenIdent = false;\n    for (const token of tokens) {\n      if (isInteger(token)) {\n        if (seenInt) return false;\n        seenInt = true;\n      } else if (isCustomIdent(token)) {\n        if (seenIdent) return false;\n        seenIdent = true;\n      } else {\n        return false;\n      }\n    }\n    return seenInt || seenIdent;\n  }\n}\n\nexport function getDefaultEnd(start: string): string {\n  return isCustomIdent(start) ? start : \"auto\";\n}\n","// b_path:: src/handlers/grid-area/expand.ts\n\nimport { getDefaultEnd, parseGridLine } from \"@/internal/grid-line\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\n\n/**\n * Property handler for the 'grid-area' CSS shorthand property\n *\n * Expands grid-area into grid-row-start, grid-column-start, grid-row-end, and grid-column-end.\n *\n * @example\n * ```typescript\n * gridAreaHandler.expand('header'); // Named grid area\n * gridAreaHandler.expand('1 / 2'); // { 'grid-row-start': '1', 'grid-column-start': '2', ... }\n * gridAreaHandler.expand('1 / 2 / 3 / 4'); // All four values specified\n * ```\n */\nexport const gridAreaHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"grid-area\",\n    longhands: [\"grid-row-start\", \"grid-column-start\", \"grid-row-end\", \"grid-column-end\"],\n    category: \"layout\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    // Handle global CSS keywords\n    if (/^(inherit|initial|unset|revert)$/i.test(value)) {\n      return {\n        \"grid-row-start\": value,\n        \"grid-column-start\": value,\n        \"grid-row-end\": value,\n        \"grid-column-end\": value,\n      };\n    }\n\n    // Split values on slash\n    const parts = value.trim().split(/\\s*\\/\\s*/);\n\n    // Validate part count - max 4 parts\n    if (parts.length > 4) {\n      return undefined;\n    }\n\n    // Validate all parts\n    for (const part of parts) {\n      if (!parseGridLine(part.trim())) {\n        return undefined;\n      }\n    }\n\n    let rowStart: string, columnStart: string, rowEnd: string, columnEnd: string;\n\n    if (parts.length === 1) {\n      // 1 value: row-start (or all if custom-ident)\n      const val = parts[0].trim();\n      if (/^[a-zA-Z_-][a-zA-Z0-9_-]*$/.test(val) && !/^(auto|span|\\d)/i.test(val)) {\n        // Custom-ident: all four get the same value\n        rowStart = columnStart = rowEnd = columnEnd = val;\n      } else {\n        // Otherwise: row-start gets value, others auto\n        rowStart = val;\n        columnStart = \"auto\";\n        rowEnd = \"auto\";\n        columnEnd = \"auto\";\n      }\n    } else if (parts.length === 2) {\n      // 2 values: row-start / column-start\n      rowStart = parts[0].trim();\n      columnStart = parts[1].trim();\n      rowEnd = getDefaultEnd(rowStart);\n      columnEnd = getDefaultEnd(columnStart);\n    } else if (parts.length === 3) {\n      // 3 values: row-start / column-start / row-end\n      rowStart = parts[0].trim();\n      columnStart = parts[1].trim();\n      rowEnd = parts[2].trim();\n      columnEnd = getDefaultEnd(columnStart);\n    } else {\n      // 4 values: row-start / column-start / row-end / column-end\n      rowStart = parts[0].trim();\n      columnStart = parts[1].trim();\n      rowEnd = parts[2].trim();\n      columnEnd = parts[3].trim();\n    }\n\n    return {\n      \"grid-row-start\": rowStart,\n      \"grid-column-start\": columnStart,\n      \"grid-row-end\": rowEnd,\n      \"grid-column-end\": columnEnd,\n    };\n  },\n\n  validate: (value: string): boolean => {\n    return gridAreaHandler.expand(value) !== undefined;\n  },\n});\n\nexport default (value: string): Record<string, string> | undefined => {\n  return gridAreaHandler.expand(value);\n};\n","// b_path:: src/handlers/grid-column/expand.ts\n\nimport { getDefaultEnd, parseGridLine } from \"@/internal/grid-line\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\n\n/**\n * Property handler for the 'grid-column' CSS shorthand property\n *\n * Expands grid-column into grid-column-start and grid-column-end.\n *\n * @example\n * ```typescript\n * gridColumnHandler.expand('2'); // { 'grid-column-start': '2', 'grid-column-end': 'auto' }\n * gridColumnHandler.expand('2 / 4'); // { 'grid-column-start': '2', 'grid-column-end': '4' }\n * gridColumnHandler.expand('span 3'); // { 'grid-column-start': 'span 3', 'grid-column-end': 'auto' }\n * ```\n */\nexport const gridColumnHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"grid-column\",\n    longhands: [\"grid-column-start\", \"grid-column-end\"],\n    category: \"layout\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    // Handle global CSS keywords\n    if (/^(inherit|initial|unset|revert)$/i.test(value)) {\n      return {\n        \"grid-column-start\": value,\n        \"grid-column-end\": value,\n      };\n    }\n\n    // Split values on slash\n    const parts = value.trim().split(/\\s*\\/\\s*/);\n\n    // Validate part count - max 2 parts\n    if (parts.length > 2) {\n      return undefined;\n    }\n\n    // Handle single value\n    if (parts.length === 1) {\n      const startValue = parts[0].trim();\n      if (!parseGridLine(startValue)) {\n        return undefined;\n      }\n      const endValue = getDefaultEnd(startValue);\n      return {\n        \"grid-column-start\": startValue,\n        \"grid-column-end\": endValue,\n      };\n    }\n\n    // Handle two values\n    if (parts.length === 2) {\n      const startValue = parts[0].trim();\n      const endValue = parts[1].trim();\n      if (!parseGridLine(startValue) || !parseGridLine(endValue)) {\n        return undefined;\n      }\n      return {\n        \"grid-column-start\": startValue,\n        \"grid-column-end\": endValue,\n      };\n    }\n\n    return undefined;\n  },\n\n  validate: (value: string): boolean => {\n    return gridColumnHandler.expand(value) !== undefined;\n  },\n});\n\nexport default (value: string): Record<string, string> | undefined => {\n  return gridColumnHandler.expand(value);\n};\n","// b_path:: src/handlers/grid-row/expand.ts\n\nimport { getDefaultEnd, parseGridLine } from \"@/internal/grid-line\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\n\n/**\n * Property handler for the 'grid-row' CSS shorthand property\n *\n * Expands grid-row into grid-row-start and grid-row-end.\n *\n * @example\n * ```typescript\n * gridRowHandler.expand('2'); // { 'grid-row-start': '2', 'grid-row-end': 'auto' }\n * gridRowHandler.expand('2 / 4'); // { 'grid-row-start': '2', 'grid-row-end': '4' }\n * gridRowHandler.expand('span 3'); // { 'grid-row-start': 'span 3', 'grid-row-end': 'auto' }\n * ```\n */\nexport const gridRowHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"grid-row\",\n    longhands: [\"grid-row-start\", \"grid-row-end\"],\n    category: \"layout\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    // Handle global CSS keywords\n    if (/^(inherit|initial|unset|revert)$/i.test(value)) {\n      return {\n        \"grid-row-start\": value,\n        \"grid-row-end\": value,\n      };\n    }\n\n    // Split values on slash\n    const parts = value.trim().split(/\\s*\\/\\s*/);\n\n    // Validate part count - max 2 parts\n    if (parts.length > 2) {\n      return undefined;\n    }\n\n    // Handle single value\n    if (parts.length === 1) {\n      const startValue = parts[0].trim();\n      if (!parseGridLine(startValue)) {\n        return undefined;\n      }\n      const endValue = getDefaultEnd(startValue);\n      return {\n        \"grid-row-start\": startValue,\n        \"grid-row-end\": endValue,\n      };\n    }\n\n    // Handle two values\n    if (parts.length === 2) {\n      const startValue = parts[0].trim();\n      const endValue = parts[1].trim();\n      if (!parseGridLine(startValue) || !parseGridLine(endValue)) {\n        return undefined;\n      }\n      return {\n        \"grid-row-start\": startValue,\n        \"grid-row-end\": endValue,\n      };\n    }\n\n    return undefined;\n  },\n\n  validate: (value: string): boolean => {\n    return gridRowHandler.expand(value) !== undefined;\n  },\n});\n\nexport default (value: string): Record<string, string> | undefined => {\n  return gridRowHandler.expand(value);\n};\n","// b_path:: src/handlers/list-style/expand.ts\n\nimport { cssUrlRegex } from \"@/internal/color-utils\";\nimport normalizeColor from \"@/internal/normalize-color\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\nimport { sortProperties } from \"@/internal/property-sorter\";\n\nconst KEYWORD = /^(inherit|initial|unset|revert)$/i;\nconst POSITION = /^(inside|outside)$/i;\nconst IMAGE = new RegExp(`^(${cssUrlRegex().source})$`, \"i\");\nconst COMMON_TYPE =\n  /^(disc|circle|square|decimal|decimal-leading-zero|lower-roman|upper-roman|lower-greek|lower-alpha|lower-latin|upper-alpha|upper-latin|armenian|georgian|none)$/i;\nconst IDENT = /^[-_a-zA-Z][-_a-zA-Z0-9]*$/;\nconst STRING_VALUE = /^[\"'].*[\"']$/;\n\n/**\n * Property handler for the 'list-style' CSS shorthand property\n *\n * Expands list-style into list-style-type, list-style-position, and list-style-image.\n *\n * @example\n * ```typescript\n * listStyleHandler.expand('none'); // { 'list-style-type': 'none', 'list-style-position': 'outside', 'list-style-image': 'none' }\n * listStyleHandler.expand('disc inside'); // { 'list-style-type': 'disc', 'list-style-position': 'inside', 'list-style-image': 'none' }\n * listStyleHandler.expand('url(bullet.png)'); // { 'list-style-type': 'disc', 'list-style-position': 'outside', 'list-style-image': 'url(bullet.png)' }\n * ```\n */\nexport const listStyleHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"list-style\",\n    longhands: [\"list-style-type\", \"list-style-position\", \"list-style-image\"],\n    defaults: {\n      \"list-style-type\": \"disc\",\n      \"list-style-position\": \"outside\",\n      \"list-style-image\": \"none\",\n    },\n    category: \"typography\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    const normalizedValue = normalizeColor(value);\n\n    // Special case: \"none\" alone sets both type and image to none, position to default\n    if (normalizedValue === \"none\") {\n      return sortProperties({\n        \"list-style-type\": \"none\",\n        \"list-style-position\": \"outside\",\n        \"list-style-image\": \"none\",\n      });\n    }\n\n    const values = normalizedValue.split(/\\s+/);\n\n    if (values.length === 1 && KEYWORD.test(values[0])) {\n      return sortProperties({\n        \"list-style-type\": values[0],\n        \"list-style-position\": values[0],\n        \"list-style-image\": values[0],\n      });\n    }\n\n    // Start with defaults - list-style shorthand resets all properties\n    const result: Record<string, string> = {\n      \"list-style-type\": \"disc\",\n      \"list-style-position\": \"outside\",\n      \"list-style-image\": \"none\",\n    };\n\n    // Track what was explicitly set to detect duplicates\n    const explicitlySet = {\n      type: false,\n      position: false,\n      image: false,\n    };\n\n    for (let i = 0; i < values.length; i++) {\n      const v = values[i];\n\n      if (POSITION.test(v)) {\n        if (explicitlySet.position) return;\n        result[\"list-style-position\"] = v;\n        explicitlySet.position = true;\n      } else if (IMAGE.test(v)) {\n        if (explicitlySet.image) return;\n        result[\"list-style-image\"] = v;\n        explicitlySet.image = true;\n      } else if (COMMON_TYPE.test(v)) {\n        if (explicitlySet.type) return;\n        result[\"list-style-type\"] = v;\n        explicitlySet.type = true;\n      } else {\n        // Custom counter-style identifier or string value\n        if (IDENT.test(v) || STRING_VALUE.test(v)) {\n          if (explicitlySet.type) return;\n          result[\"list-style-type\"] = v;\n          explicitlySet.type = true;\n        } else {\n          return;\n        }\n      }\n    }\n\n    return sortProperties(result);\n  },\n\n  validate: (value: string): boolean => {\n    return listStyleHandler.expand(value) !== undefined;\n  },\n});\n\n// Export default for backward compatibility with existing code\nexport default function listStyle(value: string): Record<string, string> | undefined {\n  return listStyleHandler.expand(value);\n}\n","// b_path:: src/handlers/mask/mask-layers.ts\n\nimport * as csstree from \"@eslint/css-tree\";\nimport type { MaskLayer, MaskResult } from \"@/core/schema\";\nimport { isPositionValueNode, isSizeValueNode } from \"@/internal/is-value-node\";\nimport { hasTopLevelCommas, parseLayersGeneric } from \"@/internal/layer-parser-utils\";\n\n// CSS default values for mask properties\nexport const MASK_DEFAULTS = {\n  image: \"none\",\n  mode: \"match-source\",\n  position: \"0% 0%\",\n  size: \"auto\",\n  repeat: \"repeat\",\n  origin: \"border-box\",\n  clip: \"border-box\",\n  composite: \"add\",\n} as const;\n\n/**\n * Detects if a mask value needs advanced parsing (multi-layer masks)\n */\nexport function needsAdvancedParser(value: string): boolean {\n  return hasTopLevelCommas(value);\n}\n\n/**\n * Parses a complex mask value using css-tree AST parsing\n */\nexport function parseMaskLayers(value: string): MaskResult | undefined {\n  const layers = parseLayersGeneric(value, parseSingleLayer);\n  return layers ? { layers } : undefined;\n}\n\n/**\n * Parses a single mask layer using css-tree AST parsing\n */\nfunction parseSingleLayer(layerValue: string): MaskLayer | undefined {\n  return parseSingleLayerWithCssTree(layerValue);\n}\n\n/**\n * Parses a single mask layer using css-tree AST parsing\n */\nfunction parseSingleLayerWithCssTree(layerValue: string): MaskLayer | undefined {\n  const result: MaskLayer = {};\n\n  const ast = csstree.parse(layerValue.trim(), { context: \"value\" });\n\n  // Collect all child nodes from the Value node\n  const children: csstree.CssNode[] = [];\n  csstree.walk(ast, {\n    visit: \"Value\",\n    enter: (node: csstree.CssNode) => {\n      if (node.type === \"Value\" && node.children) {\n        node.children.forEach((child) => {\n          children.push(child);\n        });\n      }\n    },\n  });\n\n  // Process children in order, handling position/size parsing\n  const isValid = processCssChildren(children, result);\n\n  // Return undefined if there were unrecognized tokens (stricter error handling)\n  return isValid ? result : undefined;\n}\n\n/**\n * Processes CSS AST children sequentially to extract mask properties\n *\n * This function handles the complex parsing of CSS mask layer syntax,\n * including position/size combinations separated by \"/\", various keyword types,\n * and proper ordering according to CSS specifications.\n */\nfunction processCssChildren(children: csstree.CssNode[], result: MaskLayer): boolean {\n  let i = 0;\n  let hasPositionSize = false;\n  let hasUnrecognizedToken = false;\n\n  while (i < children.length) {\n    const child = children[i];\n\n    // Skip whitespace and operators (except \"/\")\n    if (child.type === \"WhiteSpace\") {\n      i++;\n      continue;\n    }\n\n    if (child.type === \"Operator\" && (child as csstree.Operator).value !== \"/\") {\n      i++;\n      continue;\n    }\n\n    // Handle mask-image (url(), none, or image functions like gradients)\n    if (child.type === \"Url\" && !result.image) {\n      result.image = `url(${(child as csstree.Url).value})`;\n      i++;\n      continue;\n    }\n\n    if (child.type === \"Function\") {\n      const funcNode = child as csstree.FunctionNode;\n      if (\n        [\n          \"linear-gradient\",\n          \"radial-gradient\",\n          \"conic-gradient\",\n          \"repeating-linear-gradient\",\n          \"repeating-radial-gradient\",\n          \"repeating-conic-gradient\",\n          \"image\",\n          \"image-set\",\n          \"cross-fade\",\n          \"paint\",\n          \"element\",\n        ].includes(funcNode.name)\n      ) {\n        if (!result.image) {\n          result.image = csstree.generate(child);\n        }\n        i++;\n        continue;\n      }\n    }\n\n    if (\n      child.type === \"Identifier\" &&\n      (child as csstree.Identifier).name === \"none\" &&\n      !result.image\n    ) {\n      result.image = \"none\";\n      i++;\n      continue;\n    }\n\n    // Handle position and size (complex parsing needed)\n    if (\n      !hasPositionSize &&\n      ((child.type === \"Operator\" && (child as csstree.Operator).value === \"/\") ||\n        isPositionValueNode(child, [\"left\", \"center\", \"right\", \"top\", \"bottom\"]))\n    ) {\n      const positionParts: string[] = [];\n      const sizeParts: string[] = [];\n      let _hasSlash = false;\n\n      // Check if we start with \"/\"\n      if (child.type === \"Operator\" && (child as csstree.Operator).value === \"/\") {\n        _hasSlash = true;\n        i++; // skip \"/\"\n\n        // Collect size parts\n        while (i < children.length) {\n          const currentChild = children[i];\n          if (currentChild.type === \"WhiteSpace\") {\n            i++;\n            continue;\n          }\n          if (isSizeValueNode(currentChild, [\"auto\", \"cover\", \"contain\"])) {\n            sizeParts.push(csstree.generate(currentChild));\n            i++;\n          } else {\n            break;\n          }\n        }\n      } else {\n        // Collect position parts until we hit \"/\" or a non-position node\n        while (i < children.length) {\n          const currentChild = children[i];\n          if (currentChild.type === \"WhiteSpace\") {\n            i++;\n            continue;\n          }\n\n          if (\n            currentChild.type === \"Operator\" &&\n            (currentChild as csstree.Operator).value === \"/\"\n          ) {\n            _hasSlash = true;\n            i++; // skip \"/\"\n\n            // Collect size parts\n            while (i < children.length) {\n              const sizeChild = children[i];\n              if (sizeChild.type === \"WhiteSpace\") {\n                i++;\n                continue;\n              }\n              if (isSizeValueNode(sizeChild, [\"auto\", \"cover\", \"contain\"])) {\n                sizeParts.push(csstree.generate(sizeChild));\n                i++;\n              } else {\n                break;\n              }\n            }\n            break;\n          } else if (\n            isPositionValueNode(currentChild, [\"left\", \"center\", \"right\", \"top\", \"bottom\"])\n          ) {\n            positionParts.push(csstree.generate(currentChild));\n            i++;\n          } else {\n            break;\n          }\n        }\n      }\n\n      if (positionParts.length > 0) {\n        result.position = positionParts.join(\" \");\n      }\n      if (sizeParts.length > 0) {\n        result.size = sizeParts.join(\" \");\n      }\n\n      hasPositionSize = true;\n      continue;\n    }\n\n    // Handle repeat values\n    // Note: repeat-x and repeat-y are supported for compatibility with background-repeat,\n    // even though the mask-repeat spec technically only allows [repeat|no-repeat|round|space]{1,2}\n    if (child.type === \"Identifier\") {\n      const name = (child as csstree.Identifier).name;\n      if ([\"repeat\", \"repeat-x\", \"repeat-y\", \"space\", \"round\", \"no-repeat\"].includes(name)) {\n        if (!result.repeat) {\n          let repeat = name;\n          i++;\n\n          // Check for second repeat value\n          if (i < children.length && children[i].type === \"Identifier\") {\n            const nextName = (children[i] as csstree.Identifier).name;\n            if (\n              [\"repeat\", \"repeat-x\", \"repeat-y\", \"space\", \"round\", \"no-repeat\"].includes(nextName)\n            ) {\n              repeat += ` ${nextName}`;\n              i++;\n            }\n          }\n\n          result.repeat = repeat;\n        } else {\n          i++;\n        }\n        continue;\n      }\n    }\n\n    // Handle mode keywords\n    if (child.type === \"Identifier\") {\n      const name = (child as csstree.Identifier).name;\n      if ([\"alpha\", \"luminance\", \"match-source\"].includes(name)) {\n        if (!result.mode) {\n          result.mode = name;\n        }\n        i++;\n        continue;\n      }\n    }\n\n    // Handle composite keywords\n    if (child.type === \"Identifier\") {\n      const name = (child as csstree.Identifier).name;\n      if ([\"add\", \"subtract\", \"intersect\", \"exclude\"].includes(name)) {\n        if (!result.composite) {\n          result.composite = name;\n        }\n        i++;\n        continue;\n      }\n    }\n\n    // Handle geometry-box values (origin/clip)\n    if (child.type === \"Identifier\") {\n      const name = (child as csstree.Identifier).name;\n      if (\n        [\"border-box\", \"padding-box\", \"content-box\", \"fill-box\", \"stroke-box\", \"view-box\"].includes(\n          name\n        )\n      ) {\n        if (!result.origin) {\n          result.origin = name;\n        } else if (!result.clip) {\n          result.clip = name;\n        }\n        i++;\n        continue;\n      }\n    }\n\n    // Handle \"no-clip\" keyword for mask-clip\n    if (child.type === \"Identifier\") {\n      const name = (child as csstree.Identifier).name;\n      if (name === \"no-clip\") {\n        if (!result.clip) {\n          result.clip = \"no-clip\";\n        }\n        i++;\n        continue;\n      }\n    }\n\n    // Skip unrecognized nodes - mark as having unrecognized token for stricter error handling\n    hasUnrecognizedToken = true;\n    i++;\n  }\n\n  // Special handling for origin/clip: if a layer specifies only one box value,\n  // it applies to both origin and clip (CSS Masking spec behavior)\n  if (result.origin !== undefined && result.clip === undefined) {\n    result.clip = MASK_DEFAULTS.clip; // Default to border-box, not origin value\n  }\n\n  return !hasUnrecognizedToken;\n}\n\n/**\n * Reconstructs final CSS properties from layer objects\n */\nexport function reconstructLayers(layers: MaskLayer[]): Record<string, string> {\n  const result: Record<string, string> = {};\n\n  // Collect all layer values for each property\n  const properties = {\n    \"mask-image\": layers.map((l) => l.image || MASK_DEFAULTS.image),\n    \"mask-mode\": layers.map((l) => l.mode || MASK_DEFAULTS.mode),\n    \"mask-position\": layers.map((l) => l.position || MASK_DEFAULTS.position),\n    \"mask-size\": layers.map((l) => l.size || MASK_DEFAULTS.size),\n    \"mask-repeat\": layers.map((l) => l.repeat || MASK_DEFAULTS.repeat),\n    \"mask-origin\": layers.map((l) => l.origin || MASK_DEFAULTS.origin),\n    \"mask-clip\": layers.map((l) => l.clip || MASK_DEFAULTS.clip),\n    \"mask-composite\": layers.map((l) => l.composite || MASK_DEFAULTS.composite),\n  };\n\n  // Join layer values with commas\n  Object.entries(properties).forEach(([property, values]) => {\n    result[property] = values.join(\", \");\n  });\n\n  return result;\n}\n","// b_path:: src/handlers/mask/expand.ts\n\n// NOTE: This handler contains complex multi-layer parsing logic that is a candidate\n// for future refactoring. Masking syntax parsing could be simplified with better abstractions.\n\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\nimport { needsAdvancedParser, parseMaskLayers, reconstructLayers } from \"./mask-layers\";\n\nconst KEYWORD = /^(inherit|initial|unset|revert)$/i;\n\nfunction parseMaskValue(value: string): Record<string, string> | undefined {\n  // Trim the input value\n  const trimmedValue = value.trim();\n\n  // Handle global keywords first\n  if (KEYWORD.test(trimmedValue)) {\n    return {\n      \"mask-image\": trimmedValue,\n      \"mask-mode\": trimmedValue,\n      \"mask-position\": trimmedValue,\n      \"mask-size\": trimmedValue,\n      \"mask-repeat\": trimmedValue,\n      \"mask-origin\": trimmedValue,\n      \"mask-clip\": trimmedValue,\n      \"mask-composite\": trimmedValue,\n    };\n  }\n\n  // Check for multi-layer syntax\n  if (needsAdvancedParser(trimmedValue)) {\n    const result = parseMaskLayers(trimmedValue);\n    if (result) {\n      return reconstructLayers(result.layers);\n    }\n    return undefined;\n  }\n\n  // For single-layer cases, use the advanced parser as well\n  // since mask syntax is complex and the parser handles it well\n  const result = parseMaskLayers(trimmedValue);\n  if (result) {\n    return reconstructLayers(result.layers);\n  }\n\n  return undefined;\n}\n\n/**\n * Property handler for the 'mask' CSS shorthand property\n *\n * Expands mask into mask-image, mask-mode, mask-position, mask-size,\n * mask-repeat, mask-origin, mask-clip, and mask-composite.\n *\n * @example\n * ```typescript\n * maskHandler.expand('url(mask.svg)');\n * maskHandler.expand('linear-gradient(black, transparent) center / contain');\n * ```\n */\nexport const maskHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"mask\",\n    longhands: [\n      \"mask-image\",\n      \"mask-mode\",\n      \"mask-position\",\n      \"mask-size\",\n      \"mask-repeat\",\n      \"mask-origin\",\n      \"mask-clip\",\n      \"mask-composite\",\n    ],\n    category: \"visual\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    return parseMaskValue(value);\n  },\n\n  validate: (value: string): boolean => {\n    return maskHandler.expand(value) !== undefined;\n  },\n});\n\nexport default function mask(value: string): Record<string, string> | undefined {\n  return maskHandler.expand(value);\n}\n","// b_path:: src/internal/is-angle.ts\nconst ANGLE = /^(\\+|-)?([0-9]*\\.?[0-9]+)(deg|rad|turn|grad)$/i;\nconst ZERO = /^(\\+|-)?(0*\\.)?0+$/;\n\nexport default function isAngle(value: string): boolean {\n  return ANGLE.test(value) || ZERO.test(value);\n}\n","// b_path:: src/handlers/offset/expand.ts\n\n// NOTE: This handler contains complex path syntax and coordinate system parsing logic\n// (~273 lines) that is a candidate for future refactoring. The implementation handles\n// offset-position, offset-path (with path() and basic shapes), offset-distance,\n// offset-rotate, and offset-anchor with various coordinate systems. The parsing logic\n// is preserved as-is.\n\nimport isAngle from \"@/internal/is-angle\";\nimport isLength from \"@/internal/is-length\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\n\nfunction splitTopLevelSlash(input: string): [string, string?] | null {\n  let depth = 0;\n  let inQuotes = false;\n  let quoteChar = \"\";\n  let slashIndex = -1;\n\n  for (let i = 0; i < input.length; i++) {\n    const char = input[i];\n\n    if (!inQuotes && (char === '\"' || char === \"'\")) {\n      inQuotes = true;\n      quoteChar = char;\n    } else if (inQuotes && char === quoteChar) {\n      inQuotes = false;\n      quoteChar = \"\";\n    } else if (!inQuotes) {\n      if (char === \"(\") {\n        depth++;\n      } else if (char === \")\") {\n        depth--;\n      } else if (char === \"/\" && depth === 0) {\n        if (slashIndex !== -1) {\n          // More than one top-level slash\n          return null;\n        }\n        slashIndex = i;\n      }\n    }\n  }\n\n  if (slashIndex === -1) {\n    return [input.trim()];\n  }\n\n  const main = input.slice(0, slashIndex).trim();\n  const anchor = input.slice(slashIndex + 1).trim();\n  return [main, anchor];\n}\n\nfunction tokenizeRespectingFunctions(input: string): string[] {\n  const tokens: string[] = [];\n  let current = \"\";\n  let depth = 0;\n  let inQuotes = false;\n  let quoteChar = \"\";\n\n  for (let i = 0; i < input.length; i++) {\n    const char = input[i];\n\n    if (!inQuotes && (char === '\"' || char === \"'\")) {\n      inQuotes = true;\n      quoteChar = char;\n      current += char;\n    } else if (inQuotes && char === quoteChar) {\n      inQuotes = false;\n      quoteChar = \"\";\n      current += char;\n    } else if (!inQuotes) {\n      if (char === \"(\") {\n        depth++;\n        current += char;\n      } else if (char === \")\") {\n        depth--;\n        current += char;\n      } else if (char === \" \" && depth === 0) {\n        if (current.trim()) {\n          tokens.push(current.trim());\n          current = \"\";\n        }\n      } else {\n        current += char;\n      }\n    } else {\n      current += char;\n    }\n  }\n\n  if (current.trim()) {\n    tokens.push(current.trim());\n  }\n\n  return tokens;\n}\n\nfunction isPositionKeyword(token: string): boolean {\n  return /^(auto|normal|left|right|top|bottom|center)$/i.test(token);\n}\n\nfunction parsePosition(tokens: string[]): { position: string; consumed: number } | null {\n  if (tokens.length === 0) return null;\n\n  // Two tokens: x y (check first to avoid ambiguity)\n  if (tokens.length >= 2) {\n    const first = tokens[0];\n    const second = tokens[1];\n    if (\n      (isPositionKeyword(first) || isLength(first)) &&\n      (isPositionKeyword(second) || isLength(second))\n    ) {\n      return { position: `${first} ${second}`, consumed: 2 };\n    }\n  }\n\n  // auto or normal\n  if (tokens[0] === \"auto\" || tokens[0] === \"normal\") {\n    return { position: tokens[0], consumed: 1 };\n  }\n\n  // Single keyword\n  if (isPositionKeyword(tokens[0])) {\n    return { position: tokens[0], consumed: 1 };\n  }\n\n  // Single length/% (horizontal center)\n  if (isLength(tokens[0])) {\n    return { position: tokens[0], consumed: 1 };\n  }\n\n  return null;\n}\n\nfunction parsePath(tokens: string[]): { path: string; consumed: number } | null {\n  if (tokens.length === 0) return null;\n\n  const token = tokens[0];\n\n  if (token === \"none\") {\n    return { path: \"none\", consumed: 1 };\n  }\n\n  if (token.startsWith(\"path(\") || token.startsWith(\"ray(\") || token.startsWith(\"url(\")) {\n    return { path: token, consumed: 1 };\n  }\n\n  return null;\n}\n\nfunction parseDistance(tokens: string[]): { distance: string; consumed: number } | null {\n  if (tokens.length === 0) return null;\n\n  if (isLength(tokens[0])) {\n    return { distance: tokens[0], consumed: 1 };\n  }\n\n  return null;\n}\n\nfunction parseRotate(tokens: string[]): { rotate: string; consumed: number } | null {\n  if (tokens.length === 0) return null;\n\n  // Check for compound forms first: auto <angle> or reverse <angle> or <angle> auto/reverse\n  if (tokens.length >= 2) {\n    const first = tokens[0];\n    const second = tokens[1];\n\n    if ((first === \"auto\" || first === \"reverse\") && isAngle(second)) {\n      return { rotate: `${first} ${second}`, consumed: 2 };\n    }\n    if (isAngle(first) && (second === \"auto\" || second === \"reverse\")) {\n      return { rotate: `${second} ${first}`, consumed: 2 };\n    }\n  }\n\n  // Single tokens\n  const token = tokens[0];\n\n  if (token === \"auto\" || token === \"reverse\") {\n    return { rotate: token, consumed: 1 };\n  }\n\n  if (isAngle(token)) {\n    return { rotate: token, consumed: 1 };\n  }\n\n  return null;\n}\n\nfunction parseAnchor(anchor: string): string | null {\n  if (!anchor) return null;\n\n  const tokens = tokenizeRespectingFunctions(anchor);\n\n  if (tokens.length === 1) {\n    if (tokens[0] === \"auto\" || isPositionKeyword(tokens[0])) {\n      return tokens[0];\n    }\n  }\n\n  if (tokens.length === 2) {\n    if (\n      (isPositionKeyword(tokens[0]) || isLength(tokens[0])) &&\n      (isPositionKeyword(tokens[1]) || isLength(tokens[1]))\n    ) {\n      return `${tokens[0]} ${tokens[1]}`;\n    }\n  }\n\n  return null;\n}\n\nfunction parseOffsetValue(value: string): Record<string, string> | undefined {\n  // Handle global keywords\n  if (/^(inherit|initial|unset|revert)$/i.test(value)) {\n    return {\n      \"offset-position\": value,\n      \"offset-path\": value,\n      \"offset-distance\": value,\n      \"offset-rotate\": value,\n      \"offset-anchor\": value,\n    };\n  }\n\n  // Split on top-level slash\n  const slashSplit = splitTopLevelSlash(value);\n  if (!slashSplit) return undefined; // Invalid: multiple slashes\n\n  const [main, anchor] = slashSplit;\n\n  // Tokenize main part\n  const tokens = tokenizeRespectingFunctions(main);\n  if (tokens.length === 0) return undefined;\n\n  const result: Record<string, string> = {};\n\n  let index = 0;\n\n  // Try to parse position first\n  const positionResult = parsePosition(tokens.slice(index));\n  if (positionResult) {\n    result[\"offset-position\"] = positionResult.position;\n    index += positionResult.consumed;\n  }\n\n  // Try to parse path\n  const pathResult = parsePath(tokens.slice(index));\n  if (pathResult) {\n    result[\"offset-path\"] = pathResult.path;\n    index += pathResult.consumed;\n  } else {\n    // Path is required unless we have position only\n    if (index === 0) return undefined;\n  }\n\n  // Try to parse distance\n  const distanceResult = parseDistance(tokens.slice(index));\n  if (distanceResult) {\n    result[\"offset-distance\"] = distanceResult.distance;\n    index += distanceResult.consumed;\n  }\n\n  // Try to parse rotate\n  const rotateResult = parseRotate(tokens.slice(index));\n  if (rotateResult) {\n    result[\"offset-rotate\"] = rotateResult.rotate;\n    index += rotateResult.consumed;\n  }\n\n  // Check if all tokens consumed\n  if (index !== tokens.length) return undefined;\n\n  // Parse anchor if present\n  if (anchor) {\n    const parsedAnchor = parseAnchor(anchor);\n    if (parsedAnchor === null) return undefined;\n    result[\"offset-anchor\"] = parsedAnchor;\n  }\n\n  return result;\n}\n\nexport const offsetHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"offset\",\n    longhands: [\n      \"offset-position\",\n      \"offset-path\",\n      \"offset-distance\",\n      \"offset-rotate\",\n      \"offset-anchor\",\n    ],\n    defaults: {\n      \"offset-position\": \"normal\",\n      \"offset-path\": \"none\",\n      \"offset-distance\": \"0\",\n      \"offset-rotate\": \"auto\",\n      \"offset-anchor\": \"auto\",\n    },\n    category: \"visual\",\n  },\n\n  expand: (value: string) => parseOffsetValue(value),\n\n  validate: (value: string) => offsetHandler.expand(value) !== undefined,\n});\n\nexport default (value: string): Record<string, string> | undefined => {\n  return offsetHandler.expand(value);\n};\n","// b_path:: src/handlers/outline/expand.ts\n\nimport isColor from \"@/internal/is-color\";\nimport isLength from \"@/internal/is-length\";\nimport normalizeColor from \"@/internal/normalize-color\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\nimport { sortProperties } from \"@/internal/property-sorter\";\n\nconst WIDTH = /^(thin|medium|thick)$/;\nconst STYLE = /^(none|hidden|dotted|dashed|solid|double|groove|ridge|inset|outset)$/i;\nconst KEYWORD = /^(inherit|initial|unset|revert)$/i;\n\n/**\n * Property handler for the 'outline' CSS shorthand property\n *\n * Expands outline into outline-width, outline-style, and outline-color.\n *\n * @example\n * ```typescript\n * outlineHandler.expand('2px solid red'); // { 'outline-width': '2px', 'outline-style': 'solid', 'outline-color': 'red' }\n * outlineHandler.expand('dashed'); // { 'outline-width': 'medium', 'outline-style': 'dashed', 'outline-color': 'currentcolor' }\n * ```\n */\nexport const outlineHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"outline\",\n    longhands: [\"outline-width\", \"outline-style\", \"outline-color\"],\n    defaults: {\n      \"outline-width\": \"medium\",\n      \"outline-style\": \"none\",\n      \"outline-color\": \"currentcolor\",\n    },\n    category: \"visual\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    const values = normalizeColor(value).split(/\\s+/);\n\n    if (values.length > 3) return;\n    if (values.length === 1 && KEYWORD.test(values[0])) {\n      return sortProperties({\n        \"outline-width\": values[0],\n        \"outline-style\": values[0],\n        \"outline-color\": values[0],\n      });\n    }\n\n    const parsed: { width?: string; style?: string; color?: string } = {};\n    for (let i = 0; i < values.length; i++) {\n      const v = values[i];\n\n      if (isLength(v) || WIDTH.test(v)) {\n        if (parsed.width) return;\n        parsed.width = v;\n      } else if (STYLE.test(v)) {\n        if (parsed.style) return;\n        parsed.style = v;\n      } else if (isColor(v)) {\n        if (parsed.color) return;\n        parsed.color = v;\n      } else {\n        return;\n      }\n    }\n\n    // Use defaults for missing properties\n    // Per CSS spec, the default values for outline shorthand are:\n    //   width: 'medium', style: 'none', color: 'currentcolor'\n    // See: https://drafts.csswg.org/css-ui-4/#propdef-outline\n    return sortProperties({\n      \"outline-width\": parsed.width || \"medium\",\n      \"outline-style\": parsed.style || \"none\",\n      \"outline-color\": parsed.color || \"currentcolor\",\n    });\n  },\n\n  validate: (value: string): boolean => {\n    return outlineHandler.expand(value) !== undefined;\n  },\n});\n\nexport default function outline(value: string): Record<string, string> | undefined {\n  return outlineHandler.expand(value);\n}\n","// b_path:: src/handlers/overflow/expand.ts\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\n\n/**\n * Property handler for the 'overflow' CSS shorthand property\n *\n * Expands overflow into overflow-x and overflow-y.\n *\n * @example\n * ```typescript\n * overflowHandler.expand('hidden'); // { 'overflow-x': 'hidden', 'overflow-y': 'hidden' }\n * overflowHandler.expand('auto scroll'); // { 'overflow-x': 'auto', 'overflow-y': 'scroll' }\n * ```\n */\nexport const overflowHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"overflow\",\n    longhands: [\"overflow-x\", \"overflow-y\"],\n    category: \"visual\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    // Handle global CSS keywords\n    if (/^(inherit|initial|unset|revert)$/i.test(value)) {\n      return {\n        \"overflow-x\": value,\n        \"overflow-y\": value,\n      };\n    }\n\n    // Split values on whitespace\n    const values = value.trim().split(/\\s+/);\n\n    // Validate value count - max 2 values\n    if (values.length > 2) {\n      return undefined;\n    }\n\n    // Valid overflow values\n    const validValues = /^(visible|hidden|clip|scroll|auto)$/i;\n\n    // Handle single value - both x and y get the same value\n    if (values.length === 1) {\n      if (!validValues.test(values[0])) {\n        return undefined;\n      }\n      return {\n        \"overflow-x\": values[0],\n        \"overflow-y\": values[0],\n      };\n    }\n\n    // Handle two values - first=x, second=y\n    if (values.length === 2) {\n      if (!validValues.test(values[0]) || !validValues.test(values[1])) {\n        return undefined;\n      }\n      return {\n        \"overflow-x\": values[0],\n        \"overflow-y\": values[1],\n      };\n    }\n\n    return undefined;\n  },\n\n  validate: (value: string): boolean => {\n    const result = overflowHandler.expand(value);\n    return result !== undefined;\n  },\n});\n\n// Export default for backward compatibility with existing code\nexport default (value: string): Record<string, string> | undefined => {\n  return overflowHandler.expand(value);\n};\n","// b_path:: src/internal/place-utils.ts\nexport function consolidatePlaceTokens(\n  value: string,\n  nextTokenPattern: RegExp\n): string[] | undefined {\n  const tokens = value.trim().split(/\\s+/);\n  const out: string[] = [];\n  for (let i = 0; i < tokens.length; i++) {\n    const t = tokens[i];\n    if (/^(first|last)$/i.test(t) && i + 1 < tokens.length && /^baseline$/i.test(tokens[i + 1])) {\n      out.push(`${tokens[i]} ${tokens[i + 1]}`);\n      i++;\n      continue;\n    }\n    if (\n      /^(safe|unsafe)$/i.test(t) &&\n      i + 1 < tokens.length &&\n      nextTokenPattern.test(tokens[i + 1])\n    ) {\n      out.push(`${tokens[i]} ${tokens[i + 1]}`);\n      i++;\n      continue;\n    }\n    out.push(t);\n  }\n  return out.length <= 2 ? out : undefined;\n}\n","// b_path:: src/handlers/place-content/expand.ts\n\nimport { consolidatePlaceTokens } from \"@/internal/place-utils\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\n\n/**\n * Property handler for the 'place-content' CSS shorthand property\n *\n * Expands place-content into align-content and justify-content.\n *\n * @example\n * ```typescript\n * placeContentHandler.expand('center'); // { 'align-content': 'center', 'justify-content': 'center' }\n * placeContentHandler.expand('start space-between'); // { 'align-content': 'start', 'justify-content': 'space-between' }\n * ```\n */\nexport const placeContentHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"place-content\",\n    longhands: [\"align-content\", \"justify-content\"],\n    defaults: {\n      \"align-content\": \"normal\",\n      \"justify-content\": \"normal\",\n    },\n    category: \"layout\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    // Handle global CSS keywords\n    if (/^(inherit|initial|unset|revert)$/i.test(value)) {\n      return {\n        \"align-content\": value,\n        \"justify-content\": value,\n      };\n    }\n\n    // Process tokens with lookahead for compound keywords\n    const processedValues = consolidatePlaceTokens(\n      value,\n      /^(center|start|end|flex-start|flex-end)$/i\n    );\n    if (!processedValues) {\n      return undefined;\n    }\n\n    // Validate processed values\n    const validValuePattern =\n      /^(normal|space-between|space-around|space-evenly|stretch|center|start|end|flex-start|flex-end|baseline|first baseline|last baseline|safe center|safe start|safe end|safe flex-start|safe flex-end|unsafe center|unsafe start|unsafe end|unsafe flex-start|unsafe flex-end)$/i;\n\n    for (const val of processedValues) {\n      if (!validValuePattern.test(val)) {\n        return undefined;\n      }\n    }\n\n    // Handle single value - both properties get the same value\n    if (processedValues.length === 1) {\n      return {\n        \"align-content\": processedValues[0],\n        \"justify-content\": processedValues[0],\n      };\n    }\n\n    // Handle two values - first=align-content, second=justify-content\n    if (processedValues.length === 2) {\n      return {\n        \"align-content\": processedValues[0],\n        \"justify-content\": processedValues[1],\n      };\n    }\n\n    return undefined;\n  },\n\n  validate: (value: string): boolean => {\n    const result = placeContentHandler.expand(value);\n    return result !== undefined;\n  },\n});\n\n// Export default for backward compatibility with existing code\nexport default (value: string): Record<string, string> | undefined => {\n  return placeContentHandler.expand(value);\n};\n","// b_path:: src/handlers/place-items/expand.ts\n\nimport { consolidatePlaceTokens } from \"@/internal/place-utils\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\n\n/**\n * Property handler for the 'place-items' CSS shorthand property\n *\n * Expands place-items into align-items and justify-items.\n *\n * @example\n * ```typescript\n * placeItemsHandler.expand('center'); // { 'align-items': 'center', 'justify-items': 'center' }\n * placeItemsHandler.expand('start end'); // { 'align-items': 'start', 'justify-items': 'end' }\n * ```\n */\nexport const placeItemsHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"place-items\",\n    longhands: [\"align-items\", \"justify-items\"],\n    defaults: {\n      \"align-items\": \"normal\",\n      \"justify-items\": \"legacy\",\n    },\n    category: \"layout\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    // Handle global CSS keywords\n    if (/^(inherit|initial|unset|revert)$/i.test(value)) {\n      return {\n        \"align-items\": value,\n        \"justify-items\": value,\n      };\n    }\n\n    // Process tokens with lookahead for compound keywords\n    const processedValues = consolidatePlaceTokens(\n      value,\n      /^(center|start|end|self-start|self-end|flex-start|flex-end)$/i\n    );\n    if (!processedValues) {\n      return undefined;\n    }\n\n    // Helper functions for validation\n    const isValidAlignItemsValue = (val: string): boolean => {\n      return /^(normal|stretch|center|start|end|self-start|self-end|flex-start|flex-end|baseline|first baseline|last baseline|safe center|safe start|safe end|safe self-start|safe self-end|safe flex-start|safe flex-end|unsafe center|unsafe start|unsafe end|unsafe self-start|unsafe self-end|unsafe flex-start|unsafe flex-end)$/i.test(\n        val\n      );\n    };\n\n    const isValidJustifyItemsValue = (val: string): boolean => {\n      return /^(normal|stretch|center|start|end|self-start|self-end|flex-start|flex-end|baseline|first baseline|last baseline|left|right|safe center|safe start|safe end|safe self-start|safe self-end|safe flex-start|safe flex-end|unsafe center|unsafe start|unsafe end|unsafe self-start|unsafe self-end|unsafe flex-start|unsafe flex-end)$/i.test(\n        val\n      );\n    };\n\n    // Validate processed values\n    for (const val of processedValues) {\n      if (!isValidAlignItemsValue(val) && !isValidJustifyItemsValue(val)) {\n        return undefined;\n      }\n    }\n\n    // Handle single value - both properties get the same value, but left/right are invalid for single value\n    if (processedValues.length === 1) {\n      const val = processedValues[0];\n      if (val === \"left\" || val === \"right\") {\n        return undefined;\n      }\n      if (!isValidAlignItemsValue(val)) {\n        return undefined;\n      }\n      return {\n        \"align-items\": val,\n        \"justify-items\": val,\n      };\n    }\n\n    // Handle two values - first=align-items, second=justify-items\n    if (processedValues.length === 2) {\n      const [alignVal, justifyVal] = processedValues;\n      if (!isValidAlignItemsValue(alignVal) || alignVal === \"left\" || alignVal === \"right\") {\n        return undefined;\n      }\n      if (!isValidJustifyItemsValue(justifyVal)) {\n        return undefined;\n      }\n      return {\n        \"align-items\": alignVal,\n        \"justify-items\": justifyVal,\n      };\n    }\n\n    return undefined;\n  },\n\n  validate: (value: string): boolean => {\n    const result = placeItemsHandler.expand(value);\n    return result !== undefined;\n  },\n});\n\n// Export default for backward compatibility with existing code\nexport default (value: string): Record<string, string> | undefined => {\n  return placeItemsHandler.expand(value);\n};\n","// b_path:: src/handlers/place-self/expand.ts\n\nimport { consolidatePlaceTokens } from \"@/internal/place-utils\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\n\n/**\n * Property handler for the 'place-self' CSS shorthand property\n *\n * Expands place-self into align-self and justify-self.\n *\n * @example\n * ```typescript\n * placeSelfHandler.expand('center'); // { 'align-self': 'center', 'justify-self': 'center' }\n * placeSelfHandler.expand('start end'); // { 'align-self': 'start', 'justify-self': 'end' }\n * ```\n */\nexport const placeSelfHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"place-self\",\n    longhands: [\"align-self\", \"justify-self\"],\n    defaults: {\n      \"align-self\": \"auto\",\n      \"justify-self\": \"auto\",\n    },\n    category: \"layout\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    // Handle global CSS keywords\n    if (/^(inherit|initial|unset|revert)$/i.test(value)) {\n      return {\n        \"align-self\": value,\n        \"justify-self\": value,\n      };\n    }\n\n    // Process tokens with lookahead for compound keywords\n    const processedValues = consolidatePlaceTokens(\n      value,\n      /^(center|start|end|self-start|self-end|flex-start|flex-end)$/i\n    );\n    if (!processedValues) {\n      return undefined;\n    }\n\n    // Helper functions for validation\n    const isValidAlignSelfValue = (val: string): boolean => {\n      return /^(auto|normal|stretch|center|start|end|self-start|self-end|flex-start|flex-end|baseline|first baseline|last baseline|anchor-center|safe center|safe start|safe end|safe self-start|safe self-end|safe flex-start|safe flex-end|unsafe center|unsafe start|unsafe end|unsafe self-start|unsafe self-end|unsafe flex-start|unsafe flex-end)$/i.test(\n        val\n      );\n    };\n\n    const isValidJustifySelfValue = (val: string): boolean => {\n      return /^(auto|normal|stretch|center|start|end|self-start|self-end|flex-start|flex-end|baseline|first baseline|last baseline|left|right|safe center|safe start|safe end|safe self-start|safe self-end|safe flex-start|safe flex-end|unsafe center|unsafe start|unsafe end|unsafe self-start|unsafe self-end|unsafe flex-start|unsafe flex-end)$/i.test(\n        val\n      );\n    };\n\n    // Validate processed values\n    for (const val of processedValues) {\n      if (!isValidAlignSelfValue(val) && !isValidJustifySelfValue(val)) {\n        return undefined;\n      }\n    }\n\n    // Handle single value - both properties get the same value, but left/right are invalid for single value\n    if (processedValues.length === 1) {\n      const val = processedValues[0];\n      if (val === \"left\" || val === \"right\") {\n        return undefined;\n      }\n      if (!isValidAlignSelfValue(val)) {\n        return undefined;\n      }\n      return {\n        \"align-self\": val,\n        \"justify-self\": val,\n      };\n    }\n\n    // Handle two values - first=align-self, second=justify-self\n    if (processedValues.length === 2) {\n      const [alignVal, justifyVal] = processedValues;\n      if (!isValidAlignSelfValue(alignVal) || alignVal === \"left\" || alignVal === \"right\") {\n        return undefined;\n      }\n      if (!isValidJustifySelfValue(justifyVal)) {\n        return undefined;\n      }\n      return {\n        \"align-self\": alignVal,\n        \"justify-self\": justifyVal,\n      };\n    }\n\n    return undefined;\n  },\n\n  validate: (value: string): boolean => {\n    const result = placeSelfHandler.expand(value);\n    return result !== undefined;\n  },\n});\n\n// Export default for backward compatibility with existing code\nexport default (value: string): Record<string, string> | undefined => {\n  return placeSelfHandler.expand(value);\n};\n","// b_path:: src/handlers/text-decoration/expand.ts\n\nimport isColor from \"@/internal/is-color\";\nimport isLength from \"@/internal/is-length\";\nimport normalizeColor from \"@/internal/normalize-color\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\nimport { sortProperties } from \"@/internal/property-sorter\";\n\nconst KEYWORD = /^(inherit|initial|unset|revert)$/i;\nconst LINE = /^(none|underline|overline|line-through|blink|spelling-error|grammar-error)$/i;\nconst STYLE = /^(solid|double|dotted|dashed|wavy)$/i;\nconst THICKNESS = /^(auto|from-font)$/i;\n\n/**\n * Property handler for the 'text-decoration' CSS shorthand property\n *\n * Expands text-decoration into text-decoration-line, text-decoration-style,\n * text-decoration-color, and text-decoration-thickness.\n *\n * @example\n * ```typescript\n * textDecorationHandler.expand('underline'); // { 'text-decoration-line': 'underline', 'text-decoration-style': 'solid', 'text-decoration-color': 'currentColor', 'text-decoration-thickness': 'auto' }\n * textDecorationHandler.expand('underline dotted red'); // { 'text-decoration-line': 'underline', 'text-decoration-style': 'dotted', 'text-decoration-color': 'red', 'text-decoration-thickness': 'auto' }\n * textDecorationHandler.expand('overline line-through wavy'); // { 'text-decoration-line': 'overline line-through', 'text-decoration-style': 'wavy', 'text-decoration-color': 'currentColor', 'text-decoration-thickness': 'auto' }\n * ```\n */\nexport const textDecorationHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"text-decoration\",\n    longhands: [\n      \"text-decoration-line\",\n      \"text-decoration-style\",\n      \"text-decoration-color\",\n      \"text-decoration-thickness\",\n    ],\n    defaults: {\n      \"text-decoration-line\": \"none\",\n      \"text-decoration-style\": \"solid\",\n      \"text-decoration-color\": \"currentColor\",\n      \"text-decoration-thickness\": \"auto\",\n    },\n    category: \"typography\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    const values = normalizeColor(value).split(/\\s+/);\n\n    if (values.length === 1 && KEYWORD.test(values[0])) {\n      return sortProperties({\n        \"text-decoration-line\": values[0],\n        \"text-decoration-style\": values[0],\n        \"text-decoration-color\": values[0],\n        \"text-decoration-thickness\": values[0],\n      });\n    }\n\n    // Initialize with defaults - text-decoration shorthand resets all properties\n    const result: Record<string, string> = {\n      \"text-decoration-line\": \"none\",\n      \"text-decoration-style\": \"solid\",\n      \"text-decoration-color\": \"currentColor\",\n      \"text-decoration-thickness\": \"auto\",\n    };\n\n    const lines: string[] = [];\n    let hasStyle = false;\n    let hasColor = false;\n    let hasThickness = false;\n\n    for (let i = 0; i < values.length; i++) {\n      const v = values[i];\n\n      if (LINE.test(v)) {\n        lines.push(v);\n      } else if (STYLE.test(v)) {\n        if (hasStyle) return; // Duplicate style\n        result[\"text-decoration-style\"] = v;\n        hasStyle = true;\n      } else if (isColor(v)) {\n        if (hasColor) return; // Duplicate color\n        result[\"text-decoration-color\"] = v;\n        hasColor = true;\n      } else if (THICKNESS.test(v) || isLength(v)) {\n        if (hasThickness) return; // Duplicate thickness\n        result[\"text-decoration-thickness\"] = v;\n        hasThickness = true;\n      } else {\n        return;\n      }\n    }\n\n    if (lines.length > 1 && lines.includes(\"none\")) return;\n\n    if (lines.length > 0) {\n      if (lines.length !== new Set(lines).size) return; // Duplicate lines\n      result[\"text-decoration-line\"] = lines.join(\" \");\n    }\n\n    return sortProperties(result);\n  },\n\n  validate: (value: string): boolean => {\n    return textDecorationHandler.expand(value) !== undefined;\n  },\n});\n\n// Export default for backward compatibility with existing code\nexport default function textDecoration(value: string): Record<string, string> | undefined {\n  return textDecorationHandler.expand(value);\n}\n","// b_path:: src/handlers/text-emphasis/expand.ts\n\nimport isColor from \"@/internal/is-color\";\nimport normalizeColor from \"@/internal/normalize-color\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\nimport { sortProperties } from \"@/internal/property-sorter\";\n\nconst KEYWORD = /^(inherit|initial|unset|revert)$/i;\nconst FILL = /^(filled|open)$/i;\nconst SHAPE = /^(dot|circle|double-circle|triangle|sesame)$/i;\nconst STRING_VALUE = /^[\"'].*[\"']$/;\n\n/**\n * Property handler for the 'text-emphasis' CSS shorthand property\n *\n * Expands text-emphasis into text-emphasis-style and text-emphasis-color.\n *\n * @example\n * ```typescript\n * textEmphasisHandler.expand('filled dot'); // { 'text-emphasis-style': 'filled dot', 'text-emphasis-color': 'currentcolor' }\n * textEmphasisHandler.expand('circle red'); // { 'text-emphasis-style': 'circle', 'text-emphasis-color': 'red' }\n * textEmphasisHandler.expand('\"x\"'); // { 'text-emphasis-style': '\"x\"', 'text-emphasis-color': 'currentcolor' }\n * ```\n */\nexport const textEmphasisHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"text-emphasis\",\n    longhands: [\"text-emphasis-style\", \"text-emphasis-color\"],\n    defaults: {\n      \"text-emphasis-style\": \"none\",\n      \"text-emphasis-color\": \"currentcolor\",\n    },\n    category: \"typography\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    const values = normalizeColor(value).split(/\\s+/);\n\n    if (values.length === 1 && KEYWORD.test(values[0])) {\n      return sortProperties({\n        \"text-emphasis-style\": values[0],\n        \"text-emphasis-color\": values[0],\n      });\n    }\n\n    const parsed: { style?: string; color?: string } = {};\n    for (let i = 0; i < values.length; i++) {\n      const v = values[i];\n\n      if (v === \"none\") {\n        if (parsed.style) return;\n        parsed.style = v;\n      } else if (STRING_VALUE.test(v)) {\n        if (parsed.style) return;\n        parsed.style = v;\n      } else if (FILL.test(v)) {\n        if (parsed.style) return;\n        if (i + 1 < values.length && SHAPE.test(values[i + 1])) {\n          parsed.style = `${v} ${values[i + 1]}`;\n          i++;\n        } else {\n          parsed.style = v;\n        }\n      } else if (SHAPE.test(v)) {\n        if (parsed.style) return;\n        if (i + 1 < values.length && FILL.test(values[i + 1])) {\n          parsed.style = `${values[i + 1]} ${v}`;\n          i++;\n        } else {\n          parsed.style = v;\n        }\n      } else if (isColor(v)) {\n        if (parsed.color) return;\n        parsed.color = v;\n      } else {\n        return;\n      }\n    }\n\n    // Use defaults for missing properties\n    // Per CSS spec, the default values for text-emphasis shorthand are:\n    //   style: 'none', color: 'currentcolor'\n    // See: https://www.w3.org/TR/css-text-decor-3/#propdef-text-emphasis\n    return sortProperties({\n      \"text-emphasis-style\": parsed.style || \"none\",\n      \"text-emphasis-color\": parsed.color || \"currentcolor\",\n    });\n  },\n\n  validate: (value: string): boolean => {\n    return textEmphasisHandler.expand(value) !== undefined;\n  },\n});\n\n// Export default for backward compatibility with existing code\nexport default function textEmphasis(value: string): Record<string, string> | undefined {\n  return textEmphasisHandler.expand(value);\n}\n","// b_path:: src/handlers/transition/transition-layers.ts\n\nimport * as csstree from \"@eslint/css-tree\";\nimport type { TransitionLayer, TransitionResult } from \"@/core/schema\";\nimport isTime from \"@/internal/is-time\";\nimport isTimingFunction from \"@/internal/is-timing-function\";\nimport { matchesType } from \"@/internal/is-value-node\";\nimport { hasTopLevelCommas, parseLayersGeneric } from \"@/internal/layer-parser-utils\";\n\n// CSS default values for transition properties\nexport const TRANSITION_DEFAULTS = {\n  property: \"all\",\n  duration: \"0s\",\n  timingFunction: \"ease\",\n  delay: \"0s\",\n} as const;\n\n/**\n * Detects if a transition value needs advanced parsing (multi-layer transitions or complex functions)\n */\nexport function needsAdvancedParser(value: string): boolean {\n  return hasTopLevelCommas(value, true);\n}\n\n/**\n * Parses a complex transition value using css-tree AST parsing\n */\nexport function parseTransitionLayers(value: string): TransitionResult | undefined {\n  const layers = parseLayersGeneric(value, parseSingleLayer);\n  return layers ? { layers } : undefined;\n}\n\n/**\n * Parses a single transition layer using css-tree AST parsing\n */\nfunction parseSingleLayer(layerValue: string): TransitionLayer | undefined {\n  const result: TransitionLayer = {};\n\n  const ast = csstree.parse(layerValue.trim(), { context: \"value\" });\n\n  // Collect all child nodes from the Value node\n  const children: csstree.CssNode[] = [];\n  csstree.walk(ast, {\n    visit: \"Value\",\n    enter: (node: csstree.CssNode) => {\n      if (node.type === \"Value\" && node.children) {\n        node.children.forEach((child) => {\n          children.push(child);\n        });\n      }\n    },\n  });\n\n  // Process children in order, handling transition property parsing\n  if (!processCssChildren(children, result)) {\n    return undefined; // Parsing failed due to invalid syntax\n  }\n\n  return result;\n}\n\n/**\n * Processes CSS AST children sequentially to extract transition properties\n *\n * This function handles the parsing of CSS transition layer syntax,\n * including property names, time values, and timing functions.\n * CSS ordering rules: first time = duration, second time = delay\n *\n * Returns false if parsing should fail (e.g., too many time values)\n */\nfunction processCssChildren(children: csstree.CssNode[], result: TransitionLayer): boolean {\n  let timeCount = 0; // Track first vs second time value\n\n  for (const child of children) {\n    // Skip whitespace and operators\n    if (child.type === \"WhiteSpace\" || child.type === \"Operator\") {\n      continue;\n    }\n\n    // Handle timing functions FIRST (keywords and functions)\n    // Must check before time values to avoid cubic-bezier() being treated as time\n    if (!result.timingFunction) {\n      if (child.type === \"Identifier\") {\n        const timingValue = csstree.generate(child);\n        if (isTimingFunction(timingValue)) {\n          result.timingFunction = timingValue;\n          continue;\n        }\n      }\n\n      if (child.type === \"Function\") {\n        const funcValue = csstree.generate(child);\n        if (isTimingFunction(funcValue)) {\n          // Fix spacing in function calls (css-tree removes spaces after commas)\n          result.timingFunction = funcValue.replace(/,([^\\s])/g, \", $1\");\n          continue;\n        }\n      }\n    }\n\n    // Handle time values (duration and delay)\n    // Accept: Dimensions with time units (1s, 500ms), or any Function (calc, var, etc.)\n    if (matchesType(child, [\"Dimension\", \"Function\"])) {\n      const timeValue = csstree.generate(child);\n\n      // For Dimensions, validate they have time units\n      // For Functions (var, calc), accept unconditionally (carry over as-is)\n      if (child.type === \"Function\" || isTime(timeValue)) {\n        if (timeCount >= 2) {\n          // More than 2 time values is invalid\n          return false;\n        }\n        if (timeCount === 0) {\n          result.duration = timeValue;\n        } else {\n          result.delay = timeValue;\n        }\n        timeCount++;\n        continue;\n      }\n    }\n\n    // Handle transition-property (none, all, or CSS property names)\n    if (child.type === \"Identifier\" && !result.property) {\n      const name = (child as csstree.Identifier).name;\n      if (name === \"none\" || name === \"all\") {\n        result.property = name;\n        continue;\n      }\n      // Check if it looks like a CSS property name (not a timing function)\n      // Allow vendor-prefixed properties starting with hyphen\n      if (/^-?[a-zA-Z][a-zA-Z0-9-]*$/.test(name) && !isTimingFunction(name)) {\n        result.property = name;\n      }\n    }\n  }\n\n  return true;\n}\n\n/**\n * Reconstructs final CSS properties from layer objects\n */\nexport function reconstructLayers(layers: TransitionLayer[]): Record<string, string> {\n  const result: Record<string, string> = {};\n\n  // Collect all layer values for each property\n  const properties = {\n    \"transition-property\": layers.map((l) => l.property || TRANSITION_DEFAULTS.property),\n    \"transition-duration\": layers.map((l) => l.duration || TRANSITION_DEFAULTS.duration),\n    \"transition-timing-function\": layers.map(\n      (l) => l.timingFunction || TRANSITION_DEFAULTS.timingFunction\n    ),\n    \"transition-delay\": layers.map((l) => l.delay || TRANSITION_DEFAULTS.delay),\n  };\n\n  // Join layer values with commas\n  Object.entries(properties).forEach(([property, values]) => {\n    result[property] = values.join(\", \");\n  });\n\n  return result;\n}\n","// b_path:: src/handlers/transition/expand.ts\n\n// NOTE: This handler contains complex multi-layer parsing logic that is a candidate\n// for future refactoring. Property name handling and timing parsing could be simplified.\n\nimport isTime from \"@/internal/is-time\";\nimport isTimingFunction from \"@/internal/is-timing-function\";\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\nimport { needsAdvancedParser, parseTransitionLayers, reconstructLayers } from \"./transition-layers\";\n\nconst KEYWORD = /^(inherit|initial|unset|revert)$/i;\nconst PROPERTY_KEYWORD = /^(none|all)$/i;\n\nfunction parseTransitionValue(value: string): Record<string, string> | undefined {\n  // Handle global keywords first\n  if (KEYWORD.test(value.trim())) {\n    return {\n      \"transition-property\": value.trim(),\n      \"transition-duration\": value.trim(),\n      \"transition-timing-function\": value.trim(),\n      \"transition-delay\": value.trim(),\n    };\n  }\n\n  // Check for multi-layer syntax\n  if (needsAdvancedParser(value)) {\n    const layeredResult = parseTransitionLayers(value);\n    if (layeredResult) {\n      return reconstructLayers(layeredResult.layers);\n    }\n    return undefined; // Advanced parsing failed\n  }\n\n  // Simple single-layer fallback parser\n  const result: Record<string, string> = {};\n  const tokens = value.trim().split(/\\s+/);\n  let timeCount = 0; // Track first vs second time value\n\n  for (const token of tokens) {\n    // Handle time values first (duration and delay) - CSS allows flexible ordering\n    if (isTime(token) || token.startsWith(\"var(\")) {\n      if (timeCount === 0) {\n        result[\"transition-duration\"] = token;\n      } else if (timeCount === 1) {\n        result[\"transition-delay\"] = token;\n      } else {\n        // More than 2 time values is invalid\n        return undefined;\n      }\n      timeCount++;\n      continue;\n    }\n\n    // Handle timing functions\n    if (!result[\"transition-timing-function\"] && isTimingFunction(token)) {\n      result[\"transition-timing-function\"] = token;\n      continue;\n    }\n\n    // Handle transition-property (none, all, or CSS property names)\n    // Only if we haven't set it yet, and it's not a timing function\n    if (!result[\"transition-property\"]) {\n      if (PROPERTY_KEYWORD.test(token)) {\n        result[\"transition-property\"] = token;\n        continue;\n      }\n      // Check if it looks like a CSS property name (not a timing function)\n      // Allow vendor-prefixed properties starting with hyphen\n      if (/^-?[a-zA-Z][a-zA-Z0-9-]*$/.test(token) && !isTimingFunction(token)) {\n        result[\"transition-property\"] = token;\n        continue;\n      }\n    }\n\n    // If token doesn't match any category, it's invalid\n    return undefined;\n  }\n\n  // Accept single-token property values - they will expand to defaults\n\n  // Build final result with defaults\n  return {\n    \"transition-property\": result[\"transition-property\"] || \"all\",\n    \"transition-duration\": result[\"transition-duration\"] || \"0s\",\n    \"transition-timing-function\": result[\"transition-timing-function\"] || \"ease\",\n    \"transition-delay\": result[\"transition-delay\"] || \"0s\",\n  };\n}\n\n/**\n * Property handler for the 'transition' CSS shorthand property\n *\n * Expands transition into transition-property, transition-duration,\n * transition-timing-function, and transition-delay.\n *\n * @example\n * ```typescript\n * transitionHandler.expand('opacity 300ms ease-in');\n * transitionHandler.expand('all 1s');\n * ```\n */\nexport const transitionHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"transition\",\n    longhands: [\n      \"transition-property\",\n      \"transition-duration\",\n      \"transition-timing-function\",\n      \"transition-delay\",\n    ],\n    defaults: {\n      \"transition-property\": \"all\",\n      \"transition-duration\": \"0s\",\n      \"transition-timing-function\": \"ease\",\n      \"transition-delay\": \"0s\",\n    },\n    category: \"animation\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    return parseTransitionValue(value);\n  },\n\n  validate: (value: string): boolean => {\n    return transitionHandler.expand(value) !== undefined;\n  },\n});\n\nexport default function transition(value: string): Record<string, string> | undefined {\n  return transitionHandler.expand(value);\n}\n","// b_path:: src/internal/shorthand-registry.ts\n\nimport animation from \"../handlers/animation\";\nimport background from \"../handlers/background\";\nimport { backgroundPositionHandler } from \"../handlers/background-position\";\nimport border from \"../handlers/border\";\nimport borderRadius from \"../handlers/border-radius\";\nimport columnRule from \"../handlers/column-rule\";\nimport columns from \"../handlers/columns\";\nimport containIntrinsicSize from \"../handlers/contain-intrinsic-size\";\nimport flex from \"../handlers/flex\";\nimport flexFlow from \"../handlers/flex-flow\";\nimport font from \"../handlers/font\";\nimport grid from \"../handlers/grid\";\nimport gridArea from \"../handlers/grid-area\";\nimport gridColumn from \"../handlers/grid-column\";\nimport gridRow from \"../handlers/grid-row\";\nimport listStyle from \"../handlers/list-style\";\nimport mask from \"../handlers/mask\";\nimport offset from \"../handlers/offset\";\nimport outline from \"../handlers/outline\";\nimport overflow from \"../handlers/overflow\";\nimport placeContent from \"../handlers/place-content\";\nimport placeItems from \"../handlers/place-items\";\nimport placeSelf from \"../handlers/place-self\";\nimport textDecoration from \"../handlers/text-decoration\";\nimport textEmphasis from \"../handlers/text-emphasis\";\nimport transition from \"../handlers/transition\";\nimport directional from \"./directional\";\n\n/**\n * Internal shorthand property handler registry.\n * @internal\n */\n\nconst prefix =\n  (prefix: string) =>\n  (value: string): Record<string, string> | undefined => {\n    const longhand = directional(value);\n\n    if (!longhand) return;\n\n    const result: Record<string, string> = {};\n    for (const key in longhand) {\n      result[`${prefix}-${key}`] = longhand[key];\n    }\n    return result;\n  };\n\n/**\n * Central registry mapping shorthand property names to their expansion handlers.\n * @internal\n */\nexport const shorthand: Record<string, (value: string) => Record<string, string> | undefined> = {\n  animation: animation,\n  background: background,\n  \"background-position\": (value: string) => backgroundPositionHandler.expand(value),\n  border: border,\n  \"border-bottom\": border.bottom,\n  \"border-color\": border.color,\n  \"border-left\": border.left,\n  \"border-radius\": borderRadius,\n  \"border-right\": border.right,\n  \"border-style\": border.style,\n  \"border-top\": border.top,\n  \"border-width\": border.width,\n  columns: columns,\n  \"column-rule\": columnRule,\n  \"contain-intrinsic-size\": containIntrinsicSize,\n  flex: flex,\n  \"flex-flow\": flexFlow,\n  font: font,\n  grid: grid,\n  \"grid-area\": gridArea,\n  \"grid-column\": gridColumn,\n  \"grid-row\": gridRow,\n  inset: directional,\n  \"list-style\": listStyle,\n  mask: mask,\n  margin: prefix(\"margin\"),\n  offset: offset,\n  outline: outline,\n  overflow: overflow,\n  padding: prefix(\"padding\"),\n  \"place-content\": placeContent,\n  \"place-items\": placeItems,\n  \"place-self\": placeSelf,\n  \"text-decoration\": textDecoration,\n  \"text-emphasis\": textEmphasis,\n  transition: transition,\n};\n","// b_path:: src/core/validate.ts\n/**\n * Validates CSS stylesheet syntax and property values, providing detailed error formatting.\n *\n * This function parses CSS using the css-tree library and validates each CSS property\n * against the CSS specification. When validation errors are found, it generates\n * formatted error messages with visual context including line numbers, code snippets,\n * and precise error location indicators.\n *\n * @param css - The CSS string to validate\n *\n * @returns StylesheetValidation object containing:\n *   - ok: boolean indicating if validation passed (no errors)\n *   - errors: Array of syntax parsing errors (malformed CSS)\n *   - warnings: Array of property validation errors (invalid property values)\n *\n * @remarks\n * - Context window shows ±2 lines around each error for better debugging\n * - Long lines are intelligently truncated with ellipses (…) for readability\n * - Pointer indicators (^^^) precisely mark the error location and length\n * - Duplicate declarations are automatically deduplicated to avoid redundant warnings\n *\n * @throws Does not throw - parsing errors are captured in the returned errors array\n *\n * @since 1.0.0\n */\n\nimport * as csstree from \"@eslint/css-tree\";\nimport type { BStyleWarning, StylesheetValidation } from \"./schema\";\n\n// Constants\nconst DEFAULT_MAX_LINE_WIDTH = 80;\nconst LINE_NUMBER_PADDING = 4;\nconst DEFAULT_CONTEXT_WINDOW_SIZE = 2; // Lines before and after error\n\nexport interface BStyleMatchError extends csstree.SyntaxMatchError {\n  property: string;\n  formattedError?: string;\n}\n\nexport type { BStyleWarning, StylesheetValidation };\n\nexport interface Declaration {\n  property: string;\n  value: csstree.Value | csstree.Raw;\n  node: csstree.CssNode;\n}\n\nexport interface ErrorFormatOptions {\n  maxLineWidth: number;\n  contextWindowSize?: number;\n}\n\ninterface TruncationBounds {\n  startPos: number;\n  endPos: number;\n  needsStartEllipsis: boolean;\n  needsEndEllipsis: boolean;\n  availableWidth: number;\n}\n\ninterface FormattedLine {\n  content: string;\n  adjustedColumn: number;\n}\n\n/**\n * Checks if a CSS value node contains var() function.\n * CSS variables cannot be validated by @eslint/css-tree as they are runtime values.\n */\nfunction containsVar(node: csstree.CssNode): boolean {\n  if (!node) return false;\n  if (node.type === \"Function\" && node.name === \"var\") return true;\n  if (\"children\" in node && node.children) {\n    for (const child of node.children) {\n      if (containsVar(child)) return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Validates a CSS stylesheet for syntax and property value errors.\n *\n * @param css - The CSS string to validate\n * @returns StylesheetValidation object containing validation results\n */\nexport function validate(css: string): StylesheetValidation {\n  const errors: csstree.SyntaxParseError[] = [];\n  const warnings: BStyleMatchError[] = [];\n  const declarations: Declaration[] = [];\n  const syntax = csstree.lexer;\n  const uniqueDecls = new Map<string, number>();\n\n  // Parse CSS\n  const ast = csstree.parse(css, {\n    context: \"declarationList\",\n    positions: true,\n    parseAtrulePrelude: true,\n    parseRulePrelude: true,\n    parseCustomProperty: true,\n    onParseError(err: csstree.SyntaxParseError) {\n      // biome-ignore lint/correctness/noUnusedVariables: remove stack from err\n      const { stack, ...rest } = err;\n      errors.push(rest);\n    },\n  });\n\n  // Extract declarations\n  csstree.walk(ast, (node) => {\n    if (node.type !== \"Declaration\") {\n      return;\n    }\n    const id = csstree.generate(node);\n    if (uniqueDecls.has(id)) {\n      uniqueDecls.set(id, uniqueDecls.get(id)! + 1);\n      return;\n    }\n    uniqueDecls.set(id, 1);\n    declarations.push({ property: node.property, value: node.value, node });\n  });\n\n  // Validate declarations\n  // Suppress noisy csstree-match iteration warnings during matching.\n  // Control via env var: BStyle_CSSTREE_LOG_LEVEL=ERROR (default) suppresses these messages.\n  const suppressNoise = (msg: unknown): boolean => {\n    try {\n      const s = String(msg);\n      return /\\[csstree-match\\]\\s*BREAK after/i.test(s);\n    } catch {\n      return false;\n    }\n  };\n  const LOG_LEVEL = (process.env.BStyle_CSSTREE_LOG_LEVEL || \"ERROR\").toUpperCase();\n  const QUIET = LOG_LEVEL === \"ERROR\" || LOG_LEVEL === \"SILENT\";\n  const origWarn = console.warn;\n  const origError = console.error;\n  try {\n    if (QUIET) {\n      console.warn = (...args: Parameters<typeof console.warn>) => {\n        if (args.length && suppressNoise(args[0])) return;\n        return origWarn(...args);\n      };\n      console.error = (...args: Parameters<typeof console.error>) => {\n        if (args.length && suppressNoise(args[0])) return;\n        return origError(...args);\n      };\n    }\n\n    for (const decl of declarations) {\n      // Skip validation for declarations containing CSS variables (var())\n      // as they cannot be validated at parse time\n      if (containsVar(decl.value)) {\n        continue;\n      }\n\n      const match = syntax.matchProperty(decl.property, decl.value);\n      const error = match.error as csstree.SyntaxMatchError;\n\n      if (!error) continue;\n\n      // biome-ignore lint/correctness/noUnusedVariables: remove stack from error\n      const { stack, name, ...rest } = error;\n      warnings.push({\n        property: decl.property,\n        name,\n        ...rest,\n      });\n    }\n  } finally {\n    // Always restore console methods\n    console.warn = origWarn;\n    console.error = origError;\n  }\n\n  // Format and display warnings\n  const formattedWarnings: BStyleWarning[] = [];\n\n  if (warnings.length > 0) {\n    const cssLines = css.split(\"\\n\");\n    for (const warning of warnings) {\n      const formattedError = formatErrorDisplay(cssLines, warning);\n      formattedWarnings.push({\n        property: warning.property,\n        name: warning.name,\n        syntax: warning.syntax,\n        formattedWarning: `Errors found in: ${warning.property}\\n${formattedError.join(\"\\n\")}`,\n      });\n    }\n  }\n\n  // Return result with runtime type safety\n  const result: StylesheetValidation = {\n    ok: errors.length === 0,\n    errors,\n    warnings: formattedWarnings,\n  };\n\n  return result;\n}\n\nexport function validateDeclaration(value: string, prop: string): StylesheetValidation {\n  const css = `.class {${prop}: ${value};}`;\n  const result = validate(css);\n  return result;\n}\n\n// Helper functions\n/**\n * Calculates the line window to display around an error line.\n * Shows contextWindowSize lines before and after the error for better context.\n *\n * @param errorLine - The line number where the error occurred\n * @param totalLines - Total number of lines in the CSS\n * @param contextWindowSize - Number of lines to show before and after error (default: 2)\n * @returns Object with start and end line numbers for the context window\n */\nfunction calculateLineWindow(\n  errorLine: number,\n  totalLines: number,\n  contextWindowSize: number = DEFAULT_CONTEXT_WINDOW_SIZE\n): { start: number; end: number } {\n  const start = Math.max(1, errorLine - contextWindowSize);\n  const end = Math.min(totalLines, errorLine + contextWindowSize);\n  return { start, end };\n}\n\nfunction formatLineNumber(lineNum: number, maxLineNum: number): string {\n  const maxDigits = Math.max(maxLineNum.toString().length, 1);\n  const paddedNum = lineNum.toString().padStart(maxDigits, \" \");\n  const prefix = \" \".repeat(LINE_NUMBER_PADDING - maxDigits);\n  return `${prefix}${paddedNum} |`;\n}\n\nfunction trimLine(line: string): { trimmed: string; spacesRemoved: number } {\n  const trimmed = line.trimStart();\n  const spacesRemoved = line.length - trimmed.length;\n  return { trimmed, spacesRemoved };\n}\n\nfunction calculateTruncationBounds(\n  lineLength: number,\n  errorColumn: number,\n  maxWidth: number\n): TruncationBounds {\n  if (lineLength <= maxWidth) {\n    return {\n      startPos: 0,\n      endPos: lineLength,\n      needsStartEllipsis: false,\n      needsEndEllipsis: false,\n      availableWidth: maxWidth,\n    };\n  }\n\n  // Reserve space for potential ellipses\n  let availableWidth = maxWidth - 2;\n  const halfWidth = Math.floor(availableWidth / 2);\n  let startPos = Math.max(0, errorColumn - halfWidth - 1);\n\n  // Determine if we need start ellipsis\n  const needsStartEllipsis = startPos > 0;\n\n  if (!needsStartEllipsis) {\n    // No start truncation - reclaim space for end-only ellipsis\n    availableWidth = maxWidth - 1;\n  } else {\n    // Skip one additional character for better spacing after ellipsis\n    startPos = startPos + 1;\n  }\n\n  let endPos = startPos + availableWidth;\n  let needsEndEllipsis = endPos < lineLength;\n\n  // Adjust if we hit the end of the line\n  if (endPos >= lineLength) {\n    endPos = lineLength;\n    needsEndEllipsis = false;\n\n    if (needsStartEllipsis) {\n      startPos = Math.max(0, endPos - availableWidth);\n    }\n  }\n\n  return {\n    startPos,\n    endPos,\n    needsStartEllipsis,\n    needsEndEllipsis,\n    availableWidth,\n  };\n}\n\nfunction applyTruncation(\n  line: string,\n  bounds: TruncationBounds,\n  originalErrorColumn: number\n): FormattedLine {\n  let content = line.slice(bounds.startPos, bounds.endPos);\n  let adjustedColumn = originalErrorColumn - bounds.startPos;\n\n  if (bounds.needsStartEllipsis) {\n    content = `…${content}`;\n    adjustedColumn = adjustedColumn + 1;\n  }\n\n  if (bounds.needsEndEllipsis) {\n    content = `${content}…`;\n  }\n\n  return { content, adjustedColumn };\n}\n\nfunction formatContextLine(line: string, maxWidth: number): string {\n  const { trimmed } = trimLine(line);\n\n  if (trimmed.length <= maxWidth) {\n    return trimmed;\n  }\n\n  return `${trimmed.slice(0, maxWidth - 1)}…`;\n}\n\nfunction formatErrorLine(line: string, errorColumn: number, maxWidth: number): FormattedLine {\n  // Input validation\n  if (errorColumn < 1) {\n    throw new Error(\"Error column must be >= 1\");\n  }\n\n  const { trimmed, spacesRemoved } = trimLine(line);\n  const adjustedErrorColumn = Math.max(1, errorColumn - spacesRemoved);\n\n  // Handle case where line fits without truncation after trimming\n  if (trimmed.length <= maxWidth) {\n    return {\n      content: trimmed,\n      adjustedColumn: adjustedErrorColumn,\n    };\n  }\n\n  // Calculate truncation bounds using the original error column position\n  const bounds = calculateTruncationBounds(line.length, errorColumn, maxWidth);\n\n  // Special handling for start-of-line case (after trimming consideration)\n  if (bounds.startPos === 0 || bounds.startPos <= spacesRemoved) {\n    // Use trimmed line for start-of-line truncation\n    const trimmedBounds = calculateTruncationBounds(trimmed.length, adjustedErrorColumn, maxWidth);\n    return applyTruncation(trimmed, trimmedBounds, adjustedErrorColumn);\n  }\n\n  // Standard middle-of-line truncation\n  return applyTruncation(line, bounds, errorColumn);\n}\n\nfunction createPointerLine(prefixLength: number, column: number, length: number): string {\n  const safeLength = Math.max(1, length ?? 1);\n  const safeColumn = Math.max(1, column);\n\n  const pointerPrefix = \" \".repeat(prefixLength);\n  const dashes = \"-\".repeat(safeColumn - 1);\n  const carets = \"^\".repeat(safeLength);\n\n  return pointerPrefix + dashes + carets;\n}\n\n/**\n * Formats and displays CSS validation errors with visual context.\n * Shows the error line with surrounding context, line numbers, and pointer indicators.\n *\n * @param cssLines - Array of CSS source lines\n * @param warning - The validation error/warning to format\n * @param options - Formatting options (maxLineWidth, contextWindowSize)\n * @returns Array of formatted strings representing the error display\n *\n * @example\n * // Error at line 5, column 10:\n * //   3 | .class {\n * //   4 |   margin: 10px;\n * //   5 |   color: notacolor;\n * //       ---------^^^^^^^^^^^\n * //   6 | }\n */\nfunction formatErrorDisplay(\n  cssLines: string[],\n  warning: BStyleMatchError,\n  options: ErrorFormatOptions = {\n    maxLineWidth: DEFAULT_MAX_LINE_WIDTH,\n    contextWindowSize: DEFAULT_CONTEXT_WINDOW_SIZE,\n  }\n): string[] {\n  // Input validation\n  if (!cssLines.length || warning.line < 1 || warning.line > cssLines.length) {\n    return [`Invalid error location: line ${warning.line}`];\n  }\n  const errorLine = warning.line;\n  const errorColumn = warning.column;\n  const mismatchLength = warning.mismatchLength ?? 1;\n  const contextWindowSize = options.contextWindowSize ?? DEFAULT_CONTEXT_WINDOW_SIZE;\n\n  const { start, end } = calculateLineWindow(errorLine, cssLines.length, contextWindowSize);\n  const maxLineNum = end;\n  const linePrefix = formatLineNumber(1, maxLineNum);\n  const prefixLength = linePrefix.length;\n  const availableWidth = options.maxLineWidth - prefixLength;\n\n  const result: string[] = [];\n\n  for (let lineNum = start; lineNum <= end; lineNum++) {\n    const lineIndex = lineNum - 1;\n    const currentLine = cssLines[lineIndex] ?? \"\";\n    const currentPrefix = formatLineNumber(lineNum, maxLineNum);\n\n    if (lineNum === errorLine) {\n      // Format error line\n      const { content, adjustedColumn } = formatErrorLine(currentLine, errorColumn, availableWidth);\n\n      result.push(currentPrefix + content);\n\n      // Add pointer line\n      const pointerLine = createPointerLine(prefixLength, adjustedColumn, mismatchLength);\n      result.push(pointerLine);\n    } else {\n      // Format context line\n      const formattedLine = formatContextLine(currentLine, availableWidth);\n      result.push(currentPrefix + formattedLine);\n    }\n  }\n\n  return result;\n}\n","// b_path:: src/core/expand.ts\n\nimport { parseCssDeclaration, parseInputString, stripComments } from \"../internal/parsers\";\nimport { kebabToCamelCase, objectToCss, sortProperties } from \"../internal/property-sorter\";\nimport { shorthand } from \"../internal/shorthand-registry\";\nimport type { BStyleWarning, ExpandOptions, ExpandResult } from \"./schema\";\nimport { DEFAULT_EXPAND_OPTIONS, FORMAT_CSS } from \"./schema\";\nimport { validate } from \"./validate\";\n\n/**\n * Expands CSS shorthand properties into their longhand equivalents.\n *\n * @param input - CSS declaration(s) to expand (e.g., \"margin: 10px 20px;\")\n * @param options - Configuration options for expansion behavior\n * @returns Object containing expansion result, success status, and any issues\n *\n * @example\n * // Basic expansion\n * expand('margin: 10px 20px;')\n * // → { ok: true, result: 'margin-top: 10px;\\nmargin-right: 20px;...', issues: [] }\n *\n * @example\n * // JavaScript object format\n * expand('padding: 1rem;', { format: 'js' })\n * // → { ok: true, result: { paddingTop: '1rem', ... }, issues: [] }\n *\n * @example\n * // Multiple declarations with conflict resolution\n * expand('margin: 10px; margin-top: 20px;', { format: 'js' })\n * // → { ok: true, result: { marginTop: '20px', marginRight: '10px', ... }, issues: [] }\n */\nexport function expand(input: string, options: Partial<ExpandOptions> = {}): ExpandResult {\n  const cleanedInput = stripComments(input);\n\n  // Apply defaults using DEFAULT_EXPAND_OPTIONS\n  const {\n    format = DEFAULT_EXPAND_OPTIONS.format,\n    indent = DEFAULT_EXPAND_OPTIONS.indent,\n    separator = DEFAULT_EXPAND_OPTIONS.separator,\n    propertyGrouping = DEFAULT_EXPAND_OPTIONS.propertyGrouping,\n  } = options;\n\n  const validation = validate(cleanedInput);\n\n  const inputs = parseInputString(cleanedInput);\n  const finalProperties: Record<string, string> = {};\n  const issues: BStyleWarning[] = [];\n\n  for (const item of inputs) {\n    const parsed = parseCssDeclaration(item);\n    if (!parsed) {\n      continue;\n    }\n\n    const { property, value } = parsed;\n    const normalized = value.trim();\n    const important = normalized.endsWith(\"!important\") && /\\s/.test(normalized.slice(-11, -10));\n\n    if (important) {\n      issues.push({\n        property,\n        name: \"important-detected\",\n        formattedWarning: `!important flag detected in '${property}' and has been ignored. Shorthand expansion does not support !important.`,\n      });\n      finalProperties[property] = normalized;\n      continue;\n    }\n\n    const parse = shorthand[property];\n    const longhand = parse?.(normalized);\n\n    if (longhand) {\n      // Recursively expand any longhands that are themselves shorthands\n      // e.g., background → background-position → background-position-x/y\n      // Note: Skip recursive expansion for multi-layer values (e.g., \"0% 0%, 0% 0%\")\n      // as they need layer-aware splitting first\n      for (const [prop, val] of Object.entries(longhand)) {\n        const nestedParse = shorthand[prop];\n\n        if (nestedParse) {\n          const nestedLonghand = nestedParse(val);\n          if (nestedLonghand) {\n            Object.assign(finalProperties, nestedLonghand);\n            continue;\n          }\n        }\n        finalProperties[prop] = val;\n      }\n    } else {\n      finalProperties[property] = normalized;\n\n      if (property in shorthand) {\n        issues.push({\n          property,\n          name: \"expansion-failed\",\n          formattedWarning: `Could not expand shorthand property '${property}' with value '${normalized}'. Returning original shorthand.`,\n        });\n      }\n    }\n  }\n\n  let finalResult: Record<string, string> | string | undefined;\n\n  if (Object.keys(finalProperties).length === 0) {\n    finalResult = undefined;\n  } else if (format === FORMAT_CSS) {\n    finalResult = objectToCss(finalProperties, indent, separator, propertyGrouping);\n  } else {\n    const sorted = sortProperties(finalProperties, propertyGrouping);\n    const camelCased: Record<string, string> = {};\n    for (const [key, value] of Object.entries(sorted)) {\n      camelCased[kebabToCamelCase(key)] = value;\n    }\n    finalResult = camelCased;\n  }\n\n  const ok = validation.errors.length === 0;\n  const allIssues = [...validation.errors, ...validation.warnings, ...issues];\n\n  return {\n    ok,\n    result: finalResult,\n    issues: allIssues,\n  };\n}\n","// b_path:: src/internal/border-side-parser.ts\n\n/**\n * Parse border-side shorthand (border-top, border-right, etc.)\n *\n * Grammar: <line-width> || <line-style> || <color>\n * All components are optional\n */\n\nconst BORDER_STYLES = new Set([\n  \"none\",\n  \"hidden\",\n  \"dotted\",\n  \"dashed\",\n  \"solid\",\n  \"double\",\n  \"groove\",\n  \"ridge\",\n  \"inset\",\n  \"outset\",\n]);\n\nconst BORDER_WIDTHS = new Set([\"thin\", \"medium\", \"thick\"]);\n\nexport interface BorderSideResult {\n  width: string;\n  style: string;\n  color: string;\n}\n\nexport function parseBorderSide(value: string): BorderSideResult {\n  const trimmed = value.trim();\n\n  // Global values\n  if (\n    trimmed === \"initial\" ||\n    trimmed === \"inherit\" ||\n    trimmed === \"unset\" ||\n    trimmed === \"revert\"\n  ) {\n    return { width: trimmed, style: trimmed, color: trimmed };\n  }\n\n  let width = \"medium\";\n  let style = \"none\";\n  let color = \"currentcolor\";\n\n  // Split by whitespace preserving functions\n  const parts = smartSplit(trimmed);\n\n  for (const part of parts) {\n    if (BORDER_STYLES.has(part.toLowerCase())) {\n      style = part;\n    } else if (BORDER_WIDTHS.has(part.toLowerCase()) || isLength(part)) {\n      width = part;\n    } else {\n      // Assume color\n      color = part;\n    }\n  }\n\n  return { width, style, color };\n}\n\nfunction smartSplit(value: string): string[] {\n  const result: string[] = [];\n  let current = \"\";\n  let depth = 0;\n\n  for (let i = 0; i < value.length; i++) {\n    const char = value[i];\n\n    if (char === \"(\") {\n      depth++;\n      current += char;\n    } else if (char === \")\") {\n      depth--;\n      current += char;\n    } else if (char === \" \" && depth === 0) {\n      if (current.trim()) {\n        result.push(current.trim());\n        current = \"\";\n      }\n    } else {\n      current += char;\n    }\n  }\n\n  if (current.trim()) {\n    result.push(current.trim());\n  }\n\n  return result;\n}\n\nfunction isLength(value: string): boolean {\n  if (value === \"0\") return true;\n  if (value.startsWith(\"calc(\")) return true;\n  if (value.startsWith(\"var(\")) return true;\n  // Check for length units\n  return /^-?\\d*\\.?\\d+(px|em|rem|%|vh|vw|ch|ex|cm|mm|in|pt|pc)$/.test(value);\n}\n\nexport function createBorderSideExpander(side: \"top\" | \"right\" | \"bottom\" | \"left\") {\n  return (value: string): Record<string, string> => {\n    const { width, style, color } = parseBorderSide(value);\n    return {\n      [`border-${side}-width`]: width,\n      [`border-${side}-style`]: style,\n      [`border-${side}-color`]: color,\n    };\n  };\n}\n","// b_path:: src/handlers/border-block/expand.ts\n\nimport { parseBorderSide } from \"../../internal/border-side-parser\";\n\nexport function expandBorderBlock(value: string): Record<string, string> {\n  const { width, style, color } = parseBorderSide(value);\n\n  return {\n    \"border-block-start-width\": width,\n    \"border-block-start-style\": style,\n    \"border-block-start-color\": color,\n    \"border-block-end-width\": width,\n    \"border-block-end-style\": style,\n    \"border-block-end-color\": color,\n  };\n}\n","// b_path:: src/handlers/border-block/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandBorderBlock } from \"./expand\";\n\nexport const borderBlockHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"border-block\",\n    longhands: [\n      \"border-block-start-width\",\n      \"border-block-start-style\",\n      \"border-block-start-color\",\n      \"border-block-end-width\",\n      \"border-block-end-style\",\n      \"border-block-end-color\",\n    ],\n    category: \"border\",\n  },\n  expand: (value) => expandBorderBlock(value),\n};\n\nexport { expandBorderBlock };\n","// b_path:: src/handlers/border-block-end/expand.ts\n\nimport { parseBorderSide } from \"../../internal/border-side-parser\";\n\nexport function expandBorderBlockEnd(value: string): Record<string, string> {\n  const { width, style, color } = parseBorderSide(value);\n\n  return {\n    \"border-block-end-width\": width,\n    \"border-block-end-style\": style,\n    \"border-block-end-color\": color,\n  };\n}\n","// b_path:: src/handlers/border-block-end/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandBorderBlockEnd } from \"./expand\";\n\nexport const borderBlockEndHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"border-block-end\",\n    longhands: [\"border-block-end-width\", \"border-block-end-style\", \"border-block-end-color\"],\n    category: \"border\",\n  },\n  expand: (value) => expandBorderBlockEnd(value),\n};\n\nexport { expandBorderBlockEnd };\n","// b_path:: src/handlers/border-block-start/expand.ts\n\nimport { parseBorderSide } from \"../../internal/border-side-parser\";\n\nexport function expandBorderBlockStart(value: string): Record<string, string> {\n  const { width, style, color } = parseBorderSide(value);\n\n  return {\n    \"border-block-start-width\": width,\n    \"border-block-start-style\": style,\n    \"border-block-start-color\": color,\n  };\n}\n","// b_path:: src/handlers/border-block-start/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandBorderBlockStart } from \"./expand\";\n\nexport const borderBlockStartHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"border-block-start\",\n    longhands: [\"border-block-start-width\", \"border-block-start-style\", \"border-block-start-color\"],\n    category: \"border\",\n  },\n  expand: (value) => expandBorderBlockStart(value),\n};\n\nexport { expandBorderBlockStart };\n","// b_path:: src/handlers/border-bottom/expand.ts\n\nimport { createBorderSideExpander } from \"../../internal/border-side-parser\";\n\nexport const expandBorderBottom = createBorderSideExpander(\"bottom\");\n","// b_path:: src/handlers/border-bottom/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandBorderBottom } from \"./expand\";\n\nexport const borderBottomHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"border-bottom\",\n    longhands: [\"border-bottom-width\", \"border-bottom-style\", \"border-bottom-color\"],\n    category: \"border\",\n  },\n  expand: (value) => expandBorderBottom(value),\n};\n\nexport { expandBorderBottom };\n","// b_path:: src/internal/trbl-expander.ts\n\n/**\n * TRBL (Top-Right-Bottom-Left) expander utility for box model shorthands\n *\n * Handles: margin, padding, inset, scroll-margin, scroll-padding, border-width, border-style, border-color\n *\n * CSS grammar:\n * - 1 value: all sides\n * - 2 values: vertical horizontal\n * - 3 values: top horizontal bottom\n * - 4 values: top right bottom left\n */\n\nexport interface TRBLResult {\n  top: string;\n  right: string;\n  bottom: string;\n  left: string;\n}\n\n/**\n * Smart split that preserves function calls like calc(), var()\n */\nfunction smartSplit(value: string): string[] {\n  const result: string[] = [];\n  let current = \"\";\n  let depth = 0;\n\n  for (let i = 0; i < value.length; i++) {\n    const char = value[i];\n\n    if (char === \"(\") {\n      depth++;\n      current += char;\n    } else if (char === \")\") {\n      depth--;\n      current += char;\n    } else if (char === \" \" && depth === 0) {\n      if (current.trim()) {\n        result.push(current.trim());\n        current = \"\";\n      }\n    } else {\n      current += char;\n    }\n  }\n\n  if (current.trim()) {\n    result.push(current.trim());\n  }\n\n  return result;\n}\n\n/**\n * Expand a TRBL shorthand value into individual side values\n *\n * @param value - The CSS value (e.g., \"10px 20px\", \"1em\")\n * @returns Object with top, right, bottom, left values\n *\n * @example\n * expandTRBL(\"10px\") // { top: \"10px\", right: \"10px\", bottom: \"10px\", left: \"10px\" }\n * expandTRBL(\"10px 20px\") // { top: \"10px\", right: \"20px\", bottom: \"10px\", left: \"20px\" }\n * expandTRBL(\"10px 20px 30px\") // { top: \"10px\", right: \"20px\", bottom: \"30px\", left: \"20px\" }\n * expandTRBL(\"10px 20px 30px 40px\") // { top: \"10px\", right: \"20px\", bottom: \"30px\", left: \"40px\" }\n */\nexport function expandTRBL(value: string): TRBLResult {\n  const trimmed = value.trim();\n\n  // Handle global values\n  if (\n    trimmed === \"initial\" ||\n    trimmed === \"inherit\" ||\n    trimmed === \"unset\" ||\n    trimmed === \"revert\"\n  ) {\n    return { top: trimmed, right: trimmed, bottom: trimmed, left: trimmed };\n  }\n\n  const parts = smartSplit(trimmed);\n\n  if (parts.length === 0) {\n    return { top: \"0\", right: \"0\", bottom: \"0\", left: \"0\" };\n  }\n\n  // 1 value: all sides\n  if (parts.length === 1) {\n    const val = parts[0];\n    return { top: val, right: val, bottom: val, left: val };\n  }\n\n  // 2 values: vertical horizontal\n  if (parts.length === 2) {\n    const [vertical, horizontal] = parts;\n    return { top: vertical, right: horizontal, bottom: vertical, left: horizontal };\n  }\n\n  // 3 values: top horizontal bottom\n  if (parts.length === 3) {\n    const [top, horizontal, bottom] = parts;\n    return { top, right: horizontal, bottom, left: horizontal };\n  }\n\n  // 4 values: top right bottom left\n  const [top, right, bottom, left] = parts;\n  return { top, right, bottom, left };\n}\n\n/**\n * Create a TRBL property expander for a given property prefix\n *\n * @param prefix - The property prefix (e.g., \"margin\", \"padding\", \"border-width\")\n * @returns Function that expands the shorthand to longhand properties\n *\n * @example\n * const expandMargin = createTRBLExpander(\"margin\");\n * expandMargin(\"10px 20px\") // { \"margin-top\": \"10px\", \"margin-right\": \"20px\", ... }\n */\nexport function createTRBLExpander(prefix: string) {\n  return (value: string): Record<string, string> => {\n    const { top, right, bottom, left } = expandTRBL(value);\n    return {\n      [`${prefix}-top`]: top,\n      [`${prefix}-right`]: right,\n      [`${prefix}-bottom`]: bottom,\n      [`${prefix}-left`]: left,\n    };\n  };\n}\n","// b_path:: src/handlers/border-color/expand.ts\n\nimport { expandTRBL } from \"../../internal/trbl-expander\";\n\nexport function expandBorderColor(value: string): Record<string, string> {\n  const { top, right, bottom, left } = expandTRBL(value);\n\n  return {\n    \"border-top-color\": top,\n    \"border-right-color\": right,\n    \"border-bottom-color\": bottom,\n    \"border-left-color\": left,\n  };\n}\n","// b_path:: src/handlers/border-color/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandBorderColor } from \"./expand\";\n\nexport const borderColorHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"border-color\",\n    longhands: [\n      \"border-top-color\",\n      \"border-right-color\",\n      \"border-bottom-color\",\n      \"border-left-color\",\n    ],\n    category: \"border\",\n  },\n  expand: (value) => expandBorderColor(value),\n};\n\nexport { expandBorderColor };\n","// b_path:: src/handlers/border-image/expand.ts\n\n/**\n * Border-image shorthand\n * Grammar: <'border-image-source'> || <'border-image-slice'> [ / <'border-image-width'> | / <'border-image-width'>? / <'border-image-outset'> ]? || <'border-image-repeat'>\n *\n * Components:\n * - source: url(), gradient, none\n * - slice: 1-4 numbers/percentages + optional 'fill'\n * - width: 1-4 length/number/auto (after first /)\n * - outset: 1-4 length/number (after second /)\n * - repeat: stretch|repeat|round|space (1-2 values)\n */\n\nconst REPEAT_KEYWORDS = new Set([\"stretch\", \"repeat\", \"round\", \"space\"]);\n\nexport function expandBorderImage(value: string): Record<string, string> {\n  const trimmed = value.trim();\n\n  // Global values\n  if (\n    trimmed === \"initial\" ||\n    trimmed === \"inherit\" ||\n    trimmed === \"unset\" ||\n    trimmed === \"revert\" ||\n    trimmed === \"none\"\n  ) {\n    const val = trimmed === \"none\" ? trimmed : trimmed;\n    return {\n      \"border-image-source\": val,\n      \"border-image-slice\": val,\n      \"border-image-width\": val,\n      \"border-image-outset\": val,\n      \"border-image-repeat\": val,\n    };\n  }\n\n  let source = \"none\";\n  let slice = \"100%\";\n  let width = \"1\";\n  let outset = \"0\";\n  let repeat = \"stretch\";\n\n  // Split by / for slice/width/outset\n  const slashParts = trimmed.split(\"/\").map((p) => p.trim());\n\n  // First part contains source, slice, and repeat\n  const mainPart = slashParts[0];\n  const tokens = smartSplit(mainPart);\n\n  const sliceTokens: string[] = [];\n  const repeatTokens: string[] = [];\n\n  for (const token of tokens) {\n    // Check if it's a source (url, gradient, image-set)\n    if (\n      token.startsWith(\"url(\") ||\n      token.startsWith(\"linear-gradient(\") ||\n      token.startsWith(\"radial-gradient(\") ||\n      token.startsWith(\"image-set(\")\n    ) {\n      source = token;\n    }\n    // Check if it's a repeat keyword\n    else if (REPEAT_KEYWORDS.has(token)) {\n      repeatTokens.push(token);\n    }\n    // Otherwise it's part of slice\n    else {\n      sliceTokens.push(token);\n    }\n  }\n\n  // Build slice value\n  if (sliceTokens.length > 0) {\n    slice = sliceTokens.join(\" \");\n  }\n\n  // Build repeat value\n  if (repeatTokens.length > 0) {\n    repeat = repeatTokens.join(\" \");\n  }\n\n  // Handle width (after first /)\n  if (slashParts.length > 1) {\n    width = slashParts[1];\n  }\n\n  // Handle outset (after second /)\n  if (slashParts.length > 2) {\n    outset = slashParts[2];\n  }\n\n  return {\n    \"border-image-source\": source,\n    \"border-image-slice\": slice,\n    \"border-image-width\": width,\n    \"border-image-outset\": outset,\n    \"border-image-repeat\": repeat,\n  };\n}\n\nfunction smartSplit(value: string): string[] {\n  const result: string[] = [];\n  let current = \"\";\n  let depth = 0;\n\n  for (let i = 0; i < value.length; i++) {\n    const char = value[i];\n\n    if (char === \"(\") {\n      depth++;\n      current += char;\n    } else if (char === \")\") {\n      depth--;\n      current += char;\n    } else if (char === \" \" && depth === 0) {\n      if (current.trim()) {\n        result.push(current.trim());\n        current = \"\";\n      }\n    } else {\n      current += char;\n    }\n  }\n\n  if (current.trim()) {\n    result.push(current.trim());\n  }\n\n  return result;\n}\n","// b_path:: src/handlers/border-image/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandBorderImage } from \"./expand\";\n\nexport const borderImageHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"border-image\",\n    longhands: [\n      \"border-image-source\",\n      \"border-image-slice\",\n      \"border-image-width\",\n      \"border-image-outset\",\n      \"border-image-repeat\",\n    ],\n    category: \"border\",\n  },\n  expand: (value) => expandBorderImage(value),\n};\n\nexport { expandBorderImage };\n","// b_path:: src/handlers/border-inline/expand.ts\n\nimport { parseBorderSide } from \"../../internal/border-side-parser\";\n\nexport function expandBorderInline(value: string): Record<string, string> {\n  const { width, style, color } = parseBorderSide(value);\n\n  return {\n    \"border-inline-start-width\": width,\n    \"border-inline-start-style\": style,\n    \"border-inline-start-color\": color,\n    \"border-inline-end-width\": width,\n    \"border-inline-end-style\": style,\n    \"border-inline-end-color\": color,\n  };\n}\n","// b_path:: src/handlers/border-inline/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandBorderInline } from \"./expand\";\n\nexport const borderInlineHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"border-inline\",\n    longhands: [\n      \"border-inline-start-width\",\n      \"border-inline-start-style\",\n      \"border-inline-start-color\",\n      \"border-inline-end-width\",\n      \"border-inline-end-style\",\n      \"border-inline-end-color\",\n    ],\n    category: \"border\",\n  },\n  expand: (value) => expandBorderInline(value),\n};\n\nexport { expandBorderInline };\n","// b_path:: src/handlers/border-inline-end/expand.ts\n\nimport { parseBorderSide } from \"../../internal/border-side-parser\";\n\nexport function expandBorderInlineEnd(value: string): Record<string, string> {\n  const { width, style, color } = parseBorderSide(value);\n\n  return {\n    \"border-inline-end-width\": width,\n    \"border-inline-end-style\": style,\n    \"border-inline-end-color\": color,\n  };\n}\n","// b_path:: src/handlers/border-inline-end/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandBorderInlineEnd } from \"./expand\";\n\nexport const borderInlineEndHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"border-inline-end\",\n    longhands: [\"border-inline-end-width\", \"border-inline-end-style\", \"border-inline-end-color\"],\n    category: \"border\",\n  },\n  expand: (value) => expandBorderInlineEnd(value),\n};\n\nexport { expandBorderInlineEnd };\n","// b_path:: src/handlers/border-inline-start/expand.ts\n\nimport { parseBorderSide } from \"../../internal/border-side-parser\";\n\nexport function expandBorderInlineStart(value: string): Record<string, string> {\n  const { width, style, color } = parseBorderSide(value);\n\n  return {\n    \"border-inline-start-width\": width,\n    \"border-inline-start-style\": style,\n    \"border-inline-start-color\": color,\n  };\n}\n","// b_path:: src/handlers/border-inline-start/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandBorderInlineStart } from \"./expand\";\n\nexport const borderInlineStartHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"border-inline-start\",\n    longhands: [\n      \"border-inline-start-width\",\n      \"border-inline-start-style\",\n      \"border-inline-start-color\",\n    ],\n    category: \"border\",\n  },\n  expand: (value) => expandBorderInlineStart(value),\n};\n\nexport { expandBorderInlineStart };\n","// b_path:: src/handlers/border-left/expand.ts\n\nimport { createBorderSideExpander } from \"../../internal/border-side-parser\";\n\nexport const expandBorderLeft = createBorderSideExpander(\"left\");\n","// b_path:: src/handlers/border-left/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandBorderLeft } from \"./expand\";\n\nexport const borderLeftHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"border-left\",\n    longhands: [\"border-left-width\", \"border-left-style\", \"border-left-color\"],\n    category: \"border\",\n  },\n  expand: (value) => expandBorderLeft(value),\n};\n\nexport { expandBorderLeft };\n","// b_path:: src/handlers/border-right/expand.ts\n\nimport { createBorderSideExpander } from \"../../internal/border-side-parser\";\n\nexport const expandBorderRight = createBorderSideExpander(\"right\");\n","// b_path:: src/handlers/border-right/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandBorderRight } from \"./expand\";\n\nexport const borderRightHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"border-right\",\n    longhands: [\"border-right-width\", \"border-right-style\", \"border-right-color\"],\n    category: \"border\",\n  },\n  expand: (value) => expandBorderRight(value),\n};\n\nexport { expandBorderRight };\n","// b_path:: src/handlers/border-style/expand.ts\n\nimport { expandTRBL } from \"../../internal/trbl-expander\";\n\nexport function expandBorderStyle(value: string): Record<string, string> {\n  const { top, right, bottom, left } = expandTRBL(value);\n\n  return {\n    \"border-top-style\": top,\n    \"border-right-style\": right,\n    \"border-bottom-style\": bottom,\n    \"border-left-style\": left,\n  };\n}\n","// b_path:: src/handlers/border-style/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandBorderStyle } from \"./expand\";\n\nexport const borderStyleHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"border-style\",\n    longhands: [\n      \"border-top-style\",\n      \"border-right-style\",\n      \"border-bottom-style\",\n      \"border-left-style\",\n    ],\n    category: \"border\",\n  },\n  expand: (value) => expandBorderStyle(value),\n};\n\nexport { expandBorderStyle };\n","// b_path:: src/handlers/border-top/expand.ts\n\nimport { createBorderSideExpander } from \"../../internal/border-side-parser\";\n\nexport const expandBorderTop = createBorderSideExpander(\"top\");\n","// b_path:: src/handlers/border-top/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandBorderTop } from \"./expand\";\n\nexport const borderTopHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"border-top\",\n    longhands: [\"border-top-width\", \"border-top-style\", \"border-top-color\"],\n    category: \"border\",\n  },\n  expand: (value) => expandBorderTop(value),\n};\n\nexport { expandBorderTop };\n","// b_path:: src/handlers/border-width/expand.ts\n\nimport { expandTRBL } from \"../../internal/trbl-expander\";\n\nexport function expandBorderWidth(value: string): Record<string, string> {\n  const { top, right, bottom, left } = expandTRBL(value);\n\n  return {\n    \"border-top-width\": top,\n    \"border-right-width\": right,\n    \"border-bottom-width\": bottom,\n    \"border-left-width\": left,\n  };\n}\n","// b_path:: src/handlers/border-width/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandBorderWidth } from \"./expand\";\n\nexport const borderWidthHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"border-width\",\n    longhands: [\n      \"border-top-width\",\n      \"border-right-width\",\n      \"border-bottom-width\",\n      \"border-left-width\",\n    ],\n    category: \"border\",\n  },\n  expand: (value) => expandBorderWidth(value),\n};\n\nexport { expandBorderWidth };\n","// b_path:: src/handlers/container/expand.ts\n\nexport function expandContainer(value: string): Record<string, string> {\n  const trimmed = value.trim();\n\n  // Global values\n  if (\n    trimmed === \"initial\" ||\n    trimmed === \"inherit\" ||\n    trimmed === \"unset\" ||\n    trimmed === \"revert\"\n  ) {\n    return {\n      \"container-name\": trimmed,\n      \"container-type\": trimmed,\n    };\n  }\n\n  // Split on /\n  const parts = trimmed.split(\"/\").map((p) => p.trim());\n\n  if (parts.length === 1) {\n    // Just name, or just type if it's a type keyword\n    const val = parts[0];\n    if (val === \"none\" || val === \"size\" || val === \"inline-size\" || val === \"normal\") {\n      return {\n        \"container-name\": \"none\",\n        \"container-type\": val,\n      };\n    }\n    return {\n      \"container-name\": val,\n      \"container-type\": \"normal\",\n    };\n  }\n\n  // name / type\n  return {\n    \"container-name\": parts[0],\n    \"container-type\": parts[1],\n  };\n}\n","// b_path:: src/handlers/container/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandContainer } from \"./expand\";\n\nexport const containerHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"container\",\n    longhands: [\"container-name\", \"container-type\"],\n    category: \"layout\",\n  },\n  expand: (value) => expandContainer(value),\n};\n\nexport { expandContainer };\n","// b_path:: src/handlers/gap/expand.ts\n\nimport { createPropertyHandler, type PropertyHandler } from \"@/internal/property-handler\";\nimport { sortProperties } from \"@/internal/property-sorter\";\n\n/**\n * Parses gap shorthand value\n * Syntax: gap = <'row-gap'> <'column-gap'>?\n *\n * If one value: both row-gap and column-gap use that value\n * If two values: first is row-gap, second is column-gap\n */\nfunction parseGapValue(value: string): Record<string, string> | undefined {\n  const trimmed = value.trim();\n\n  // Handle CSS-wide keywords\n  if (/^(inherit|initial|unset|revert)$/i.test(trimmed)) {\n    return sortProperties({\n      \"row-gap\": trimmed,\n      \"column-gap\": trimmed,\n    });\n  }\n\n  // Split by whitespace\n  const parts = trimmed.split(/\\s+/);\n\n  if (parts.length === 0 || parts.length > 2) {\n    return undefined;\n  }\n\n  if (parts.length === 1) {\n    // Single value - applies to both\n    return sortProperties({\n      \"row-gap\": parts[0],\n      \"column-gap\": parts[0],\n    });\n  }\n\n  // Two values - row then column\n  return sortProperties({\n    \"row-gap\": parts[0],\n    \"column-gap\": parts[1],\n  });\n}\n\n/**\n * Property handler for the 'gap' CSS shorthand property\n *\n * Expands gap into row-gap and column-gap.\n *\n * @example\n * ```typescript\n * gapHandler.expand('10px');          // row-gap: 10px; column-gap: 10px\n * gapHandler.expand('10px 20px');     // row-gap: 10px; column-gap: 20px\n * gapHandler.expand('normal');        // row-gap: normal; column-gap: normal\n * ```\n */\nexport const gapHandler: PropertyHandler = createPropertyHandler({\n  meta: {\n    shorthand: \"gap\",\n    longhands: [\"row-gap\", \"column-gap\"],\n    category: \"layout\",\n  },\n\n  expand: (value: string): Record<string, string> | undefined => {\n    return parseGapValue(value);\n  },\n\n  validate: (value: string): boolean => {\n    return gapHandler.expand(value) !== undefined;\n  },\n});\n\nexport default function gap(value: string): Record<string, string> | undefined {\n  return gapHandler.expand(value);\n}\n","// b_path:: src/handlers/grid-template/expand.ts\n\n/**\n * Grid-template is complex - supports multiple syntaxes:\n * 1. none\n * 2. grid-template-rows / grid-template-columns\n * 3. [ line-names ] \"grid-area-strings\" track-size [ line-names ]\n *\n * For v2.0.0, we'll handle the common cases correctly\n */\n\nexport function expandGridTemplate(value: string): Record<string, string> {\n  const trimmed = value.trim();\n\n  // Global values\n  if (\n    trimmed === \"initial\" ||\n    trimmed === \"inherit\" ||\n    trimmed === \"unset\" ||\n    trimmed === \"revert\" ||\n    trimmed === \"none\"\n  ) {\n    return {\n      \"grid-template-rows\": trimmed,\n      \"grid-template-columns\": trimmed,\n      \"grid-template-areas\": trimmed === \"none\" ? \"none\" : trimmed,\n    };\n  }\n\n  // Check for / separator (rows / columns syntax)\n  if (trimmed.includes(\" / \")) {\n    const [rows, columns] = trimmed.split(\" / \").map((p) => p.trim());\n    return {\n      \"grid-template-rows\": rows,\n      \"grid-template-columns\": columns,\n      \"grid-template-areas\": \"none\",\n    };\n  }\n\n  // Check for grid-area syntax (contains quotes)\n  if (trimmed.includes('\"') || trimmed.includes(\"'\")) {\n    // Complex grid-areas syntax\n    // Extract area strings and optional track sizes\n    const areaMatches = trimmed.match(/[\"'][^\"']+[\"']/g);\n    if (areaMatches) {\n      const areas = areaMatches.join(\" \");\n      // Remove area strings to get track sizes\n      let remaining = trimmed;\n      for (const area of areaMatches) {\n        remaining = remaining.replace(area, \"\");\n      }\n      const trackSize = remaining.trim() || \"auto\";\n\n      return {\n        \"grid-template-rows\": trackSize,\n        \"grid-template-columns\": \"none\",\n        \"grid-template-areas\": areas,\n      };\n    }\n  }\n\n  // Fallback: treat as rows\n  return {\n    \"grid-template-rows\": trimmed,\n    \"grid-template-columns\": \"none\",\n    \"grid-template-areas\": \"none\",\n  };\n}\n","// b_path:: src/handlers/grid-template/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandGridTemplate } from \"./expand\";\n\nexport const gridTemplateHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"grid-template\",\n    longhands: [\"grid-template-rows\", \"grid-template-columns\", \"grid-template-areas\"],\n    category: \"grid\",\n  },\n  expand: (value) => expandGridTemplate(value),\n};\n\nexport { expandGridTemplate };\n","// b_path:: src/handlers/inset/expand.ts\n\nimport { expandTRBL } from \"../../internal/trbl-expander\";\n\nexport function expandInset(value: string): Record<string, string> {\n  const { top, right, bottom, left } = expandTRBL(value);\n\n  return {\n    top,\n    right,\n    bottom,\n    left,\n  };\n}\n","// b_path:: src/handlers/inset/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandInset } from \"./expand\";\n\nexport const insetHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"inset\",\n    longhands: [\"top\", \"right\", \"bottom\", \"left\"],\n    category: \"positioning\",\n  },\n  expand: (value) => expandInset(value),\n};\n\nexport { expandInset };\n","// b_path:: src/handlers/inset-block/expand.ts\n\nexport function expandInsetBlock(value: string): Record<string, string> {\n  const trimmed = value.trim();\n\n  // Global values\n  if (\n    trimmed === \"initial\" ||\n    trimmed === \"inherit\" ||\n    trimmed === \"unset\" ||\n    trimmed === \"revert\"\n  ) {\n    return {\n      \"inset-block-start\": trimmed,\n      \"inset-block-end\": trimmed,\n    };\n  }\n\n  const parts = trimmed.split(/\\s+/).filter((p) => p);\n\n  if (parts.length === 1) {\n    return {\n      \"inset-block-start\": parts[0],\n      \"inset-block-end\": parts[0],\n    };\n  }\n\n  // 2 values: start end\n  return {\n    \"inset-block-start\": parts[0],\n    \"inset-block-end\": parts[1],\n  };\n}\n","// b_path:: src/handlers/inset-block/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandInsetBlock } from \"./expand\";\n\nexport const insetBlockHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"inset-block\",\n    longhands: [\"inset-block-start\", \"inset-block-end\"],\n    category: \"positioning\",\n  },\n  expand: (value) => expandInsetBlock(value),\n};\n\nexport { expandInsetBlock };\n","// b_path:: src/handlers/inset-inline/expand.ts\n\nexport function expandInsetInline(value: string): Record<string, string> {\n  const trimmed = value.trim();\n\n  // Global values\n  if (\n    trimmed === \"initial\" ||\n    trimmed === \"inherit\" ||\n    trimmed === \"unset\" ||\n    trimmed === \"revert\"\n  ) {\n    return {\n      \"inset-inline-start\": trimmed,\n      \"inset-inline-end\": trimmed,\n    };\n  }\n\n  const parts = trimmed.split(/\\s+/).filter((p) => p);\n\n  if (parts.length === 1) {\n    return {\n      \"inset-inline-start\": parts[0],\n      \"inset-inline-end\": parts[0],\n    };\n  }\n\n  // 2 values: start end\n  return {\n    \"inset-inline-start\": parts[0],\n    \"inset-inline-end\": parts[1],\n  };\n}\n","// b_path:: src/handlers/inset-inline/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandInsetInline } from \"./expand\";\n\nexport const insetInlineHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"inset-inline\",\n    longhands: [\"inset-inline-start\", \"inset-inline-end\"],\n    category: \"positioning\",\n  },\n  expand: (value) => expandInsetInline(value),\n};\n\nexport { expandInsetInline };\n","// b_path:: src/handlers/margin/expand.ts\n\nimport { createTRBLExpander } from \"../../internal/trbl-expander\";\n\nexport const expandMargin = createTRBLExpander(\"margin\");\n","// b_path:: src/handlers/margin/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandMargin } from \"./expand\";\n\nexport const marginHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"margin\",\n    longhands: [\"margin-top\", \"margin-right\", \"margin-bottom\", \"margin-left\"],\n    category: \"box-model\",\n  },\n  expand: (value) => expandMargin(value),\n};\n\nexport { expandMargin };\n","// b_path:: src/handlers/mask-position/expand.ts\n\nimport { parsePosition } from \"../../internal/position-parser\";\n\nexport function expandMaskPosition(value: string): Record<string, string> {\n  const { x, y } = parsePosition(value);\n\n  return {\n    \"mask-position-x\": x,\n    \"mask-position-y\": y,\n  };\n}\n","// b_path:: src/handlers/mask-position/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandMaskPosition } from \"./expand\";\n\nexport const maskPositionHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"mask-position\",\n    longhands: [\"mask-position-x\", \"mask-position-y\"],\n    category: \"position\",\n  },\n  expand: (value) => expandMaskPosition(value),\n};\n\nexport { expandMaskPosition };\n","// b_path:: src/handlers/object-position/expand.ts\n\nimport { parsePosition } from \"../../internal/position-parser\";\n\nexport function expandObjectPosition(value: string): Record<string, string> {\n  const { x, y } = parsePosition(value);\n\n  return {\n    \"object-position-x\": x,\n    \"object-position-y\": y,\n  };\n}\n","// b_path:: src/handlers/object-position/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandObjectPosition } from \"./expand\";\n\nexport const objectPositionHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"object-position\",\n    longhands: [\"object-position-x\", \"object-position-y\"],\n    category: \"position\",\n  },\n  expand: (value) => expandObjectPosition(value),\n};\n\nexport { expandObjectPosition };\n","// b_path:: src/handlers/padding/expand.ts\n\nimport { createTRBLExpander } from \"../../internal/trbl-expander\";\n\nexport const expandPadding = createTRBLExpander(\"padding\");\n","// b_path:: src/handlers/padding/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandPadding } from \"./expand\";\n\nexport const paddingHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"padding\",\n    longhands: [\"padding-top\", \"padding-right\", \"padding-bottom\", \"padding-left\"],\n    category: \"box-model\",\n  },\n  expand: (value) => expandPadding(value),\n};\n\nexport { expandPadding };\n","// b_path:: src/handlers/scroll-margin/expand.ts\n\nimport { createTRBLExpander } from \"../../internal/trbl-expander\";\n\nexport const expandScrollMargin = createTRBLExpander(\"scroll-margin\");\n","// b_path:: src/handlers/scroll-margin/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandScrollMargin } from \"./expand\";\n\nexport const scrollMarginHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"scroll-margin\",\n    longhands: [\n      \"scroll-margin-top\",\n      \"scroll-margin-right\",\n      \"scroll-margin-bottom\",\n      \"scroll-margin-left\",\n    ],\n    category: \"box-model\",\n  },\n  expand: (value) => expandScrollMargin(value),\n};\n\nexport { expandScrollMargin };\n","// b_path:: src/handlers/scroll-padding/expand.ts\n\nimport { createTRBLExpander } from \"../../internal/trbl-expander\";\n\nexport const expandScrollPadding = createTRBLExpander(\"scroll-padding\");\n","// b_path:: src/handlers/scroll-padding/index.ts\n\nimport type { PropertyHandler } from \"../../internal/property-handler\";\nimport { expandScrollPadding } from \"./expand\";\n\nexport const scrollPaddingHandler: PropertyHandler = {\n  meta: {\n    shorthand: \"scroll-padding\",\n    longhands: [\n      \"scroll-padding-top\",\n      \"scroll-padding-right\",\n      \"scroll-padding-bottom\",\n      \"scroll-padding-left\",\n    ],\n    category: \"box-model\",\n  },\n  expand: (value) => expandScrollPadding(value),\n};\n\nexport { expandScrollPadding };\n","// b_path:: src/internal/handler-registry.ts\n\n/**\n * Centralized registry for all PropertyHandler instances.\n * Enables dynamic property lookup, introspection, and foundation for collapse API.\n * @module handler-registry\n */\n\n// Import all handlers\nimport { animationHandler } from \"../handlers/animation\";\nimport { backgroundHandler } from \"../handlers/background\";\nimport { backgroundPositionHandler } from \"../handlers/background-position\";\nimport { borderHandler } from \"../handlers/border\";\nimport { borderBlockHandler } from \"../handlers/border-block\";\nimport { borderBlockEndHandler } from \"../handlers/border-block-end\";\nimport { borderBlockStartHandler } from \"../handlers/border-block-start\";\nimport { borderBottomHandler } from \"../handlers/border-bottom\";\nimport { borderColorHandler } from \"../handlers/border-color\";\nimport { borderImageHandler } from \"../handlers/border-image\";\nimport { borderInlineHandler } from \"../handlers/border-inline\";\nimport { borderInlineEndHandler } from \"../handlers/border-inline-end\";\nimport { borderInlineStartHandler } from \"../handlers/border-inline-start\";\nimport { borderLeftHandler } from \"../handlers/border-left\";\nimport { borderRadiusHandler } from \"../handlers/border-radius\";\nimport { borderRightHandler } from \"../handlers/border-right\";\nimport { borderStyleHandler } from \"../handlers/border-style\";\nimport { borderTopHandler } from \"../handlers/border-top\";\nimport { borderWidthHandler } from \"../handlers/border-width\";\nimport { columnRuleHandler } from \"../handlers/column-rule\";\nimport { columnsHandler } from \"../handlers/columns\";\nimport { containIntrinsicSizeHandler } from \"../handlers/contain-intrinsic-size\";\nimport { containerHandler } from \"../handlers/container\";\nimport { flexHandler } from \"../handlers/flex\";\nimport { flexFlowHandler } from \"../handlers/flex-flow\";\nimport { fontHandler } from \"../handlers/font\";\nimport { gapHandler } from \"../handlers/gap\";\nimport { gridHandler } from \"../handlers/grid\";\nimport { gridAreaHandler } from \"../handlers/grid-area\";\nimport { gridColumnHandler } from \"../handlers/grid-column\";\nimport { gridRowHandler } from \"../handlers/grid-row\";\nimport { gridTemplateHandler } from \"../handlers/grid-template\";\nimport { insetHandler } from \"../handlers/inset\";\nimport { insetBlockHandler } from \"../handlers/inset-block\";\nimport { insetInlineHandler } from \"../handlers/inset-inline\";\nimport { listStyleHandler } from \"../handlers/list-style\";\nimport { marginHandler } from \"../handlers/margin\";\nimport { maskHandler } from \"../handlers/mask\";\nimport { maskPositionHandler } from \"../handlers/mask-position\";\nimport { objectPositionHandler } from \"../handlers/object-position\";\nimport { offsetHandler } from \"../handlers/offset\";\nimport { outlineHandler } from \"../handlers/outline\";\nimport { overflowHandler } from \"../handlers/overflow\";\nimport { paddingHandler } from \"../handlers/padding\";\nimport { placeContentHandler } from \"../handlers/place-content\";\nimport { placeItemsHandler } from \"../handlers/place-items\";\nimport { placeSelfHandler } from \"../handlers/place-self\";\nimport { scrollMarginHandler } from \"../handlers/scroll-margin\";\nimport { scrollPaddingHandler } from \"../handlers/scroll-padding\";\nimport { textDecorationHandler } from \"../handlers/text-decoration\";\nimport { textEmphasisHandler } from \"../handlers/text-emphasis\";\nimport { transitionHandler } from \"../handlers/transition\";\nimport type { PropertyCategory, PropertyHandler, PropertyHandlerOptions } from \"./property-handler\";\n\n/**\n * Handler registry interface providing centralized access to all PropertyHandlers.\n */\nexport interface HandlerRegistry {\n  /** Read-only map of all registered handlers */\n  readonly handlers: ReadonlyMap<string, PropertyHandler>;\n\n  /** Get a handler by shorthand property name */\n  get(shorthand: string): PropertyHandler | undefined;\n\n  /** Check if a shorthand property is registered */\n  has(shorthand: string): boolean;\n\n  /** Get all handlers in a specific category */\n  getByCategory(category: PropertyCategory): PropertyHandler[];\n\n  /** Get all registered shorthand property names */\n  getAllShorthands(): string[];\n\n  /** Get longhand properties for a shorthand */\n  getLonghands(shorthand: string): string[] | undefined;\n\n  /** Get all shorthands that include a specific longhand */\n  getShorthandsForLonghand(longhand: string): string[];\n}\n\n/**\n * Internal handler map with all 25 PropertyHandlers.\n * @internal\n */\nconst handlerMap = new Map<string, PropertyHandler>([\n  [\"animation\", animationHandler],\n  [\"background\", backgroundHandler],\n  [\"background-position\", backgroundPositionHandler],\n  [\"border\", borderHandler],\n  [\"border-block\", borderBlockHandler],\n  [\"border-block-end\", borderBlockEndHandler],\n  [\"border-block-start\", borderBlockStartHandler],\n  [\"border-bottom\", borderBottomHandler],\n  [\"border-color\", borderColorHandler],\n  [\"border-image\", borderImageHandler],\n  [\"border-inline\", borderInlineHandler],\n  [\"border-inline-end\", borderInlineEndHandler],\n  [\"border-inline-start\", borderInlineStartHandler],\n  [\"border-left\", borderLeftHandler],\n  [\"border-radius\", borderRadiusHandler],\n  [\"border-right\", borderRightHandler],\n  [\"border-style\", borderStyleHandler],\n  [\"border-top\", borderTopHandler],\n  [\"border-width\", borderWidthHandler],\n  [\"column-rule\", columnRuleHandler],\n  [\"columns\", columnsHandler],\n  [\"contain-intrinsic-size\", containIntrinsicSizeHandler],\n  [\"container\", containerHandler],\n  [\"flex\", flexHandler],\n  [\"flex-flow\", flexFlowHandler],\n  [\"font\", fontHandler],\n  [\"gap\", gapHandler],\n  [\"grid\", gridHandler],\n  [\"grid-area\", gridAreaHandler],\n  [\"grid-column\", gridColumnHandler],\n  [\"grid-row\", gridRowHandler],\n  [\"grid-template\", gridTemplateHandler],\n  [\"inset\", insetHandler],\n  [\"inset-block\", insetBlockHandler],\n  [\"inset-inline\", insetInlineHandler],\n  [\"list-style\", listStyleHandler],\n  [\"margin\", marginHandler],\n  [\"mask\", maskHandler],\n  [\"mask-position\", maskPositionHandler],\n  [\"object-position\", objectPositionHandler],\n  [\"offset\", offsetHandler],\n  [\"outline\", outlineHandler],\n  [\"overflow\", overflowHandler],\n  [\"padding\", paddingHandler],\n  [\"place-content\", placeContentHandler],\n  [\"place-items\", placeItemsHandler],\n  [\"place-self\", placeSelfHandler],\n  [\"scroll-margin\", scrollMarginHandler],\n  [\"scroll-padding\", scrollPaddingHandler],\n  [\"text-decoration\", textDecorationHandler],\n  [\"text-emphasis\", textEmphasisHandler],\n  [\"transition\", transitionHandler],\n]);\n\n/**\n * Reverse index: longhand → shorthands[]\n * Built once at module load time for O(1) lookups.\n * @internal\n */\nconst longhandToShorthandsMap = new Map<string, string[]>();\n\n// Build reverse index\nfor (const [shorthand, handler] of handlerMap.entries()) {\n  for (const longhand of handler.meta.longhands) {\n    const existing = longhandToShorthandsMap.get(longhand) ?? [];\n    existing.push(shorthand);\n    longhandToShorthandsMap.set(longhand, existing);\n  }\n}\n\n/**\n * Global handler registry instance.\n *\n * Provides centralized access to all PropertyHandler instances, enabling:\n * - Dynamic property expansion\n * - Handler introspection\n * - Reverse longhand → shorthand lookups\n * - Category-based filtering\n *\n * @example\n * ```typescript\n * import { registry } from 'b_short';\n *\n * // Get a handler\n * const handler = registry.get('overflow');\n *\n * // Check availability\n * if (registry.has('flex-flow')) {\n *   const longhands = registry.getLonghands('flex-flow');\n * }\n *\n * // Get by category\n * const layoutHandlers = registry.getByCategory('layout');\n * ```\n */\nexport const registry: HandlerRegistry = {\n  handlers: handlerMap,\n\n  get(shorthand: string): PropertyHandler | undefined {\n    return handlerMap.get(shorthand);\n  },\n\n  has(shorthand: string): boolean {\n    return handlerMap.has(shorthand);\n  },\n\n  getByCategory(category: PropertyCategory): PropertyHandler[] {\n    return Array.from(handlerMap.values()).filter((h) => h.meta.category === category);\n  },\n\n  getAllShorthands(): string[] {\n    return Array.from(handlerMap.keys());\n  },\n\n  getLonghands(shorthand: string): string[] | undefined {\n    return handlerMap.get(shorthand)?.meta.longhands;\n  },\n\n  getShorthandsForLonghand(longhand: string): string[] {\n    return longhandToShorthandsMap.get(longhand) ?? [];\n  },\n};\n\n/**\n * Dynamically expand a CSS shorthand property value.\n *\n * @param property - The shorthand property name (e.g., 'overflow', 'flex-flow')\n * @param value - The CSS value to expand\n * @param options - Optional handler options\n * @returns Expanded longhand properties, or undefined if expansion fails\n *\n * @example\n * ```typescript\n * import { expandProperty } from 'b_short';\n *\n * const result = expandProperty('overflow', 'hidden auto');\n * // { 'overflow-x': 'hidden', 'overflow-y': 'auto' }\n *\n * const invalid = expandProperty('overflow', 'not-valid');\n * // undefined\n * ```\n */\nexport function expandProperty(\n  property: string,\n  value: string,\n  options?: PropertyHandlerOptions\n): Record<string, string> | undefined {\n  const handler = registry.get(property);\n  return handler?.expand(value, options);\n}\n\n/**\n * Validate a CSS shorthand property value without expanding it.\n *\n * @param property - The shorthand property name\n * @param value - The CSS value to validate\n * @returns true if valid, false otherwise\n *\n * @example\n * ```typescript\n * import { validateProperty } from 'b_short';\n *\n * validateProperty('overflow', 'hidden'); // true\n * validateProperty('overflow', 'invalid'); // false\n * validateProperty('unknown-property', 'value'); // false\n * ```\n */\nexport function validateProperty(property: string, value: string): boolean {\n  const handler = registry.get(property);\n  return handler?.validate?.(value) ?? false;\n}\n\n/**\n * Check if a CSS property is a registered shorthand.\n *\n * @param property - The property name to check\n * @returns true if the property is a registered shorthand\n *\n * @example\n * ```typescript\n * import { isShorthandProperty } from 'b_short';\n *\n * isShorthandProperty('overflow'); // true\n * isShorthandProperty('overflow-x'); // false (longhand)\n * isShorthandProperty('unknown'); // false\n * ```\n */\nexport function isShorthandProperty(property: string): boolean {\n  return registry.has(property);\n}\n"]}