chaincss 2.1.38 → 2.2.0

package/ROADMAP.md

@@ -0,0 +1,31 @@
+
+## v3.0 Ideas
+
+### 1. Predictive & Self-Healing CSS
+- Context-aware typo correction (not just fuzzy matching)
+- Intent detection: `display: "flexbox"` → maps to `display: flex` + applies defaults
+- Modes: strict (error), dev (auto-fix), smart (fix + log)
+- Builds on: suggestions.ts, explain()
+
+### 2. Style Graph Compiler
+- Instead of linear compilation, build a dependency graph of styles
+- Dead style elimination
+- Automatic merging of identical rules
+- Predictive pre-compilation
+- Order-safe CSS output
+- Builds on: compile(), atomic optimizer
+
+### 3. Unit-Aware Math Engine
+- Full CSS expression evaluator
+- `add("10px", "2rem")` → resolves units → optimized calc()
+- `fluidType(14, 20)` → responsive clamp()
+- Context-aware scaling
+- Builds on: helpers.ts
+
+### 4. IDE Intelligence Layer (VS Code Extension)
+- Real-time invalid property detection
+- Shorthand translation hints
+- Animation suggestion
+- Breakpoint inference
+- Style conflict detection
+- Builds on: suggestions.ts

package/dist/cli/index.js

@@ -2612,6 +2612,431 @@ var init_content_addressable_cache = __esm({
   }
 });
 
+// src/compiler/style-graph.ts
+import crypto4 from "crypto";
+function calculateSpecificity(selector) {
+  let a = 0;
+  let b = 0;
+  let c = 0;
+  const idMatches = selector.match(/#[a-zA-Z0-9_-]+/g);
+  if (idMatches) a += idMatches.length;
+  const classMatches = selector.match(/\.[a-zA-Z0-9_-]+/g);
+  if (classMatches) b += classMatches.length;
+  const attrMatches = selector.match(/\[[^\]]+\]/g);
+  if (attrMatches) b += attrMatches.length;
+  const pseudoClassMatches = selector.match(/:[a-zA-Z-]+(?:\([^)]*\))?/g);
+  if (pseudoClassMatches) {
+    const notMatches = selector.match(/:not\(([^)]+)\)/g);
+    const regularPseudoClasses = pseudoClassMatches.length - (notMatches?.length || 0);
+    b += Math.max(0, regularPseudoClasses);
+  }
+  const elementMatches = selector.match(/^[a-zA-Z]+|[a-zA-Z]+(?=[.#[:])/g);
+  if (elementMatches) c += elementMatches.length;
+  return a * 1e4 + b * 100 + c;
+}
+function hashProperties(properties) {
+  const sorted = Object.entries(properties).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}:${v}`).join(";");
+  return crypto4.createHash("md5").update(sorted).digest("hex").slice(0, 8);
+}
+function kebab2(prop) {
+  return prop.replace(/([A-Z])/g, "-$1").toLowerCase();
+}
+function eliminateDeadStyles(graph, knownSelectors) {
+  if (knownSelectors.length === 0) {
+    return { eliminated: 0, graph };
+  }
+  const reachable = /* @__PURE__ */ new Set();
+  const queue = [];
+  for (const [id, node] of graph.nodes) {
+    if (knownSelectors.some((ks) => node.selector.includes(ks) || ks.includes(node.selector))) {
+      reachable.add(id);
+      queue.push(id);
+    }
+  }
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const node = graph.nodes.get(current);
+    if (!node) continue;
+    for (const depId of node.dependents) {
+      if (!reachable.has(depId)) {
+        reachable.add(depId);
+        queue.push(depId);
+      }
+    }
+  }
+  let eliminated = 0;
+  for (const [id, node] of graph.nodes) {
+    if (!reachable.has(id)) {
+      node.isDead = true;
+      eliminated++;
+    }
+  }
+  return { eliminated, graph };
+}
+function mergeIdenticalRules(graph, threshold) {
+  const hashGroups = /* @__PURE__ */ new Map();
+  for (const [, node] of graph.nodes) {
+    if (node.isDead) continue;
+    if (Object.keys(node.properties).length < threshold) continue;
+    const existing = hashGroups.get(node.hash) || [];
+    existing.push(node);
+    hashGroups.set(node.hash, existing);
+  }
+  let merged = 0;
+  for (const [, group] of hashGroups) {
+    if (group.length < 2) continue;
+    const mergedSelector = group.map((n) => n.selector).join(", ");
+    const primary = group[0];
+    primary.selector = mergedSelector;
+    for (let i = 1; i < group.length; i++) {
+      group[i].isDead = true;
+      merged++;
+    }
+  }
+  return { merged, graph };
+}
+function topologicalSort(graph) {
+  const visited = /* @__PURE__ */ new Set();
+  const sorted = [];
+  const visiting = /* @__PURE__ */ new Set();
+  function visit(id) {
+    if (visited.has(id)) return true;
+    if (visiting.has(id)) return false;
+    visiting.add(id);
+    const node = graph.nodes.get(id);
+    if (node) {
+      for (const depId of node.dependencies) {
+        if (!visit(depId)) return false;
+      }
+    }
+    visiting.delete(id);
+    visited.add(id);
+    if (node && !node.isDead) {
+      sorted.push(node);
+    }
+    return true;
+  }
+  for (const id of graph.rootNodes) {
+    if (!visit(id)) {
+      return Array.from(graph.nodes.values()).filter((n) => !n.isDead).sort((a, b) => a.sourceComponent?.localeCompare(b.sourceComponent || "") || 0);
+    }
+  }
+  for (const [id] of graph.nodes) {
+    if (!visited.has(id)) {
+      visit(id);
+    }
+  }
+  return sorted;
+}
+function generateCSSFromGraph(graph, sortOutput = "specificity") {
+  let nodes;
+  switch (sortOutput) {
+    case "specificity":
+      nodes = Array.from(graph.nodes.values()).filter((n) => !n.isDead).sort((a, b) => a.specificity - b.specificity);
+      break;
+    case "topological":
+      nodes = topologicalSort(graph);
+      break;
+    case "source-order":
+    default:
+      nodes = Array.from(graph.nodes.values()).filter((n) => !n.isDead);
+      break;
+  }
+  let css = "";
+  let currentMediaQuery;
+  for (const node of nodes) {
+    if (node.isDead) continue;
+    if (node.mediaQuery !== currentMediaQuery) {
+      if (currentMediaQuery) {
+        css += "}\n\n";
+      }
+      if (node.mediaQuery) {
+        css += `@media ${node.mediaQuery} {
+`;
+      }
+      currentMediaQuery = node.mediaQuery;
+    }
+    const rules = Object.entries(node.properties).map(([prop, value]) => `  ${kebab2(prop)}: ${value};`).join("\n");
+    if (rules) {
+      css += `${node.selector} {
+${rules}
+}
+`;
+    }
+  }
+  if (currentMediaQuery) {
+    css += "}\n";
+  }
+  return css;
+}
+var StyleGraphBuilder, StyleGraphCompiler;
+var init_style_graph = __esm({
+  "src/compiler/style-graph.ts"() {
+    "use strict";
+    StyleGraphBuilder = class {
+      entries = [];
+      nodes = /* @__PURE__ */ new Map();
+      edges = [];
+      orderCounter = 0;
+      addEntry(entry) {
+        entry.sourceOrder = this.orderCounter++;
+        this.entries.push(entry);
+      }
+      build() {
+        this.nodes.clear();
+        this.edges = [];
+        for (const entry of this.entries) {
+          const id = `node-${this.nodes.size}`;
+          const node = {
+            id,
+            selector: entry.selector,
+            properties: entry.properties,
+            specificity: calculateSpecificity(entry.selector),
+            dependencies: [],
+            dependents: [],
+            mediaQuery: entry.mediaQuery,
+            isDead: false,
+            hash: hashProperties(entry.properties),
+            sourceComponent: entry.sourceComponent
+          };
+          this.nodes.set(id, node);
+        }
+        const nodeArray = Array.from(this.nodes.values());
+        for (let i = 0; i < nodeArray.length; i++) {
+          for (let j = i + 1; j < nodeArray.length; j++) {
+            const a = nodeArray[i];
+            const b = nodeArray[j];
+            if (this.selectorsOverlap(a.selector, b.selector)) {
+              if (a.specificity <= b.specificity) {
+                this.edges.push({ from: a.id, to: b.id, type: "overrides" });
+                a.dependents.push(b.id);
+                b.dependencies.push(a.id);
+              }
+              if (b.specificity <= a.specificity) {
+                this.edges.push({ from: b.id, to: a.id, type: "overrides" });
+                b.dependents.push(a.id);
+                a.dependencies.push(b.id);
+              }
+            }
+          }
+        }
+        const rootNodes = nodeArray.filter((n) => n.dependencies.length === 0).map((n) => n.id);
+        const leafNodes = nodeArray.filter((n) => n.dependents.length === 0).map((n) => n.id);
+        return {
+          nodes: this.nodes,
+          edges: this.edges,
+          rootNodes,
+          leafNodes
+        };
+      }
+      selectorsOverlap(a, b) {
+        const partsA = a.split(/[\s>+~]+/).filter(Boolean);
+        const partsB = b.split(/[\s>+~]+/).filter(Boolean);
+        for (const pa of partsA) {
+          for (const pb of partsB) {
+            if (pa === pb) return true;
+            if (pa.startsWith(".") && pb.startsWith(".") && pa === pb) return true;
+          }
+        }
+        return false;
+      }
+    };
+    StyleGraphCompiler = class {
+      options;
+      constructor(options = {}) {
+        this.options = {
+          eliminateDead: options.eliminateDead ?? false,
+          knownSelectors: options.knownSelectors ?? [],
+          mergeIdentical: options.mergeIdentical ?? false,
+          mergeThreshold: options.mergeThreshold ?? 3,
+          sortOutput: options.sortOutput ?? "specificity",
+          verbose: options.verbose ?? false
+        };
+      }
+      /**
+       * Compile a set of style definitions through the graph compiler.
+       */
+      compile(styles) {
+        const startTime = Date.now();
+        const builder = new StyleGraphBuilder();
+        let preOptimizationSize = 0;
+        for (const [componentName, styleDef] of Object.entries(styles)) {
+          if (!styleDef || !styleDef.selectors) continue;
+          for (const selector of styleDef.selectors) {
+            const properties = {};
+            for (const [prop, value] of Object.entries(styleDef)) {
+              if (prop === "selectors" || prop === "atRules" || prop === "nestedRules" || prop === "hover" || prop === "themes" || prop.startsWith("_")) {
+                continue;
+              }
+              if (typeof value === "string" || typeof value === "number") {
+                properties[prop] = String(value);
+                preOptimizationSize += String(value).length + prop.length;
+              }
+            }
+            if (Object.keys(properties).length > 0) {
+              builder.addEntry({
+                selector,
+                properties,
+                sourceComponent: componentName,
+                sourceOrder: 0
+              });
+            }
+            if (styleDef.hover && typeof styleDef.hover === "object") {
+              const hoverProperties = {};
+              for (const [prop, value] of Object.entries(styleDef.hover)) {
+                if (typeof value === "string" || typeof value === "number") {
+                  hoverProperties[prop] = String(value);
+                }
+              }
+              if (Object.keys(hoverProperties).length > 0) {
+                builder.addEntry({
+                  selector: `${selector}:hover`,
+                  properties: hoverProperties,
+                  sourceComponent: componentName,
+                  sourceOrder: 0
+                });
+              }
+            }
+            if (styleDef.atRules) {
+              for (const rule of styleDef.atRules) {
+                if (rule.type === "media" && rule.styles && rule.query) {
+                  const mediaProperties = {};
+                  for (const [prop, value] of Object.entries(rule.styles)) {
+                    if (typeof value === "string" || typeof value === "number") {
+                      mediaProperties[prop] = String(value);
+                    }
+                  }
+                  if (Object.keys(mediaProperties).length > 0) {
+                    builder.addEntry({
+                      selector,
+                      properties: mediaProperties,
+                      sourceComponent: componentName,
+                      sourceOrder: 0,
+                      mediaQuery: rule.query
+                    });
+                  }
+                }
+              }
+            }
+          }
+        }
+        let graph = builder.build();
+        let eliminatedDead = 0;
+        if (this.options.eliminateDead && this.options.knownSelectors.length > 0) {
+          const result = eliminateDeadStyles(graph, this.options.knownSelectors);
+          eliminatedDead = result.eliminated;
+          graph = result.graph;
+        }
+        let mergedRules = 0;
+        if (this.options.mergeIdentical) {
+          const result = mergeIdenticalRules(graph, this.options.mergeThreshold);
+          mergedRules = result.merged;
+          graph = result.graph;
+        }
+        const css = generateCSSFromGraph(graph, this.options.sortOutput);
+        let postOptimizationSize = css.length;
+        if (postOptimizationSize === 0) {
+          postOptimizationSize = preOptimizationSize;
+        }
+        const classMap = {};
+        for (const [, node] of graph.nodes) {
+          if (!node.isDead && node.sourceComponent) {
+            if (classMap[node.sourceComponent]) {
+              classMap[node.sourceComponent] += ` ${node.selector.replace(/^\./, "")}`;
+            } else {
+              classMap[node.sourceComponent] = node.selector.replace(/^\./, "");
+            }
+          }
+        }
+        const totalNodes = graph.nodes.size;
+        const aliveNodes = totalNodes - eliminatedDead;
+        const savingsPercent = preOptimizationSize > 0 ? `${((preOptimizationSize - postOptimizationSize) / preOptimizationSize * 100).toFixed(1)}%` : "0%";
+        const stats = {
+          totalStyles: totalNodes,
+          atomicStyles: 0,
+          uniqueProperties: new Set(
+            Array.from(graph.nodes.values()).filter((n) => !n.isDead).flatMap((n) => Object.keys(n.properties))
+          ).size,
+          savings: savingsPercent,
+          compileTime: Date.now() - startTime
+        };
+        return {
+          css,
+          classMap,
+          atomicClasses: [],
+          stats,
+          graph,
+          eliminatedDead,
+          mergedRules,
+          optimizationTime: Date.now() - startTime,
+          preOptimizationSize,
+          postOptimizationSize
+        };
+      }
+      /**
+       * Analyze a style graph without generating CSS.
+       */
+      analyze(styles) {
+        const builder = new StyleGraphBuilder();
+        for (const [componentName, styleDef] of Object.entries(styles)) {
+          if (!styleDef || !styleDef.selectors) continue;
+          for (const selector of styleDef.selectors) {
+            const properties = {};
+            for (const [prop, value] of Object.entries(styleDef)) {
+              if (prop === "selectors" || prop.startsWith("_")) continue;
+              if (typeof value === "string" || typeof value === "number") {
+                properties[prop] = String(value);
+              }
+            }
+            if (Object.keys(properties).length > 0) {
+              builder.addEntry({ selector, properties, sourceComponent: componentName, sourceOrder: 0 });
+            }
+          }
+        }
+        return builder.build();
+      }
+      /**
+       * Get optimization statistics for a graph.
+       */
+      getStats(graph) {
+        const nodes = Array.from(graph.nodes.values());
+        const deadNodes = nodes.filter((n) => n.isDead).length;
+        const averageSpecificity = nodes.length > 0 ? nodes.reduce((sum, n) => sum + n.specificity, 0) / nodes.length : 0;
+        let maxDepth = 0;
+        const depths = /* @__PURE__ */ new Map();
+        function getDepth(id) {
+          if (depths.has(id)) return depths.get(id);
+          const node = graph.nodes.get(id);
+          if (!node || node.dependencies.length === 0) {
+            depths.set(id, 0);
+            return 0;
+          }
+          const max = Math.max(...node.dependencies.map((d) => getDepth(d)));
+          const depth = max + 1;
+          depths.set(id, depth);
+          return depth;
+        }
+        for (const [id] of graph.nodes) {
+          maxDepth = Math.max(maxDepth, getDepth(id));
+        }
+        return {
+          totalNodes: nodes.length,
+          deadNodes,
+          mergedGroups: 0,
+          averageSpecificity: Math.round(averageSpecificity * 100) / 100,
+          deepestDependencyChain: maxDepth
+        };
+      }
+      /**
+       * Update options.
+       */
+      configure(options) {
+        this.options = { ...this.options, ...options };
+      }
+    };
+  }
+});
+
 // src/core/compiler.ts
 var compiler_exports = {};
 __export(compiler_exports, {
@@ -2620,7 +3045,7 @@ __export(compiler_exports, {
 });
 import fs7 from "fs";
 import path6 from "path";
-import crypto4 from "crypto";
+import crypto5 from "crypto";
 import chalk2 from "chalk";
 import { fileURLToPath, pathToFileURL } from "url";
 async function compileChainCSS(inputFile, outputDir, config) {
@@ -2639,6 +3064,7 @@ var init_compiler = __esm({
     init_cache_manager();
     init_content_addressable_cache();
     init_shorthands();
+    init_style_graph();
     __filename = typeof import.meta !== "undefined" ? (() => {
       try {
         return fileURLToPath(import.meta.url);
@@ -2689,6 +3115,35 @@ var init_compiler = __esm({
         this.initOptimizer();
         this.initPrefixer();
       }
+      /**
+      * Compile using the style graph compiler for advanced optimizations.
+      * 
+      * @example
+      * const result = compiler.compileWithGraph(styles, { 
+      *   eliminateDead: true, 
+      *   knownSelectors: ['.header', '.footer'],
+      *   mergeIdentical: true 
+      * });
+      */
+      compileWithGraph(styles, options) {
+        const graphCompiler = new StyleGraphCompiler({
+          ...options,
+          verbose: this.config.verbose
+        });
+        const result = graphCompiler.compile(styles);
+        if (this.config.verbose) {
+          if (result.eliminatedDead > 0) {
+            console.log(`  \u{1F9F9} Eliminated ${result.eliminatedDead} dead styles`);
+          }
+          if (result.mergedRules > 0) {
+            console.log(`  \u{1F517} Merged ${result.mergedRules} identical rules`);
+          }
+          if (result.optimizationTime > 0) {
+            console.log(`  \u26A1 Graph compilation: ${result.optimizationTime}ms`);
+          }
+        }
+        return result;
+      }
       hasStyles() {
         const combined = this.getCombinedCSS();
         return !!(combined && combined.trim().length > 0);
@@ -2726,7 +3181,7 @@ var init_compiler = __esm({
         if (result.css && result.css.trim()) {
           this.accumulatedCSS += result.css + "\n";
         }
-        const cacheKey = crypto4.createHash("sha256").update(`${componentName}-${JSON.stringify(styleObj)}`).digest("hex").slice(0, 16);
+        const cacheKey = crypto5.createHash("sha256").update(`${componentName}-${JSON.stringify(styleObj)}`).digest("hex").slice(0, 16);
         this.addToCache(cacheKey, {
           result: {
             css: result.css || "",
@@ -2854,7 +3309,7 @@ var init_compiler = __esm({
       // ============================================================================
       hashStyleDef(styleDef) {
         const { _componentName, _generateComponent, _framework, _propsDefinition, ...relevant } = styleDef;
-        return crypto4.createHash("sha256").update(JSON.stringify(relevant)).digest("hex").slice(0, 16);
+        return crypto5.createHash("sha256").update(JSON.stringify(relevant)).digest("hex").slice(0, 16);
       }
       async importModule(filePath) {
         const absolutePath = path6.resolve(filePath);

package/dist/compiler/analyzer.d.ts

@@ -0,0 +1,12 @@
+import type { StyleDefinition, StyleDiagnostic, StyleAnalysis, BreakpointInference, DiagnosticSeverity } from '../core/types.js';
+export type { StyleDiagnostic, StyleAnalysis, BreakpointInference, DiagnosticSeverity };
+export declare class StyleAnalyzer {
+    private _diagnostics;
+    analyzeStyle(selector: string, styles: Record<string, any>, _opts?: any): StyleDiagnostic[];
+    analyze(sd: StyleDefinition): StyleAnalysis;
+    reset(): void;
+    getDiagnostics(): StyleDiagnostic[];
+}
+export declare function analyze(sd: StyleDefinition): StyleAnalysis;
+export declare function analyzeStyle(sd: StyleDefinition): StyleAnalysis;
+export default StyleAnalyzer;

package/dist/compiler/css-if-transpiler.d.ts

@@ -0,0 +1,33 @@
+/**
+ * CSS if() Transpiler
+ * Detects conditional style patterns and emits:
+ *   1. Native CSS if() — Chrome 137+
+ *   2. @supports fallback — Firefox, Safari
+ */
+export interface IfCondition {
+    property: string;
+    variable: string;
+    conditions: Record<string, string | number>;
+    defaultValue: string | number;
+}
+export interface DetectedCondition {
+    property: string;
+    variable: string;
+    conditions: Record<string, string | number>;
+    defaultValue: string | number;
+}
+/**
+ * Detect conditional patterns from _conditions metadata.
+ * When chain.when() branches set the same property to different values,
+ * those can be compiled to CSS if().
+ */
+export declare function detectIfPatterns(styles: Record<string, any>): DetectedCondition[];
+/**
+ * Generate CSS if() output for detected conditions.
+ */
+export declare function emitCSSIf(selector: string, detectedConditions: DetectedCondition[], baseProperties?: Record<string, string | number>): string;
+declare const _default: {
+    detectIfPatterns: typeof detectIfPatterns;
+    emitCSSIf: typeof emitCSSIf;
+};
+export default _default;

package/dist/compiler/design-orchestrator.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Design System Orchestrator
+ *
+ * 1. WCAG Contrast Ratio Checker — validates text/background combos at build time
+ * 2. Contextual Tokens — tokens that auto-flip based on container context
+ * 3. Token Relationship Validator — ensures design tokens are consistent
+ */
+export interface ContrastResult {
+    foreground: string;
+    background: string;
+    ratio: number;
+    passes: {
+        AA: boolean;
+        AALarge: boolean;
+        AAA: boolean;
+        AAALarge: boolean;
+    };
+    suggestion?: string;
+}
+export interface ContrastReport {
+    checks: ContrastResult[];
+    failures: ContrastResult[];
+    warnings: ContrastResult[];
+    passCount: number;
+    failCount: number;
+    summary: string;
+}
+export interface ContextualToken {
+    name: string;
+    default: string;
+    contexts: Record<string, string>;
+}
+export interface TokenContext {
+    name: string;
+    parentSelector?: string;
+    tokens: Record<string, any>;
+}
+/**
+ * Parse CSS color to RGBA components.
+ * Supports: hex, rgb(), rgba(), named colors
+ */
+declare function parseColor(color: string): {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+} | null;
+/**
+ * Calculate WCAG contrast ratio between two colors.
+ * Returns value between 1 (no contrast) and 21 (max contrast).
+ */
+export declare function contrastRatio(foreground: string, background: string): number;
+/**
+ * Check WCAG compliance levels.
+ * AA: 4.5:1 normal, 3:1 large text
+ * AAA: 7:1 normal, 4.5:1 large text
+ */
+export declare function checkContrast(foreground: string, background: string): ContrastResult;
+/**
+ * Run contrast checks across a set of style definitions.
+ */
+export declare function auditContrast(styles: Array<{
+    selector: string;
+    color: string;
+    backgroundColor: string;
+}>): ContrastReport;
+/**
+ * Contextual tokens that auto-resolve based on parent container.
+ *
+ * @example
+ *   const buttonText = contextualToken({
+ *     default: '#1a1a1a',
+ *     contexts: {
+ *       '.dark-section': '#ffffff',
+ *       '.hero': '#ffffff',
+ *     },
+ *   });
+ *
+ *   resolveContextual(buttonText, '.dark-section .my-button')
+ *   // => '#ffffff'
+ */
+export declare function createContextualToken(defaultValue: string, contexts?: Record<string, string>): ContextualToken;
+/**
+ * Resolve a contextual token based on the current selector path.
+ * Matches the most specific context that applies.
+ */
+export declare function resolveContextual(token: ContextualToken, selectorPath: string): string;
+/**
+ * Generate CSS custom property fallback for contextual tokens.
+ *
+ * @example
+ *   generateContextualCSS('button-text', contextualToken)
+ *   // => "
+ *   //   .my-button { --button-text: #1a1a1a; }
+ *   //   .dark-section .my-button { --button-text: #ffffff; }
+ *   // "
+ */
+export declare function generateContextualCSS(propertyName: string, token: ContextualToken, baseSelector: string): string;
+/**
+ * Validate that token references are consistent.
+ * E.g., "primary" should have both foreground and background variants
+ * that contrast well with each other.
+ */
+export declare function validateTokenRelationships(tokens: Record<string, any>, pairs: Array<{
+    foreground: string;
+    background: string;
+    label: string;
+}>): ContrastReport;
+export declare const orchestrator: {
+    contrastRatio: typeof contrastRatio;
+    checkContrast: typeof checkContrast;
+    auditContrast: typeof auditContrast;
+    createContextualToken: typeof createContextualToken;
+    resolveContextual: typeof resolveContextual;
+    generateContextualCSS: typeof generateContextualCSS;
+    validateTokenRelationships: typeof validateTokenRelationships;
+    parseColor: typeof parseColor;
+};
+export default orchestrator;