stoop 0.3.0 → 0.4.1

package/dist/utils/helpers.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Helper utilities for Stoop.
+ * Consolidates environment detection, type guards, theme validation, and utility function application.
+ */
+import type { CSS, DefaultTheme, StyledComponentRef, Theme, UtilityFunction } from "../types";
+/**
+ * Checks if code is running in a browser environment.
+ *
+ * @returns True if running in browser, false if in SSR/Node environment
+ */
+export declare function isBrowser(): boolean;
+/**
+ * Checks if running in production mode.
+ * Extracted to helper function for consistency.
+ *
+ * @returns True if running in production mode
+ */
+export declare function isProduction(): boolean;
+/**
+ * Type guard for CSS objects.
+ *
+ * @param value - Value to check
+ * @returns True if value is a CSS object
+ */
+export declare function isCSSObject(value: unknown): value is CSS;
+/**
+ * Checks if a value is a styled component reference.
+ * Consolidated function used across the codebase.
+ *
+ * @param value - Value to check
+ * @returns True if value is a styled component reference
+ */
+export declare function isStyledComponentRef(value: unknown): value is StyledComponentRef;
+/**
+ * Type guard for valid CSS objects (excludes styled component references).
+ *
+ * @param value - Value to check
+ * @returns True if value is a valid CSS object
+ */
+export declare function isValidCSSObject(value: unknown): value is CSS;
+/**
+ * Type guard for theme objects.
+ *
+ * @param value - Value to check
+ * @returns True if value is a theme object
+ */
+export declare function isThemeObject(value: unknown): value is Theme;
+/**
+ * Validates that a theme object only contains approved scales.
+ * In production, skips all validation for performance.
+ *
+ * @param theme - Theme object to validate
+ * @returns Validated theme as DefaultTheme
+ * @throws Error if theme contains invalid scales (development only)
+ */
+export declare function validateTheme(theme: unknown): DefaultTheme;
+/**
+ * Applies utility functions to transform shorthand properties into CSS.
+ *
+ * @param styles - CSS object to process
+ * @param utils - Optional utility functions object
+ * @returns CSS object with utilities applied
+ */
+export declare function applyUtilities(styles: CSS, utils?: Record<string, UtilityFunction>): CSS;

package/dist/utils/storage.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Storage and theme detection utilities.
+ * Provides simplified localStorage and cookie management, plus automatic theme selection.
+ * Supports SSR compatibility and error handling.
+ */
+import type { ThemeDetectionOptions, ThemeDetectionResult, StorageOptions, StorageResult } from "../types";
+/**
+ * Safely gets a value from localStorage.
+ *
+ * @param key - Storage key
+ * @returns Storage result
+ */
+export declare function getFromStorage(key: string): StorageResult<string | null>;
+/**
+ * Safely sets a value in localStorage.
+ *
+ * @param key - Storage key
+ * @param value - Value to store
+ * @returns Storage result
+ */
+export declare function setInStorage(key: string, value: string): StorageResult<void>;
+/**
+ * Safely removes a value from localStorage.
+ *
+ * @param key - Storage key
+ * @returns Storage result
+ */
+export declare function removeFromStorage(key: string): StorageResult<void>;
+/**
+ * Gets a cookie value.
+ *
+ * @param name - Cookie name
+ * @returns Cookie value or null if not found
+ */
+export declare function getCookie(name: string): string | null;
+/**
+ * Sets a cookie value.
+ *
+ * @param name - Cookie name
+ * @param value - Cookie value
+ * @param options - Cookie options
+ * @returns Success status
+ */
+export declare function setCookie(name: string, value: string, options?: Omit<StorageOptions, "type"> & {
+    maxAge?: number;
+    path?: string;
+    secure?: boolean;
+}): boolean;
+/**
+ * Removes a cookie by setting it to expire.
+ *
+ * @param name - Cookie name
+ * @param path - Cookie path
+ * @returns Success status
+ */
+export declare function removeCookie(name: string, path?: string): boolean;
+/**
+ * Unified storage API that works with both localStorage and cookies.
+ *
+ * @param key - Storage key
+ * @param options - Storage options
+ * @returns Storage result
+ */
+export declare function getStorage(key: string, options?: StorageOptions): StorageResult<string | null>;
+/**
+ * Unified storage API that works with both localStorage and cookies.
+ *
+ * @param key - Storage key
+ * @param value - Value to store
+ * @param options - Storage options
+ * @returns Storage result
+ */
+export declare function setStorage(key: string, value: string, options?: StorageOptions): StorageResult<void>;
+/**
+ * Unified storage API that works with both localStorage and cookies.
+ *
+ * @param key - Storage key
+ * @param options - Storage options
+ * @returns Storage result
+ */
+export declare function removeStorage(key: string, options?: StorageOptions): StorageResult<void>;
+/**
+ * Gets a JSON value from storage with automatic parsing.
+ *
+ * @param key - Storage key
+ * @param fallback - Fallback value if parsing fails or key not found
+ * @param options - Storage options
+ * @returns Parsed JSON value or fallback
+ */
+export declare function getJsonFromStorage<T>(key: string, fallback: T, options?: StorageOptions): StorageResult<T>;
+/**
+ * Sets a JSON value in storage with automatic serialization.
+ *
+ * @param key - Storage key
+ * @param value - Value to serialize and store
+ * @param options - Storage options
+ * @returns Storage result
+ */
+export declare function setJsonInStorage<T>(key: string, value: T, options?: StorageOptions): StorageResult<void>;
+/**
+ * Creates a typed storage interface for a specific key.
+ *
+ * @param key - Storage key
+ * @param options - Storage options
+ * @returns Typed storage interface
+ */
+export declare function createStorage<T = string>(key: string, options?: StorageOptions): {
+    get: () => StorageResult<string | null>;
+    getJson: (fallback: T) => StorageResult<T>;
+    remove: () => StorageResult<void>;
+    set: (value: string) => StorageResult<void>;
+    setJson: (value: T) => StorageResult<void>;
+};
+/**
+ * Detects the best theme to use based on multiple sources with priority.
+ *
+ * Priority order (highest to lowest):
+ * 1. Explicit localStorage preference
+ * 2. Cookie preference (for SSR compatibility)
+ * 3. System color scheme preference
+ * 4. Default theme
+ *
+ * @param options - Theme detection options
+ * @returns Theme detection result
+ */
+export declare function detectTheme(options?: ThemeDetectionOptions): ThemeDetectionResult;
+/**
+ * Creates a theme detector function with pre-configured options.
+ *
+ * @param options - Theme detection options
+ * @returns Theme detection function
+ */
+export declare function createThemeDetector(options: ThemeDetectionOptions): () => ThemeDetectionResult;
+/**
+ * Auto-detects theme for SSR contexts (server-side or during hydration).
+ * Uses only cookie and default sources since localStorage isn't available.
+ *
+ * @param options - Theme detection options
+ * @returns Theme name
+ */
+export declare function detectThemeForSSR(options?: ThemeDetectionOptions): string;
+/**
+ * Listens for system theme changes and calls callback when changed.
+ *
+ * @param callback - Function to call when system theme changes
+ * @returns Cleanup function
+ */
+export declare function onSystemThemeChange(callback: (theme: "dark" | "light") => void): () => void;

package/dist/utils/{string.d.ts → theme-utils.d.ts}

@@ -1,8 +1,8 @@
 /**
- * String utility functions.
- * Provides hashing for class name generation, camelCase to kebab-case conversion,
- * and CSS sanitization utilities for security.
+ * Theme-related string utilities and property mapping.
+ * Provides hashing, CSS sanitization, and theme scale mapping for property-aware token resolution.
  */
+import type { ThemeScale } from "../types";
 /**
  * Generates a hash string from an input string using FNV-1a algorithm.
  * Includes string length to reduce collision probability.
@@ -107,3 +107,20 @@ export declare function validateKeyframeKey(key: string): boolean;
  * @returns RegExp for matching :root selector blocks
  */
 export declare function getRootRegex(prefix?: string): RegExp;
+/**
+ * Auto-detects theme scale from CSS property name using pattern matching.
+ * Used as fallback when property is not in DEFAULT_THEME_MAP.
+ *
+ * @param property - CSS property name
+ * @returns Theme scale name or undefined if no pattern matches
+ */
+export declare function autoDetectScale(property: string): ThemeScale | undefined;
+/**
+ * Gets the theme scale for a CSS property.
+ * Checks user themeMap first, then default themeMap, then pattern matching.
+ *
+ * @param property - CSS property name
+ * @param userThemeMap - Optional user-provided themeMap override
+ * @returns Theme scale name or undefined if no mapping found
+ */
+export declare function getScaleForProperty(property: string, userThemeMap?: Record<string, ThemeScale>): ThemeScale | undefined;

package/dist/utils/theme.d.ts

@@ -28,9 +28,21 @@ export declare function tokenToCSSVar(token: string, theme?: Theme, property?: s
  *
  * @param theme - Theme object to convert to CSS variables
  * @param prefix - Optional prefix for CSS variable names
- * @returns CSS string with :root selector and CSS variables
+ * @param attributeSelector - Optional attribute selector (e.g., '[data-theme="light"]'). Defaults to ':root'
+ * @returns CSS string with selector and CSS variables
  */
-export declare function generateCSSVariables(theme: Theme, prefix?: string): string;
+export declare function generateCSSVariables(theme: Theme, prefix?: string, attributeSelector?: string): string;
+/**
+ * Generates CSS custom properties for all themes using attribute selectors.
+ * This allows all themes to be available simultaneously, with theme switching
+ * handled by changing the data-theme attribute.
+ *
+ * @param themes - Map of theme names to theme objects
+ * @param prefix - Optional prefix for CSS variable names
+ * @param attribute - Attribute name for theme selection (defaults to 'data-theme')
+ * @returns CSS string with all theme CSS variables
+ */
+export declare function generateAllThemeVariables(themes: Record<string, Theme>, prefix?: string, attribute?: string): string;
 /**
  * Recursively replaces theme tokens with CSS variable references in a CSS object.
  *

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "stoop",
   "description": "CSS-in-JS library with type inference, theme creation, and variants support.",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "author": "Jackson Dolman <mail@dolmios.com>",
-  "main": "./dist/index.js",
+  "main": "./dist/create-stoop.js",
+  "types": "./dist/create-stoop.d.ts",
   "repository": {
     "type": "git",
     "url": "https://github.com/dolmios/stoop.git"
@@ -16,24 +17,48 @@
     "react-polymorphic-types": "^2.0.0"
   },
   "devDependencies": {
-    "@types/node": "^22.10.5",
-    "@types/react": "^19.0.6",
-    "@types/react-dom": "^19.0.2",
-    "bun-types": "^1.2.6",
-    "typescript": "^5.7.2"
+    "@types/node": "^25.0.3",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "bun-types": "^1.3.5",
+    "typescript": "^5.9.3"
   },
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.js",
-      "default": "./dist/index.js"
+      "types": "./dist/create-stoop.d.ts",
+      "import": "./dist/create-stoop.js",
+      "require": "./dist/create-stoop.js",
+      "default": "./dist/create-stoop.js"
+    },
+    "./utils/storage": {
+      "types": "./dist/utils/storage.d.ts",
+      "import": "./dist/utils/storage.js",
+      "require": "./dist/utils/storage.js",
+      "default": "./dist/utils/storage.js"
+    },
+    "./utils/auto-preload": {
+      "types": "./dist/utils/auto-preload.d.ts",
+      "import": "./dist/utils/auto-preload.js",
+      "require": "./dist/utils/auto-preload.js",
+      "default": "./dist/utils/auto-preload.js"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/types/index.js",
+      "require": "./dist/types/index.js",
+      "default": "./dist/types/index.js"
+    },
+    "./inject": {
+      "types": "./dist/inject.d.ts",
+      "import": "./dist/inject.js",
+      "require": "./dist/inject.js",
+      "default": "./dist/inject.js"
     },
     "./ssr": {
-      "types": "./dist/ssr.d.ts",
-      "import": "./dist/ssr.js",
-      "require": "./dist/ssr.js",
-      "default": "./dist/ssr.js"
+      "types": "./dist/create-stoop-ssr.d.ts",
+      "import": "./dist/create-stoop-ssr.js",
+      "require": "./dist/create-stoop-ssr.js",
+      "default": "./dist/create-stoop-ssr.js"
     }
   },
   "files": [
@@ -72,11 +97,13 @@
     "react-dom": ">=16.8.0"
   },
   "scripts": {
-    "build": "bun run build:clean && bun run build:types",
+    "build": "bun run build:clean && bun run build:js && bun run build:js:ssr && bun run build:types",
     "build:clean": "rm -rf dist",
     "build:copy-declarations": "mkdir -p dist/types && cp src/types/react-polymorphic-types.d.ts dist/types/react-polymorphic-types.d.ts 2>/dev/null || :",
-    "build:js": "NODE_ENV=production bun build ./src/index.ts --outdir ./dist --target node --minify --jsx=automatic --splitting --external react --external react-dom --external react/jsx-runtime --define process.env.NODE_ENV='\"production\"'",
+    "build:js": "NODE_ENV=production bun build ./src/create-stoop.ts --outfile ./dist/create-stoop.js --target browser --format esm --minify --jsx=automatic --external react --external react-dom --external react/jsx-runtime --define process.env.NODE_ENV='\"production\"'",
+    "build:js:ssr": "NODE_ENV=production bun build ./src/create-stoop-ssr.ts --outfile ./dist/create-stoop-ssr.js --target browser --format esm --minify --jsx=automatic --external react --external react-dom --external react/jsx-runtime --define process.env.NODE_ENV='\"production\"'",
     "build:types": "bunx tsc --project tsconfig.build.json && bun run build:copy-declarations",
+    "lint": "eslint src --fix",
     "prepare": "bun run build",
     "test": "bun test",
     "test:coverage": "bun test --coverage",

package/dist/api/create-theme.d.ts

@@ -1,13 +0,0 @@
-/**
- * Theme extension API.
- * Creates a function that deep merges theme overrides with a base theme.
- */
-import type { Theme } from "../types";
-/**
- * Creates a function that extends a base theme with overrides.
- * The returned function deep merges theme overrides with the base theme.
- *
- * @param baseTheme - Base theme to extend
- * @returns Function that accepts theme overrides and returns a merged theme
- */
-export declare function createTheme(baseTheme: Theme): (themeOverrides: Partial<Theme>) => Theme;

package/dist/api/create-theme.js

@@ -1,43 +0,0 @@
-/**
- * Theme extension API.
- * Creates a function that deep merges theme overrides with a base theme.
- */
-import { validateTheme } from "../utils/theme-validation";
-import { isThemeObject } from "../utils/type-guards";
-/**
- * Creates a function that extends a base theme with overrides.
- * The returned function deep merges theme overrides with the base theme.
- *
- * @param baseTheme - Base theme to extend
- * @returns Function that accepts theme overrides and returns a merged theme
- */
-export function createTheme(baseTheme) {
-    return function createTheme(themeOverrides) {
-        const validatedOverrides = validateTheme(themeOverrides);
-        function deepMerge(target, source) {
-            const result = { ...target };
-            const sourceKeys = Object.keys(source);
-            for (const key of sourceKeys) {
-                const sourceValue = source[key];
-                const targetValue = target[key];
-                if (isThemeObject(sourceValue) && isThemeObject(targetValue)) {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    result[key] = { ...targetValue, ...sourceValue };
-                }
-                else if (sourceValue !== undefined) {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    result[key] = sourceValue;
-                }
-            }
-            const targetKeys = Object.keys(target);
-            for (const key of targetKeys) {
-                if (!(key in result)) {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    result[key] = target[key];
-                }
-            }
-            return result;
-        }
-        return deepMerge(baseTheme, validatedOverrides);
-    };
-}

package/dist/api/css.d.ts

@@ -1,16 +0,0 @@
-/**
- * CSS class generation API.
- * Creates a function that compiles CSS objects into class names.
- */
-import type { CSS, Theme, ThemeScale, UtilityFunction } from "../types";
-/**
- * Creates a CSS function that compiles CSS objects into class names.
- *
- * @param defaultTheme - Default theme for token resolution
- * @param prefix - Optional prefix for generated class names
- * @param media - Optional media query breakpoints
- * @param utils - Optional utility functions
- * @param themeMap - Optional theme scale mappings
- * @returns Function that accepts CSS objects and returns class names
- */
-export declare function createCSSFunction(defaultTheme: Theme, prefix?: string, media?: Record<string, string>, utils?: Record<string, UtilityFunction>, themeMap?: Record<string, ThemeScale>): (styles: CSS) => string;

package/dist/api/css.js

@@ -1,20 +0,0 @@
-/**
- * CSS class generation API.
- * Creates a function that compiles CSS objects into class names.
- */
-import { compileCSS } from "../core/compiler";
-/**
- * Creates a CSS function that compiles CSS objects into class names.
- *
- * @param defaultTheme - Default theme for token resolution
- * @param prefix - Optional prefix for generated class names
- * @param media - Optional media query breakpoints
- * @param utils - Optional utility functions
- * @param themeMap - Optional theme scale mappings
- * @returns Function that accepts CSS objects and returns class names
- */
-export function createCSSFunction(defaultTheme, prefix = "stoop", media, utils, themeMap) {
-    return function css(styles) {
-        return compileCSS(styles, defaultTheme, prefix, media, utils, themeMap);
-    };
-}

package/dist/api/global-css.js

@@ -1,89 +0,0 @@
-/**
- * Global CSS injection API.
- * Creates a function that injects global styles into the document.
- * Supports media queries, nested selectors, and theme tokens.
- */
-import { MAX_CSS_NESTING_DEPTH } from "../constants";
-import { injectCSS } from "../inject";
-import { escapeCSSValue, hashObject, sanitizeCSSPropertyName, sanitizeCSSSelector, sanitizeMediaQuery, sanitizePrefix, } from "../utils/string";
-import { replaceThemeTokensWithVars } from "../utils/theme";
-import { isCSSObject } from "../utils/type-guards";
-import { applyUtilities } from "../utils/utilities";
-/**
- * Creates a global CSS injection function.
- * Injects styles directly into the document with deduplication support.
- *
- * @param defaultTheme - Default theme for token resolution
- * @param prefix - Optional prefix for CSS rules
- * @param media - Optional media query breakpoints
- * @param utils - Optional utility functions
- * @param themeMap - Optional theme scale mappings
- * @returns Function that accepts CSS objects and returns a cleanup function
- */
-const globalInjectedStyles = new WeakMap();
-function getInjectedSet(theme) {
-    let set = globalInjectedStyles.get(theme);
-    if (!set) {
-        set = new Set();
-        globalInjectedStyles.set(theme, set);
-    }
-    return set;
-}
-export function createGlobalCSSFunction(defaultTheme, prefix = "stoop", media, utils, themeMap) {
-    return function globalCss(styles) {
-        const injected = getInjectedSet(defaultTheme);
-        const cssKey = hashObject(styles);
-        if (injected.has(cssKey)) {
-            return () => { };
-        }
-        injected.add(cssKey);
-        function generateGlobalCSS(obj, depth = 0) {
-            if (depth > MAX_CSS_NESTING_DEPTH) {
-                return "";
-            }
-            let result = "";
-            const sortedEntries = Object.entries(obj).sort(([a], [b]) => a.localeCompare(b));
-            sortedEntries.forEach(([key, value]) => {
-                if (isCSSObject(value)) {
-                    if (media && key in media) {
-                        const mediaQuery = sanitizeMediaQuery(media[key]);
-                        if (mediaQuery) {
-                            const nestedCss = generateGlobalCSS(value, depth + 1);
-                            result += `${mediaQuery} { ${nestedCss} }`;
-                        }
-                    }
-                    else if (key.startsWith("@")) {
-                        const sanitizedKey = sanitizeCSSSelector(key);
-                        if (sanitizedKey) {
-                            const nestedCss = generateGlobalCSS(value, depth + 1);
-                            result += `${sanitizedKey} { ${nestedCss} }`;
-                        }
-                    }
-                    else {
-                        const sanitizedKey = sanitizeCSSSelector(key);
-                        if (sanitizedKey) {
-                            const nestedCss = generateGlobalCSS(value, depth + 1);
-                            result += `${sanitizedKey} { ${nestedCss} }`;
-                        }
-                    }
-                }
-                else if (value !== undefined) {
-                    const property = sanitizeCSSPropertyName(key);
-                    if (property && (typeof value === "string" || typeof value === "number")) {
-                        const escapedValue = escapeCSSValue(value);
-                        result += `${property}: ${escapedValue}; `;
-                    }
-                }
-            });
-            return result;
-        }
-        const sanitizedPrefix = sanitizePrefix(prefix);
-        const stylesWithUtils = applyUtilities(styles, utils);
-        const themedStyles = replaceThemeTokensWithVars(stylesWithUtils, defaultTheme, themeMap);
-        const cssText = generateGlobalCSS(themedStyles);
-        injectCSS(cssText, sanitizedPrefix, `__global_${cssKey}`);
-        return () => {
-            injected.delete(cssKey);
-        };
-    };
-}

package/dist/api/keyframes.d.ts

@@ -1,16 +0,0 @@
-/**
- * CSS keyframes animation API.
- * Creates a function that generates and injects @keyframes rules.
- * Caches animations by content hash to prevent duplicates.
- */
-import type { CSS, Theme, ThemeScale } from "../types";
-/**
- * Creates a keyframes animation function.
- * Generates and injects @keyframes rules with caching to prevent duplicates.
- *
- * @param prefix - Optional prefix for animation names
- * @param theme - Optional theme for token resolution
- * @param themeMap - Optional theme scale mappings
- * @returns Function that accepts keyframes objects and returns animation names
- */
-export declare function createKeyframesFunction(prefix?: string, theme?: Theme, themeMap?: Record<string, ThemeScale>): (keyframes: Record<string, CSS>) => string;

package/dist/api/keyframes.js

@@ -1,95 +0,0 @@
-/**
- * CSS keyframes animation API.
- * Creates a function that generates and injects @keyframes rules.
- * Caches animations by content hash to prevent duplicates.
- */
-import { LRUCache } from "../core/cache";
-import { injectCSS } from "../inject";
-import { hashObject, sanitizeCSSPropertyName, sanitizePrefix, validateKeyframeKey, } from "../utils/string";
-import { replaceThemeTokensWithVars } from "../utils/theme";
-/**
- * Converts a keyframes object to a CSS @keyframes rule string.
- *
- * @param keyframesObj - Keyframes object with percentage/from/to keys
- * @param animationName - Name for the animation
- * @param theme - Optional theme for token resolution
- * @param themeMap - Optional theme scale mappings
- * @returns CSS @keyframes rule string
- */
-function keyframesToCSS(keyframesObj, animationName, theme, themeMap) {
-    let css = `@keyframes ${animationName} {`;
-    const sortedKeys = Object.keys(keyframesObj).sort((a, b) => {
-        const aNum = parseFloat(a.replace("%", ""));
-        const bNum = parseFloat(b.replace("%", ""));
-        if (a === "from") {
-            return -1;
-        }
-        if (b === "from") {
-            return 1;
-        }
-        if (a === "to") {
-            return 1;
-        }
-        if (b === "to") {
-            return -1;
-        }
-        return aNum - bNum;
-    });
-    for (const key of sortedKeys) {
-        if (!validateKeyframeKey(key)) {
-            continue;
-        }
-        const styles = keyframesObj[key];
-        if (!styles || typeof styles !== "object") {
-            continue;
-        }
-        css += ` ${key} {`;
-        const themedStyles = replaceThemeTokensWithVars(styles, theme, themeMap);
-        // Sort properties for deterministic CSS generation
-        const sortedProps = Object.keys(themedStyles).sort();
-        for (const prop of sortedProps) {
-            const value = themedStyles[prop];
-            if (value !== undefined && (typeof value === "string" || typeof value === "number")) {
-                const sanitizedProp = sanitizeCSSPropertyName(prop);
-                if (sanitizedProp) {
-                    // Don't escape keyframe values - escaping breaks complex CSS functions
-                    const cssValue = String(value);
-                    css += ` ${sanitizedProp}: ${cssValue};`;
-                }
-            }
-        }
-        css += " }";
-    }
-    css += " }";
-    return css;
-}
-const KEYFRAME_CACHE_LIMIT = 500;
-/**
- * Creates a keyframes animation function.
- * Generates and injects @keyframes rules with caching to prevent duplicates.
- *
- * @param prefix - Optional prefix for animation names
- * @param theme - Optional theme for token resolution
- * @param themeMap - Optional theme scale mappings
- * @returns Function that accepts keyframes objects and returns animation names
- */
-export function createKeyframesFunction(prefix = "stoop", theme, themeMap) {
-    const sanitizedPrefix = sanitizePrefix(prefix);
-    const animationCache = new LRUCache(KEYFRAME_CACHE_LIMIT);
-    return function keyframes(keyframesObj) {
-        const keyframesKey = hashObject(keyframesObj);
-        const cachedName = animationCache.get(keyframesKey);
-        if (cachedName) {
-            return cachedName;
-        }
-        const hashValue = keyframesKey.slice(0, 8);
-        const animationName = sanitizedPrefix
-            ? `${sanitizedPrefix}-${hashValue}`
-            : `stoop-${hashValue}`;
-        const css = keyframesToCSS(keyframesObj, animationName, theme, themeMap);
-        const ruleKey = `__keyframes_${animationName}`;
-        injectCSS(css, sanitizedPrefix, ruleKey);
-        animationCache.set(keyframesKey, animationName);
-        return animationName;
-    };
-}