@yahoo/uds-v5-wip 1.61.0 → 1.62.0

package/dist/config/dist/resolveStyleProp.js

@@ -1,260 +0,0 @@
-import { isTokenAcceptedByProperty } from "./propertyAcceptedTypes.js";
-import { safeTokenName } from "../../utils/dist/string-utils/cssVar.js";
-import "../../utils/dist/index.js";
-import { resolveTokenValue } from "./refs.js";
-import { sniffTokenTypeFromValue } from "./sniffTokenType.js";
-//#region ../config/dist/resolveStyleProp.js
-/**
-* Resolve a {@link StyleProp} authored via `defineStyleProp` against the
-* active UDS config, producing a flat list of accepted tokens, literal
-* keywords, and the arbitrary spec — the data that downstream codegen
-* consumes to populate `Custom*` interfaces and emit utility CSS.
-*
-* Filtering invariant: a token is exposed in the resolved pool only when
-* its detected CSS value type is accepted by the prop's `cssProperty`,
-* per {@link PROPERTY_ACCEPTED_TYPES}. Properties absent from that table
-* accept every token.
-*
-* The resolver is pure — given the same `(StyleProp, UdsConfigData)` input
-* it returns the same output. Group lookups are by `namespace` (with a
-* fallback to `cssPrefix`) on the resolved config's `atomic` array.
-*/
-/**
-* Map the legacy 8-entry `TokenType` enum to a {@link CssValueTypeName}.
-* The `'dimension'` case is ambiguous (length vs. percentage); callers
-* disambiguate by sniffing the value string.
-*/
-function tokenTypeToValueType(t) {
-	switch (t) {
-		case "color": return "color";
-		case "dimension": return "length-percentage";
-		case "number": return "number";
-		case "fontFamily": return "font-family";
-		case "fontWeight": return "font-weight";
-		case "duration": return "time";
-		case "strokeStyle": return "string";
-		case "string": return "string";
-		default: return;
-	}
-}
-/**
-* A value looks like a CSS shadow when it combines at least one length
-* (offset/blur/spread) with a color reference. Catches both single-shadow
-* (`'0 1px 2px rgba(...)'`) and multi-shadow (`'..., ...'`) forms, plus
-* inset shadows. Used to refine `'string'`-typed tokens to the more precise
-* `'shadow'` value type so they pass the runtime filter on `box-shadow` /
-* `text-shadow` props.
-*/
-const SHADOW_LENGTH_RE = /(?:^|[\s,])-?\d+(?:\.\d+)?(?:px|rem|em|ch|ex)/i;
-const SHADOW_COLOR_RE = /(?:rgba?|hsla?|color|oklch|oklab|lch|lab|hwb)\(|#[0-9a-fA-F]{3,8}\b/;
-function looksLikeShadow(value) {
-	const trimmed = value.trim();
-	return SHADOW_LENGTH_RE.test(trimmed) && SHADOW_COLOR_RE.test(trimmed);
-}
-/**
-* Detect a token's CSS value type. Resolution order:
-*  1. Per-token `type` override.
-*  2. Group-level `type`.
-*
-* When the resolved type is `'length-percentage'` and the raw value ends in
-* `%`, narrow to `'percentage'`; otherwise narrow to `'length'`. When the
-* resolved type is `'string'`, narrow shadow-like values to `'shadow'` and
-* ratio-shaped values to `'ratio'`.
-*
-* Exported so Studio (and any other runtime consumer) can resolve a cell's
-* effective `CssValueTypeName`.
-*
-* The input shapes ({@link DetectTokenValueTypeInput} /
-* {@link DetectTokenValueTypeGroup}) are intentionally minimal: the resolver
-* reads only `token.value`, `token.type`, and `group.type` — never walks
-* `group.tokens`, never checks that `token` is inside `group`. Typing them
-* as full `AtomicToken` would force trimmed-shape consumers (Studio's
-* `TokenEntry`) to either round-trip back to the source group or `as`-assert
-* past the type system.
-*/
-function detectTokenValueType(token, group) {
-	let resolved;
-	if (token.type) resolved = tokenTypeToValueType(token.type);
-	else {
-		const sniffed = sniffTokenTypeFromValue(token.value);
-		resolved = sniffed ? tokenTypeToValueType(sniffed) : void 0;
-		if (resolved === void 0 && group.type) resolved = tokenTypeToValueType(group.type);
-	}
-	if (resolved === "length-percentage") {
-		const trimmed = token.value.trim();
-		if (trimmed.endsWith("%")) return "percentage";
-		if (/(deg|rad|grad|turn)$/.test(trimmed)) return "angle";
-		if (/(ms|s)$/.test(trimmed)) return "time";
-		return "length";
-	}
-	if (resolved === "string") {
-		if (looksLikeShadow(token.value)) return "shadow";
-		if (/^\d+(?:\.\d+)?\s*\/\s*\d+(?:\.\d+)?$/.test(token.value.trim())) return "ratio";
-	}
-	return resolved;
-}
-/**
-* Split a `tokenGroup` marker's `group` field into `{ group, key? }`.
-* Plain `'spacing'` resolves the whole group; `'spacing/4'` picks one
-* token from it.
-*/
-function parseGroupPath(raw) {
-	const slash = raw.indexOf("/");
-	if (slash <= 0 || slash >= raw.length - 1) return { group: raw };
-	return {
-		group: raw.slice(0, slash),
-		key: raw.slice(slash + 1)
-	};
-}
-function findGroup(atomic, name) {
-	return atomic.find((g) => g.namespace === name || g.cssPrefix === name);
-}
-function isTokenGroupMarker(entry) {
-	return typeof entry === "object" && entry !== null && entry.__kind === "tokenGroup" && typeof entry.group === "string";
-}
-function isTokenMarker(entry) {
-	return typeof entry === "object" && entry !== null && entry.__kind === "token" && typeof entry.ref === "string";
-}
-/**
-* Build `--{configPrefix}-{varPrefix}-{safeName}` (or omit the configPrefix
-* when empty). Mirrors `buildTokenVarName` in `@uds/codegen/css/prepareCss`.
-*/
-function buildCssVar(configPrefix, varPrefix, safeName) {
-	return configPrefix ? `--${configPrefix}-${varPrefix}-${safeName}` : `--${varPrefix}-${safeName}`;
-}
-function resolveGroupTokens(group, cssProperty, configPrefix, namespace, skipPropertyFilter = false) {
-	const groupName = group.namespace ?? group.cssPrefix ?? "";
-	const varPrefix = group.cssPrefix ?? group.namespace ?? "";
-	const out = [];
-	for (const token of group.tokens) {
-		const tokenValue = resolveTokenValue(token.value, configPrefix);
-		const valueType = detectTokenValueType({
-			...token,
-			value: tokenValue
-		}, group);
-		if (!skipPropertyFilter && !isTokenAcceptedByProperty(cssProperty, valueType, tokenValue)) continue;
-		const safeName = safeTokenName(token.name);
-		out.push({
-			name: token.name,
-			value: tokenValue,
-			valueType,
-			group: groupName,
-			namespace,
-			qualifiedName: namespace !== void 0 ? `${namespace}.${token.name}` : token.name,
-			safeName,
-			cssVar: buildCssVar(configPrefix, varPrefix, safeName),
-			modifiers: token.modifiers
-		});
-	}
-	return out;
-}
-/**
-* Resolve a style prop against the given resolved UDS config. Unknown group
-* refs are silently dropped from `tokens` (callers can detect this by
-* comparing input refs vs. resolved tokens if they need to surface a
-* config-build warning).
-*
-* @param propName - The JSX prop name (the map key from `registerStyleProps`).
-*/
-function resolveStyleProp(propName, styleProp, config) {
-	const { cssProperty, classPrefix, values, arbitrary, metadata } = styleProp;
-	const transform = styleProp.transform;
-	const pairedWith = styleProp._pairedWith;
-	const separator = styleProp._separator;
-	const primaryCssProperty = Array.isArray(cssProperty) ? cssProperty[0] : cssProperty;
-	const configPrefix = config.prefix;
-	const tokens = [];
-	const literals = [];
-	const literalAliases = {};
-	for (const entry of values ?? []) {
-		if (typeof entry === "number") {
-			if (!literals.includes(entry)) literals.push(entry);
-			literalAliases[String(entry)] = transform ? transform(entry) : String(entry);
-			continue;
-		}
-		if (typeof entry === "string") {
-			literals.push(entry);
-			if (transform) literalAliases[entry] = transform(entry);
-			continue;
-		}
-		if (isTokenGroupMarker(entry)) {
-			const parsed = parseGroupPath(entry.group);
-			const group = findGroup(config.atomic, parsed.group);
-			if (!group) continue;
-			if (parsed.key !== void 0) {
-				const token = group.tokens.find((t) => t.name === parsed.key);
-				if (!token) continue;
-				const tokenValue = resolveTokenValue(token.value, configPrefix);
-				const valueType = detectTokenValueType({
-					...token,
-					value: tokenValue
-				}, group);
-				if (!pairedWith && !isTokenAcceptedByProperty(primaryCssProperty, valueType, tokenValue)) continue;
-				const safeName = safeTokenName(token.name);
-				const varPrefix = group.cssPrefix ?? group.namespace ?? parsed.group;
-				tokens.push({
-					name: token.name,
-					value: tokenValue,
-					valueType,
-					group: group.namespace ?? group.cssPrefix ?? parsed.group,
-					qualifiedName: token.name,
-					safeName,
-					cssVar: buildCssVar(configPrefix, varPrefix, safeName),
-					modifiers: token.modifiers
-				});
-			} else tokens.push(...resolveGroupTokens(group, primaryCssProperty, configPrefix, void 0, pairedWith !== void 0));
-			continue;
-		}
-		if (typeof entry === "object" && entry !== null && "ref" in entry && "namespace" in entry && isTokenGroupMarker(entry.ref)) {
-			const ns = entry.namespace;
-			const ref = entry.ref;
-			const group = findGroup(config.atomic, ref.group);
-			if (!group) continue;
-			tokens.push(...resolveGroupTokens(group, primaryCssProperty, configPrefix, ns, pairedWith !== void 0));
-			continue;
-		}
-		if (typeof entry === "object" && entry !== null && "alias" in entry && "value" in entry) {
-			const aliasEntry = entry;
-			const aliasKey = aliasEntry.alias;
-			const aliasMapKey = typeof aliasKey === "string" ? aliasKey : String(aliasKey);
-			let resolvedValue;
-			if (isTokenMarker(aliasEntry.value)) resolvedValue = resolveTokenValue(aliasEntry.value, configPrefix);
-			else if (typeof aliasEntry.value === "string") resolvedValue = aliasEntry.value;
-			else resolvedValue = aliasEntry.value;
-			if (!literals.includes(aliasKey)) literals.push(aliasKey);
-			literalAliases[aliasMapKey] = resolvedValue;
-		}
-	}
-	return {
-		propName,
-		cssProperty,
-		classPrefix,
-		...pairedWith !== void 0 ? {
-			pairedWith,
-			separator
-		} : {},
-		tokens,
-		literals,
-		...Object.keys(literalAliases).length > 0 ? { literalAliases } : {},
-		arbitrary,
-		metadata: metadata ?? {}
-	};
-}
-/**
-* Walk a resolved config's `resolvedStyleProps` and return the
-* color-prop → opacity-sibling-prop map. Built from each opacity
-* sibling's `pairedWith` field (set by the resolver when expanding a
-* `.withOpacity({ as })` parent). Returns an empty object when no
-* pairings exist.
-*
-* Replaces the legacy `colorPropToOpacityProp` table that lived in
-* `@uds/core` — consumers (codegen safelist generation, runtime
-* `getStyles`, loader style-transform) should call this instead.
-*/
-function getColorOpacityMap(config) {
-	const map = {};
-	for (const resolved of config.resolvedStyleProps ?? []) if (resolved.pairedWith) map[resolved.pairedWith] = resolved.propName;
-	return map;
-}
-//#endregion
-export { detectTokenValueType, getColorOpacityMap, resolveStyleProp };

package/dist/config/dist/runtime-registry.js

@@ -1,37 +0,0 @@
-//#region ../config/dist/runtime-registry.js
-let registeredStyleProps = /* @__PURE__ */ new Map();
-let registeredComposites = /* @__PURE__ */ new Map();
-/**
-* Replace the active style-prop registry. Called by `resolveConfig`
-* with the full `config.styleProps` map (keyed by JSX prop name).
-*/
-function setRegisteredStyleProps(entries) {
-	registeredStyleProps = new Map(Object.entries(entries));
-}
-/**
-* Look up a registered style prop by JSX prop name (the key used in
-* `.registerStyleProps({ bg: ... })`). Returns `undefined` if no prop
-* was registered under that name.
-*/
-function getRegisteredStyleProp(name) {
-	return registeredStyleProps.get(name);
-}
-/**
-* Replace the active composite-style registry. Called by
-* `resolveConfig` with the full `config.compositeStyles` map.
-* Composites authored via `.defineCompositeStyles({...})` or
-* `.registerComposites({...})` both populate the same map.
-*/
-function setRegisteredComposites(entries) {
-	registeredComposites = new Map(Object.entries(entries));
-}
-/**
-* Look up a registered composite by name (the brace-stripped form —
-* `'textVariant'`, not `'{textVariant}'`). Returns `undefined` if no
-* composite was registered under that name.
-*/
-function getRegisteredComposite(name) {
-	return registeredComposites.get(name);
-}
-//#endregion
-export { getRegisteredComposite, getRegisteredStyleProp, setRegisteredComposites, setRegisteredStyleProps };

package/dist/config/dist/serialize.d.ts

@@ -1,47 +0,0 @@
-import { CompositeStylesConfig } from "./defineCompositeStyle.js";
-import { VarsConfig } from "./types.js";
-import { AtomicToken, ModeGroup, ModifierDef, MotionPresetsDef, UdsConfig } from "./createConfig.js";
-
-//#region ../config/dist/serialize.d.ts
-//#region src/serialize.d.ts
-type ModifierNameShape = `_${string}`;
-type TokenRef = {
-  $ref: string;
-};
-interface SerializedConfig {
-  modes: ModeGroup[];
-  modifiers?: ModifierDef[];
-  /** Verbatim `defineVars` input — the authoritative source of CSS variable
-   *  declarations. */
-  vars?: VarsConfig;
-  /** Derived (property × token) data for utility-class generation. */
-  atomic: AtomicToken<ModifierNameShape>[];
-  compositeStyles?: CompositeStylesConfig;
-  motion?: MotionPresetsDef;
-  globalStyles?: Record<string, Record<string, SerializedValue>>;
-  preflight: boolean;
-  prefix: string;
-}
-type SerializedValue = string | TokenRef | {
-  [key: string]: SerializedValue;
-};
-/**
- * Build a reverse map from `var(--prefix-xxx-yyy)` strings back to
- * `propName.tokenName` reference paths.
- */
-declare function buildReverseMap(atomic: AtomicToken<ModifierNameShape>[], configPrefix: string): Map<string, string>;
-/**
- * Serialize a UdsConfig for database storage. Walks global styles and
- * replaces known `var()` strings with `{ $ref: "propName.tokenName" }`
- * markers so the authoring intent survives a JSON round-trip.
- */
-declare function serializeConfig(config: UdsConfig): SerializedConfig;
-/**
- * Deserialize stored config data back into a UdsConfig builder.
- *
- * Resolves `$ref` markers back to `var()` strings using the atomic token
- * definitions, then reconstructs the builder chain.
- */
-declare function deserializeConfig(data: SerializedConfig): UdsConfig; //#endregion
-//#endregion
-export { SerializedConfig, TokenRef, buildReverseMap, deserializeConfig, serializeConfig };

package/dist/config/dist/serialize.js

@@ -1,111 +0,0 @@
-import { safeTokenName } from "../../utils/dist/string-utils/cssVar.js";
-import "../../utils/dist/index.js";
-import { buildTokenReference, createConfigBuilder, resolveConfig } from "./createConfig.js";
-//#region ../config/dist/serialize.js
-/**
-* Config serialization for lossless round-tripping through a database.
-*
-* serializeConfig:   UdsConfig → SerializedConfig  (var() → $ref markers)
-* deserializeConfig: SerializedConfig → UdsConfig   ($ref markers → var())
-*/
-function isTokenRef(val) {
-	return typeof val === "object" && val !== null && "$ref" in val && typeof val.$ref === "string";
-}
-/**
-* Build a reverse map from `var(--prefix-xxx-yyy)` strings back to
-* `propName.tokenName` reference paths.
-*/
-function buildReverseMap(atomic, configPrefix) {
-	const map = /* @__PURE__ */ new Map();
-	for (const token of atomic) for (const prop of token.properties) {
-		const varPrefix = token.cssPrefix ?? token.properties[0];
-		if (!varPrefix) continue;
-		for (const t of token.tokens) {
-			const safeName = safeTokenName(t.name);
-			const varRef = `var(${configPrefix ? `--${configPrefix}-${varPrefix}-${safeName}` : `--${varPrefix}-${safeName}`})`;
-			map.set(varRef, `${prop}.${t.name}`);
-		}
-	}
-	return map;
-}
-/**
-* Walk an object, transforming every string leaf with `fn`. Nested
-* objects (pseudo-state blocks like `_hover: { ... }`) are recursed.
-*/
-function walkStrings(obj, fn) {
-	const result = {};
-	for (const [key, val] of Object.entries(obj)) if (typeof val === "string") result[key] = fn(val);
-	else if (typeof val === "object" && val !== null && !Array.isArray(val)) result[key] = walkStrings(val, fn);
-	else result[key] = val;
-	return result;
-}
-/**
-* Walk a serialized value, resolving `$ref` markers back to strings.
-* Regular string values are passed through unchanged.
-*/
-function resolveRefs(obj, tokenRef) {
-	const result = {};
-	for (const [key, val] of Object.entries(obj)) if (isTokenRef(val)) {
-		const dotIdx = val.$ref.indexOf(".");
-		const prop = val.$ref.slice(0, dotIdx);
-		const name = val.$ref.slice(dotIdx + 1);
-		result[key] = tokenRef[prop]?.[name] ?? `$ref(${val.$ref})`;
-	} else if (typeof val === "object" && val !== null && !Array.isArray(val)) result[key] = resolveRefs(val, tokenRef);
-	else result[key] = val;
-	return result;
-}
-/**
-* Serialize a UdsConfig for database storage. Walks global styles and
-* replaces known `var()` strings with `{ $ref: "propName.tokenName" }`
-* markers so the authoring intent survives a JSON round-trip.
-*/
-function serializeConfig(config) {
-	const data = resolveConfig(config);
-	const reverseMap = buildReverseMap(data.atomic, data.prefix);
-	const replaceVars = (val) => {
-		const ref = reverseMap.get(val);
-		return ref ? { $ref: ref } : val;
-	};
-	const globalStyles = {};
-	if (data.globalStyles) for (const [selector, styles] of Object.entries(data.globalStyles)) globalStyles[selector] = walkStrings(styles, replaceVars);
-	return {
-		modes: data.modes,
-		modifiers: data.modifiers.length > 0 ? data.modifiers : void 0,
-		vars: data.vars && Object.keys(data.vars).length > 0 ? data.vars : void 0,
-		atomic: data.atomic,
-		compositeStyles: Object.keys(data.compositeStyles).length > 0 ? data.compositeStyles : void 0,
-		motion: Object.keys(data.motion).length > 0 ? data.motion : void 0,
-		globalStyles: Object.keys(globalStyles).length > 0 ? globalStyles : void 0,
-		preflight: data.preflight,
-		prefix: data.prefix
-	};
-}
-/**
-* Deserialize stored config data back into a UdsConfig builder.
-*
-* Resolves `$ref` markers back to `var()` strings using the atomic token
-* definitions, then reconstructs the builder chain.
-*/
-function deserializeConfig(data) {
-	const tokenRef = buildTokenReference(data.atomic, data.prefix);
-	let config = createConfigBuilder({
-		modes: data.modes,
-		modifiers: data.modifiers ?? [],
-		vars: data.vars,
-		atomic: data.atomic,
-		compositeStyles: data.compositeStyles ?? {},
-		motion: data.motion ?? {},
-		components: {},
-		preflight: data.preflight,
-		prefix: data.prefix ?? "uds",
-		globalStyles: {}
-	});
-	if (data.globalStyles && Object.keys(data.globalStyles).length > 0) {
-		const globalStyles = {};
-		for (const [selector, styles] of Object.entries(data.globalStyles)) globalStyles[selector] = resolveRefs(styles, tokenRef);
-		config = config.defineGlobalStyles(globalStyles);
-	}
-	return config;
-}
-//#endregion
-export { buildReverseMap, deserializeConfig, serializeConfig };

package/dist/config/dist/sniffTokenType.d.ts

@@ -1,7 +0,0 @@
-import { TokenType } from "./types.js";
-
-//#region ../config/dist/sniffTokenType.d.ts
-//#region src/sniffTokenType.d.ts
-declare function sniffTokenTypeFromValue(value: string): TokenType | undefined; //#endregion
-//#endregion
-export { sniffTokenTypeFromValue };

package/dist/config/dist/sniffTokenType.js

@@ -1,67 +0,0 @@
-//#region ../config/dist/sniffTokenType.js
-const CSS_WIDE_KEYWORDS = new Set([
-	"inherit",
-	"initial",
-	"unset",
-	"revert",
-	"revert-layer",
-	"auto",
-	"none",
-	"currentColor",
-	"currentcolor",
-	"transparent"
-]);
-const HEX_COLOR_RE = /^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
-const COLOR_FUNCTION_RE = /^(?:rgb|rgba|hsl|hsla|hwb|lab|lch|oklab|oklch|color|color-mix|light-dark)\s*\(/i;
-const NAMED_COLOR_KEYWORDS = new Set([
-	"aliceblue",
-	"antiquewhite",
-	"aqua",
-	"aquamarine",
-	"azure",
-	"beige",
-	"bisque",
-	"black",
-	"blue",
-	"brown",
-	"crimson",
-	"cyan",
-	"fuchsia",
-	"gold",
-	"gray",
-	"grey",
-	"green",
-	"indigo",
-	"lime",
-	"magenta",
-	"maroon",
-	"navy",
-	"olive",
-	"orange",
-	"pink",
-	"purple",
-	"red",
-	"silver",
-	"teal",
-	"violet",
-	"white",
-	"yellow"
-]);
-const NUMBER_RE_SRC = "(?:\\d+(?:\\.\\d+)?|\\.\\d+)";
-const DIMENSION_RE = new RegExp(`^-?${NUMBER_RE_SRC}(?:px|rem|em|%|vh|vw|vmin|vmax|vi|vb|svh|svw|lvh|lvw|dvh|dvw|ch|ex|cap|ic|lh|rlh|pt|pc|in|cm|mm|q|fr|deg|turn|rad|grad)$`, "i");
-const DURATION_RE = new RegExp(`^-?${NUMBER_RE_SRC}(?:ms|s)$`, "i");
-const PURE_NUMBER_RE = new RegExp(`^-?${NUMBER_RE_SRC}$`);
-function sniffTokenTypeFromValue(value) {
-	const v = value.trim();
-	if (v.length === 0) return void 0;
-	if (CSS_WIDE_KEYWORDS.has(v)) return "string";
-	if (v.startsWith("var(")) return void 0;
-	if (COLOR_FUNCTION_RE.test(v)) return "color";
-	if (HEX_COLOR_RE.test(v)) return "color";
-	if (NAMED_COLOR_KEYWORDS.has(v.toLowerCase())) return "color";
-	if (DURATION_RE.test(v)) return "duration";
-	if (DIMENSION_RE.test(v)) return "dimension";
-	if (PURE_NUMBER_RE.test(v)) return "number";
-}
-//#endregion
-export { sniffTokenTypeFromValue };

package/dist/config/dist/style-prop-runtime.d.ts

@@ -1,75 +0,0 @@
-import { UdsConfigData } from "./createConfig.js";
-
-//#region ../config/dist/style-prop-runtime.d.ts
-//#region src/style-prop-runtime.d.ts
-/**
- * Serialized lookup data the runtime consumes. Built once per config (per
- * app or per preview-bundle) by `buildStylePropRuntime`. Plain objects so
- * the whole thing serializes to JSON for codegen embedding.
- */
-interface StylePropRuntimeData {
-  /** propName → class-generation info. */
-  readonly styleProps: Readonly<Record<string, StylePropEntry>>;
-  /** modifier-prop name (with leading underscore) → resolved selector. */
-  readonly modifiers: Readonly<Record<string, ResolvedModifier>>;
-  /**
-   * Composite group name → variant key → expanded style-prop map.
-   * `<Box elevation="1" />` → look up `composites.elevation['1']`, merge
-   * into the prop bundle, add the marker class `elevation-1`.
-   */
-  readonly composites: Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, unknown>>>>>>;
-}
-interface StylePropEntry {
-  /** Class prefix the prop emits (`bg`, `p`, `rounded`). */
-  readonly classPrefix: string;
-  /** Primary CSS property — fan-out arrays collapse to first entry. */
-  readonly cssProperty: string;
-  /** The CSS variable prefix this prop's tokens live under. Used to build
-   *  `var(--<prefix>-<token>)` for opacity-fallback rule injection. */
-  readonly varPrefix?: string;
-  /** Set on opacity sibling props. */
-  readonly pairedWith?: string;
-  /** Class-name separator for opacity (default `_`). */
-  readonly separator?: string;
-  /** Alias → CSS-value map for literal-alias entries (e.g. `col` → `column`). */
-  readonly literalAliases?: Readonly<Record<string, string>>;
-}
-/**
- * Selector contribution of a modifier. Two flavors:
- *   - `pseudo` — appends to the selector, like `:hover`.
- *   - `ancestor` — wraps the selector, like `.dark &` or `@media (...)`.
- */
-interface ResolvedModifier {
-  readonly tailwindPrefix: string;
-  readonly kind: 'pseudo' | 'ancestor' | 'at-rule';
-  /** For pseudo: the suffix (`:hover`). For ancestor: the prefix selector (`.dark`). For at-rule: the rule (`(min-width: 640px)`). */
-  readonly selector: string;
-}
-/** Output of `processStyleProps`. */
-interface ProcessStylePropsResult {
-  readonly className: string;
-  /** CSS rules the runtime needs to inject for arbitrary or fallback classes.
-   *  Empty when all input resolves to build-time-known utilities. */
-  readonly dynamicRules: readonly DynamicRule[];
-}
-/** A single CSS rule the consumer should ensure exists in the document. */
-interface DynamicRule {
-  /** Class name the rule targets. Already escaped per CSS spec. */
-  readonly className: string;
-  /** Full selector (`.cls`, `.dark .cls`, `.cls:hover`). */
-  readonly selector: string;
-  /** CSS property in kebab-case. */
-  readonly cssProperty: string;
-  readonly cssValue: string;
-  /** Wrapping at-rule, if any (e.g. `@media (min-width: 640px)`). */
-  readonly atRule?: string;
-}
-interface ProcessStylePropsOpts {
-  /** Compound modifier prefix accumulated through recursion. */
-  readonly modifier?: string;
-}
-declare const BUILT_IN_PSEUDO: Record<string, string>;
-declare function buildStylePropRuntime(config: UdsConfigData): StylePropRuntimeData;
-declare function processStyleProps(props: Record<string, unknown>, runtime: StylePropRuntimeData, opts?: ProcessStylePropsOpts): ProcessStylePropsResult; //#endregion
-//#endregion
-export { BUILT_IN_PSEUDO, DynamicRule, ProcessStylePropsOpts, ProcessStylePropsResult, ResolvedModifier, StylePropEntry, StylePropRuntimeData, buildStylePropRuntime, processStyleProps };