How far in degrees the accent hue has to sit from each status hue before validate_theme stops warning. At the chroma links and labels render at, 12 degrees reads as one color with a shift (a red accent beside the default orange caution) while 30 reads as two (a pink accent beside the default red negative), so the threshold sits between them. The defaults' closest accent and status pair, blue and cyan, is 40 degrees apart.

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

Overlays a baked theme onto a resolved variable set, last-wins by name.

This is how a theme is baked in at build time: the overlaid values flow through the dependency graph like any other, so the variables a theme references are pulled in transitively and the output stays tree-shaken. The overlay follows render_theme_style's order - the stance mirror (minus the names the theme or its caps set), then the theme's own variables (minus any internal name, which a theme can't set), then the caps. A slot the stylesheet can't hold is dropped before it overlays, as render_theme_style drops it, so the value beneath it stays.

Array - all elements extracted

Derives what a build-time theme renders with from the configured variable set: the stance mirror, re-slotted from the configured variables (so a build that customizes a scheme-adaptive variable mirrors its own value, not the default), and the caps compute_theme_caps recomputes for the theme's hues and lightness - the derived half of compile_theme. A ResolvedTheme passed in has its theme baked the same way - a supplied mirror or caps are recomputed, so the output can't depend on derived data computed against another variable set or an older release.

The theme's variables pass the containment checks first, as build_variable_graph applies them: a slot the stylesheet can't hold, or an entry without a plain-identifier name, is reported as an uncontained_theme_value error and left out, and the caps, the gates, and the overlay all see the contained theme - what renders.

The caps and the gates measure the theme over the configured set: a knob-tier value (theme_knobs) the configured variables change from the default is folded in beneath the theme's own, re-slotted for a stance as the mirror re-slots it, so a build that retunes a ramp knob is capped and gated at what it renders. A configured value the gates can't read lands in unchecked.

The gates (check_theme with the caps) report as warnings, since a theme can knowingly give up a gate: theme_gate_failed lists the failing gate entries and theme_gate_unchecked the inputs the gates couldn't evaluate. A stanced theme renders its one appearance in both schemes, so only the stanced scheme's entries are listed. The lint (validate_theme) runs over the contained theme, so a slot reported as uncontained isn't reported again: each issue is a theme_lint diagnostic at the issue's level, so an unknown variable fails a build that throws on errors.

The default theme - inherits every base default variable.

Type for the base_css option used by the generator.

Supports four forms:

• undefined - Use default style.css (framework defaults)
• null - Disable base styles entirely (explicit opt-out)
• string - Custom CSS to replace defaults
• (default_css) => string - Callback to modify default CSS

See module documentation for the undefined vs null convention, and CssOutputOptions.base_css for what the generator does with the stylesheet.

Base diagnostic with common fields.

The border family's chroma as a multiple of --neutral_chroma - borders carry a stronger tint than surfaces so they read at low alpha. In CSS this is --border_color_chroma: calc(var(--neutral_chroma) * <multiple>).

Alpha (in %) of each border color stop. A perceptually-uniform curve - small gaps at the low end, large at the high end - boosted at the low end in dark mode where borders are less visible against dark backgrounds. Stop 00 renders transparent and stop 100 opaque.

OKLCH lightness of the border color family (--border_color_lightness), fitted from the HSL palette. Sits mid-ramp so borders read against both the page background and fills.

Computes the default OKLCH color of the border family (without alpha).

Border radii in rem, before the --radius_scale multiplier.

Builds a dependency graph from an array of style variables.

The graph is what the bundled theme CSS renders from, verbatim, so it applies the containment checks render_theme_style does: a slot whose value could end its own declaration (or is blank), or a variable whose name isn't a plain identifier, is left out and reported as an uncontained_theme_value error rather than written into the stylesheet.

Builds a variable dependency graph from a variables option, with a build-time theme baked in through bake_theme. Handles all option forms: undefined (defaults), null (disabled), array, or callback.

Bundled CSS resources needed to emit base styles and theme variables. Build via create_bundled_resources; pass null for utility-only output.

Cache-related file system deps. Abstracted to enable test isolation from the actual filesystem.

Named CacheDeps (not FsDeps) because it only covers the specific deps needed for cache management, not general filesystem access.

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.

Runs the gamut, monotonicity, and contrast gates against a theme, resolving its authored CSS back to numbers through the resolution core. Report-only: failures land in entries (with pass: false), inputs that can't be evaluated land in unchecked, and ok is true only when every entry passes and nothing is unchecked. Never throws.

Every color a gate reads is looked up by its variable name, so a theme that authors one directly - a stop (palette_a_50, shade_00, text_max, border_color_30) or a role (text_color, link_color, border_color) - is measured at the authored color when it is an oklch(L C H) numeric literal or an exact var() reference to another color the gates evaluate, and recorded in unchecked otherwise. An authored color a gate depends on never passes unread, and one no gate reads stays out of the report.

A contrast subject names what was measured: the default stop while a role is at its default (text_80 on shade_00), the role once the theme authors it (text_color on shade_00).

An intent stop that renders the same color as a palette letter's (the default for every intent) folds into that letter's gamut entry rather than duplicating it, so reports for letter-bound themes list fewer subjects than the full letters × intents grid.

Matches the capped form render_chroma_stop_css emits, capturing the stop and the cap - how the resolver reads a compiled cap back, and how the Theme schema admits the one intermediate a theme can carry (see StyleVariable). It admits CSS whitespace only, around the value and inside it, so a match needs no trim() (which, like \s, takes U+00A0).

Knobs for the symmetric mid-peaked chroma curve, C(t) = min + (max - min) * pow(4t(1-t), curve). The curve expresses the *request*; rendered stops are clamped by PALETTE_CHROMA_CAPS per stop, and --chroma_scale multiplies above the clamp (so vivid themes can knowingly push past the caps and gamut-clip).

Type for the class_definitions option used by the generator.

Supports three forms:

• undefined - Use the default token and composite classes
• Record - Definitions merged over the defaults (a definition with a default's name replaces it)
• (defaults) => Record - Callback returning the whole set, which receives a copy of the defaults; () => my_definitions uses only your own

Type for the class_interpreters option used by the generator.

Supports three forms:

• undefined - Use the default interpreters (the CSS-literal interpreter)
• Array<CssClassDefinitionInterpreter> - Interpreters replacing the defaults
• (defaults) => Array<CssClassDefinitionInterpreter> - Callback returning the interpreters to use, which receives a copy of the defaults

Collects all CSS variables used by the included rules.

The root selectors that put a page in each color scheme: explicit names the scheme with a class on the root element (fuz_ui's theme state sets one), and preferred holds while the root names neither scheme, so the page follows the OS preference without JS.

Orders media modifiers for emission, so the later rule wins where two apply: none first, then min width bounds ascending, then max width bounds descending, then feature queries in registration order. Width values that can't be compared statically sort after the comparable ones of their bound, by value.

Compiles a theme: computes its stance mirror and its recomputed chroma caps (compute_theme_caps), re-checks the gates with the caps, and lints it. The theme comes back as the same reference and never carries the derived data, so compiling the same theme again gives the same result.

The output of compile_theme: the input theme with everything derived from it - the stance mirror and the recomputed caps - plus the gate report and lint over that rendering. Renders as render_theme_style(c.theme, c).

Composes a base theme with overlay fragments by flatten + last-wins: later variables replace same-named earlier ones wholesale, a dark-only overlay keeping the base slot beneath it (see overlay_style_variable). Any knob-only theme is already a valid fragment - the contrast modifiers in contrast_modifiers are the canonical overlays. This is the hand-flatten precursor to a first-class extends, with the same merge semantics.

The base's scheme stance wins; when the base is single-scheme, each overlay variable is re-slotted to the stanced scheme's value so a dual-slot fragment can't leak the other scheme's appearance past the stance. The result is a plain theme like its inputs - resolve it to render a stance faithfully. The composed name appends the overlay names so name-keyed pickers and renderers treat the composition as its own theme, and the base's summary carries through.

Recomputes a theme's per-stop worst-hue chroma caps from its own hues and the palette lightness each stop resolves to, then returns _palette_chroma_NN caps wherever the baked ones no longer fit - the fix for a theme (rotated hues, a monochrome collapse, a moved lightness ramp) whose gamut headroom the baked worst-hue table misjudges. The caps are derived data beside the theme, never in it: a theme can't set an internal variable, so they render through render_theme_style's caps option and recomputing them for the same theme gives the same caps.

Each stop's cap is computed at the lightness the resolution core resolves for the stop in that scheme - the theme's endpoint-and-curve ramp - so the caps describe the same colors check_theme gates.

A stop is emitted when either scheme's recomputed cap is tighter than the baked value, or looser by more than the emit epsilon. Nothing is emitted when a hue fails to resolve to a number, since caps computed without it could overshoot its gamut, and a stop whose lightness fails to resolve is skipped. An override emits both slots together, so a one-scheme override can't silently kill the base default's other slot by cascade-layer order, collapsing to a single slot in the base position when the two rendered values coincide.

A stanced theme's two schemes resolve to the stanced appearance through the mirror, so its caps are baselined against the stanced scheme's baked table - the values the mirror already re-slots - and a stance alone (hues and lightness unmoved) emits nothing. Its overrides coincide across schemes and emit single-slot unless the theme authors a dark slot that splits them.

The caps bound the requested chroma only: chroma_scale and the per-slot *_chroma_scale multipliers apply above the clamp. A theme that raises one past 1 clips by design - its gamut failures survive the compile, and a cap the compile loosens can add to them, since the multiplier then pushes more stops past the looser cap. Gate the theme with them through check_theme(theme, {caps}).

Computes the worst-hue safe chroma cap at one lightness: the minimum oklch_max_srgb_chroma across the hues, floored to 4 decimals to stay conservative (the browser clips anything past it). The generalization of the baked PALETTE_CHROMA_CAPS to an arbitrary hue set and lightness - a theme's compile step calls it with each stop's own resolved lightness to detect where the baked worst-hue envelope no longer fits.

The contrast modifiers: small axis fragments composed over any theme via compose_themes rather than picked as themes themselves. Composition is flatten + last-wins, so a modifier's variables replace the base theme's same-named ones - a base that moves the same knobs cedes them to the modifier. Both move the shade endpoint (shade_lightness_00), since contrast is the ground-to-text range, so a theme whose identity is its ground yields it. High contrast also bends the text curve (text_lightness_curve) and sets border_color to a stop that holds a control's boundary against a ground its fill can no longer separate from

• a base with its own border_color cedes it like any other variable,

stronger rules included. Neither touches the neutral cast, which stays the theme's.

Reasons a rule is considered "core" and always included. conditional_core marks a conditional group rule (@media, @supports, @container) that contains something which always ships on its own - a core rule or an at_rule. at_rule marks every at-rule that is not a conditional group (@keyframes, @font-face, @property, @scope, ...): detection has no way to tell whether one is used, so it ships as written. untargetable marks rules with a selector the index can't match - one that names no element or class at all (pseudo-element or attribute selectors like ::selection and [hidden]), or one with an escaped or non-ASCII identifier (.md\:flex, .café) - so tree-shaking would drop them whether or not the project uses them.

A core style rule that is always included in output.

Builds the bundled CSS resources from generator options. The style-rule index is always built, even when only theme output is enabled - from the default style.css unless base_css supplies a stylesheet.

Creates the extraction cache-path lookup: a file's cache path under cache_dir in project_root, or null on CI, where nothing is cached.

Creates the core a generator renders through.

Creates the diagnostic dispatch a generator runs after each render: a diagnostic level set to 'throw' fails the render with a CssGenerationError, and the rest are logged to sink - except that a message the previous dispatch already logged isn't logged again.

A render reports every file's diagnostics, so a dev server or watch mode re-rendering on each edit would otherwise repeat every warning in the project on every change. A diagnostic that goes away and comes back is logged again.

Converts an InterpreterDiagnostic to a GenerationDiagnostic with locations.

Creates a StyleRuleIndex from the stylesheet a base_css option supplies, reporting a value that can't be parsed as a base_css problem.

Creates a ThemeKnobResolver for theme, sharing the resolution core used by validate_theme/check_theme/compile_theme. The instance memoizes per name+scheme, so repeated lookups (a UI rendering every knob) stay cheap - create one per theme value and discard when the theme changes.

The builtin composite classes. The multi-property ones render in the fuz.utilities.composites sublayer (composite: true, the default for rulesets), so a token or literal class on the same element wins over them; the single-property shortcuts (circular, pixelated, mb_flow, mt_flow) are single-purpose and order with the token classes. Their forced-colors rules nest inside their own rules (`@media (forced-colors: active)`), so a modified variant keeps them conditional, and a browser without CSS nesting, which also has no forced-colors mode, skips them.

All built-in CSS class definitions (composites, keyword classes, and token classes).

Collection of all builtin interpreters for dynamic CSS class generation. Modifier handling isn't an interpreter - the generator strips modifiers from every class name and applies them to whatever the base resolves to.

The keyword classes, plus hidden. Spread into css_class_definitions.

Checks that text can sit inside a CSS comment without closing it.

Checks that a custom property name is a plain identifier - word characters, hyphens, and non-ASCII (--aé, --Δx) - so it can't smuggle a value or a second declaration in with it.

Interpreter for CSS-literal classes (e.g., display:flex, opacity:80%). Modifiers (hover:opacity:80%) are stripped by the generator before an interpreter runs, so a literal reaching it is exactly property:value.

A CSS <number> as a pattern source, stricter than what Number() accepts - no hex, binary, Infinity, or empty string.

Checks that a declaration value can't end its own declaration or rule: quotes and brackets balance, and nothing outside a string closes the declaration (a top-level ;), opens or closes a block, sets !important, opens a comment, or escapes a character. Stricter than the grammar where that keeps the rule simple - braces, comments, and escapes outside strings are rejected outright, as is an unquoted url( whose contents a quoted one would hold, so quote a URL that needs them.

Options for cache behavior.

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.

An interpreter sees a class name with its modifiers already stripped - md:hover:grid-cols-4 reaches it as grid-cols-4 - and returns a definition like a static one, so modifiers, ordering, and layering apply to what it returns the same as to a static class. A ruleset names the class it was given; the generator renames it to the full modified class. What an interpreter returns renders verbatim, so containing values built from class names found in markup is the interpreter's job.

Leading segments named like modifiers are stripped greedily, and the generator backs off one at a time, so an interpreter is offered the shortest base first: marker:none arrives as none before the full literal, since marker is also a pseudo-element modifier (cue likewise). A broad pattern shouldn't claim such a sub-base.

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.

Options for CSS class definitions and interpretation. Controls how classes are defined and how dynamic classes are generated.

A utility class resolved to the rule it renders, before it's written as CSS - what generate_classes_css orders, groups, and layers.

What a class rule renders: a declaration block on the class selector, a set of rules with their selectors already rewritten for the class and its state and pseudo-element modifiers, or an unmodified ruleset as written (which may hold at-rules of its own).

Options for error and warning handling.

Options for CSS class extraction from source files. Controls which files to scan and how to parse them.

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.

A generator's shared core - see create_css_generator.

The combined options the generator core reads, which VitePluginFuzCssOptions extends.

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 ExtractionResult 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) { ... }

Options for CSS output generation (theme + base + utilities). Controls how the three CSS layers are combined.

What one render reads: the classes extracted so far and the var() names scanned from source.

Options for CSS resolution.

Result from CSS resolution.

Default filesystem deps using node:fs/promises.

Default cache directory relative to project root.

The curated theme registry that theme pickers enumerate.

Registry themes are semantic-tier by policy: they move intent bindings (which palette letter a meaning points at) and levers (chroma scale, curves, form knobs) but never the palette hues themselves, so the letters stay a stable vocabulary across every registered theme.

Themes live one module per theme under themes/ and every module ships as an importable export - registry membership, not file location, is what separates registered themes from shipped exemplars. The registry holds the plain working themes: the base and themes/ledger.ts (compact, cool, for tools used all day).

The exemplars deliberately stay out of this list. Each takes one channel to carry the structure and quiets the rest, and is named for the artifact that already looks that way: themes/zine.ts (line and weight), themes/pebble.ts (depth and softness), themes/parchment.ts (type and ruling), themes/phosphor.ts (packing, dark-only), themes/guestbook.ts (controls as beveled objects), themes/marquee.ts (color, dark-only and the one palette-tier exemplar), and themes/signage.ts (scale and weight, for legibility).

Contrast is not a theme: the low/high contrast pair are modifiers (contrast_modifiers) composed over any theme with compose_themes.

These are implicitly the variables for the base theme. See also the empty variables array of the base theme in themes/base.ts.

Deletes a cached extraction file. Best-effort: every unlink error is swallowed, not just not_found - the cache is disposable and callers delete fire-and-forget.

*_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.

How generation diagnostics are handled - see CssDiagnosticsOptions.

Where a dispatcher writes the diagnostics it logs.

The display keywords with a class: the inside formatting contexts and the legacy inline forms, plus block.

Layout distances in px - breakpoint-ish widths, insensitive to font size.

Transition durations in seconds, from a UI beat to a slow ambient sweep.

Serializes a string as a CSS identifier, so any string can name an element id in a selector ('#' + escape_css_identifier(id) matches the element whose id attribute is that string). Follows the CSSOM identifier serialization, except that ASCII punctuation is escaped by code point (\3c ) rather than with a bare backslash, since \</style still closes a <style> element - the output can't end its rule or its element.

Escapes special characters in a CSS class name for use in a selector. ASCII punctuation like :, %, (, and ) takes a bare backslash, as does a space, which would otherwise split the selector in two; a leading digit (also after a leading -) and control characters take a hex escape, since neither is valid there as written, and NUL becomes U+FFFD.

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.

Extracts content from balanced parentheses after a prefix. Supports nested parens for calc(), clamp(), min(), max(), etc.