@styleframe/core 3.4.0 → 3.6.0

package/dist/styleframe.d.ts

@@ -1,638 +1,20 @@
-import { Properties } from 'csstype';
-
-export declare function applyModifiers<InstanceType extends Container>(baseInstance: InstanceType, root: Root, modifiers: Map<string, ModifierFactory>): InstanceType;
-
-export declare type AtRule = {
-    type: "at-rule";
-    id: string;
-    parentId?: string;
-    identifier: string;
-    rule: string;
-    declarations: DeclarationsBlock;
-    variables: Variable[];
-    children: ContainerChild[];
-};
-
-export declare type CapitalizeFirst<T extends string> = T extends `${infer First}${infer Rest}` ? `${Uppercase<First>}${Rest}` : T;
-
-/**
- * Capitalizes the first letter of a string
- */
-export declare function capitalizeFirst(str: string): string;
-
-/**
- * Convert a raw class name to a CSS selector by adding a `.` prefix
- * and escaping special characters.
- */
-export declare function classNameToCssSelector(className: string): string;
-
-/**
- * Deep clone a value.
- *
- * We're using rfdc for this, but maintaining our own implementation
- * to avoid production dependencies on external libraries.
- *
- * @source https://github.com/davidmarkclements/rfdc
- */
-declare type CloneFunction<T = any> = (obj: T) => T;
-
-declare type ConstructorHandler<T = any> = (obj: T, fn: CloneFunction) => T;
-
-declare type ConstructorHandlerTuple<T = any> = [
-new (...args: any[]) => T,
-ConstructorHandler<T>
-];
-
-export declare type Container = {
-    id: string;
-    parentId?: string;
-    children: ContainerChild[];
-    variables: Variable[];
-    declarations: DeclarationsBlock;
-};
-
-export declare type ContainerChild = Variable | Selector | AtRule | Utility;
-
-export declare type ContainerInput = Pick<Container, "declarations" | "variables" | "children">;
-
-export declare function createAtRuleFunction(parent: Container, root: Root): (identifier: string, rule: string, declarationsOrCallback?: DeclarationsBlock | ContainerInput | DeclarationsCallback) => AtRule;
-
-export declare function createCssFunction(_parent: Container, _root: Root): (strings: TemplateStringsArray, ...interpolations: (TokenValue | Variable | AtRule)[]) => CSS_2;
-
-export declare function createDeclarationsCallbackContext(parent: Container, root: Root): DeclarationsCallbackContext;
-
-export declare function createKeyframesFunction(parent: Container, root: Root): (name: string, declarations: Record<string, DeclarationsBlock>) => AtRule;
-
-export declare function createMediaFunction(parent: Container, root: Root): (query: string, declarationsOrCallback?: DeclarationsBlock | ContainerInput | DeclarationsCallback) => AtRule;
-
-export declare function createModifierFunction(_parent: Container, root: Root): <Key extends string>(key: Key | Key[], factory: ModifierFactory["factory"]) => ModifierFactory;
-
-/**
- * Creates a resolver that converts @-prefixed variable references in string values.
- * - Exact match "@name" → Reference object
- * - Embedded "1px solid @name" → CSS object with mixed parts
- * - Non-string or no @ → returns value unchanged
- */
-export declare function createPropertyValueResolver(parent: Container, root: Root): (value: TokenValue) => TokenValue;
-
-/**
- * Creates a recipe function to define design system recipes with variants.
- *
- * @example ```ts
- * recipe({
- *     name: "button",
- *     base: {
- *         borderWidth: ref(borderWidth), // Token reference => Variable<'border-width'> => Auto-generate _border-width
- *         borderStyle: ref(borderStyle), // Token reference => Variable<'border-style'> => Auto-generate _border-style
- *  	   boxShadow: ref(boxShadowMd), // Token reference => Variable<'box-shadow.md'> => Auto-generate _box-shadow:md
- *         'hover:focus': { // Applying hover and focus modifiers
- *             boxShadow: ref(boxShadowSm), // Token reference => Variable<'box-shadow.sm'> => Auto-generate _hover:box-shadow:sm
- *         }
- *     },
- *     variants: {
- *         color: {
- *             primary: {
- *                 background: ref(colorPrimary), // Token reference => Variable<'color.primary'> => Auto-generate _background:primary
- *                 color: ref(colorWhite), // Token reference => Variable<'color.white'> => Auto-generate _color:white
- *                 borderColor: ref(colorPrimaryShade50), // Token reference => Variable<'color.primary-shade-50'> => Auto-generate _border-color:primary-shade-50,
- *             },
- *             secondary: {
- *                 background: "@color.secondary", // Token path => Variable<'color.secondary'> => Auto-generate _background:secondary
- *                 color: "@color.white", // Token path => Variable<'color.white'> => Auto-generate _color:white
- *                 borderColor: "@color.secondary-shade-50", // Token path => Variable<'color.secondary-shade-50'> => Auto-generate _border-color:secondary
- *             },
- * 			   disabled: {
- * 				   false: {},
- * 				   true: {
- * 					   opacity: "@opacity.50", // Token path => Variable<'opacity.50'> => Auto-generate _opacity:50
- * 					   cursor: "not-allowed", // Arbitrary value => Auto-generate _cursor:[not-allowed]
- * 				   }
- *             }
- *         },
- *         size: {
- *             sm: {
- *                 padding: "@spacing.sm", // Token path => Variable<'spacing.sm'> => Auto-generate _padding:sm
- *                 fontSize: "@font-size.sm", // Token path => Variable<'font-size.sm'> => Auto-generate _font-size:sm
- *             },
- *             md: {
- *                 padding: "1rem", // Arbitrary value => Auto-generate _padding:[1rem]
- *                 fontSize: "1rem", // Arbitrary value => Auto-generate _font-size:[1rem]
- *             },
- *             lg: {
- *                 padding: "@spacing.lg", // Token path => Variable<'spacing.lg'> => Auto-generate _padding:lg
- *                 fontSize: "1.25rem", // Arbitrary value => Auto-generate _font-size:[1.25rem]
- *             },
- *         },
- *     },
- *     defaultVariants: {
- * 		   color: "primary",
- * 	       size: "md",
- *     },
- *     compoundVariants: [
- *         {
- *             match: {
- *                 color: "primary",
- *                 disabled: false
- *             },
- *             css: {
- * 				   hover: {
- * 					   background: "@color.primary-shade-50", // Token path => Variable<'color.primary-shade-50'> => Auto-generate _hover:background:primary-shade-50
- * 				   }
- *             },
- *         },
- *         {
- *             match: {
- *                 color: "secondary",
- *                 disabled: false
- *             },
- *             css: {
- * 				   hover: {
- * 					   background: ref(colorSecondaryShade50), // Token reference => Variable<'color.secondary-shade-50'> => Auto-generate _hover:background:secondary-shade-50
- * 				   }
- *             },
- *         },
- *     ],
- *     _runtime: {
- * 	       base: {
- * 				borderWidth: 'default',
- *         		borderStyle: 'default',
- *  	   		boxShadow: 'md',
- *         		'hover:focus': {
- *             		boxShadow: 'sm',
- *         		}
- *         },
- * 	   	   variants: {
- * 			   color: {
- * 				   primary: {
- * 					   background: "primary",
- * 					   color: "white",
- * 					   borderColor: "primary-shade-50",
- * 				   },
- * 				   secondary: {
- * 					   background: "secondary",
- * 					   color: "white",
- * 					   borderColor: "secondary-shade-50",
- * 				   }
- * 			   },
- * 			   disabled: {
- * 				   	false: {},
- * 				   	true: {
- * 					   	opacity: "50",
- * 					   	cursor: "[not-allowed]",
- * 				   	}
- *            },
- *            size: {
- *             		sm: {
- *                 		padding: "sm",
- *                 		fontSize: "sm",
- *             		},
- *             		md: {
- *                 		padding: "[1rem]",
- *                 		fontSize: "[1rem]",
- *             		},
- *             		lg: {
- *                 		padding: "lg",
- *                 		fontSize: "[1.25rem]",
- *             		},
- *         		},
- *          },
- *     		defaultVariants: {
- * 		   		color: "primary",
- * 	       		size: "md",
- *     		},
- *     		compoundVariants: [
- *         		{
- *             		match: {
- *                 		color: "primary",
- *                 		disabled: false
- *             		},
- *             		css: {
- * 				   		hover: {
- * 					   		background: "primary-shade-50",
- * 				   		}
- *             		},
- *         		},
- *         		{
- *             		match: {
- *                 		color: "secondary",
- *                 		disabled: false
- *             		},
- *             		css: {
- * 				   		hover: {
- * 					   		background: 'secondary-shade-50',
- * 				   		}
- *             		},
- *         		},
- *     		],
- *     }
- * });
- * ```
- */
-export declare function createRecipeFunction(_parent: Container, root: Root): <Name extends string, Variants extends VariantsBase>(options: Omit<Recipe<Name, Variants>, "type">) => Recipe<Name, Variants>;
-
-export declare function createRefFunction(parent: Container, root: Root): <Name extends string>(variable: Variable<Name> | Name, fallback?: string) => Reference<Name>;
-
-export declare function createRoot(): Root;
-
-export declare function createSelectorFunction(parent: Container, root: Root): (query: string, declarationsOrCallback: DeclarationsBlock | ContainerInput | DeclarationsCallback) => Selector;
-
-export declare function createThemeFunction(parent: Container, root: Root): (name: string, callback: DeclarationsCallback) => Theme;
-
-export declare function createUtilityFunction(parent: Container, root: Root): <Name extends string>(name: Name, factory: UtilityCallbackFn, options?: {
-    autogenerate?: UtilityAutogenerateFn;
-    namespace?: string | string[];
-}) => UtilityCreatorFn;
-
-export declare function createVariableFunction(parent: Container, root: Root): <Name extends string>(nameOrInstance: Name | Variable<Name>, value: TokenValue, options?: {
-    default: boolean;
-}) => Variable<Name>;
-
-declare type CSS_2 = {
-    type: "css";
-    value: TokenValue[];
-};
-export { CSS_2 as CSS }
-
-declare type CSSValueWithReference<T> = T extends string | number | undefined ? T | TokenValue : T extends object ? CSSValueWithReference<T> : T | TokenValue;
-
-export declare type DeclarationsBlock = {
-    [K in keyof Properties]: CSSValueWithReference<Properties[K]>;
-} & {
-    [key: string]: CSSValueWithReference<Properties[keyof Properties]> | DeclarationsBlock | ContainerInput;
-};
-
-export declare type DeclarationsCallback<Context extends DeclarationsCallbackContext = DeclarationsCallbackContext> = (context: Context) => DeclarationsBlock | void;
-
-export declare type DeclarationsCallbackContext = {
-    variable: ReturnType<typeof createVariableFunction>;
-    selector: ReturnType<typeof createSelectorFunction>;
-    atRule: ReturnType<typeof createAtRuleFunction>;
-    keyframes: ReturnType<typeof createKeyframesFunction>;
-    media: ReturnType<typeof createMediaFunction>;
-    ref: ReturnType<typeof createRefFunction>;
-    css: ReturnType<typeof createCssFunction>;
-};
-
-export declare const deepClone: CloneFunction<any>;
-
-export declare const defaultUtilitySelectorFn: UtilitySelectorFn;
-
-/**
- * Checks whether a variable with the given name exists in the scope chain,
- * walking from the given scope up through ancestors via parentId.
- */
-export declare function findVariableInScope(name: string, scope: Container, root: Root): boolean;
-
-/**
- * Generates a random ID string
- *
- * @param length - The length of the random ID to generate (default: 8)
- * @param prefix - Optional prefix to prepend to the random ID
- * @returns A random alphanumeric string with optional prefix
- */
-export declare function generateRandomId(prefix?: string, length?: number): string;
-
-/**
- * Generates the runtime object for a recipe.
- * This object contains resolved runtime keys for efficient class name lookups.
- *
- * @param recipe - The recipe to generate runtime for
- * @param root - The root object containing utility factories
- * @returns The runtime object
- */
-export declare function generateRecipeRuntime<Name extends string, Variants extends VariantsBase>(recipe: Recipe<Name, Variants>, root: Root): RecipeRuntime<Variants>;
-
-export declare function getModifier(root: Root, name: string): ModifierFactory;
-
-export declare function getUtility(root: Root, name: string): UtilityFactory;
-
-export declare function getVariable(root: Container, name: string): Variable;
-
-/**
- * Generates a deterministic, CSS-safe hash string from an arbitrary value.
- * Uses DJB2 algorithm for fast, low-collision hashing.
- *
- * @param value - The string value to hash
- * @returns A lowercase hex string of 7 characters (e.g., "a1b2c3d")
- */
-export declare function hashValue(value: string): string;
-
-export declare function isAtRule(value: unknown): value is AtRule;
-
-export declare function isContainer(value: unknown): value is Container;
-
-export declare function isContainerInput(value: unknown): value is ContainerInput;
-
-export declare function isCSS(value: unknown): value is CSS_2;
-
-export declare function isKeyReferenceValue(value: unknown): value is `@${string}`;
-
-export declare function isModifier(value: unknown): value is ModifierFactory;
-
-export declare function isObject(value: unknown): value is object;
-
-export declare function isPrimitiveTokenValue(value: unknown): value is PrimitiveTokenValue;
-
-export declare function isRecipe(value: unknown): value is Recipe;
-
-export declare function isRef<Name extends string = string>(value: unknown): value is Reference<Name>;
-
-export declare function isRoot(value: unknown): value is Root;
-
-export declare function isSelector(value: unknown): value is Selector;
-
-export declare function isStyleframe(value: unknown): value is Styleframe;
-
-export declare function isTheme(value: unknown): value is Theme;
-
-/**
- * Tokens
- */
-export declare function isToken<T>(value: unknown, type: TokenType): value is T;
-
-export declare function isTokenEqual(a: TokenValue, b: TokenValue): boolean;
-
-export declare function isTokenValue(value: unknown): value is TokenValue;
-
-export declare function isUtility<Name extends string = string>(value: unknown): value is Utility<Name>;
-
-export declare function isVariable<Name extends string = string>(value: unknown): value is Variable<Name>;
-
-export declare function merge(base: Styleframe, ...instances: Styleframe[]): Styleframe;
-
-export declare function mergeContainers<T extends Container>(a: T, b: T): T;
-
-export declare function mergeThemesArray(a: Theme[], b: Theme[]): Theme[];
-
-export declare function mergeVariablesArray(a: Variable[], b: Variable[]): Variable[];
-
-export declare type ModifierCallbackFn = DeclarationsCallback<DeclarationsCallbackContext & Pick<Utility, "declarations" | "variables" | "children">>;
-
-export declare type ModifierDeclarationsBlock = Record<string, TokenValue>;
-
-export declare type ModifierFactory = {
-    type: "modifier";
-    key: string[];
-    factory: ModifierCallbackFn;
-};
-
-export declare function parseAtReferences(str: string): TokenValue[];
-
-export declare function parseDeclarationsBlock(declarations: DeclarationsBlock, context: DeclarationsCallbackContext, parent: Container, root: Root): DeclarationsBlock;
-
-export declare type PrimitiveTokenValue = number | string | boolean | null | undefined;
-
-/**
- * Processes a recipe and creates utilities for all style declarations.
- *
- * This function iterates through all style fields in a recipe:
- * 1. `base` - Root level field key-value pairs
- * 2. `variants.*.*` - Each variant group's options containing field key-value pairs
- * 3. `compoundVariants.*.css` - Each compound variant's css declarations
- *
- * For efficiency, it:
- * - Collects all values needed for each utility key across the entire recipe
- * - Retrieves each utility factory only once
- * - Creates all utility instances in a single call per utility
- *
- * @param recipe - The recipe to process
- * @param root - The root object containing utility factories
- *
- * @example
- * ```ts
- * const buttonRecipe = recipe({
- *   name: "button",
- *   base: { borderWidth: "thin" },
- *   variants: {
- *     size: {
- *       sm: { padding: "0.5rem" },
- *       lg: { padding: "1rem" },
- *     },
- *   },
- * });
- *
- * processRecipeUtilities(buttonRecipe, root);
- * // Creates:
- * // - borderWidth utility with value "thin"
- * // - padding utility with values ["0.5rem", "1rem"]
- * ```
- */
-export declare function processRecipeUtilities(recipe: Recipe, root: Root): void;
-
-export declare function rebuildRegistry(root: Root): void;
-
-export declare type Recipe<Name extends string = string, Variants extends VariantsBase = VariantsBase> = {
-    type: "recipe";
-    name: Name;
-    base?: VariantDeclarationsBlock;
-    variants?: Variants;
-    defaultVariants?: {
-        [K in keyof Variants]?: keyof Variants[K] & string;
-    };
-    compoundVariants?: Array<{
-        match: {
-            [K in keyof Variants]?: keyof Variants[K] & string;
-        };
-        css?: VariantDeclarationsBlock;
-        className?: string;
-    }>;
-    _runtime?: RecipeRuntime<Variants>;
-    _exportName?: string;
-};
-
-export declare type RecipeRuntime<Variants extends VariantsBase = VariantsBase> = {
-    base?: RuntimeVariantDeclarationsBlock;
-    variants?: {
-        [K in keyof Variants]?: {
-            [O in keyof Variants[K]]?: RuntimeVariantDeclarationsBlock;
-        };
-    };
-    defaultVariants?: {
-        [K in keyof Variants]?: keyof Variants[K] & string;
-    };
-    compoundVariants?: Array<{
-        match: {
-            [K in keyof Variants]?: keyof Variants[K] & string;
-        };
-        css?: RuntimeVariantDeclarationsBlock;
-        className?: string;
-    }>;
-};
-
-export declare type Reference<Name extends string = string> = {
-    type: "reference";
-    name: Name;
-    fallback?: TokenValue;
-};
-
-export declare type RefFunction = (variable: string, fallback?: string) => Reference;
-
-export declare function rfdc<T = any>(opts?: RfdcOptions): CloneFunction<T>;
-
-declare interface RfdcOptions {
-    circular?: boolean;
-    proto?: boolean;
-    constructorHandlers?: ConstructorHandlerTuple[];
-}
-
-export declare type Root = {
-    type: "root";
-    id: string;
-    parentId?: string;
-    declarations: DeclarationsBlock;
-    utilities: UtilityFactory[];
-    modifiers: ModifierFactory[];
-    recipes: Recipe[];
-    variables: Variable[];
-    children: ContainerChild[];
-    themes: Theme[];
-    _registry: Map<string, Container | Root | Theme>;
-    _usage: {
-        variables: Set<string>;
-    };
-};
-
-export declare type RuntimeModifierDeclarationsBlock = Record<string, PrimitiveTokenValue>;
-
-export declare type RuntimeVariantDeclarationsBlock = Record<string, RuntimeVariantDeclarationsValue>;
-
-export declare type RuntimeVariantDeclarationsValue = PrimitiveTokenValue | RuntimeModifierDeclarationsBlock;
-
-export declare type Selector = {
-    type: "selector";
-    id: string;
-    parentId?: string;
-    query: string;
-    declarations: DeclarationsBlock;
-    variables: Variable[];
-    children: ContainerChild[];
-    _exportName?: string;
-};
-
-export declare interface Styleframe {
-    id: string;
-    root: Root;
-    variable: ReturnType<typeof createVariableFunction>;
-    selector: ReturnType<typeof createSelectorFunction>;
-    utility: ReturnType<typeof createUtilityFunction>;
-    modifier: ReturnType<typeof createModifierFunction>;
-    recipe: ReturnType<typeof createRecipeFunction>;
-    theme: ReturnType<typeof createThemeFunction>;
-    atRule: ReturnType<typeof createAtRuleFunction>;
-    keyframes: ReturnType<typeof createKeyframesFunction>;
-    media: ReturnType<typeof createMediaFunction>;
-    ref: ReturnType<typeof createRefFunction>;
-    css: ReturnType<typeof createCssFunction>;
-    options: StyleframeOptions;
-}
-
-export declare function styleframe(userOptions?: StyleframeOptions): Styleframe;
-
-export declare type StyleframeOptions = {
-    indent?: string;
-    variables?: {
-        name?: VariableNameFn;
-    };
-    utilities?: {
-        selector?: UtilitySelectorFn;
-    };
-    themes?: {
-        selector?: ThemeSelectorFn;
-    };
-};
-
-export declare type Theme = {
-    type: "theme";
-    id: string;
-    parentId?: string;
-    name: string;
-    declarations: DeclarationsBlock;
-    variables: Variable[];
-    children: ContainerChild[];
-};
-
-export declare type ThemeSelectorFn = (options: {
-    name: string;
-}) => string;
-
-export declare type TokenType = Variable["type"] | Reference["type"] | Selector["type"] | AtRule["type"] | CSS_2["type"] | Utility["type"] | ModifierFactory["type"] | Recipe["type"] | Theme["type"] | Root["type"];
-
-export declare type TokenValue = PrimitiveTokenValue | Reference | CSS_2 | Array<PrimitiveTokenValue | Reference | CSS_2>;
-
-export declare function transformUtilityKey(replacerOrOptions?: ((key: string) => string) | TransformUtilityKeyOptions): (value: TokenValue) => Record<string, TokenValue>;
-
-export declare interface TransformUtilityKeyOptions {
-    /** Transforms the key used in the utility class name */
-    replacer?: (key: string) => string;
-    /** Namespace prepended to the reference name (e.g., "spacing" makes "@sm" resolve to ref("spacing.sm")) */
-    namespace?: string | string[];
-}
-
-export declare type Utility<Name extends string = string> = {
-    type: "utility";
-    id: string;
-    parentId?: string;
-    name: Name;
-    value: string;
-    declarations: DeclarationsBlock;
-    variables: Variable[];
-    children: ContainerChild[];
-    modifiers: string[];
-};
-
-export declare type UtilityAutogenerateFn = (value: TokenValue) => Record<string, TokenValue>;
-
-export declare type UtilityCallbackFn = DeclarationsCallback<DeclarationsCallbackContext & {
-    value: TokenValue;
-}>;
-
-export declare type UtilityCreatorFn = (values: Record<string, TokenValue> | TokenValue[], modifiers?: (ModifierFactory | ModifierFactory[])[]) => void;
-
-export declare type UtilityFactory<Name extends string = string> = {
-    type: "utility";
-    name: Name;
-    factory: UtilityCallbackFn;
-    values: Array<{
-        key: string;
-        value: TokenValue;
-        modifiers: string[];
-    }>;
-    autogenerate: UtilityAutogenerateFn;
-    namespace?: string | string[];
-    create: UtilityCreatorFn;
-};
-
-export declare type UtilitySelectorFn = (options: UtilitySelectorOptions) => string;
-
-export declare interface UtilitySelectorOptions {
-    name: string;
-    value: string;
-    modifiers: string[];
-}
-
-/**
- * Validates that a variable name exists in the scope chain.
- * Walks from the given scope up through ancestors to root.
- * Throws if the variable is not defined.
- */
-export declare function validateReference(name: string, scope: Container, root: Root): void;
-
-export declare type Variable<Name extends string = string> = {
-    type: "variable";
-    id: string;
-    parentId?: string;
-    name: Name;
-    value: TokenValue;
-};
-
-export declare type VariableNameFn = (options: {
-    name: string;
-}) => string;
-
-export declare type VariantDeclarationsBlock = Record<string, VariantDeclarationsValue>;
-
-export declare type VariantDeclarationsValue = TokenValue | ModifierDeclarationsBlock;
-
-export declare type VariantsBase = Record<string, Record<string, VariantDeclarationsBlock>>;
-
-export { }
+import { createAtRuleFunction, createCssFunction, createKeyframesFunction, createMediaFunction, createRefFunction, createSelectorFunction, createVariableFunction, createModifierFunction, createRecipeFunction, createThemeFunction, createUtilityFunction } from './tokens';
+import { Root, StyleframeOptions } from './types';
+export interface Styleframe {
+    id: string;
+    root: Root;
+    variable: ReturnType<typeof createVariableFunction>;
+    selector: ReturnType<typeof createSelectorFunction>;
+    utility: ReturnType<typeof createUtilityFunction>;
+    modifier: ReturnType<typeof createModifierFunction>;
+    recipe: ReturnType<typeof createRecipeFunction>;
+    theme: ReturnType<typeof createThemeFunction>;
+    atRule: ReturnType<typeof createAtRuleFunction>;
+    keyframes: ReturnType<typeof createKeyframesFunction>;
+    media: ReturnType<typeof createMediaFunction>;
+    ref: ReturnType<typeof createRefFunction>;
+    css: ReturnType<typeof createCssFunction>;
+    options: StyleframeOptions;
+}
+export declare function styleframe(userOptions?: StyleframeOptions): Styleframe;
+//# sourceMappingURL=styleframe.d.ts.map

package/dist/styleframe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styleframe.d.ts","sourceRoot":"","sources":["../src/styleframe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,oBAAoB,EACpB,iBAAiB,EACjB,uBAAuB,EACvB,mBAAmB,EACnB,iBAAiB,EACjB,sBAAsB,EACtB,sBAAsB,EACtB,MAAM,UAAU,CAAC;AAClB,OAAO,EAEN,sBAAsB,EACtB,oBAAoB,EAEpB,mBAAmB,EACnB,qBAAqB,EACrB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,IAAI,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAGvD,MAAM,WAAW,UAAU;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,IAAI,CAAC;IACX,QAAQ,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC;IACpD,QAAQ,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC;IACpD,OAAO,EAAE,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;IAClD,QAAQ,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC;IACpD,MAAM,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;IAChD,KAAK,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;IAC9C,MAAM,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;IAChD,SAAS,EAAE,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;IACtD,KAAK,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC;IAC9C,GAAG,EAAE,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC1C,GAAG,EAAE,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC1C,OAAO,EAAE,iBAAiB,CAAC;CAC3B;AAED,wBAAgB,UAAU,CAAC,WAAW,CAAC,EAAE,iBAAiB,GAAG,UAAU,CA8BtE"}