@yahoo/uds-v5-wip 1.60.0 → 1.61.0

package/dist/core/dist/getComponentStyles.js

@@ -1,85 +0,0 @@
-import { componentSlotClass, componentVariantClass } from "../../utils/dist/string-utils/componentClassName.js";
-import "../../utils/dist/index.js";
-import { cx, processStyleProps } from "./getStyles.js";
-import { ELEMENT_HTML_PROPS, classifyResolvedProps } from "./resolveProps.boundaries.js";
-//#region ../core/dist/getComponentStyles.js
-function getRuntimeMap() {
-	if (!("document" in globalThis)) return null;
-	if (!globalThis.__UDS_META__) globalThis.__UDS_META__ = {};
-	return globalThis.__UDS_META__;
-}
-function nextRuntimeId() {
-	const current = globalThis.__UDS_ID_COUNTER__ ?? 1e5;
-	globalThis.__UDS_ID_COUNTER__ = current + 1;
-	return String(current);
-}
-function registerRuntimeMeta(id, meta) {
-	const map = getRuntimeMap();
-	if (!map) return;
-	map[id] = meta;
-}
-/**
-* Create a type-safe style resolver for a slot-based component.
-*
-* Returns a function that maps variant selections to per-slot class names.
-* Pure string concatenation — no hooks, no context, no side effects.
-*
-* The returned function also has a `.resolve()` method that handles
-* the full prop separation pipeline for configurable components.
-*
-* @param componentName - Registry component name
-* @param slots - Array of slot names
-* @param element - Optional HTML element tag for element-specific prop forwarding
-*/
-function createComponentStyler(componentName, slots, element, variants) {
-	const elementProps = element ? ELEMENT_HTML_PROPS[element] : void 0;
-	const variantSet = variants ? new Set(variants) : null;
-	const styler = ((variants = {}) => {
-		const passed = variants;
-		const result = {};
-		for (const slot of slots) {
-			const parts = [componentSlotClass(componentName, slot)];
-			for (const [axis, value] of Object.entries(passed)) {
-				if (axis.startsWith("data-uds")) continue;
-				if (value) parts.push(componentVariantClass(componentName, slot, axis, value));
-			}
-			result[slot] = parts.join(" ");
-		}
-		return result;
-	});
-	styler.resolve = (allProps) => {
-		const { _html, className: userClassName, ...rest } = allProps;
-		const internalUdsId = typeof rest["data-uds-id"] === "string" ? rest["data-uds-id"] : void 0;
-		const internalUdsSource = typeof rest["data-uds-source"] === "string" ? rest["data-uds-source"] : void 0;
-		delete rest["data-uds-id"];
-		delete rest["data-uds-source"];
-		const [styleClassName, remaining] = processStyleProps(rest, { extractNativeProps: true });
-		const { htmlProps, variantProps } = classifyResolvedProps({
-			remaining,
-			variantSet,
-			elementProps
-		});
-		const classes = styler(variantProps);
-		if (_html && typeof _html === "object") Object.assign(htmlProps, _html);
-		const rootClass = classes.root;
-		const merged = cx(rootClass, styleClassName, remaining.className, userClassName) || void 0;
-		const udsId = internalUdsId ?? nextRuntimeId();
-		htmlProps["data-uds-slot"] = "root";
-		htmlProps["data-uds-component"] = String(componentName);
-		htmlProps["data-uds-id"] = udsId;
-		registerRuntimeMeta(udsId, {
-			c: String(componentName),
-			s: "root",
-			v: variantProps,
-			src: internalUdsSource
-		});
-		return {
-			classes,
-			htmlProps,
-			className: merged
-		};
-	};
-	return styler;
-}
-//#endregion
-export { createComponentStyler };

package/dist/core/dist/getStyles.d.ts

@@ -1,42 +0,0 @@
-import { ClassValue } from "clsx";
-import { ModifierProp, ModifierProps, StyleAndModifierProps, StyleProps } from "@uds/types";
-
-//#region ../core/dist/getStyles.d.ts
-/** Convert kebab-case CSS property to camelCase for React inline styles.
- *  CSS custom properties (--*) are kept as-is since React supports them verbatim. */
-declare function toCamelCase(str: string): string;
-declare function createVariants<K extends Record<string, StyleAndModifierProps>>(variants: K): K;
-declare function cx(...inputs: ClassValue[]): string;
-interface ProcessStylesParams {
-  extractNativeProps?: boolean;
-  modifier?: ModifierProp;
-  /**
-   * Existing className string. When provided, any style prop that is already
-   * represented by a class in this string will be skipped. This prevents
-   * component defaults from conflicting with user-provided values
-   * (e.g. HStack defaulting alignItems='center' when user set 'end').
-   */
-  existingClassName?: string;
-  /**
-   * Config-driven modifier prefix → CSS selector map.
-   * Used by ensureArbitraryRule to generate correct CSS for custom modifiers
-   * (e.g. { "dark:": ".dark", "sm:": "@media (min-width: 640px)" }).
-   *
-   * Built-in pseudo modifiers (hover:, focus:, etc.) are handled automatically.
-   * Only needed for config modes and custom modifiers.
-   */
-  modifierSelectors?: Record<string, string>;
-}
-declare function processStyleProps(props?: StyleProps, opts?: ProcessStylesParams): readonly [string, Record<string, unknown>];
-interface GetStylesParams extends StyleProps, ModifierProps {
-  className?: string;
-}
-/** Consumer facing function that takes style props and returns a className.
- *  Unlike processStyleProps (runtime), this produces Tailwind-compatible
- *  class names for arbitrary bracket values (e.g. `[768px]` → `max-w-[768px]`)
- *  so they can be included in the CSS safelist.
- */
-declare function getStyles(props: GetStylesParams): string;
-declare function getVariantClassName(componentName: string, variant: string | undefined): string;
-//#endregion
-export { createVariants, cx, getStyles, getVariantClassName, processStyleProps, toCamelCase };

package/dist/core/dist/getStyles.js

@@ -1,300 +0,0 @@
-import { componentSlotClass } from "../../utils/dist/string-utils/componentClassName.js";
-import "../../utils/dist/index.js";
-import { expandCompositeStyles, getCompositeStylesConfig } from "./compositeStyles.js";
-import { propMappings } from "./style-prop-data.js";
-import { stylePropsTwMap } from "./generated/stylePropsTwMap.js";
-import { modifierMappings } from "./modifier-mappings.js";
-import { colorPropToOpacityProp } from "./color-opacity-map.js";
-import { clsx } from "clsx";
-//#region ../core/dist/getStyles.js
-/** Convert kebab-case CSS property to camelCase for React inline styles.
-*  CSS custom properties (--*) are kept as-is since React supports them verbatim. */
-function toCamelCase(str) {
-	if (str.startsWith("--")) return str;
-	return str.replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase());
-}
-const _dynRuleCache = /* @__PURE__ */ new Set();
-let _dynSheet = null;
-/**
-* Built-in modifier prefix → CSS pseudo-selector, derived from modifierMappings.
-* e.g. "hover:" → ":hover", "focus-visible:" → ":focus-visible"
-*
-* Complex modifiers (data attributes, pseudo-elements, at-rules) are excluded —
-* they're unlikely to appear with arbitrary values at runtime.
-*/
-const _builtinPseudoMap = {};
-for (const prefix of Object.values(modifierMappings)) {
-	if (prefix.startsWith("data-[") || prefix.startsWith("aria-") || prefix.includes("::") || prefix.includes("*")) continue;
-	_builtinPseudoMap[prefix] = `:${prefix.slice(0, -1)}`;
-}
-/**
-* Resolve a single modifier part to its CSS selector contribution.
-*
-* @param modifierSelectors - Config-driven map of custom modifier prefix → CSS selector
-*   (e.g. { "dark:": ".dark", "sm:": "@media (min-width: 640px)" }).
-*   Passed through from processStyleProps opts.
-*/
-/** @internal Exported for testing only. */
-function resolveModifierPart(part, modifierSelectors) {
-	const pseudo = _builtinPseudoMap[part];
-	if (pseudo) return {
-		type: "pseudo",
-		selector: pseudo
-	};
-	const custom = modifierSelectors?.[part];
-	if (custom) return {
-		type: "ancestor",
-		selector: custom
-	};
-	const name = part.slice(0, -1);
-	if (name) return {
-		type: "ancestor",
-		selector: `.${name}`
-	};
-	return null;
-}
-/**
-* Inject a CSS rule for an arbitrary value class if it doesn't already exist.
-* Handles both top-level (bg-[#ff0000]) and modifier (hover:bg-[#00cc6e]) classes.
-*
-* @param modifierSelectors - Config-driven modifier → CSS selector map, threaded
-*   from processStyleProps. Enables config-aware CSS rule generation.
-*/
-function ensureArbitraryRule(className, modifier, cssProperty, cssValue, modifierSelectors) {
-	if (_dynRuleCache.has(className)) return;
-	_dynRuleCache.add(className);
-	if (typeof document === "undefined") return;
-	if (!_dynSheet) {
-		const el = document.createElement("style");
-		el.setAttribute("data-uds-dynamic-arb", "");
-		document.head.appendChild(el);
-		_dynSheet = el.sheet;
-	}
-	let ancestorParts = "";
-	let pseudoParts = "";
-	if (modifier) {
-		const parts = modifier.split(":").filter(Boolean).map((p) => `${p}:`);
-		for (const part of parts) {
-			const resolved = resolveModifierPart(part, modifierSelectors);
-			if (!resolved) continue;
-			if (resolved.type === "ancestor") ancestorParts += `${resolved.selector} `;
-			else pseudoParts += resolved.selector;
-		}
-	}
-	const escaped = CSS.escape(className);
-	const rule = `${ancestorParts}.${escaped}${pseudoParts} { ${cssProperty}: ${cssValue}; }`;
-	try {
-		_dynSheet.insertRule(rule, _dynSheet.cssRules.length);
-	} catch {}
-}
-/** Detect arbitrary values like `[#ff0000]` or `[250px]` */
-function parseArbitraryValue(val, propName) {
-	if (typeof val !== "string") return null;
-	const match = val.match(/^\[(.+)\]$/);
-	if (!match) return null;
-	const mapping = propMappings[propName];
-	if (!mapping?.cssProperty && !mapping?.arbitraryValueTemplate) return null;
-	const rawValue = match[1];
-	if (mapping.arbitraryValueTemplate) {
-		const { cssProperty, valueTemplate } = mapping.arbitraryValueTemplate;
-		return {
-			cssValue: valueTemplate.replace("%s", rawValue),
-			cssProperty: toCamelCase(cssProperty)
-		};
-	}
-	return {
-		cssValue: rawValue,
-		cssProperty: toCamelCase(mapping.cssProperty ?? "")
-	};
-}
-/** Set of opacity prop names — these are consumed by their parent color prop, not processed independently */
-const opacityPropSet = new Set(Object.values(colorPropToOpacityProp));
-function createVariants(variants) {
-	return variants;
-}
-const parse = (prefix, value) => {
-	if (value === "") return prefix;
-	return (prefix === value ? String(value) : `${prefix}-${value}`).replace(/\./g, "_").replace(/\//g, "-");
-};
-const classnames = {};
-const styleOptionsByProp = {};
-for (const entry of Object.values(stylePropsTwMap)) {
-	const [propName, option] = Object.entries(entry)[0] ?? [];
-	if (!propName || typeof option !== "string") continue;
-	if (!styleOptionsByProp[propName]) styleOptionsByProp[propName] = /* @__PURE__ */ new Set();
-	styleOptionsByProp[propName].add(option);
-}
-for (const [propName, mapping] of Object.entries(propMappings)) {
-	const options = styleOptionsByProp[propName] ?? /* @__PURE__ */ new Set();
-	const hasBoolean = options.has("boolean");
-	const isNoPrefix = mapping.classPrefix === "no-prefix";
-	const handler = (val) => {
-		if (hasBoolean && options.size === 1) return val === true ? mapping.classPrefix : "";
-		if (hasBoolean) return val === true ? mapping.classPrefix : parse(mapping.classPrefix, val);
-		if (isNoPrefix) return String(val);
-		return parse(mapping.classPrefix, val);
-	};
-	classnames[propName] = handler;
-}
-const colorPropCssInfo = {};
-for (const [colorProp] of Object.entries(colorPropToOpacityProp)) {
-	const mapping = propMappings[colorProp];
-	if (mapping?.cssProperty && mapping.defaultVarPrefix) colorPropCssInfo[colorProp] = {
-		cssProperty: mapping.cssProperty,
-		varPrefix: mapping.defaultVarPrefix
-	};
-}
-function cx(...inputs) {
-	return clsx(inputs);
-}
-function processStyleProps(props = {}, opts = {}) {
-	const compositeStylesConfig = getCompositeStylesConfig();
-	const hasCompositeStyles = Object.keys(compositeStylesConfig).length > 0;
-	let effectiveProps = props;
-	let compositeStyleMarkerClasses;
-	if (hasCompositeStyles && !opts.modifier) {
-		const { expanded, markerClasses } = expandCompositeStyles(props, compositeStylesConfig);
-		effectiveProps = expanded;
-		if (markerClasses.length > 0) compositeStyleMarkerClasses = markerClasses;
-	}
-	const coveredProps = opts.existingClassName ? getPropsFromClassName(opts.existingClassName) : void 0;
-	const classnameParts = [];
-	const nativeProps = {};
-	let inlineStyles;
-	if (compositeStyleMarkerClasses) classnameParts.push(...compositeStyleMarkerClasses);
-	for (const propKey in effectiveProps) {
-		if (!Object.hasOwn(effectiveProps, propKey)) continue;
-		const propValue = effectiveProps[propKey];
-		if (propValue === void 0) continue;
-		const modifierName = modifierMappings[propKey];
-		if (modifierName) {
-			const combinedModifier = opts.modifier ? `${opts.modifier}${modifierName}` : modifierName;
-			const [newClassName] = processStyleProps(propValue, {
-				...opts,
-				modifier: combinedModifier
-			});
-			if (newClassName) classnameParts.push(newClassName);
-			continue;
-		}
-		if (propKey.startsWith("_")) {
-			const customModifierName = `${propKey.slice(1)}:`;
-			const combinedModifier = opts.modifier ? `${opts.modifier}${customModifierName}` : customModifierName;
-			const [newClassName] = processStyleProps(propValue, {
-				...opts,
-				modifier: combinedModifier
-			});
-			if (newClassName) classnameParts.push(newClassName);
-			continue;
-		}
-		if (coveredProps?.has(propKey)) continue;
-		{
-			const arbitrary = parseArbitraryValue(propValue, propKey);
-			if (arbitrary) {
-				const opacityPropName = colorPropToOpacityProp[propKey];
-				if (opacityPropName) {
-					const opacityValue = effectiveProps[opacityPropName];
-					if (opacityValue !== void 0) arbitrary.cssValue = `color-mix(in srgb, ${arbitrary.cssValue} ${opacityValue}%, transparent)`;
-				}
-				const handler = classnames[propKey];
-				if (handler) {
-					const baseClass = handler(propValue);
-					if (baseClass) {
-						const opacityPropName = colorPropToOpacityProp[propKey];
-						const opacityValue = opacityPropName ? effectiveProps[opacityPropName] : void 0;
-						const classWithOpacity = `${baseClass}${opacityValue !== void 0 ? `/${opacityValue}` : ""}`;
-						const fullClass = opts.modifier ? `${opts.modifier}${classWithOpacity}` : classWithOpacity;
-						const kebabProp = arbitrary.cssProperty.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
-						ensureArbitraryRule(fullClass, opts.modifier ?? null, kebabProp, arbitrary.cssValue, opts.modifierSelectors);
-						classnameParts.push(fullClass);
-					}
-				}
-				continue;
-			}
-		}
-		if (opacityPropSet.has(propKey)) continue;
-		const handler = classnames[propKey];
-		if (handler) {
-			const opacityPropName = colorPropToOpacityProp[propKey];
-			if (opacityPropName && !opts.modifier && typeof propValue === "string") {
-				const opacityValue = effectiveProps[opacityPropName];
-				const baseToken = propValue;
-				if (opacityValue !== void 0) {
-					const cssInfo = colorPropCssInfo[propKey];
-					if (cssInfo) {
-						const safeToken = baseToken.replace(/[./]/g, "_");
-						const varName = `--uds-${cssInfo.varPrefix}-${safeToken}`;
-						const cssProp = toCamelCase(cssInfo.cssProperty);
-						inlineStyles ??= {};
-						inlineStyles[cssProp] = `color-mix(in srgb, var(${varName}) ${opacityValue}%, transparent)`;
-						continue;
-					}
-				}
-			}
-			const propClassname = String(handler(propValue));
-			if (propClassname) {
-				const finalClassname = opts.modifier ? `${opts.modifier}${propClassname}` : propClassname;
-				classnameParts.push(finalClassname);
-			}
-			continue;
-		}
-		if (opts.extractNativeProps) nativeProps[propKey] = propValue;
-	}
-	if (inlineStyles && opts.extractNativeProps) nativeProps.style = nativeProps.style ? {
-		...nativeProps.style,
-		...inlineStyles
-	} : inlineStyles;
-	return [clsx(classnameParts.join(" ")), nativeProps];
-}
-/**
-* Extract the set of style prop names represented by classes in a className string.
-* Uses the reverse map (stylePropsTwMap) to identify which props are covered.
-*/
-function getPropsFromClassName(className) {
-	const props = /* @__PURE__ */ new Set();
-	for (const token of className.split(" ")) {
-		if (!token) continue;
-		const entry = stylePropsTwMap[token];
-		if (!entry) continue;
-		const propName = Object.keys(entry)[0];
-		if (propName) props.add(propName);
-	}
-	return props;
-}
-/** Consumer facing function that takes style props and returns a className.
-*  Unlike processStyleProps (runtime), this produces Tailwind-compatible
-*  class names for arbitrary bracket values (e.g. `[768px]` → `max-w-[768px]`)
-*  so they can be included in the CSS safelist.
-*/
-function getStyles(props) {
-	const processed = {};
-	const arbitraryParts = [];
-	for (const key in props) {
-		if (!Object.hasOwn(props, key)) continue;
-		const val = props[key];
-		if (typeof val === "string" && /^\[.+\](?:\/\d+)?$/.test(val)) {
-			const mapping = propMappings[key];
-			if (mapping?.classPrefix && mapping.classPrefix !== "no-prefix") {
-				arbitraryParts.push(`${mapping.classPrefix}-${val}`);
-				continue;
-			}
-		}
-		processed[key] = val;
-	}
-	for (const [colorProp, opacityPropName] of Object.entries(colorPropToOpacityProp)) {
-		const opacityValue = processed[opacityPropName];
-		if (opacityValue !== void 0 && processed[colorProp] !== void 0) {
-			processed[colorProp] = `${processed[colorProp]}/${opacityValue}`;
-			delete processed[opacityPropName];
-		}
-	}
-	const [finalClassName] = processStyleProps(processed, { extractNativeProps: false });
-	if (arbitraryParts.length === 0) return finalClassName;
-	return [finalClassName, ...arbitraryParts].filter(Boolean).join(" ");
-}
-function getVariantClassName(componentName, variant) {
-	const base = componentSlotClass(componentName, "root");
-	if (!variant) return base;
-	return `${base} ${base}--variant-${variant}`;
-}
-//#endregion
-export { createVariants, cx, getStyles, getVariantClassName, processStyleProps, toCamelCase };

package/dist/core/dist/index.d.ts

@@ -1,13 +0,0 @@
-import { expandCompositeStyles, getCompositeStylesConfig, setCompositeStylesConfig } from "./compositeStyles.js";
-import { PropMapping, propMappings } from "./style-prop-data.js";
-import { ConfigurablePropertyEntry, CssVariablePrefixEntry, getConfigurablePropMapping, getConfigurableProperties, getCssVariablePrefixes } from "./configurable-prop-helpers.js";
-import { createComponent } from "./createComponent.js";
-import { ComponentExample, createComponentExample } from "./createComponentExample.js";
-import { createProvider } from "./createProvider.js";
-import { stylePropsTwMap } from "./generated/stylePropsTwMap.js";
-import { createComponentStyler } from "./getComponentStyles.js";
-import { createVariants, cx, getStyles, getVariantClassName, processStyleProps, toCamelCase } from "./getStyles.js";
-import { ModifierEntry, modifierMappings } from "./modifier-mappings.js";
-import { resolveMotionState } from "./resolveMotionState.js";
-import { TransformedMotionProps, transformPreset } from "./transformPreset.js";
-import { withDefaultStyleProps } from "./withDefaultStyleProps.js";

package/dist/core/dist/index.js

@@ -1,13 +0,0 @@
-import "./compositeStyles.js";
-import "./style-prop-data.js";
-import "./configurable-prop-helpers.js";
-import "./generated/stylePropsTwMap.js";
-import "./modifier-mappings.js";
-import "./getStyles.js";
-import "./getComponentStyles.js";
-import "./createComponent.js";
-import "./createComponentExample.js";
-import "./createProvider.js";
-import "./resolveMotionState.js";
-import "./transformPreset.js";
-import "./withDefaultStyleProps.js";

package/dist/core/dist/modifier-mappings.d.ts

@@ -1,12 +0,0 @@
-import { ModifierProp } from "@uds/types";
-
-//#region ../core/dist/modifier-mappings.d.ts
-declare const modifierMappings: Record<ModifierProp, string>;
-interface ModifierEntry {
-  prop: string;
-  cssSelector: string;
-  category: string;
-  description: string;
-}
-//#endregion
-export { ModifierEntry, modifierMappings };

package/dist/core/dist/modifier-mappings.js

@@ -1,61 +0,0 @@
-//#region ../core/dist/modifier-mappings.js
-const modifierMappings = {
-	_after: "after:",
-	_hover: "hover:",
-	_focus: "focus:",
-	_focusWithin: "focus-within:",
-	_focusVisible: "focus-visible:",
-	_active: "active:",
-	_visited: "visited:",
-	_target: "target:",
-	_first: "first:",
-	_last: "last:",
-	_only: "only:",
-	_odd: "odd:",
-	_even: "even:",
-	_firstOfType: "first-of-type:",
-	_lastOfType: "last-of-type:",
-	_onlyOfType: "only-of-type:",
-	_empty: "empty:",
-	_disabled: "disabled:",
-	_enabled: "enabled:",
-	_checked: "checked:",
-	_indeterminate: "indeterminate:",
-	_default: "default:",
-	_required: "required:",
-	_valid: "valid:",
-	_invalid: "invalid:",
-	_inRange: "in-range:",
-	_outOfRange: "out-of-range:",
-	_placeholderShown: "placeholder-shown:",
-	_autofill: "autofill:",
-	_readonly: "read-only:",
-	_file: "file:",
-	_selection: "selection:",
-	_backdrop: "backdrop:",
-	_motionReduce: "motion-reduce:",
-	_motionSafe: "motion-safe:",
-	_contrastMore: "contrast-more:",
-	_contrastLess: "contrast-less:",
-	_forcedColors: "forced-colors:",
-	_placeholder: "placeholder:",
-	_ariaBusy: "aria-busy:",
-	_ariaChecked: "aria-checked:",
-	_ariaHidden: "aria-hidden:",
-	_ariaPressed: "aria-pressed:",
-	_ariaReadonly: "aria-readonly:",
-	_ariaRequired: "aria-required:",
-	_ariaSelected: "aria-selected:",
-	_ariaCurrent: "aria-[current]:",
-	_ariaDisabled: "aria-disabled:",
-	_ariaExpanded: "aria-expanded:",
-	_dataDisabled: "data-[disabled=true]:",
-	_dataStateOpen: "data-[state=open]:",
-	_dataStateClosed: "data-[state=closed]:",
-	_startingStyle: "starting-style:",
-	_scrollbar: "*::-webkit-scrollbar:",
-	_scrollbarThumb: "*::-webkit-scrollbar-thumb:",
-	_scrollbarTrack: "*::-webkit-scrollbar-track:"
-};
-//#endregion
-export { modifierMappings };

package/dist/core/dist/resolveMotionState.d.ts

@@ -1,4 +0,0 @@
-//#region ../core/dist/resolveMotionState.d.ts
-declare function resolveMotionState(stateKeyframe: Record<string, unknown>, index: number): Record<string, number>;
-//#endregion
-export { resolveMotionState };

package/dist/core/dist/resolveMotionState.js

@@ -1,17 +0,0 @@
-//#region ../core/dist/resolveMotionState.js
-function resolveInterpolate(marker, index) {
-	const { output, extrapolate } = marker;
-	if (index < output.length) return output[index];
-	if (extrapolate === "clamp") return output[output.length - 1];
-	if (extrapolate === "identity") return index;
-	const last = output[output.length - 1];
-	return last + (last - output[output.length - 2]) * (index - (output.length - 1));
-}
-function resolveMotionState(stateKeyframe, index) {
-	const resolved = {};
-	for (const [key, value] of Object.entries(stateKeyframe)) if (typeof value === "number") resolved[key] = value;
-	else if (value && typeof value === "object" && value.__type === "interpolate") resolved[key] = resolveInterpolate(value, index);
-	return resolved;
-}
-//#endregion
-export { resolveMotionState };

package/dist/core/dist/resolveProps.boundaries.js

@@ -1,131 +0,0 @@
-//#region ../core/dist/resolveProps.boundaries.js
-/** Matches event handlers (`onClick`, `onKeyDown`, etc.) */
-const EVENT_HANDLER_RE = /^on[A-Z]/;
-/** Returns true if the key should be forwarded to the DOM by pattern. */
-function isPatternMatchedHtmlProp(key) {
-	return EVENT_HANDLER_RE.test(key) || key.startsWith("aria-") || key.startsWith("data-");
-}
-/** HTML attributes that are universally forwarded on every element. */
-const UNIVERSAL_HTML_PROPS = new Set([
-	"id",
-	"ref",
-	"style",
-	"tabIndex",
-	"role",
-	"title",
-	"hidden",
-	"dir",
-	"lang",
-	"slot",
-	"draggable",
-	"spellCheck",
-	"autoFocus",
-	"enterKeyHint",
-	"inputMode",
-	"contentEditable",
-	"suppressContentEditableWarning",
-	"suppressHydrationWarning",
-	"translate",
-	"itemScope",
-	"itemType",
-	"itemID",
-	"itemProp",
-	"itemRef",
-	"nonce",
-	"inert"
-]);
-/**
-* Per-element HTML props that should be kept flat (not inside `_html`).
-* Arrays are `satisfies` checked at the type level in the source file;
-* at runtime they're plain Sets for O(1) lookup.
-*/
-const ELEMENT_HTML_PROPS = {
-	button: new Set([
-		"disabled",
-		"type",
-		"form",
-		"formAction",
-		"formMethod",
-		"formNoValidate",
-		"formTarget",
-		"formEncType",
-		"popoverTarget",
-		"value"
-	]),
-	a: new Set([
-		"href",
-		"target",
-		"rel",
-		"download",
-		"hrefLang",
-		"ping",
-		"referrerPolicy"
-	]),
-	input: new Set([
-		"type",
-		"name",
-		"value",
-		"defaultValue",
-		"placeholder",
-		"disabled",
-		"readOnly",
-		"required",
-		"autoComplete",
-		"maxLength",
-		"minLength",
-		"pattern",
-		"min",
-		"max",
-		"step",
-		"checked",
-		"defaultChecked",
-		"multiple",
-		"accept",
-		"list",
-		"form"
-	]),
-	textarea: new Set([
-		"name",
-		"value",
-		"defaultValue",
-		"placeholder",
-		"disabled",
-		"readOnly",
-		"required",
-		"autoComplete",
-		"maxLength",
-		"minLength",
-		"rows",
-		"cols",
-		"wrap",
-		"form"
-	]),
-	select: new Set([
-		"name",
-		"value",
-		"defaultValue",
-		"disabled",
-		"required",
-		"multiple",
-		"form"
-	])
-};
-function classifyResolvedProps({ remaining, variantSet, elementProps }) {
-	const htmlProps = {};
-	const variantProps = {};
-	for (const key in remaining) {
-		if (!Object.hasOwn(remaining, key)) continue;
-		if (key === "className") continue;
-		if (key.startsWith("data-uds")) continue;
-		if (isPatternMatchedHtmlProp(key) || UNIVERSAL_HTML_PROPS.has(key) || elementProps?.has(key)) htmlProps[key] = remaining[key];
-		else if (variantSet) if (variantSet.has(key)) variantProps[key] = remaining[key];
-		else htmlProps[key] = remaining[key];
-		else variantProps[key] = remaining[key];
-	}
-	return {
-		htmlProps,
-		variantProps
-	};
-}
-//#endregion
-export { ELEMENT_HTML_PROPS, classifyResolvedProps };