api #

Acorn plugin type - a function that extends the Parser class.

All modifier names for quick lookup

Map of ancestor modifier names to their CSS output

Pattern for arbitrary max-width breakpoints: max-width(600px):

Pattern for arbitrary min-width breakpoints: min-width(800px):

Array - all elements extracted

Base diagnostic with common fields.

Cached extraction result for a single file. Uses null instead of empty arrays to avoid allocation overhead.

Checks if a value contains a possibly invalid calc expression.

Computes SHA-256 hash of content using Web Crypto API.

Converts a InterpreterDiagnostic to a GenerationDiagnostic with locations.

All built-in CSS class definitions (token classes + composites).

Collection of all builtin interpreters for dynamic CSS class generation. Order matters: modified_class_interpreter runs first to handle hover:box before css_literal_interpreter tries to interpret it as hover:box (property:value).

Interpreter for CSS-literal classes (e.g., display:flex, hover:opacity:80%). Generates full CSS rulesets including any modifier wrappers.

Full union including interpreters.

Pure utility composition (composes only).

Custom CSS declaration (optionally seeded with composes).

Interpreter for dynamic CSS class generation based on pattern matching.

Full ruleset with selectors.

Static definitions (not interpreter-based).

Collection of CSS classes extracted from source files. Tracks classes per-file for efficient incremental updates. Handles include/exclude filtering and explicit class tracking. Uses null instead of empty collections to avoid allocation overhead.

Context passed to CSS class interpreters. Provides access to logging, diagnostics collection, and the class registry.

Error thrown when CSS generation encounters errors or warnings (depending on on_error and on_warning settings). Contains the full diagnostics array for programmatic access.

Information needed to generate CSS output for a CSS-literal class.

Result of parsing a CSS-literal class name.

Uses a discriminated union (Result type) because parsing a single class is binary: it either succeeds or fails entirely. This differs from which uses embedded diagnostics because file extraction can partially succeed (some classes extracted, others have errors).

Uses | null for diagnostics to avoid allocating empty arrays. Callers should use a guard pattern: if (result.diagnostics) { ... }

Default cache directory relative to project root.

These are super basic proof-of-concept themes.

These are implicitly the variables for the base theme. See also the empty variables array of the base theme above.

Deletes a cached extraction file. Silently succeeds if the file doesn't exist.

*_class suffix (snake_case)

SCREAMING_SNAKE_CASE naming

*class_list suffix (snake_case)

*class_lists suffix (snake_case) - plural, multiple classes

*class_name suffix (snake_case)

*class_names suffix (snake_case) - plural, multiple classes

*_classes suffix (snake_case) - plural, multiple classes

*Class suffix (camelCase)

*Classes suffix (camelCase) - plural, multiple classes

*ClassList suffix (camelCase)

*ClassLists suffix (camelCase) - plural, multiple classes

*ClassName suffix (camelCase)

*ClassNames suffix (camelCase) - plural, multiple classes

Union of all diagnostic types.

Escapes special characters in a CSS class name for use in a selector. CSS selectors require escaping of characters like :, %, (, ), etc.

Extracts and validates modifiers from the beginning of a segments array. Modifiers are consumed from the front until a non-modifier segment is found.

Used by both CSS-literal parsing and modified class interpretation.

Unified extraction function that auto-detects file type. Returns just the class names as a Set.

Unified extraction function that auto-detects file type. Returns full extraction result with locations and diagnostics.

Extracts the CSS comment from a ruleset (if any). Looks for comments before the first rule.

Extracts CSS classes from a Svelte file using AST parsing.

Extracts CSS classes from a TypeScript/JS file using AST parsing.

Extracts colon-separated segments from a class name, handling parentheses. Parenthesized content (like function arguments) is kept intact.

Options for CSS class extraction.

Extracted modifiers from a class name. Used by both CSS-literal parsing and modified class interpretation.

Diagnostic from the extraction phase.

Extraction result with classes mapped to their source locations. Uses null instead of empty collections to avoid allocation overhead.

Uses embedded diagnostics (rather than a Result type) because file extraction can partially succeed: some classes may be extracted while others produce errors. This differs from which uses a discriminated union because single-class parsing is binary success/failure.

Filter function to determine which files to process for CSS class extraction.

Default file filter for CSS class extraction. Includes .svelte, .html, .ts, .js, .tsx, .jsx files. Excludes test files and generated files.

Finds the end position of the compound selector containing the class at class_pos. A compound selector is a sequence of simple selectors without combinators.

Formats a CSS-literal value for CSS output. - Replaces ~ with space - Ensures space before !important

Formats a diagnostic for display.

Format width/height values for CSS (handles 0, auto, percentages, pixels, content values, and CSS variables). Used by width and height properties.

Format spacing values for CSS (handles 0, auto, percentages, pixels, and CSS variables). Used by margin, padding, gap, inset, top/right/bottom/left, etc.

Converts a cached extraction back to the runtime format. Preserves null semantics (null = empty).

Comment hint - extracted via

Marker comment used to delimit generated CSS in the output.

Generate border radius corner classes for all four corners. Creates classes for top-left, top-right, bottom-left, bottom-right corners.

Generates CSS class declarations from templates. Supports up to 3 dimensions of multiplicative combinations.

Generates simple CSS for a CSS-literal class (without grouping). Used by the interpreter for basic output.

Generates the CSS declaration for a parsed CSS-literal class.

Generate directional classes for properties like margin and padding. Creates classes for all directions: base, top, right, bottom, left, x (horizontal), y (vertical).

Generates CSS for a modified ruleset with applied modifiers.

Conflict handling is per-selector within selector lists: - For .plain:hover, .plain:active with hover: modifier, only .plain:hover skips the :hover addition; .plain:active still gets :hover appended. - For multiple states like :hover:focus, each is checked individually; conflicting states are skipped while non-conflicting ones are still applied.

Generate classes for a single CSS property with various values.

Generates the CSS selector for a parsed CSS-literal class. Includes state pseudo-classes and pseudo-element in the selector.

Generate shadow classes for various shadow types and sizes. Creates classes for regular, top, bottom, inset, inset-top, and inset-bottom shadows. Each shadow uses color-mix with alpha values for transparency.

Result from CSS class generation.

Diagnostic from the generation phase.

Gets all modifier names for error message suggestions.

Computes the cache file path for a source file. Cache structure mirrors source tree: src/lib/Foo.svelte → .fuz/cache/css/src/lib/Foo.svelte.json

Gets the modifier definition for a segment. Handles both static modifiers and dynamic patterns (arbitrary breakpoints, parameterized states).

Checks if extracted modifiers contain any modifier. Useful for tooling that needs to detect modified classes.

Checks if a parsed CSS literal has any modifiers.

Interprets a CSS-literal class and returns CSS generation info.

Callers should first check is_possible_css_literal() to filter non-CSS-literal classes.

Result of interpreting a CSS-literal class.

Uses | null for warnings to avoid allocating empty arrays. Callers should use a guard pattern: if (result.warnings) { ... }

Diagnostic from CSS class interpretation. Used internally by interpreters; converted to GenerationDiagnostic with locations.

Checks if a class name could be a CSS-literal class. Quick check before attempting full parse.

Checks if a ruleset has only a single simple selector (just the class name). Used to detect rulesets that could be converted to declaration format.

Checks if a property name is a valid CSS property. Custom properties (--*) always return true.