@cube-dev/ui-kit 0.114.0 → 0.115.0

package/types/tasty/chunks/cacheKey.d.ts

@@ -1,26 +0,0 @@
-/**
- * Chunk-specific cache key generation.
- *
- * Generates cache keys that only include styles relevant to a specific chunk,
- * enabling more granular caching and reuse.
- *
- * Enhanced to support predefined states:
- * - Global predefined states don't affect cache keys (constant across app)
- * - Local predefined states only affect cache keys if referenced in the chunk
- */
-import { Styles } from '../styles/types';
-/**
- * Generate a cache key for a specific chunk.
- *
- * Only includes the styles that belong to this chunk, allowing
- * chunks to be cached independently.
- *
- * Also includes relevant local predefined states that are referenced
- * by this chunk's styles.
- *
- * @param styles - The full styles object
- * @param chunkName - Name of the chunk
- * @param styleKeys - Keys of styles belonging to this chunk
- * @returns A stable cache key string
- */
-export declare function generateChunkCacheKey(styles: Styles, chunkName: string, styleKeys: string[]): string;

package/types/tasty/chunks/definitions.d.ts

@@ -1,120 +0,0 @@
-/**
- * Style chunk definitions for CSS chunking optimization.
- *
- * Styles are grouped into chunks based on:
- * 1. Handler dependencies - styles that share a handler MUST be in the same chunk
- * 2. Logical grouping - related styles grouped for better cache reuse
- *
- * See STYLE_CHUNKING_SPEC.md for detailed rationale.
- *
- * ============================================================================
- * ⚠️  CRITICAL ARCHITECTURAL CONSTRAINT: NO CROSS-CHUNK HANDLER DEPENDENCIES
- * ============================================================================
- *
- * Style handlers declare their dependencies via `__lookupStyles` array.
- * This creates a dependency graph where handlers read multiple style props.
- *
- * **ALL styles in a handler's `__lookupStyles` MUST be in the SAME chunk.**
- *
- * Why this matters:
- * 1. Each chunk computes a cache key from ONLY its own style values
- * 2. If a handler reads a style from another chunk, that value isn't in the cache key
- * 3. Changing the cross-chunk style won't invalidate this chunk's cache
- * 4. Result: stale CSS output or incorrect cache hits
- *
- * Example of a violation:
- * ```
- * // flowStyle.__lookupStyles = ['display', 'flow']
- * // If 'display' is in DISPLAY chunk and 'flow' is in LAYOUT chunk:
- * // - User sets { display: 'grid', flow: 'column' }
- * // - LAYOUT chunk caches CSS with flow=column, display=grid
- * // - User changes to { display: 'flex', flow: 'column' }
- * // - LAYOUT chunk cache key unchanged (only has 'flow')
- * // - Returns stale CSS computed with display=grid!
- * ```
- *
- * Before adding/moving styles, verify:
- * 1. Find all handlers that use this style (grep for the style name in __lookupStyles)
- * 2. Ensure ALL styles from each handler's __lookupStyles are in the same chunk
- * ============================================================================
- */
-/**
- * Appearance chunk - visual styling with independent handlers
- */
-export declare const APPEARANCE_CHUNK_STYLES: readonly ["fill", "color", "opacity", "border", "radius", "outline", "outlineOffset", "shadow", "fade"];
-/**
- * Font chunk - typography styles
- *
- * Handler dependencies (all styles in each handler MUST stay in this chunk):
- * ⚠️ presetStyle: preset, fontSize, lineHeight, letterSpacing, textTransform,
- *    fontWeight, fontStyle, font
- */
-export declare const FONT_CHUNK_STYLES: readonly ["preset", "font", "fontWeight", "fontStyle", "fontSize", "lineHeight", "letterSpacing", "textTransform", "fontFamily", "textAlign", "textDecoration", "wordBreak", "wordWrap", "boldFontWeight"];
-/**
- * Dimension chunk - sizing and spacing
- *
- * Handler dependencies (all styles in each handler MUST stay in this chunk):
- * ⚠️ paddingStyle: padding, paddingTop/Right/Bottom/Left, paddingBlock/Inline
- * ⚠️ marginStyle: margin, marginTop/Right/Bottom/Left, marginBlock/Inline
- * ⚠️ widthStyle: width, minWidth, maxWidth
- * ⚠️ heightStyle: height, minHeight, maxHeight
- */
-export declare const DIMENSION_CHUNK_STYLES: readonly ["padding", "paddingTop", "paddingRight", "paddingBottom", "paddingLeft", "paddingBlock", "paddingInline", "margin", "marginTop", "marginRight", "marginBottom", "marginLeft", "marginBlock", "marginInline", "width", "minWidth", "maxWidth", "height", "minHeight", "maxHeight", "flexBasis", "flexGrow", "flexShrink", "flex"];
-/**
- * Display chunk - display mode, layout flow, text overflow, and scrollbar
- *
- * Handler dependencies (all styles in each handler MUST stay in this chunk):
- * ⚠️ displayStyle: display, hide, textOverflow, overflow, whiteSpace
- * ⚠️ flowStyle: display, flow
- * ⚠️ gapStyle: display, flow, gap
- * ⚠️ scrollbarStyle: scrollbar, overflow
- */
-export declare const DISPLAY_CHUNK_STYLES: readonly ["display", "hide", "textOverflow", "overflow", "whiteSpace", "flow", "gap", "scrollbar", "styledScrollbar"];
-/**
- * Layout chunk - flex/grid alignment and grid templates
- *
- * Note: flow and gap are in DISPLAY chunk due to handler dependencies
- * (flowStyle and gapStyle both require 'display' prop).
- */
-export declare const LAYOUT_CHUNK_STYLES: readonly ["placeItems", "placeContent", "alignItems", "alignContent", "justifyItems", "justifyContent", "align", "justify", "place", "columnGap", "rowGap", "gridColumns", "gridRows", "gridTemplate", "gridAreas", "gridAutoFlow", "gridAutoColumns", "gridAutoRows"];
-/**
- * Position chunk - element positioning
- *
- * Handler dependencies (all styles in each handler MUST stay in this chunk):
- * ⚠️ insetStyle: inset, insetBlock, insetInline, top, right, bottom, left
- */
-export declare const POSITION_CHUNK_STYLES: readonly ["position", "inset", "insetBlock", "insetInline", "top", "right", "bottom", "left", "zIndex", "gridArea", "gridColumn", "gridRow", "order", "placeSelf", "alignSelf", "justifySelf", "transform", "transition", "animation"];
-export declare const CHUNK_NAMES: {
-    /** Special chunk for styles that cannot be split (e.g., @starting-style) */
-    readonly COMBINED: "combined";
-    readonly SUBCOMPONENTS: "subcomponents";
-    readonly APPEARANCE: "appearance";
-    readonly FONT: "font";
-    readonly DIMENSION: "dimension";
-    readonly DISPLAY: "display";
-    readonly LAYOUT: "layout";
-    readonly POSITION: "position";
-    readonly MISC: "misc";
-};
-export type ChunkName = (typeof CHUNK_NAMES)[keyof typeof CHUNK_NAMES];
-/**
- * Pre-computed map for O(1) style-to-chunk lookup.
- * Built once at module load time.
- */
-export declare const STYLE_TO_CHUNK: Map<string, ChunkName>;
-export interface ChunkInfo {
-    /** Name of the chunk */
-    name: ChunkName | string;
-    /** Style keys belonging to this chunk */
-    styleKeys: string[];
-}
-/**
- * Categorize style keys into chunks.
- *
- * Returns chunks in a deterministic order (by CHUNK_ORDER) regardless
- * of the order of keys in the input styles object.
- *
- * @param styles - The styles object to categorize
- * @returns Map of chunk name to array of style keys in that chunk (in priority order)
- */
-export declare function categorizeStyleKeys(styles: Record<string, unknown>): Map<string, string[]>;

package/types/tasty/chunks/index.d.ts

@@ -1,4 +0,0 @@
-export { APPEARANCE_CHUNK_STYLES, FONT_CHUNK_STYLES, DIMENSION_CHUNK_STYLES, DISPLAY_CHUNK_STYLES, LAYOUT_CHUNK_STYLES, POSITION_CHUNK_STYLES, CHUNK_NAMES, STYLE_TO_CHUNK, categorizeStyleKeys, } from './definitions';
-export type { ChunkName, ChunkInfo } from './definitions';
-export { generateChunkCacheKey } from './cacheKey';
-export { renderStylesForChunk } from './renderChunk';

package/types/tasty/chunks/renderChunk.d.ts

@@ -1,25 +0,0 @@
-/**
- * Chunk-specific style rendering.
- *
- * Renders styles for a specific chunk by filtering the styles object
- * to only include relevant keys before passing to renderStyles.
- */
-import { RenderResult } from '../pipeline';
-import { Styles } from '../styles/types';
-/**
- * Render styles for a specific chunk.
- *
- * Creates a filtered styles object containing only the keys for this chunk,
- * then delegates to the existing renderStyles function.
- *
- * IMPORTANT: Local predefined states (e.g., '@mobile': '@media(w < 600px)')
- * are always included in the filtered styles, regardless of which chunk is
- * being rendered. This ensures that state references like '@mobile' in any
- * chunk can be properly resolved by the pipeline.
- *
- * @param styles - The full styles object
- * @param chunkName - Name of the chunk being rendered
- * @param styleKeys - Keys of styles belonging to this chunk
- * @returns RenderResult with rules for this chunk
- */
-export declare function renderStylesForChunk(styles: Styles, chunkName: string, styleKeys: string[]): RenderResult;

package/types/tasty/config.d.ts

@@ -1,320 +0,0 @@
-/**
- * Tasty Configuration Module
- *
- * Centralizes all tasty configuration, including:
- * - Style injector settings (nonce, cleanup thresholds, etc.)
- * - Global predefined states for advanced state mapping
- * - stylesGenerated flag that locks configuration after first style generation
- *
- * Configuration must be done BEFORE any styles are generated.
- * After the first `inject()` call, configuration is locked and attempts to
- * reconfigure will emit a warning and be ignored.
- */
-import type { KeyframesSteps, PropertyDefinition } from './injector/types';
-import type { StyleDetails, UnitHandler } from './parser/types';
-import type { TastyPlugin } from './plugins/types';
-import type { RecipeStyles } from './styles/types';
-import type { StyleHandlerDefinition } from './utils/styles';
-/**
- * Configuration options for the Tasty style system
- */
-export interface TastyConfig {
-    /** CSP nonce for style elements */
-    nonce?: string;
-    /** Maximum rules per stylesheet (default: 8192) */
-    maxRulesPerSheet?: number;
-    /** Threshold for bulk cleanup of unused styles (default: 500) */
-    unusedStylesThreshold?: number;
-    /** Delay before bulk cleanup in ms, ignored if idleCleanup is true (default: 5000) */
-    bulkCleanupDelay?: number;
-    /** Use requestIdleCallback for cleanup when available (default: true) */
-    idleCleanup?: boolean;
-    /** Force text injection mode, auto-detected in test environments (default: auto) */
-    forceTextInjection?: boolean;
-    /** Enable development mode features: performance metrics and debug info (default: auto) */
-    devMode?: boolean;
-    /**
-     * Ratio of unused styles to delete per bulk cleanup run (0..1).
-     * Defaults to 0.5 (oldest half) to reduce risk of removing styles
-     * that may be restored shortly after being marked unused.
-     */
-    bulkCleanupBatchRatio?: number;
-    /**
-     * Minimum age (in ms) a style must remain unused before eligible for deletion.
-     * Helps avoid races during rapid mount/unmount cycles. Default: 10000ms.
-     */
-    unusedStylesMinAgeMs?: number;
-    /**
-     * Global predefined states for advanced state mapping.
-     * These are state aliases that can be used in any component.
-     * Example: { '@mobile': '@media(w < 920px)', '@dark': '@root(theme=dark)' }
-     */
-    states?: Record<string, string>;
-    /**
-     * Parser LRU cache size (default: 1000).
-     * Larger values improve performance for apps with many unique style values.
-     */
-    parserCacheSize?: number;
-    /**
-     * Custom units for the style parser (merged with built-in units).
-     * Units transform numeric values like `2x` → `calc(2 * var(--gap))`.
-     * @example { em: 'em', vw: 'vw', custom: (n) => `${n * 10}px` }
-     */
-    units?: Record<string, string | UnitHandler>;
-    /**
-     * Custom functions for the style parser (merged with existing).
-     * Functions process parsed style groups and return CSS values.
-     * @example { myFunc: (groups) => groups.map(g => g.output).join(' ') }
-     */
-    funcs?: Record<string, (groups: StyleDetails[]) => string>;
-    /**
-     * Plugins that extend tasty with custom functions, units, or states.
-     * Plugins are processed in order, with later plugins overriding earlier ones.
-     * @example
-     * ```ts
-     * import { okhslPlugin } from '@cube-dev/ui-kit/tasty/plugins';
-     *
-     * configure({
-     *   plugins: [okhslPlugin()],
-     * });
-     * ```
-     */
-    plugins?: TastyPlugin[];
-    /**
-     * Global keyframes definitions that can be referenced by animation names in styles.
-     * Keys are animation names, values are keyframes step definitions.
-     * Keyframes are only injected when actually used in styles.
-     * @example
-     * ```ts
-     * configure({
-     *   keyframes: {
-     *     fadeIn: { from: { opacity: 0 }, to: { opacity: 1 } },
-     *     pulse: { '0%, 100%': { transform: 'scale(1)' }, '50%': { transform: 'scale(1.05)' } },
-     *   },
-     * });
-     * ```
-     */
-    keyframes?: Record<string, KeyframesSteps>;
-    /**
-     * Global CSS @property definitions for custom properties.
-     * Keys use tasty token syntax ($name for properties, #name for colors).
-     * Properties are only injected when the component using them is rendered.
-     *
-     * For color tokens (#name), `syntax: '<color>'` is auto-set and
-     * `initialValue` defaults to `'transparent'` if not specified.
-     *
-     * @example
-     * ```ts
-     * configure({
-     *   properties: {
-     *     '$rotation': { syntax: '<angle>', initialValue: '0deg' },
-     *     '$scale': { syntax: '<number>', inherits: false, initialValue: 1 },
-     *     '#accent': { initialValue: 'purple' }, // syntax: '<color>' auto-set
-     *   },
-     * });
-     *
-     * // Now use in styles - properties are registered when component renders:
-     * const Spinner = tasty({
-     *   styles: {
-     *     transform: 'rotate($rotation)',
-     *     transition: '$$rotation 0.3s', // outputs: --rotation 0.3s
-     *   },
-     * });
-     * ```
-     */
-    properties?: Record<string, PropertyDefinition>;
-    /**
-     * Custom style handlers that transform style properties into CSS declarations.
-     * Handlers replace built-in handlers for the same style name.
-     * @example
-     * ```ts
-     * import { styleHandlers } from '@cube-dev/ui-kit';
-     *
-     * configure({
-     *   handlers: {
-     *     // Override fill with custom behavior
-     *     fill: ({ fill }) => {
-     *       if (fill?.startsWith('gradient:')) {
-     *         return { background: fill.slice(9) };
-     *       }
-     *       return styleHandlers.fill({ fill });
-     *     },
-     *     // Add new custom style
-     *     elevation: ({ elevation }) => {
-     *       const level = parseInt(elevation) || 1;
-     *       return {
-     *         'box-shadow': `0 ${level * 2}px ${level * 4}px rgba(0,0,0,0.1)`,
-     *         'z-index': String(level * 100),
-     *       };
-     *     },
-     *   },
-     * });
-     * ```
-     */
-    handlers?: Record<string, StyleHandlerDefinition>;
-    /**
-     * Predefined tokens that are replaced during style parsing.
-     * Token values are processed through the parser (like component tokens).
-     * Use `$name` for custom properties and `#name` for color tokens.
-     *
-     * For color tokens (#name), boolean `true` is converted to `transparent`.
-     *
-     * @example
-     * ```ts
-     * configure({
-     *   tokens: {
-     *     $spacing: '2x',
-     *     '$card-padding': '4x',
-     *     '#accent': '#purple',
-     *     '#surface': '#white',
-     *     '#overlay': true, // → transparent
-     *   },
-     * });
-     *
-     * // Now use in styles - tokens are replaced at parse time:
-     * const Card = tasty({
-     *   styles: {
-     *     padding: '$card-padding',  // → calc(4 * var(--gap))
-     *     fill: '#surface',          // → var(--white-color)
-     *   },
-     * });
-     * ```
-     */
-    tokens?: {
-        [key: `$${string}`]: string | number | boolean;
-    } & {
-        [key: `#${string}`]: string | number | boolean;
-    };
-    /**
-     * Predefined style recipes -- named style bundles that can be applied via `recipe` style property.
-     * Recipe values are flat tasty styles (no sub-element keys). They may contain base styles,
-     * tokens (`$name`/`#name` definitions), local states, `@keyframes`, and `@properties`.
-     *
-     * Components reference recipes via: `recipe: 'name1, name2'` in their styles.
-     * Recipes are resolved before the style pipeline by merging in order:
-     * `recipe_1 → recipe_2 → ... → component styles`.
-     *
-     * Recipes cannot reference other recipes.
-     *
-     * @example
-     * ```ts
-     * configure({
-     *   recipes: {
-     *     card: { padding: '4x', fill: '#surface', radius: '1r', border: true },
-     *     elevated: { shadow: '2x 2x 4x #shadow' },
-     *   },
-     * });
-     *
-     * // Usage in styles:
-     * const Card = tasty({
-     *   styles: {
-     *     recipe: 'card, elevated',
-     *     color: '#text', // Overrides recipe values
-     *   },
-     * });
-     * ```
-     */
-    recipes?: Record<string, RecipeStyles>;
-}
-/**
- * Internal properties required by tasty core features.
- * These are always injected when styles are first generated.
- * Keys use tasty token syntax (#name for colors, $name for other properties).
- */
-export declare const INTERNAL_PROPERTIES: Record<string, PropertyDefinition>;
-declare const GLOBAL_INJECTOR_KEY = "__TASTY_GLOBAL_INJECTOR__";
-declare global {
-    interface Window {
-        [GLOBAL_INJECTOR_KEY]?: import('./injector/injector').StyleInjector;
-    }
-}
-/**
- * Detect if we're running in a test environment
- */
-export declare function isTestEnvironment(): boolean;
-/**
- * Mark that styles have been generated (called by injector on first inject)
- * This locks the configuration - no further changes allowed.
- * Also injects internal and global properties.
- */
-export declare function markStylesGenerated(): void;
-/**
- * Check if styles have been generated (configuration is locked)
- */
-export declare function hasStylesGenerated(): boolean;
-/**
- * Reset styles generated flag (for testing only)
- */
-export declare function resetStylesGenerated(): void;
-/**
- * Check if any global keyframes are configured.
- * Fast path: returns false if no keyframes were ever set.
- */
-export declare function hasGlobalKeyframes(): boolean;
-/**
- * Get global keyframes configuration.
- * Returns null if no keyframes configured (fast path for zero-overhead).
- */
-export declare function getGlobalKeyframes(): Record<string, KeyframesSteps> | null;
-/**
- * Check if any global properties are configured.
- * Fast path: returns false if no properties were ever set.
- */
-export declare function hasGlobalProperties(): boolean;
-/**
- * Get global properties configuration.
- * Returns null if no properties configured (fast path for zero-overhead).
- */
-export declare function getGlobalProperties(): Record<string, PropertyDefinition> | null;
-/**
- * Check if any global recipes are configured.
- * Fast path: returns false if no recipes were ever set.
- */
-export declare function hasGlobalRecipes(): boolean;
-/**
- * Get global recipes configuration.
- * Returns null if no recipes configured (fast path for zero-overhead).
- */
-export declare function getGlobalRecipes(): Record<string, RecipeStyles> | null;
-/**
- * Check if configuration is locked (styles have been generated)
- */
-export declare function isConfigLocked(): boolean;
-/**
- * Configure the Tasty style system.
- *
- * Must be called BEFORE any styles are generated (before first render that uses tasty).
- * After styles are generated, configuration is locked and calls to configure() will
- * emit a warning and be ignored.
- *
- * @example
- * ```ts
- * import { configure } from '@cube-dev/ui-kit';
- *
- * // Configure before app renders
- * configure({
- *   nonce: 'abc123',
- *   states: {
- *     '@mobile': '@media(w < 768px)',
- *     '@dark': '@root(theme=dark)',
- *   },
- * });
- * ```
- */
-export declare function configure(config?: Partial<TastyConfig>): void;
-/**
- * Get the current configuration.
- * If not configured, returns default configuration.
- */
-export declare function getConfig(): TastyConfig;
-/**
- * Get the global injector instance.
- * Auto-configures with defaults if not already configured.
- */
-export declare function getGlobalInjector(): import('./injector/injector').StyleInjector;
-/**
- * Reset configuration (for testing only).
- * Clears the global injector and allows reconfiguration.
- */
-export declare function resetConfig(): void;
-export type { TastyConfig as StyleInjectorConfig };

package/types/tasty/debug.d.ts

@@ -1,196 +0,0 @@
-/**
- * Debug utilities for inspecting tasty-generated CSS at runtime
- */
-type CSSTarget = 'all' | 'global' | 'active' | 'unused' | 'page' | string | string[] | Element;
-interface CssOptions {
-    root?: Document | ShadowRoot;
-    prettify?: boolean;
-    log?: boolean;
-}
-interface ChunkInfo {
-    className: string;
-    chunkName: string | null;
-}
-interface InspectResult {
-    element?: Element | null;
-    classes: string[];
-    chunks: ChunkInfo[];
-    css: string;
-    size: number;
-    rules: number;
-}
-interface CacheMetrics {
-    hits: number;
-    misses: number;
-    bulkCleanups: number;
-    totalInsertions: number;
-    totalUnused: number;
-    stylesCleanedUp: number;
-    cleanupHistory: Array<{
-        timestamp: number;
-        classesDeleted: number;
-        cssSize: number;
-        rulesDeleted: number;
-    }>;
-    startTime: number;
-    unusedHits?: number;
-}
-interface CacheStatus {
-    classes: {
-        active: string[];
-        unused: string[];
-        all: string[];
-    };
-    metrics: CacheMetrics | null;
-}
-interface Definitions {
-    properties: string[];
-    keyframes: Array<{
-        name: string;
-        refCount: number;
-    }>;
-}
-interface SummaryOptions {
-    root?: Document | ShadowRoot;
-    log?: boolean;
-    includePageCSS?: false | true | 'all';
-}
-interface Summary {
-    activeClasses: string[];
-    unusedClasses: string[];
-    totalStyledClasses: string[];
-    activeCSSSize: number;
-    unusedCSSSize: number;
-    globalCSSSize: number;
-    rawCSSSize: number;
-    keyframesCSSSize: number;
-    propertyCSSSize: number;
-    totalCSSSize: number;
-    activeCSS: string;
-    unusedCSS: string;
-    globalCSS: string;
-    rawCSS: string;
-    keyframesCSS: string;
-    propertyCSS: string;
-    allCSS: string;
-    globalRuleCount: number;
-    rawRuleCount: number;
-    keyframesRuleCount: number;
-    propertyRuleCount: number;
-    page?: {
-        css?: string;
-        cssSize: number;
-        ruleCount: number;
-        stylesheetCount: number;
-        skippedStylesheets: number;
-    };
-    metrics: CacheMetrics | null;
-    definedProperties: string[];
-    definedKeyframes: Array<{
-        name: string;
-        refCount: number;
-    }>;
-    propertyCount: number;
-    keyframeCount: number;
-    cleanupSummary: {
-        enabled: boolean;
-        totalCleanups: number;
-        totalClassesDeleted: number;
-        totalCssDeleted: number;
-        totalRulesDeleted: number;
-        averageClassesPerCleanup: number;
-        averageCssPerCleanup: number;
-        averageRulesPerCleanup: number;
-        lastCleanup?: {
-            timestamp: number;
-            date: string;
-            classesDeleted: number;
-            cssSize: number;
-            rulesDeleted: number;
-        };
-    };
-    chunkBreakdown: {
-        byChunk: Record<string, {
-            classes: string[];
-            cssSize: number;
-            ruleCount: number;
-        }>;
-        totalChunkTypes: number;
-    };
-}
-/**
- * Concise tastyDebug API for inspecting styles at runtime
- */
-export declare const tastyDebug: {
-    css(target: CSSTarget, opts?: CssOptions): string;
-    inspect(target: string | Element, opts?: {
-        root?: Document | ShadowRoot;
-    }): InspectResult;
-    cache(opts?: {
-        root?: Document | ShadowRoot;
-        includeHistory?: boolean;
-    }): CacheStatus;
-    cleanup(opts?: {
-        root?: Document | ShadowRoot;
-    }): void;
-    metrics(opts?: {
-        root?: Document | ShadowRoot;
-    }): CacheMetrics | null;
-    resetMetrics(opts?: {
-        root?: Document | ShadowRoot;
-    }): void;
-    /**
-     * Get breakdown of styles by chunk type.
-     *
-     * With style chunking enabled, styles are split into logical chunks
-     * (appearance, font, dimension, container, etc.) for better caching
-     * and CSS reuse.
-     *
-     * @param opts - Options including root document/shadow root
-     * @returns Breakdown by chunk type with class counts and CSS sizes
-     */
-    chunks(opts?: {
-        root?: Document | ShadowRoot;
-        log?: boolean;
-    }): {
-        byChunk: Record<string, {
-            classes: string[];
-            cssSize: number;
-            ruleCount: number;
-        }>;
-        totalChunkTypes: number;
-        totalClasses: number;
-    };
-    getGlobalTypeCSS(type: "global" | "raw" | "keyframes" | "property", opts?: {
-        root?: Document | ShadowRoot;
-    }): {
-        css: string;
-        ruleCount: number;
-        size: number;
-    };
-    defs(opts?: {
-        root?: Document | ShadowRoot;
-    }): Definitions;
-    summary(opts?: SummaryOptions): Summary;
-    pageCSS(opts?: {
-        root?: Document | ShadowRoot;
-        prettify?: boolean;
-        log?: boolean;
-        includeCrossOrigin?: boolean;
-    }): string;
-    pageStats(opts?: {
-        root?: Document | ShadowRoot;
-        includeCrossOrigin?: boolean;
-    }): {
-        cssSize: number;
-        ruleCount: number;
-        stylesheetCount: number;
-        skippedStylesheets: number;
-    };
-    install(): void;
-    log(target: CSSTarget, opts?: CssOptions & {
-        title?: string;
-    }): void;
-    help(): void;
-};
-export {};