@tenphi/tasty 2.0.3 → 2.1.0

package/dist/pipeline/simplify.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"simplify.js","names":[],"sources":["../../src/pipeline/simplify.ts"],"sourcesContent":["/**\n * Condition Simplification Engine\n *\n * Simplifies condition trees by applying boolean algebra rules,\n * detecting contradictions, merging ranges, and deduplicating terms.\n *\n * This is critical for:\n * 1. Detecting invalid combinations (A & !A → FALSE)\n * 2. Reducing CSS output size\n * 3. Producing cleaner selectors\n */\n\nimport { Lru } from '../parser/lru';\n\nimport type {\n  ConditionNode,\n  ContainerCondition,\n  MediaCondition,\n  ModifierCondition,\n  NumericBound,\n  OwnCondition,\n  RootCondition,\n} from './conditions';\nimport {\n  and,\n  createOwnCondition,\n  createParentCondition,\n  createRootCondition,\n  falseCondition,\n  getConditionUniqueId,\n  not,\n  or,\n  trueCondition,\n} from './conditions';\n\n// ============================================================================\n// Caching\n// ============================================================================\n\nconst simplifyCache = new Lru<string, ConditionNode>(5000);\n\n// ============================================================================\n// Main Simplify Function\n// ============================================================================\n\n/**\n * Simplify a condition tree aggressively.\n *\n * This applies all possible simplification rules:\n * - Boolean algebra (identity, annihilator, idempotent, absorption)\n * - Contradiction detection (A & !A → FALSE)\n * - Tautology detection (A | !A → TRUE)\n * - Range intersection for numeric queries\n * - Attribute value conflict detection\n * - Deduplication and sorting\n */\nexport function simplifyCondition(node: ConditionNode): ConditionNode {\n  // Check cache\n  const key = getConditionUniqueId(node);\n  const cached = simplifyCache.get(key);\n  if (cached) {\n    return cached;\n  }\n\n  const result = simplifyInner(node);\n\n  // Cache result\n  simplifyCache.set(key, result);\n\n  return result;\n}\n\n/**\n * Clear the simplify cache (for testing)\n */\nexport function clearSimplifyCache(): void {\n  simplifyCache.clear();\n}\n\n// ============================================================================\n// Inner Simplification\n// ============================================================================\n\nfunction simplifyInner(node: ConditionNode): ConditionNode {\n  // Base cases\n  if (node.kind === 'true' || node.kind === 'false') {\n    return node;\n  }\n\n  // State conditions: most are leaves, but @root / @own / @parent wrap a\n  // nested condition that benefits from the same simplification (e.g.\n  // `@root(schema=dark & schema=light)` → inner is FALSE → wrapper is FALSE).\n  // Only descend on non-negated wrappers; negated wrappers would need\n  // additional reasoning (`!@root(FALSE)` = TRUE) that isn't worth the\n  // surface area for the current bug.\n  if (node.kind === 'state') {\n    if (\n      (node.type === 'root' || node.type === 'own' || node.type === 'parent') &&\n      !node.negated\n    ) {\n      const simplifiedInner = simplifyInner(node.innerCondition);\n      if (simplifiedInner.kind === 'false') return falseCondition();\n      if (simplifiedInner === node.innerCondition) return node;\n      if (node.type === 'root') {\n        return createRootCondition(simplifiedInner, false, node.raw);\n      }\n      if (node.type === 'own') {\n        return createOwnCondition(simplifiedInner, false, node.raw);\n      }\n      return createParentCondition(\n        simplifiedInner,\n        node.direct,\n        false,\n        node.raw,\n      );\n    }\n    return node;\n  }\n\n  // Compound conditions - recursively simplify\n  if (node.kind === 'compound') {\n    // First, recursively simplify all children\n    const simplifiedChildren = node.children.map((c) => simplifyInner(c));\n\n    // Then apply compound-specific simplifications\n    if (node.operator === 'AND') {\n      return simplifyAnd(simplifiedChildren);\n    } else {\n      return simplifyOr(simplifiedChildren);\n    }\n  }\n\n  return node;\n}\n\n// ============================================================================\n// AND Simplification\n// ============================================================================\n\nfunction simplifyAnd(children: ConditionNode[]): ConditionNode {\n  let terms: ConditionNode[] = [];\n\n  // ─── Pass 1: flatten + identity/annihilator ────────────────────────────\n  // Flatten nested ANDs, drop TRUE children, short-circuit on any FALSE.\n  for (const child of children) {\n    if (child.kind === 'false') {\n      // AND with FALSE → FALSE\n      return falseCondition();\n    }\n    if (child.kind === 'true') {\n      // AND with TRUE → skip (identity)\n      continue;\n    }\n    if (child.kind === 'compound' && child.operator === 'AND') {\n      // Flatten nested AND\n      terms.push(...child.children);\n    } else {\n      terms.push(child);\n    }\n  }\n\n  // Empty → TRUE\n  if (terms.length === 0) {\n    return trueCondition();\n  }\n\n  // Single term → return it\n  if (terms.length === 1) {\n    return terms[0];\n  }\n\n  // ─── Pass 2: filter contradictions ─────────────────────────────────────\n  // Any of these indicates the conjunction can never be satisfied.\n\n  // Check for contradictions\n  if (hasContradiction(terms)) {\n    return falseCondition();\n  }\n\n  // Check for range contradictions in media/container queries\n  if (hasRangeContradiction(terms)) {\n    return falseCondition();\n  }\n\n  // Check for attribute value conflicts\n  if (hasAttributeConflict(terms)) {\n    return falseCondition();\n  }\n\n  // Check for container style query conflicts\n  if (hasContainerStyleConflict(terms)) {\n    return falseCondition();\n  }\n\n  // ─── Pass 3: redundancy elimination + canonicalization ─────────────────\n\n  // Remove redundant negations implied by positive terms\n  // e.g., style(--variant: danger) implies NOT style(--variant: success)\n  // and style(--variant: danger) implies style(--variant) (existence)\n  terms = removeImpliedNegations(terms);\n\n  // Deduplicate (by uniqueId)\n  terms = deduplicateTerms(terms);\n\n  // Try to merge numeric ranges\n  terms = mergeRanges(terms);\n\n  // Sort for canonical form\n  terms = sortTerms(terms);\n\n  // ─── Pass 4: boolean-algebra reductions ────────────────────────────────\n\n  // Apply absorption: A & (A | B) → A\n  terms = applyAbsorptionAnd(terms);\n\n  // Apply consensus/resolution: (A | B) & (A | !B) → A\n  terms = applyConsensusAnd(terms);\n\n  if (terms.length === 0) {\n    return trueCondition();\n  }\n  if (terms.length === 1) {\n    return terms[0];\n  }\n\n  return {\n    kind: 'compound',\n    operator: 'AND',\n    children: terms,\n  };\n}\n\n// ============================================================================\n// OR Simplification\n// ============================================================================\n\nfunction simplifyOr(children: ConditionNode[]): ConditionNode {\n  let terms: ConditionNode[] = [];\n\n  // ─── Pass 1: flatten + identity/annihilator ────────────────────────────\n  // Flatten nested ORs, drop FALSE children, short-circuit on any TRUE.\n  for (const child of children) {\n    if (child.kind === 'true') {\n      // OR with TRUE → TRUE\n      return trueCondition();\n    }\n    if (child.kind === 'false') {\n      // OR with FALSE → skip (identity)\n      continue;\n    }\n    if (child.kind === 'compound' && child.operator === 'OR') {\n      // Flatten nested OR\n      terms.push(...child.children);\n    } else {\n      terms.push(child);\n    }\n  }\n\n  // Empty → FALSE\n  if (terms.length === 0) {\n    return falseCondition();\n  }\n\n  // Single term → return it\n  if (terms.length === 1) {\n    return terms[0];\n  }\n\n  // ─── Pass 2: filter tautologies ────────────────────────────────────────\n  // A | !A means the disjunction is always satisfied.\n  if (hasTautology(terms)) {\n    return trueCondition();\n  }\n\n  // ─── Pass 3: redundancy elimination + canonicalization ─────────────────\n\n  // Deduplicate\n  terms = deduplicateTerms(terms);\n\n  // Sort for canonical form\n  terms = sortTerms(terms);\n\n  // ─── Pass 4: boolean-algebra reductions ────────────────────────────────\n\n  // Apply absorption: A | (A & B) → A\n  terms = applyAbsorptionOr(terms);\n\n  // Apply complementary factoring: (A & B) | (A & !B) → A\n  terms = applyComplementaryFactoring(terms);\n\n  if (terms.length === 0) {\n    return falseCondition();\n  }\n  if (terms.length === 1) {\n    return terms[0];\n  }\n\n  return {\n    kind: 'compound',\n    operator: 'OR',\n    children: terms,\n  };\n}\n\n// ============================================================================\n// Contradiction Detection\n// ============================================================================\n\n/**\n * Check if any pair of terms has complementary negation (A and !A).\n * Used for both contradiction detection (in AND) and tautology detection (in OR),\n * since the underlying check is identical: the context determines the semantics.\n */\nfunction hasComplementaryPair(terms: ConditionNode[]): boolean {\n  const uniqueIds = new Set<string>();\n\n  for (const term of terms) {\n    if (term.kind !== 'state') continue;\n\n    const id = term.uniqueId;\n    const negatedId = term.negated ? id.slice(1) : `!${id}`;\n\n    if (uniqueIds.has(negatedId)) {\n      return true;\n    }\n    uniqueIds.add(id);\n  }\n\n  return false;\n}\n\nconst hasContradiction = hasComplementaryPair;\nconst hasTautology = hasComplementaryPair;\n\n// ============================================================================\n// Range Contradiction Detection\n// ============================================================================\n\n/**\n * Effective bounds computed from conditions (including negated single-bound conditions)\n */\ninterface EffectiveBounds {\n  lowerBound: number | null;\n  lowerInclusive: boolean;\n  upperBound: number | null;\n  upperInclusive: boolean;\n}\n\n/**\n * Excluded range from a negated range condition\n */\ninterface ExcludedRange {\n  lower: number;\n  lowerInclusive: boolean;\n  upper: number;\n  upperInclusive: boolean;\n}\n\n/**\n * Check for range contradictions in media/container queries\n * e.g., @media(w < 400px) & @media(w > 800px) → FALSE\n *\n * Also handles negated conditions:\n * - Single-bound negations are inverted (not (w < 600px) → w >= 600px)\n * - Range negations create excluded ranges that are checked against positive bounds\n */\nfunction hasRangeContradiction(terms: ConditionNode[]): boolean {\n  // Group by dimension, separating positive and negated conditions\n  const mediaByDim = new Map<\n    string,\n    { positive: MediaCondition[]; negated: MediaCondition[] }\n  >();\n  const containerByDim = new Map<\n    string,\n    { positive: ContainerCondition[]; negated: ContainerCondition[] }\n  >();\n\n  for (const term of terms) {\n    if (term.kind !== 'state') continue;\n\n    if (term.type === 'media' && term.subtype === 'dimension') {\n      const key = term.dimension || 'width';\n      if (!mediaByDim.has(key)) {\n        mediaByDim.set(key, { positive: [], negated: [] });\n      }\n      const group = mediaByDim.get(key)!;\n      if (term.negated) {\n        group.negated.push(term);\n      } else {\n        group.positive.push(term);\n      }\n    }\n\n    if (term.type === 'container' && term.subtype === 'dimension') {\n      const key = `${term.containerName || '_'}:${term.dimension || 'width'}`;\n      if (!containerByDim.has(key)) {\n        containerByDim.set(key, { positive: [], negated: [] });\n      }\n      const group = containerByDim.get(key)!;\n      if (term.negated) {\n        group.negated.push(term);\n      } else {\n        group.positive.push(term);\n      }\n    }\n  }\n\n  // Check each dimension group for impossible ranges\n  for (const group of mediaByDim.values()) {\n    if (rangesAreImpossibleWithNegations(group.positive, group.negated)) {\n      return true;\n    }\n  }\n\n  for (const group of containerByDim.values()) {\n    if (rangesAreImpossibleWithNegations(group.positive, group.negated)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Check if conditions are impossible, including negated conditions.\n *\n * For negated single-bound conditions:\n *   not (w < 600px) → w >= 600px (inverted to lower bound)\n *   not (w >= 800px) → w < 800px (inverted to upper bound)\n *\n * For negated range conditions:\n *   not (400px <= w < 800px) → excludes [400, 800)\n *   If the effective bounds fall entirely within an excluded range, it's impossible.\n */\nfunction rangesAreImpossibleWithNegations(\n  positive: (MediaCondition | ContainerCondition)[],\n  negated: (MediaCondition | ContainerCondition)[],\n): boolean {\n  // Start with bounds from positive conditions\n  const bounds = computeEffectiveBounds(positive);\n\n  // Apply inverted bounds from single-bound negated conditions\n  // and collect excluded ranges from range negated conditions\n  const excludedRanges: ExcludedRange[] = [];\n\n  for (const cond of negated) {\n    const hasLower = cond.lowerBound?.valueNumeric != null;\n    const hasUpper = cond.upperBound?.valueNumeric != null;\n\n    if (hasLower && hasUpper) {\n      // Range negation: not (lower <= w < upper) excludes [lower, upper)\n      excludedRanges.push({\n        lower: cond.lowerBound!.valueNumeric!,\n        lowerInclusive: cond.lowerBound!.inclusive,\n        upper: cond.upperBound!.valueNumeric!,\n        upperInclusive: cond.upperBound!.inclusive,\n      });\n    } else if (hasUpper) {\n      // not (w < upper) → w >= upper (becomes lower bound)\n      // not (w <= upper) → w > upper (becomes lower bound, exclusive)\n      const value = cond.upperBound!.valueNumeric!;\n      const inclusive = !cond.upperBound!.inclusive; // flip inclusivity\n\n      if (bounds.lowerBound === null || value > bounds.lowerBound) {\n        bounds.lowerBound = value;\n        bounds.lowerInclusive = inclusive;\n      } else if (value === bounds.lowerBound && !inclusive) {\n        bounds.lowerInclusive = false;\n      }\n    } else if (hasLower) {\n      // not (w >= lower) → w < lower (becomes upper bound)\n      // not (w > lower) → w <= lower (becomes upper bound, inclusive)\n      const value = cond.lowerBound!.valueNumeric!;\n      const inclusive = !cond.lowerBound!.inclusive; // flip inclusivity\n\n      if (bounds.upperBound === null || value < bounds.upperBound) {\n        bounds.upperBound = value;\n        bounds.upperInclusive = inclusive;\n      } else if (value === bounds.upperBound && !inclusive) {\n        bounds.upperInclusive = false;\n      }\n    }\n  }\n\n  // Check if effective bounds are impossible on their own\n  if (bounds.lowerBound !== null && bounds.upperBound !== null) {\n    if (bounds.lowerBound > bounds.upperBound) {\n      return true;\n    }\n    if (\n      bounds.lowerBound === bounds.upperBound &&\n      (!bounds.lowerInclusive || !bounds.upperInclusive)\n    ) {\n      return true;\n    }\n  }\n\n  // Check if effective bounds fall entirely within any excluded range\n  if (\n    bounds.lowerBound !== null &&\n    bounds.upperBound !== null &&\n    excludedRanges.length > 0\n  ) {\n    for (const excluded of excludedRanges) {\n      if (boundsWithinExcludedRange(bounds, excluded)) {\n        return true;\n      }\n    }\n  }\n\n  return false;\n}\n\n/**\n * Compute effective bounds from positive (non-negated) conditions\n */\nfunction computeEffectiveBounds(\n  conditions: (MediaCondition | ContainerCondition)[],\n): EffectiveBounds {\n  let lowerBound: number | null = null;\n  let lowerInclusive = false;\n  let upperBound: number | null = null;\n  let upperInclusive = false;\n\n  for (const cond of conditions) {\n    if (cond.lowerBound?.valueNumeric != null) {\n      const value = cond.lowerBound.valueNumeric;\n      const inclusive = cond.lowerBound.inclusive;\n\n      if (lowerBound === null || value > lowerBound) {\n        lowerBound = value;\n        lowerInclusive = inclusive;\n      } else if (value === lowerBound && !inclusive) {\n        lowerInclusive = false;\n      }\n    }\n\n    if (cond.upperBound?.valueNumeric != null) {\n      const value = cond.upperBound.valueNumeric;\n      const inclusive = cond.upperBound.inclusive;\n\n      if (upperBound === null || value < upperBound) {\n        upperBound = value;\n        upperInclusive = inclusive;\n      } else if (value === upperBound && !inclusive) {\n        upperInclusive = false;\n      }\n    }\n  }\n\n  return { lowerBound, lowerInclusive, upperBound, upperInclusive };\n}\n\n/**\n * Check if effective bounds fall entirely within an excluded range.\n *\n * For example:\n *   Effective: [400, 800)\n *   Excluded:  [400, 800)\n *   → bounds fall entirely within excluded range → impossible\n */\nfunction boundsWithinExcludedRange(\n  bounds: EffectiveBounds,\n  excluded: ExcludedRange,\n): boolean {\n  if (bounds.lowerBound === null || bounds.upperBound === null) {\n    return false;\n  }\n\n  // Check if bounds.lower >= excluded.lower\n  let lowerOk = false;\n  if (bounds.lowerBound > excluded.lower) {\n    lowerOk = true;\n  } else if (bounds.lowerBound === excluded.lower) {\n    // If excluded includes lower, and bounds includes or excludes lower, it's within\n    // If excluded excludes lower, bounds must also exclude it to be within\n    lowerOk = excluded.lowerInclusive || !bounds.lowerInclusive;\n  }\n\n  // Check if bounds.upper <= excluded.upper\n  let upperOk = false;\n  if (bounds.upperBound < excluded.upper) {\n    upperOk = true;\n  } else if (bounds.upperBound === excluded.upper) {\n    // If excluded includes upper, and bounds includes or excludes upper, it's within\n    // If excluded excludes upper, bounds must also exclude it to be within\n    upperOk = excluded.upperInclusive || !bounds.upperInclusive;\n  }\n\n  return lowerOk && upperOk;\n}\n\n// ============================================================================\n// Attribute Conflict Detection\n// ============================================================================\n\n/**\n * Check for attribute value conflicts\n * e.g., [data-theme=\"dark\"] & [data-theme=\"light\"] → FALSE\n * e.g., [data-theme=\"dark\"] & ![data-theme] → FALSE\n */\n/**\n * Generic value-conflict checker for grouped conditions.\n *\n * Groups terms by a key, splits into positive/negated, then checks:\n *   1. Multiple distinct positive values → conflict\n *   2. Positive value + negated existence (value === undefined) → conflict\n *   3. Positive value + negated same value → conflict\n */\nfunction hasGroupedValueConflict<T extends { negated: boolean }>(\n  terms: ConditionNode[],\n  match: (term: ConditionNode) => T | null,\n  groupKey: (term: T) => string,\n  getValue: (term: T) => string | undefined,\n): boolean {\n  const groups = new Map<string, { positive: T[]; negated: T[] }>();\n\n  for (const term of terms) {\n    const matched = match(term);\n    if (!matched) continue;\n\n    const key = groupKey(matched);\n    let group = groups.get(key);\n    if (!group) {\n      group = { positive: [], negated: [] };\n      groups.set(key, group);\n    }\n\n    if (matched.negated) {\n      group.negated.push(matched);\n    } else {\n      group.positive.push(matched);\n    }\n  }\n\n  for (const [, group] of groups) {\n    const positiveValues = group.positive\n      .map(getValue)\n      .filter((v) => v !== undefined);\n    if (new Set(positiveValues).size > 1) return true;\n\n    const hasPositiveValue = positiveValues.length > 0;\n    const hasNegatedExistence = group.negated.some(\n      (t) => getValue(t) === undefined,\n    );\n    if (hasPositiveValue && hasNegatedExistence) return true;\n\n    for (const pos of group.positive) {\n      const posVal = getValue(pos);\n      if (posVal !== undefined) {\n        for (const neg of group.negated) {\n          if (getValue(neg) === posVal) return true;\n        }\n      }\n    }\n  }\n\n  return false;\n}\n\nfunction hasAttributeConflict(terms: ConditionNode[]): boolean {\n  // Top-level modifiers: `schema=dark & schema=light`.\n  if (\n    hasGroupedValueConflict<ModifierCondition>(\n      terms,\n      (t) => (t.kind === 'state' && t.type === 'modifier' ? t : null),\n      (t) => t.attribute,\n      (t) => t.value,\n    )\n  ) {\n    return true;\n  }\n\n  // @root scope (single :root element):\n  // `@root(schema=dark) & @root(schema=light)` cannot match anything because\n  // there is only one document root.\n  if (hasNestedModifierConflict(terms, 'root')) return true;\n\n  // @own scope (single sub-element / styled element under `&`):\n  // `@own(schema=dark) & @own(schema=light)` is impossible for the same\n  // reason — both refer to the same element.\n  if (hasNestedModifierConflict(terms, 'own')) return true;\n\n  // NOTE: @parent is intentionally NOT checked. Different ancestor elements\n  // can hold different attribute values, so two `@parent(schema=...)` calls\n  // can both match (different ancestors), even when the values differ.\n\n  return false;\n}\n\n/**\n * Collect modifier conditions inside non-negated state wrappers of `kind`\n * and check for the same value-conflict pattern as the top-level pass.\n *\n * Modifiers from multiple sibling wrappers are combined — both wrappers\n * scope to the same element (one :root, one own scope), so an attribute\n * conflict across wrappers is still impossible.\n */\nfunction hasNestedModifierConflict(\n  terms: ConditionNode[],\n  wrapperType: 'root' | 'own',\n): boolean {\n  const innerTerms: ConditionNode[] = [];\n  for (const term of terms) {\n    if (term.kind === 'state' && term.type === wrapperType && !term.negated) {\n      flattenAndIntoArray(\n        (term as RootCondition | OwnCondition).innerCondition,\n        innerTerms,\n      );\n    }\n  }\n  if (innerTerms.length < 2) return false;\n  return hasGroupedValueConflict<ModifierCondition>(\n    innerTerms,\n    (t) => (t.kind === 'state' && t.type === 'modifier' ? t : null),\n    (t) => t.attribute,\n    (t) => t.value,\n  );\n}\n\n/**\n * Flatten a top-level AND tree into a flat list of conjuncts. Non-AND nodes\n * are pushed as-is.\n */\nfunction flattenAndIntoArray(node: ConditionNode, into: ConditionNode[]): void {\n  if (node.kind === 'compound' && node.operator === 'AND') {\n    for (const child of node.children) flattenAndIntoArray(child, into);\n  } else {\n    into.push(node);\n  }\n}\n\nfunction hasContainerStyleConflict(terms: ConditionNode[]): boolean {\n  return hasGroupedValueConflict<ContainerCondition>(\n    terms,\n    (t) =>\n      t.kind === 'state' && t.type === 'container' && t.subtype === 'style'\n        ? t\n        : null,\n    (t) => `${t.containerName || '_'}:${t.property}`,\n    (t) => t.propertyValue,\n  );\n}\n\n// ============================================================================\n// Implied Negation Removal\n// ============================================================================\n\n/**\n * Remove negations that are implied by positive terms.\n *\n * Key optimizations:\n * 1. style(--variant: danger) implies NOT style(--variant: success)\n *    → If we have style(--variant: danger) & not style(--variant: success),\n *      the negation is redundant and can be removed.\n *\n * 2. [data-theme=\"dark\"] implies NOT [data-theme=\"light\"]\n *    → Same logic for attribute selectors.\n *\n * This produces cleaner CSS:\n *   Before: @container style(--variant: danger) and (not style(--variant: success))\n *   After:  @container style(--variant: danger)\n */\n/**\n * Collect positive values from terms and build a \"is this negation implied?\" check.\n *\n * A negation is implied (redundant) when a positive term for the same group\n * already pins a specific value, making \"NOT other-value\" obvious.\n * e.g. style(--variant: danger) implies NOT style(--variant: success).\n */\nfunction buildImpliedNegationCheck(\n  terms: ConditionNode[],\n): (term: ConditionNode) => boolean {\n  const positiveValues = new Map<string, string>();\n\n  for (const term of terms) {\n    if (term.kind !== 'state' || term.negated) continue;\n\n    if (term.type === 'container' && term.subtype === 'style') {\n      if (term.propertyValue !== undefined) {\n        positiveValues.set(\n          `c:${term.containerName || '_'}:${term.property}`,\n          term.propertyValue,\n        );\n      }\n    } else if (term.type === 'modifier' && term.value !== undefined) {\n      positiveValues.set(`m:${term.attribute}`, term.value);\n    }\n  }\n\n  return (term: ConditionNode): boolean => {\n    if (term.kind !== 'state' || !term.negated) return false;\n\n    if (term.type === 'container' && term.subtype === 'style') {\n      if (term.propertyValue === undefined) return false;\n      const pos = positiveValues.get(\n        `c:${term.containerName || '_'}:${term.property}`,\n      );\n      return pos !== undefined && term.propertyValue !== pos;\n    }\n\n    if (term.type === 'modifier' && term.value !== undefined) {\n      const pos = positiveValues.get(`m:${term.attribute}`);\n      return pos !== undefined && term.value !== pos;\n    }\n\n    return false;\n  };\n}\n\nfunction removeImpliedNegations(terms: ConditionNode[]): ConditionNode[] {\n  const isImplied = buildImpliedNegationCheck(terms);\n  return terms.filter((t) => !isImplied(t));\n}\n\n// ============================================================================\n// Deduplication\n// ============================================================================\n\nfunction deduplicateTerms(terms: ConditionNode[]): ConditionNode[] {\n  const seen = new Set<string>();\n  const result: ConditionNode[] = [];\n\n  for (const term of terms) {\n    const id = getConditionUniqueId(term);\n    if (!seen.has(id)) {\n      seen.add(id);\n      result.push(term);\n    }\n  }\n\n  return result;\n}\n\n// ============================================================================\n// Range Merging\n// ============================================================================\n\n/**\n * Merge compatible range conditions\n * e.g., @media(w >= 400px) & @media(w <= 800px) → @media(400px <= w <= 800px)\n */\nfunction mergeRanges(terms: ConditionNode[]): ConditionNode[] {\n  // Group media conditions by dimension\n  const mediaByDim = new Map<\n    string,\n    { conditions: MediaCondition[]; indices: number[] }\n  >();\n  const containerByDim = new Map<\n    string,\n    { conditions: ContainerCondition[]; indices: number[] }\n  >();\n\n  terms.forEach((term, index) => {\n    if (term.kind !== 'state') return;\n\n    if (\n      term.type === 'media' &&\n      term.subtype === 'dimension' &&\n      !term.negated\n    ) {\n      const key = term.dimension || 'width';\n      if (!mediaByDim.has(key)) {\n        mediaByDim.set(key, { conditions: [], indices: [] });\n      }\n      const group = mediaByDim.get(key)!;\n      group.conditions.push(term);\n      group.indices.push(index);\n    }\n\n    if (\n      term.type === 'container' &&\n      term.subtype === 'dimension' &&\n      !term.negated\n    ) {\n      const key = `${term.containerName || '_'}:${term.dimension || 'width'}`;\n      if (!containerByDim.has(key)) {\n        containerByDim.set(key, { conditions: [], indices: [] });\n      }\n      const group = containerByDim.get(key)!;\n      group.conditions.push(term);\n      group.indices.push(index);\n    }\n  });\n\n  // Track indices to remove\n  const indicesToRemove = new Set<number>();\n  const mergedTerms: ConditionNode[] = [];\n\n  // Merge media conditions\n  for (const [_dim, group] of mediaByDim) {\n    if (group.conditions.length > 1) {\n      const merged = mergeMediaRanges(group.conditions);\n      if (merged) {\n        group.indices.forEach((i) => indicesToRemove.add(i));\n        mergedTerms.push(merged);\n      }\n    }\n  }\n\n  // Merge container conditions\n  for (const [, group] of containerByDim) {\n    if (group.conditions.length > 1) {\n      const merged = mergeContainerRanges(group.conditions);\n      if (merged) {\n        group.indices.forEach((i) => indicesToRemove.add(i));\n        mergedTerms.push(merged);\n      }\n    }\n  }\n\n  // Build result\n  const result: ConditionNode[] = [];\n  terms.forEach((term, index) => {\n    if (!indicesToRemove.has(index)) {\n      result.push(term);\n    }\n  });\n  result.push(...mergedTerms);\n\n  return result;\n}\n\n/**\n * Tighten bounds by picking the most restrictive lower and upper bounds\n * from a set of conditions that have lowerBound/upperBound fields.\n */\nfunction tightenBounds(\n  conditions: { lowerBound?: NumericBound; upperBound?: NumericBound }[],\n): { lowerBound?: NumericBound; upperBound?: NumericBound } {\n  let lowerBound: NumericBound | undefined;\n  let upperBound: NumericBound | undefined;\n\n  for (const cond of conditions) {\n    if (cond.lowerBound) {\n      if (\n        !lowerBound ||\n        (cond.lowerBound.valueNumeric ?? -Infinity) >\n          (lowerBound.valueNumeric ?? -Infinity)\n      ) {\n        lowerBound = cond.lowerBound;\n      }\n    }\n    if (cond.upperBound) {\n      if (\n        !upperBound ||\n        (cond.upperBound.valueNumeric ?? Infinity) <\n          (upperBound.valueNumeric ?? Infinity)\n      ) {\n        upperBound = cond.upperBound;\n      }\n    }\n  }\n\n  return { lowerBound, upperBound };\n}\n\nfunction appendBoundsToUniqueId(\n  parts: string[],\n  lowerBound?: NumericBound,\n  upperBound?: NumericBound,\n): void {\n  if (lowerBound) {\n    parts.push(lowerBound.inclusive ? '>=' : '>');\n    parts.push(lowerBound.value);\n  }\n  if (upperBound) {\n    parts.push(upperBound.inclusive ? '<=' : '<');\n    parts.push(upperBound.value);\n  }\n}\n\nfunction mergeDimensionRanges<T extends MediaCondition | ContainerCondition>(\n  conditions: T[],\n  idPrefix: string[],\n): T | null {\n  if (conditions.length === 0) return null;\n\n  const { lowerBound, upperBound } = tightenBounds(conditions);\n  const base = conditions[0];\n\n  const parts = [...idPrefix];\n  appendBoundsToUniqueId(parts, lowerBound, upperBound);\n\n  return {\n    ...base,\n    negated: false,\n    raw: buildMergedRaw(base.dimension || 'width', lowerBound, upperBound),\n    uniqueId: parts.join(':'),\n    lowerBound,\n    upperBound,\n  };\n}\n\nfunction mergeMediaRanges(conditions: MediaCondition[]): MediaCondition | null {\n  const dim = conditions[0]?.dimension ?? 'width';\n  return mergeDimensionRanges(conditions, ['media', 'dim', dim]);\n}\n\nfunction mergeContainerRanges(\n  conditions: ContainerCondition[],\n): ContainerCondition | null {\n  const base = conditions[0];\n  if (!base) return null;\n  const name = base.containerName || '_';\n  const dim = base.dimension ?? 'width';\n  return mergeDimensionRanges(conditions, ['container', 'dim', name, dim]);\n}\n\nfunction buildMergedRaw(\n  dimension: string,\n  lowerBound?: NumericBound,\n  upperBound?: NumericBound,\n): string {\n  if (lowerBound && upperBound) {\n    const lowerOp = lowerBound.inclusive ? '<=' : '<';\n    const upperOp = upperBound.inclusive ? '<=' : '<';\n    return `@media(${lowerBound.value} ${lowerOp} ${dimension} ${upperOp} ${upperBound.value})`;\n  } else if (upperBound) {\n    const op = upperBound.inclusive ? '<=' : '<';\n    return `@media(${dimension} ${op} ${upperBound.value})`;\n  } else if (lowerBound) {\n    const op = lowerBound.inclusive ? '>=' : '>';\n    return `@media(${dimension} ${op} ${lowerBound.value})`;\n  }\n  return '@media()';\n}\n\n// ============================================================================\n// Complementary Factoring\n// ============================================================================\n\n/**\n * Apply complementary factoring: (A & B) | (A & !B) → A\n *\n * Finds pairs of AND compounds that share all children except one,\n * where the differing child is complementary (X vs !X).\n * Replaces the pair with the common terms.\n *\n * This is applied iteratively until no more reductions are possible,\n * since factoring can expose further simplification opportunities.\n */\nfunction applyComplementaryFactoring(terms: ConditionNode[]): ConditionNode[] {\n  let changed = true;\n\n  while (changed) {\n    changed = false;\n\n    for (let i = 0; i < terms.length; i++) {\n      const a = terms[i];\n      if (a.kind !== 'compound' || a.operator !== 'AND') continue;\n\n      for (let j = i + 1; j < terms.length; j++) {\n        const b = terms[j];\n        if (b.kind !== 'compound' || b.operator !== 'AND') continue;\n\n        const factored = tryFactorPair(a.children, b.children);\n        if (factored) {\n          const replacement = simplifyInner(factored);\n          terms = [\n            ...terms.slice(0, i),\n            ...terms.slice(i + 1, j),\n            ...terms.slice(j + 1),\n            replacement,\n          ];\n          changed = true;\n          break;\n        }\n      }\n\n      if (changed) break;\n    }\n  }\n\n  return terms;\n}\n\n/**\n * Try to factor two AND children lists.\n *\n * Extracts the common children (by uniqueId). If the remaining\n * (non-common) parts of each side OR to TRUE, the common part alone\n * is sufficient: `(common & restA) | (common & restB) → common`\n * when `restA | restB → TRUE`.\n *\n * Also handles the simpler case where exactly one child is\n * complementary: `[A, B, C]` and `[A, !B, C]` → `AND(A, C)`.\n */\nfunction tryFactorPair(\n  aChildren: ConditionNode[],\n  bChildren: ConditionNode[],\n): ConditionNode | null {\n  const aIds = aChildren.map((c) => getConditionUniqueId(c));\n  const bIds = bChildren.map((c) => getConditionUniqueId(c));\n\n  const bIdSet = new Set(bIds);\n  const aIdSet = new Set(aIds);\n\n  // Extract common children (present in both by uniqueId)\n  const commonIndicesA: number[] = [];\n  const restIndicesA: number[] = [];\n  for (let i = 0; i < aIds.length; i++) {\n    if (bIdSet.has(aIds[i])) {\n      commonIndicesA.push(i);\n    } else {\n      restIndicesA.push(i);\n    }\n  }\n\n  const restIndicesB: number[] = [];\n  for (let i = 0; i < bIds.length; i++) {\n    if (!aIdSet.has(bIds[i])) {\n      restIndicesB.push(i);\n    }\n  }\n\n  // Must have at least one common child and differing parts on both sides\n  if (commonIndicesA.length === 0) return null;\n  if (restIndicesA.length === 0 && restIndicesB.length === 0) return null;\n\n  // Build the \"rest\" conditions for each side\n  const restA =\n    restIndicesA.length === 0\n      ? trueCondition()\n      : restIndicesA.length === 1\n        ? aChildren[restIndicesA[0]]\n        : and(...restIndicesA.map((i) => aChildren[i]));\n\n  const restB =\n    restIndicesB.length === 0\n      ? trueCondition()\n      : restIndicesB.length === 1\n        ? bChildren[restIndicesB[0]]\n        : and(...restIndicesB.map((i) => bChildren[i]));\n\n  // Check if restA | restB simplifies to TRUE\n  const combined = simplifyInner({\n    kind: 'compound',\n    operator: 'OR',\n    children: [restA, restB],\n  });\n\n  if (combined.kind !== 'true') {\n    // Direct complement check for compound conditions.\n    // hasTautology only detects leaf-level A/!A pairs, so compound\n    // complements like @hc / !@hc (which expand via De Morgan into\n    // structurally different trees) are missed. Compare the simplified\n    // negation of one rest against the simplified other rest instead.\n    const simplifiedRestB = simplifyInner(restB);\n    const negRestA = simplifyInner(not(restA));\n\n    if (\n      getConditionUniqueId(negRestA) !== getConditionUniqueId(simplifiedRestB)\n    ) {\n      return null;\n    }\n  }\n\n  // restA | restB = TRUE → (common & restA) | (common & restB) = common\n  const common = commonIndicesA.map((i) => aChildren[i]);\n\n  if (common.length === 0) {\n    return trueCondition();\n  }\n  if (common.length === 1) {\n    return common[0];\n  }\n  return and(...common);\n}\n\n// ============================================================================\n// Sorting\n// ============================================================================\n\nfunction sortTerms(terms: ConditionNode[]): ConditionNode[] {\n  const withIds = terms.map((t) => [getConditionUniqueId(t), t] as const);\n  withIds.sort((a, b) => a[0].localeCompare(b[0]));\n  return withIds.map(([, t]) => t);\n}\n\n// ============================================================================\n// Absorption\n// ============================================================================\n\n/**\n * Apply the absorption law: removes compound terms that are absorbed by\n * another term already present (simple or compound).\n *\n * For AND context: A & (A | B) → A  (absorbs OR compounds)\n * For OR  context: A | (A & B) → A  (absorbs AND compounds)\n *\n * After flattening, a compound A = OR(X, Y) becomes [X, Y, ...] in the\n * outer OR. A child AND(A, B) = AND(OR(X, Y), B) still references the\n * original un-flattened compound. We reconstruct possible compound\n * absorbers from the flattened terms so absorption works across nesting.\n */\nfunction applyAbsorption(\n  terms: ConditionNode[],\n  absorbedOperator: 'OR' | 'AND',\n): ConditionNode[] {\n  // Collect IDs of ALL top-level terms as potential absorbers.\n  const absorberIds = new Set<string>();\n  for (const term of terms) {\n    absorberIds.add(getConditionUniqueId(term));\n  }\n\n  // Reconstruct compound absorbers: if all children of a compound node\n  // (found inside an absorbable term) are themselves absorbers, then\n  // that compound is also an absorber. This handles the case where\n  // A = OR(X, Y) was flattened into [X, Y, ...] at the top level,\n  // but appears un-flattened as a child of AND(A, B).\n  let changed = true;\n  while (changed) {\n    changed = false;\n    for (const term of terms) {\n      if (term.kind !== 'compound' || term.operator !== absorbedOperator) {\n        continue;\n      }\n      for (const child of term.children) {\n        if (child.kind !== 'compound') continue;\n        const childId = getConditionUniqueId(child);\n        if (absorberIds.has(childId)) continue;\n        if (\n          child.children.every((c) => absorberIds.has(getConditionUniqueId(c)))\n        ) {\n          absorberIds.add(childId);\n          changed = true;\n        }\n      }\n    }\n  }\n\n  return terms.filter((term) => {\n    if (term.kind === 'compound' && term.operator === absorbedOperator) {\n      for (const child of term.children) {\n        if (absorberIds.has(getConditionUniqueId(child))) {\n          return false;\n        }\n      }\n    }\n    return true;\n  });\n}\n\nfunction applyAbsorptionAnd(terms: ConditionNode[]): ConditionNode[] {\n  return applyAbsorption(terms, 'OR');\n}\n\nfunction applyAbsorptionOr(terms: ConditionNode[]): ConditionNode[] {\n  return applyAbsorption(terms, 'AND');\n}\n\n// ============================================================================\n// Consensus / Resolution (AND dual of complementary factoring)\n// ============================================================================\n\n/**\n * Apply the consensus/resolution rule for AND:\n *   (A | B) & (A | !B) → A\n *\n * This is the dual of complementary factoring in OR context:\n *   (A & B) | (A & !B) → A\n *\n * Extracts common children from two OR terms. If the remaining\n * parts of each side AND to FALSE, the common part alone is\n * sufficient.\n */\nfunction applyConsensusAnd(terms: ConditionNode[]): ConditionNode[] {\n  let changed = true;\n\n  while (changed) {\n    changed = false;\n\n    for (let i = 0; i < terms.length; i++) {\n      const a = terms[i];\n      if (a.kind !== 'compound' || a.operator !== 'OR') continue;\n\n      for (let j = i + 1; j < terms.length; j++) {\n        const b = terms[j];\n        if (b.kind !== 'compound' || b.operator !== 'OR') continue;\n\n        const resolved = tryResolvePair(a.children, b.children);\n        if (resolved) {\n          const replacement = simplifyInner(resolved);\n          terms = [\n            ...terms.slice(0, i),\n            ...terms.slice(i + 1, j),\n            ...terms.slice(j + 1),\n            replacement,\n          ];\n          changed = true;\n          break;\n        }\n      }\n\n      if (changed) break;\n    }\n  }\n\n  return terms;\n}\n\n/**\n * Try to resolve two OR children lists.\n *\n * Extracts common children (by uniqueId). If the remaining\n * (non-common) parts AND to FALSE, the common part alone\n * is sufficient: `(common | restA) & (common | restB) → common`\n * when `restA & restB → FALSE`.\n */\nfunction tryResolvePair(\n  aChildren: ConditionNode[],\n  bChildren: ConditionNode[],\n): ConditionNode | null {\n  const aIds = aChildren.map((c) => getConditionUniqueId(c));\n  const bIds = bChildren.map((c) => getConditionUniqueId(c));\n\n  const bIdSet = new Set(bIds);\n  const aIdSet = new Set(aIds);\n\n  const commonIndicesA: number[] = [];\n  const restIndicesA: number[] = [];\n  for (let i = 0; i < aIds.length; i++) {\n    if (bIdSet.has(aIds[i])) {\n      commonIndicesA.push(i);\n    } else {\n      restIndicesA.push(i);\n    }\n  }\n\n  const restIndicesB: number[] = [];\n  for (let i = 0; i < bIds.length; i++) {\n    if (!aIdSet.has(bIds[i])) {\n      restIndicesB.push(i);\n    }\n  }\n\n  if (commonIndicesA.length === 0) return null;\n  if (restIndicesA.length === 0 && restIndicesB.length === 0) return null;\n\n  const restA =\n    restIndicesA.length === 0\n      ? falseCondition()\n      : restIndicesA.length === 1\n        ? aChildren[restIndicesA[0]]\n        : or(...restIndicesA.map((i) => aChildren[i]));\n\n  const restB =\n    restIndicesB.length === 0\n      ? falseCondition()\n      : restIndicesB.length === 1\n        ? bChildren[restIndicesB[0]]\n        : or(...restIndicesB.map((i) => bChildren[i]));\n\n  // Check if restA & restB simplifies to FALSE\n  const combined = simplifyInner({\n    kind: 'compound',\n    operator: 'AND',\n    children: [restA, restB],\n  });\n\n  if (combined.kind !== 'false') {\n    // Direct complement check for compound conditions\n    const simplifiedRestB = simplifyInner(restB);\n    const negRestA = simplifyInner(not(restA));\n\n    if (\n      getConditionUniqueId(negRestA) !== getConditionUniqueId(simplifiedRestB)\n    ) {\n      return null;\n    }\n  }\n\n  // restA & restB = FALSE → (common | restA) & (common | restB) = common\n  const common = commonIndicesA.map((i) => aChildren[i]);\n\n  if (common.length === 0) {\n    return falseCondition();\n  }\n  if (common.length === 1) {\n    return common[0];\n  }\n  return or(...common);\n}\n"],"mappings":"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"}

package/dist/pipeline/warnings.js

@@ -1,18 +0,0 @@
-//#region src/pipeline/warnings.ts
-const defaultWarningHandler = (warning) => {
-	console.warn(`[Tasty] ${warning.message}`);
-};
-let warningHandler = defaultWarningHandler;
-/**
-* Emit a structured pipeline warning via the configured handler.
-*/
-function emitWarning(code, message) {
-	warningHandler({
-		code,
-		message
-	});
-}
-//#endregion
-export { emitWarning };
-
-//# sourceMappingURL=warnings.js.map

package/dist/pipeline/warnings.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"warnings.js","names":[],"sources":["../../src/pipeline/warnings.ts"],"sourcesContent":["/**\n * Structured warning system for the pipeline.\n *\n * Provides typed warning codes and a configurable handler so consumers\n * can programmatically intercept, suppress, or reroute warnings.\n */\n\nexport type TastyWarningCode = 'INVALID_SELECTOR_AFFIX' | 'XOR_CHAIN_TOO_LONG';\n\nexport interface TastyWarning {\n  code: TastyWarningCode;\n  message: string;\n}\n\nexport type TastyWarningHandler = (warning: TastyWarning) => void;\n\nconst defaultWarningHandler: TastyWarningHandler = (warning) => {\n  console.warn(`[Tasty] ${warning.message}`);\n};\n\nlet warningHandler: TastyWarningHandler = defaultWarningHandler;\n\n/**\n * Set a custom warning handler for pipeline warnings.\n * Returns a function that restores the previous handler.\n */\nexport function setWarningHandler(handler: TastyWarningHandler): () => void {\n  const previous = warningHandler;\n  warningHandler = handler;\n  return () => {\n    warningHandler = previous;\n  };\n}\n\n/**\n * Emit a structured pipeline warning via the configured handler.\n */\nexport function emitWarning(code: TastyWarningCode, message: string): void {\n  warningHandler({ code, message });\n}\n"],"mappings":";AAgBA,MAAM,yBAA8C,YAAY;AAC9D,SAAQ,KAAK,WAAW,QAAQ,UAAU;;AAG5C,IAAI,iBAAsC;;;;AAiB1C,SAAgB,YAAY,MAAwB,SAAuB;AACzE,gBAAe;EAAE;EAAM;EAAS,CAAC"}

package/dist/plugins/index.d.ts

@@ -1,2 +0,0 @@
-import { TastyPlugin, TastyPluginFactory } from "./types.js";
-import { okhslFunc, okhslPlugin } from "./okhsl-plugin.js";

package/dist/plugins/okhsl-plugin.d.ts

@@ -1,35 +0,0 @@
-import { StyleDetails } from "../parser/types.js";
-import { TastyPluginFactory } from "./types.js";
-
-//#region src/plugins/okhsl-plugin.d.ts
-/**
- * The okhsl function handler for tasty parser.
- * Receives parsed style groups and returns an RGB color string.
- */
-declare const okhslFunc: (groups: StyleDetails[]) => string;
-/**
- * OKHSL Plugin for Tasty.
- *
- * Adds support for the `okhsl()` color function in tasty styles.
- *
- * @example
- * ```ts
- * import { configure } from '@tenphi/tasty';
- * import { okhslPlugin } from '@tenphi/tasty';
- *
- * configure({
- *   plugins: [okhslPlugin()],
- * });
- *
- * // Now you can use okhsl in styles:
- * const Box = tasty({
- *   styles: {
- *     fill: 'okhsl(240 50% 50%)',
- *   },
- * });
- * ```
- */
-declare const okhslPlugin: TastyPluginFactory;
-//#endregion
-export { okhslFunc, okhslPlugin };
-//# sourceMappingURL=okhsl-plugin.d.ts.map

package/dist/plugins/okhsl-plugin.js

@@ -1,97 +0,0 @@
-import { Lru } from "../parser/lru.js";
-import { okhslToSrgb } from "../utils/color-math.js";
-//#region src/plugins/okhsl-plugin.ts
-/**
-* OKHSL Plugin for Tasty
-*
-* Converts OKHSL color syntax to RGB notation.
-* Supports angle units: deg, turn, rad, or unitless (degrees).
-*
-* Examples:
-*   okhsl(240.5 50% 50%)
-*   okhsl(240.5deg 50% 50%)
-*   okhsl(0.25turn 50% 50%)
-*   okhsl(1.57rad 50% 50%)
-*/
-const conversionCache = new Lru(500);
-const clamp = (value, min, max) => Math.max(Math.min(value, max), min);
-/**
-* Parse an angle value with optional unit.
-* Supports: deg, turn, rad, or unitless (treated as degrees).
-*/
-const parseAngle = (value) => {
-	const match = value.match(/^([+-]?\d*\.?\d+)(deg|turn|rad)?$/);
-	if (!match) return 0;
-	const num = parseFloat(match[1]);
-	switch (match[2]) {
-		case "turn": return num * 360;
-		case "rad": return num * 180 / Math.PI;
-		default: return num;
-	}
-};
-/**
-* Parse a percentage value (e.g., "50%") to a 0-1 range.
-*/
-const parsePercentage = (value) => {
-	const match = value.match(/^([+-]?\d*\.?\d+)%?$/);
-	if (!match) return 0;
-	const num = parseFloat(match[1]);
-	return value.includes("%") ? num / 100 : num;
-};
-/**
-* The okhsl function handler for tasty parser.
-* Receives parsed style groups and returns an RGB color string.
-*/
-const okhslFunc = (groups) => {
-	if (groups.length === 0 || groups[0].all.length < 3) {
-		console.warn("[okhsl] Expected 3 values (H S L), got:", groups);
-		return "rgb(0% 0% 0%)";
-	}
-	const group = groups[0];
-	const tokens = group.all;
-	const alpha = group.parts.length > 1 && group.parts[1].all.length > 0 ? group.parts[1].output : void 0;
-	const cacheKey = tokens.slice(0, 3).join(" ") + (alpha ? ` / ${alpha}` : "");
-	const cached = conversionCache.get(cacheKey);
-	if (cached) return cached;
-	const h = parseAngle(tokens[0]);
-	const s = parsePercentage(tokens[1]);
-	const l = parsePercentage(tokens[2]);
-	const [r, g, b] = okhslToSrgb(h, clamp(s, 0, 1), clamp(l, 0, 1));
-	const format = (n) => {
-		const pct = n * 100;
-		return parseFloat(pct.toFixed(1)).toString() + "%";
-	};
-	const result = alpha ? `rgb(${format(r)} ${format(g)} ${format(b)} / ${alpha})` : `rgb(${format(r)} ${format(g)} ${format(b)})`;
-	conversionCache.set(cacheKey, result);
-	return result;
-};
-/**
-* OKHSL Plugin for Tasty.
-*
-* Adds support for the `okhsl()` color function in tasty styles.
-*
-* @example
-* ```ts
-* import { configure } from '@tenphi/tasty';
-* import { okhslPlugin } from '@tenphi/tasty';
-*
-* configure({
-*   plugins: [okhslPlugin()],
-* });
-*
-* // Now you can use okhsl in styles:
-* const Box = tasty({
-*   styles: {
-*     fill: 'okhsl(240 50% 50%)',
-*   },
-* });
-* ```
-*/
-const okhslPlugin = () => ({
-	name: "okhsl",
-	funcs: { okhsl: okhslFunc }
-});
-//#endregion
-export { okhslFunc, okhslPlugin };
-
-//# sourceMappingURL=okhsl-plugin.js.map

package/dist/plugins/okhsl-plugin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"okhsl-plugin.js","names":[],"sources":["../../src/plugins/okhsl-plugin.ts"],"sourcesContent":["/**\n * OKHSL Plugin for Tasty\n *\n * Converts OKHSL color syntax to RGB notation.\n * Supports angle units: deg, turn, rad, or unitless (degrees).\n *\n * Examples:\n *   okhsl(240.5 50% 50%)\n *   okhsl(240.5deg 50% 50%)\n *   okhsl(0.25turn 50% 50%)\n *   okhsl(1.57rad 50% 50%)\n */\n\nimport { Lru } from '../parser/lru';\nimport { okhslToSrgb } from '../utils/color-math';\n\nimport type { StyleDetails } from '../parser/types';\nimport type { TastyPlugin, TastyPluginFactory } from './types';\n\nconst conversionCache = new Lru<string, string>(500);\n\nconst clamp = (value: number, min: number, max: number): number =>\n  Math.max(Math.min(value, max), min);\n\n/**\n * Parse an angle value with optional unit.\n * Supports: deg, turn, rad, or unitless (treated as degrees).\n */\nconst parseAngle = (value: string): number => {\n  const match = value.match(/^([+-]?\\d*\\.?\\d+)(deg|turn|rad)?$/);\n  if (!match) return 0;\n\n  const num = parseFloat(match[1]);\n  const unit = match[2];\n\n  switch (unit) {\n    case 'turn':\n      return num * 360;\n    case 'rad':\n      return (num * 180) / Math.PI;\n    case 'deg':\n    default:\n      return num;\n  }\n};\n\n/**\n * Parse a percentage value (e.g., \"50%\") to a 0-1 range.\n */\nconst parsePercentage = (value: string): number => {\n  const match = value.match(/^([+-]?\\d*\\.?\\d+)%?$/);\n  if (!match) return 0;\n\n  const num = parseFloat(match[1]);\n  return value.includes('%') ? num / 100 : num;\n};\n\n/**\n * The okhsl function handler for tasty parser.\n * Receives parsed style groups and returns an RGB color string.\n */\nconst okhslFunc = (groups: StyleDetails[]): string => {\n  if (groups.length === 0 || groups[0].all.length < 3) {\n    console.warn('[okhsl] Expected 3 values (H S L), got:', groups);\n    return 'rgb(0% 0% 0%)';\n  }\n\n  const group = groups[0];\n  const tokens = group.all;\n\n  const alpha =\n    group.parts.length > 1 && group.parts[1].all.length > 0\n      ? group.parts[1].output\n      : undefined;\n\n  const cacheKey = tokens.slice(0, 3).join(' ') + (alpha ? ` / ${alpha}` : '');\n  const cached = conversionCache.get(cacheKey);\n  if (cached) return cached;\n\n  const h = parseAngle(tokens[0]);\n  const s = parsePercentage(tokens[1]);\n  const l = parsePercentage(tokens[2]);\n\n  const [r, g, b] = okhslToSrgb(h, clamp(s, 0, 1), clamp(l, 0, 1));\n\n  const format = (n: number): string => {\n    const pct = n * 100;\n    return parseFloat(pct.toFixed(1)).toString() + '%';\n  };\n\n  const result = alpha\n    ? `rgb(${format(r)} ${format(g)} ${format(b)} / ${alpha})`\n    : `rgb(${format(r)} ${format(g)} ${format(b)})`;\n\n  conversionCache.set(cacheKey, result);\n  return result;\n};\n\n/**\n * OKHSL Plugin for Tasty.\n *\n * Adds support for the `okhsl()` color function in tasty styles.\n *\n * @example\n * ```ts\n * import { configure } from '@tenphi/tasty';\n * import { okhslPlugin } from '@tenphi/tasty';\n *\n * configure({\n *   plugins: [okhslPlugin()],\n * });\n *\n * // Now you can use okhsl in styles:\n * const Box = tasty({\n *   styles: {\n *     fill: 'okhsl(240 50% 50%)',\n *   },\n * });\n * ```\n */\nexport const okhslPlugin: TastyPluginFactory = (): TastyPlugin => ({\n  name: 'okhsl',\n  funcs: {\n    okhsl: okhslFunc,\n  },\n});\n\nexport { okhslFunc };\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,MAAM,kBAAkB,IAAI,IAAoB,IAAI;AAEpD,MAAM,SAAS,OAAe,KAAa,QACzC,KAAK,IAAI,KAAK,IAAI,OAAO,IAAI,EAAE,IAAI;;;;;AAMrC,MAAM,cAAc,UAA0B;CAC5C,MAAM,QAAQ,MAAM,MAAM,oCAAoC;AAC9D,KAAI,CAAC,MAAO,QAAO;CAEnB,MAAM,MAAM,WAAW,MAAM,GAAG;AAGhC,SAFa,MAAM,IAEnB;EACE,KAAK,OACH,QAAO,MAAM;EACf,KAAK,MACH,QAAQ,MAAM,MAAO,KAAK;EAE5B,QACE,QAAO;;;;;;AAOb,MAAM,mBAAmB,UAA0B;CACjD,MAAM,QAAQ,MAAM,MAAM,uBAAuB;AACjD,KAAI,CAAC,MAAO,QAAO;CAEnB,MAAM,MAAM,WAAW,MAAM,GAAG;AAChC,QAAO,MAAM,SAAS,IAAI,GAAG,MAAM,MAAM;;;;;;AAO3C,MAAM,aAAa,WAAmC;AACpD,KAAI,OAAO,WAAW,KAAK,OAAO,GAAG,IAAI,SAAS,GAAG;AACnD,UAAQ,KAAK,2CAA2C,OAAO;AAC/D,SAAO;;CAGT,MAAM,QAAQ,OAAO;CACrB,MAAM,SAAS,MAAM;CAErB,MAAM,QACJ,MAAM,MAAM,SAAS,KAAK,MAAM,MAAM,GAAG,IAAI,SAAS,IAClD,MAAM,MAAM,GAAG,SACf,KAAA;CAEN,MAAM,WAAW,OAAO,MAAM,GAAG,EAAE,CAAC,KAAK,IAAI,IAAI,QAAQ,MAAM,UAAU;CACzE,MAAM,SAAS,gBAAgB,IAAI,SAAS;AAC5C,KAAI,OAAQ,QAAO;CAEnB,MAAM,IAAI,WAAW,OAAO,GAAG;CAC/B,MAAM,IAAI,gBAAgB,OAAO,GAAG;CACpC,MAAM,IAAI,gBAAgB,OAAO,GAAG;CAEpC,MAAM,CAAC,GAAG,GAAG,KAAK,YAAY,GAAG,MAAM,GAAG,GAAG,EAAE,EAAE,MAAM,GAAG,GAAG,EAAE,CAAC;CAEhE,MAAM,UAAU,MAAsB;EACpC,MAAM,MAAM,IAAI;AAChB,SAAO,WAAW,IAAI,QAAQ,EAAE,CAAC,CAAC,UAAU,GAAG;;CAGjD,MAAM,SAAS,QACX,OAAO,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,KAAK,MAAM,KACtD,OAAO,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC;AAE/C,iBAAgB,IAAI,UAAU,OAAO;AACrC,QAAO;;;;;;;;;;;;;;;;;;;;;;;;AAyBT,MAAa,qBAAsD;CACjE,MAAM;CACN,OAAO,EACL,OAAO,WACR;CACF"}

package/dist/plugins/types.d.ts

@@ -1,87 +0,0 @@
-import { StyleDetails, UnitHandler } from "../parser/types.js";
-import { StyleHandlerDefinition } from "../utils/styles.js";
-import { ConfigTokens, RecipeStyles, Styles } from "../styles/types.js";
-import { TypographyPreset } from "../utils/typography.js";
-
-//#region src/plugins/types.d.ts
-/**
- * A tasty plugin that extends the style system with custom functions, units, states, or handlers.
- */
-interface TastyPlugin {
-  /** Unique name for the plugin (used for debugging and conflict detection) */
-  name: string;
-  /** Custom functions that transform parsed style groups into CSS values */
-  funcs?: Record<string, (groups: StyleDetails[]) => string>;
-  /** Custom units that transform numeric values (e.g., `2x` → `calc(2 * var(--gap))`) */
-  units?: Record<string, string | UnitHandler>;
-  /** Custom state aliases (e.g., `'@mobile': '@media(w < 768px)'`) */
-  states?: Record<string, string>;
-  /**
-   * Custom style handlers that transform style properties into CSS declarations.
-   * Handlers replace built-in handlers for the same style name.
-   * @example
-   * ```ts
-   * handlers: {
-   *   // Simple handler - lookup style inferred from key
-   *   fill: ({ fill }) => fill ? { 'background-color': fill } : undefined,
-   *   // Multi-property handler
-   *   spacing: [['gap', 'padding'], ({ gap, padding }) => ({ ... })],
-   * }
-   * ```
-   */
-  handlers?: Record<string, StyleHandlerDefinition>;
-  /**
-   * Design tokens injected as CSS custom properties on `:root`.
-   * Values are parsed through the Tasty DSL. Supports state maps.
-   * - `$name` → `--name` CSS custom property
-   * - `#name` → `--name-color` and `--name-color-{colorSpace}`
-   */
-  tokens?: ConfigTokens;
-  /** Predefined tokens replaced during style parsing (`$name` or `#name`) */
-  replaceTokens?: Record<`$${string}` | `#${string}`, string | number>;
-  /**
-   * Predefined style recipes -- named style bundles that can be applied via `recipe` style property.
-   * Recipe values are flat tasty styles (no sub-element keys).
-   * @example
-   * ```ts
-   * recipes: {
-   *   card: { padding: '4x', fill: '#surface', radius: '1r', border: true },
-   *   elevated: { shadow: '2x 2x 4x #shadow' },
-   * }
-   * ```
-   */
-  recipes?: Record<string, RecipeStyles>;
-  /**
-   * Typography presets — shorthand for `generateTypographyTokens()`.
-   * Generated tokens are merged under explicit `tokens` (tokens win on conflict).
-   */
-  presets?: Record<string, TypographyPreset>;
-  /**
-   * Global Tasty styles keyed by CSS selector.
-   * Supports the full Tasty style syntax.
-   */
-  globalStyles?: Record<string, Styles>;
-}
-/**
- * A factory function that creates a TastyPlugin.
- * Can optionally accept configuration options.
- *
- * @example
- * ```ts
- * // Plugin without options
- * const okhslPlugin: TastyPluginFactory = () => ({
- *   name: 'okhsl',
- *   funcs: { okhsl: okhslFunc },
- * });
- *
- * // Plugin with options
- * const debugPlugin: TastyPluginFactory<{ verbose: boolean }> = (options) => ({
- *   name: 'debug',
- *   funcs: { debug: createDebugFunc(options.verbose) },
- * });
- * ```
- */
-type TastyPluginFactory<TOptions = void> = TOptions extends void ? () => TastyPlugin : (options: TOptions) => TastyPlugin;
-//#endregion
-export { TastyPlugin, TastyPluginFactory };
-//# sourceMappingURL=types.d.ts.map

package/dist/properties/index.js

@@ -1,222 +0,0 @@
-import { RE_NUMBER, RE_RAW_UNIT } from "../parser/const.js";
-import "../utils/color-space.js";
-//#region src/properties/index.ts
-const PROPERTIES_KEY = "@properties";
-/**
-* Valid CSS custom property name pattern (after the -- prefix).
-* Must start with a letter or underscore, followed by letters, digits, hyphens, or underscores.
-*/
-const VALID_PROPERTY_NAME_PATTERN = /^[a-z_][a-z0-9-_]*$/i;
-/**
-* Validate a CSS custom property name (the part after --).
-* Returns true if the name is valid for use as a CSS custom property.
-*/
-function isValidPropertyName(name) {
-	return VALID_PROPERTY_NAME_PATTERN.test(name);
-}
-/**
-* Check if styles object has local @properties definition.
-* Fast path: single property lookup.
-*/
-function hasLocalProperties(styles) {
-	return PROPERTIES_KEY in styles;
-}
-/**
-* Extract local @properties from styles object.
-* Returns null if no local properties (fast path).
-*/
-function extractLocalProperties(styles) {
-	const properties = styles[PROPERTIES_KEY];
-	if (!properties || typeof properties !== "object") return null;
-	return properties;
-}
-/**
-* Parse a property token name and return the CSS property name and whether it's a color.
-* Supports tasty token syntax and validates the property name.
-*
-* Token formats:
-* - `$name` → { cssName: '--name', isColor: false }
-* - `#name` → { cssName: '--name-color', isColor: true }
-* - `--name` → { cssName: '--name', isColor: false } (legacy, auto-detect color by suffix)
-* - `name` → { cssName: '--name', isColor: false } (legacy)
-*
-* @param token - The property token to parse
-* @returns Parsed result with cssName, isColor, isValid, and optional error
-*/
-function parsePropertyToken(token) {
-	if (!token || typeof token !== "string") return {
-		cssName: "",
-		isColor: false,
-		isValid: false,
-		error: "Property token must be a non-empty string"
-	};
-	let name;
-	let isColor;
-	if (token.startsWith("$")) {
-		name = token.slice(1);
-		isColor = false;
-	} else if (token.startsWith("#")) {
-		name = token.slice(1);
-		isColor = true;
-	} else if (token.startsWith("--")) {
-		name = token.slice(2);
-		isColor = token.endsWith("-color");
-	} else {
-		name = token;
-		isColor = token.endsWith("-color");
-	}
-	if (!name) return {
-		cssName: "",
-		isColor,
-		isValid: false,
-		error: "Property name cannot be empty"
-	};
-	if (!isValidPropertyName(name)) return {
-		cssName: "",
-		isColor,
-		isValid: false,
-		error: `Invalid property name "${name}". Must start with a letter or underscore, followed by letters, digits, hyphens, or underscores.`
-	};
-	let cssName;
-	if (token.startsWith("#")) cssName = `--${name}-color`;
-	else cssName = `--${name}`;
-	return {
-		cssName,
-		isColor,
-		isValid: true
-	};
-}
-/**
-* Normalize a property definition to a consistent string representation.
-* Used for comparing definitions to detect type conflicts.
-*
-* Only `syntax` and `inherits` are compared — `initialValue` is intentionally
-* excluded because different components may set different defaults for the
-* same typed property (e.g. auto-inferred `0px` vs explicit `6px`).
-*
-* Keys are sorted alphabetically to ensure consistent comparison:
-* { inherits: true, syntax: '<color>' } === { syntax: '<color>', inherits: true }
-*/
-function normalizePropertyDefinition(def) {
-	const normalized = {};
-	if (def.inherits !== void 0) normalized.inherits = def.inherits;
-	if (def.syntax !== void 0) normalized.syntax = def.syntax;
-	return JSON.stringify(normalized);
-}
-/**
-* Get the effective property definition for a token.
-* For color tokens (#name), auto-sets syntax to '<color>' and defaults initialValue to 'transparent'.
-*
-* @param token - Property token ($name, #name, --name, or plain name)
-* @param userDefinition - User-provided definition options
-* @returns Effective definition with cssName, definition, isValid, and optional error
-*/
-function getEffectiveDefinition(token, userDefinition) {
-	const parsed = parsePropertyToken(token);
-	if (!parsed.isValid) return {
-		cssName: "",
-		definition: userDefinition,
-		isColor: false,
-		isValid: false,
-		error: parsed.error
-	};
-	if (parsed.isColor) return {
-		cssName: parsed.cssName,
-		definition: {
-			syntax: "<color>",
-			inherits: userDefinition.inherits,
-			initialValue: userDefinition.initialValue ?? "transparent"
-		},
-		isColor: true,
-		isValid: true
-	};
-	return {
-		cssName: parsed.cssName,
-		definition: userDefinition,
-		isColor: false,
-		isValid: true
-	};
-}
-const UNIT_TO_SYNTAX = {};
-const LENGTH_UNITS = [
-	"px",
-	"em",
-	"rem",
-	"vw",
-	"vh",
-	"vmin",
-	"vmax",
-	"ch",
-	"ex",
-	"cap",
-	"ic",
-	"lh",
-	"rlh",
-	"svw",
-	"svh",
-	"lvw",
-	"lvh",
-	"dvw",
-	"dvh",
-	"cqw",
-	"cqh",
-	"cqi",
-	"cqb",
-	"cqmin",
-	"cqmax"
-];
-const ANGLE_UNITS = [
-	"deg",
-	"rad",
-	"grad",
-	"turn"
-];
-const TIME_UNITS = ["ms", "s"];
-for (const u of LENGTH_UNITS) UNIT_TO_SYNTAX[u] = {
-	syntax: "<length-percentage>",
-	initialValue: "0px"
-};
-UNIT_TO_SYNTAX["%"] = {
-	syntax: "<length-percentage>",
-	initialValue: "0px"
-};
-for (const u of ANGLE_UNITS) UNIT_TO_SYNTAX[u] = {
-	syntax: "<angle>",
-	initialValue: "0deg"
-};
-for (const u of TIME_UNITS) UNIT_TO_SYNTAX[u] = {
-	syntax: "<time>",
-	initialValue: "0s"
-};
-/**
-* Infer CSS @property syntax from a concrete value.
-* Detects numeric types: \<number\>, \<length-percentage\>, \<angle\>, \<time\>.
-* Length and percentage values both map to \<length-percentage\> for maximum flexibility.
-* Color properties are handled separately via the #name token convention
-* (--name-color gets \<color\> syntax automatically in getEffectiveDefinition).
-*
-* @param value - The CSS value to infer from (e.g. '10px', '1', '45deg')
-* @returns Inferred syntax and initial value, or null if not inferable
-*/
-function inferSyntaxFromValue(value) {
-	if (!value || typeof value !== "string") return null;
-	const trimmed = value.trim();
-	if (!trimmed) return null;
-	if (RE_NUMBER.test(trimmed)) {
-		if (parseFloat(trimmed) === 0) return null;
-		return {
-			syntax: "<number>",
-			initialValue: "0"
-		};
-	}
-	const unitMatch = trimmed.match(RE_RAW_UNIT);
-	if (unitMatch) {
-		const mapping = UNIT_TO_SYNTAX[unitMatch[2]];
-		if (mapping) return mapping;
-	}
-	return null;
-}
-//#endregion
-export { extractLocalProperties, getEffectiveDefinition, hasLocalProperties, inferSyntaxFromValue, normalizePropertyDefinition, parsePropertyToken };
-
-//# sourceMappingURL=index.js.map