cva 1.0.0-beta.0 → 1.0.0-beta.10

package/LICENSE

@@ -175,7 +175,7 @@
 
    END OF TERMS AND CONDITIONS
 
-   Copyright 2022 Joe Bell
+   Copyright 2022-present Joe Bell
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/dist/config-CE5oXWBq.d.cts

@@ -0,0 +1,160 @@
+//#region src/types.d.ts
+type Uninferred<T> = [T][T extends any ? 0 : never];
+type StringToBoolean<T> = T extends "true" | "false" ? boolean : T;
+type InternalVariantKey = `_${string}`;
+type InternalOnlyWarning = "cva's generic parameters are restricted to internal use only.";
+type CVAComponentConfigBase<T extends ClassValue = ClassValue> = {
+  base?: T;
+};
+type CVAVariantSchema<V> = { [Variant in keyof V]?: StringToBoolean<keyof V[Variant]> | undefined; };
+type CVACompoundVariantSchema<V> = { [Variant in keyof V]?: StringToBoolean<keyof V[Variant]> | StringToBoolean<keyof V[Variant]>[] | undefined; };
+type CVACompoundVariants<V, T extends ClassValue> = (CVACompoundVariantSchema<V> & CVAClassProp<T>)[];
+type CVAClassProp<T extends ClassValue = ClassValue> = {
+  class?: T;
+  className?: never;
+} | {
+  class?: never;
+  className?: T;
+};
+type CVAComponentConfig<Config, Variants, ComposedSingle extends CVAComponentShape | undefined = CVAComponentShape | undefined, ComposedList extends readonly CVAComponentShape[] = readonly CVAComponentShape[], T extends ClassValue = ClassValue, Merged = Variants> = Config & {
+  composes?: ComposedSingle | readonly [...ComposedList];
+} & (Variants extends Record<string, Record<string, T>> ? CVAComponentConfigBase<T> & {
+  variants?: Variants & {
+    __proto__?: never;
+  };
+} : CVAComponentConfigBase<T> & {
+  variants?: never;
+}) & ([keyof Merged] extends [never] ? {
+  compoundVariants?: never;
+  defaultVariants?: never;
+} : {
+  compoundVariants?: CVACompoundVariants<Uninferred<Merged>, T>;
+  defaultVariants?: CVAVariantSchema<Uninferred<Merged>>;
+});
+//#endregion
+//#region src/config.d.ts
+type ClassValue = ClassArray | ClassDictionary | string | number | bigint | null | boolean | undefined;
+type ClassDictionary = Record<string, any>;
+type ClassArray = ClassValue[];
+/**
+ * Any function usable as a `cx` concatenator.
+ */
+type AnyCX = (...inputs: any[]) => string;
+type CXInputs<TCX extends AnyCX> = TCX extends ((...inputs: readonly [...infer Inputs]) => string) ? Inputs : never;
+type CXInputElement<TCX extends AnyCX> = CXInputs<TCX>[number];
+type CXHasSafeArity<TCX extends AnyCX> = CXInputs<TCX> extends (infer Inputs) ? Inputs extends readonly unknown[] ? Inputs extends [] ? true : [] extends Inputs ? number extends Inputs["length"] ? true : false : false : false : false;
+type CXConstraint<TCX extends AnyCX> = false extends CXHasSafeArity<TCX> ? "cva's cx must accept zero arguments and an unbounded rest parameter." : [TCX] extends [(...inputs: (string | CXInput<TCX>)[]) => string] ? unknown : "cva's cx must accept its inferred class values and composed strings.";
+/**
+ * The class value type a concatenator accepts, inferred from its
+ * parameters — `defineConfig` uses this to type the authoring surface
+ * (`base`, variant values, `class`/`className`) against the configured
+ * concatenator's own input grammar.
+ */
+type CXInput<TCX extends AnyCX> = CXInputElement<TCX> extends (infer P) ? 0 extends 1 & P ? ClassValue : [P] extends [never] ? ClassValue : [P] extends [ClassValue] ? P : [Extract<P, ClassValue>] extends [never] ? ClassValue : Extract<P, ClassValue> : ClassValue;
+type OmitUndefined<T> = T extends undefined ? never : T;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type ComposedTuple<S extends CVAComponentShape | undefined, L extends readonly CVAComponentShape[]> = [S] extends [CVAComponentShape] ? [S] : L;
+type MergedVariants<T extends readonly unknown[]> = UnionToIntersection<{ [K in keyof T]: T[K] extends {
+  config: {
+    variants?: infer V extends CVAVariantShape;
+  };
+} ? V : never; }[number]>;
+type RightMerge<A, B> = { [K in keyof A | keyof B]: K extends keyof B ? B[K] : K extends keyof A ? A[K] : never; };
+type DefaultsOf<Component> = Component extends {
+  config: {
+    defaultVariants?: infer D;
+  };
+} ? D extends undefined ? {} : D : {};
+type MergedDefaultVariants<T extends readonly unknown[]> = T extends readonly [infer Head, ...infer Rest] ? RightMerge<DefaultsOf<Head>, MergedDefaultVariants<Rest>> : {};
+type ComponentProps<Component extends (...args: any) => any> = Omit<OmitUndefined<Parameters<Component>[0]>, "class" | "className">;
+type VariantProps<Component extends (...args: any) => any> = Omit<OmitUndefined<Parameters<Component>[0]>, "class" | "className" | InternalVariantKey>;
+/**
+ * @deprecated Use the `composes` property inside `cva` instead.
+ * @example
+ * // Before
+ * const card = compose(box, stack)
+ * // After
+ * const card = cva({ composes: [box, stack] })
+ */
+interface Compose<T extends ClassValue = ClassValue> {
+  <Components extends readonly unknown[]>(...components: Components & (Components[number] extends CVAComponentShape ? unknown : never)): (props?: (UnionToIntersection<{ [K in keyof Components]: Components[K] extends CVAComponentShape ? ComponentProps<Components[K]> : never; }[number]> | undefined) & CVAClassProp<T>) => string;
+}
+interface CX<T extends ClassValue = ClassValue> {
+  (...inputs: T[]): string;
+}
+type CXOptions = Parameters<CX>;
+type CXReturn = ReturnType<CX>;
+/**
+ * Exported so TypeScript can name this type in your generated declarations
+ * (`declaration: true`) — you shouldn't really use it directly.
+ */
+type CVAVariantShape = Record<string, Record<string, ClassValue>>;
+/**
+ * Exported so TypeScript can name this type in your generated declarations
+ * (`declaration: true`) — you shouldn't really use it directly.
+ */
+interface CVAComponent<Config, Variants, T extends ClassValue = ClassValue> {
+  (props?: Variants extends CVAVariantShape ? CVAVariantSchema<Variants> & CVAClassProp<T> : CVAClassProp<T>): string;
+  /** @internal */
+  config: Config;
+}
+/**
+ * Exported so TypeScript can name this type in your generated declarations
+ * (`declaration: true`) — you shouldn't really use it directly.
+ */
+type CVAComponentShape = CVAComponent<any, any, any>;
+type CVADefaultVariants<Config> = Config extends {
+  defaultVariants?: infer D;
+} ? D : {};
+type AllVariants<Variants, ComposedSingle extends CVAComponentShape | undefined, ComposedList extends readonly CVAComponentShape[]> = [ComposedSingle] extends [undefined] ? [ComposedList] extends [readonly []] ? Variants : Variants & MergedVariants<ComposedList> : Variants & MergedVariants<ComposedTuple<ComposedSingle, ComposedList>>;
+interface CVA<T extends ClassValue = ClassValue> {
+  <_ extends InternalOnlyWarning, Config, Variants, ComposedSingle extends CVAComponentShape | undefined = undefined, ComposedList extends readonly CVAComponentShape[] = []>(config: CVAComponentConfig<Config, Variants, ComposedSingle, ComposedList, T, AllVariants<Variants, ComposedSingle, ComposedList>>): CVAComponent<Omit<Config, "defaultVariants"> & {
+    variants: AllVariants<Variants, ComposedSingle, ComposedList>;
+    defaultVariants: Omit<MergedDefaultVariants<ComposedTuple<ComposedSingle, ComposedList>>, keyof CVADefaultVariants<Config>> & CVADefaultVariants<Config>;
+  }, AllVariants<Variants, ComposedSingle, ComposedList>, T>;
+}
+interface DefineConfigOptions<TCX extends AnyCX = CX> {
+  /**
+   * The class name concatenator used by `cva`, `cx`, and `compose`. It owns
+   * the class name grammar entirely: cva assembles the authored values
+   * (composed component outputs, `base`, matched variant and compound
+   * variant values, `class`/`className`) and passes them through verbatim,
+   * one argument each, without interpreting them.
+   *
+   * The authoring surface adopts the concatenator's own input type
+   * automatically (see {@link CXInput}): pass `twMerge` and your variants
+   * are checked against tailwind-merge's `ClassNameValue`; pass `clsx` (or
+   * any function whose parameters don't narrow further) and you keep the
+   * full clsx-flavored `ClassValue` grammar.
+   */
+  cx: TCX & CXConstraint<TCX>;
+  hooks?: {
+    /**
+     * @deprecated please use the `cx` option instead
+     */
+    "cx:done"?: (className: string) => string;
+    /**
+     * @deprecated please use the `cx` option instead
+     */
+    onComplete?: (className: string) => string;
+  };
+}
+interface DefineConfig {
+  <TCX extends AnyCX>(options: DefineConfigOptions<TCX>): {
+    /**
+     * @deprecated Use the `composes` property inside `cva` instead.
+     * @example
+     * // Before
+     * const card = compose(box, stack)
+     * // After
+     * const card = cva({ composes: [box, stack] })
+     */
+    compose: Compose<CXInput<TCX>>;
+    cx: CX<CXInput<TCX>>;
+    cva: CVA<CXInput<TCX>>;
+  };
+}
+declare const defineConfig: DefineConfig;
+//#endregion
+export { defineConfig as _, CVAVariantShape as a, InternalVariantKey as b, CXOptions as c, ClassDictionary as d, ClassValue as f, VariantProps as g, DefineConfigOptions as h, CVAComponentShape as i, CXReturn as l, DefineConfig as m, CVA as n, CX as o, Compose as p, CVAComponent as r, CXInput as s, AnyCX as t, ClassArray as u, CVAComponentConfig as v, StringToBoolean as x, InternalOnlyWarning as y };
+//# sourceMappingURL=config-CE5oXWBq.d.cts.map

package/dist/config-CE5oXWBq.d.mts

@@ -0,0 +1,160 @@
+//#region src/types.d.ts
+type Uninferred<T> = [T][T extends any ? 0 : never];
+type StringToBoolean<T> = T extends "true" | "false" ? boolean : T;
+type InternalVariantKey = `_${string}`;
+type InternalOnlyWarning = "cva's generic parameters are restricted to internal use only.";
+type CVAComponentConfigBase<T extends ClassValue = ClassValue> = {
+  base?: T;
+};
+type CVAVariantSchema<V> = { [Variant in keyof V]?: StringToBoolean<keyof V[Variant]> | undefined; };
+type CVACompoundVariantSchema<V> = { [Variant in keyof V]?: StringToBoolean<keyof V[Variant]> | StringToBoolean<keyof V[Variant]>[] | undefined; };
+type CVACompoundVariants<V, T extends ClassValue> = (CVACompoundVariantSchema<V> & CVAClassProp<T>)[];
+type CVAClassProp<T extends ClassValue = ClassValue> = {
+  class?: T;
+  className?: never;
+} | {
+  class?: never;
+  className?: T;
+};
+type CVAComponentConfig<Config, Variants, ComposedSingle extends CVAComponentShape | undefined = CVAComponentShape | undefined, ComposedList extends readonly CVAComponentShape[] = readonly CVAComponentShape[], T extends ClassValue = ClassValue, Merged = Variants> = Config & {
+  composes?: ComposedSingle | readonly [...ComposedList];
+} & (Variants extends Record<string, Record<string, T>> ? CVAComponentConfigBase<T> & {
+  variants?: Variants & {
+    __proto__?: never;
+  };
+} : CVAComponentConfigBase<T> & {
+  variants?: never;
+}) & ([keyof Merged] extends [never] ? {
+  compoundVariants?: never;
+  defaultVariants?: never;
+} : {
+  compoundVariants?: CVACompoundVariants<Uninferred<Merged>, T>;
+  defaultVariants?: CVAVariantSchema<Uninferred<Merged>>;
+});
+//#endregion
+//#region src/config.d.ts
+type ClassValue = ClassArray | ClassDictionary | string | number | bigint | null | boolean | undefined;
+type ClassDictionary = Record<string, any>;
+type ClassArray = ClassValue[];
+/**
+ * Any function usable as a `cx` concatenator.
+ */
+type AnyCX = (...inputs: any[]) => string;
+type CXInputs<TCX extends AnyCX> = TCX extends ((...inputs: readonly [...infer Inputs]) => string) ? Inputs : never;
+type CXInputElement<TCX extends AnyCX> = CXInputs<TCX>[number];
+type CXHasSafeArity<TCX extends AnyCX> = CXInputs<TCX> extends (infer Inputs) ? Inputs extends readonly unknown[] ? Inputs extends [] ? true : [] extends Inputs ? number extends Inputs["length"] ? true : false : false : false : false;
+type CXConstraint<TCX extends AnyCX> = false extends CXHasSafeArity<TCX> ? "cva's cx must accept zero arguments and an unbounded rest parameter." : [TCX] extends [(...inputs: (string | CXInput<TCX>)[]) => string] ? unknown : "cva's cx must accept its inferred class values and composed strings.";
+/**
+ * The class value type a concatenator accepts, inferred from its
+ * parameters — `defineConfig` uses this to type the authoring surface
+ * (`base`, variant values, `class`/`className`) against the configured
+ * concatenator's own input grammar.
+ */
+type CXInput<TCX extends AnyCX> = CXInputElement<TCX> extends (infer P) ? 0 extends 1 & P ? ClassValue : [P] extends [never] ? ClassValue : [P] extends [ClassValue] ? P : [Extract<P, ClassValue>] extends [never] ? ClassValue : Extract<P, ClassValue> : ClassValue;
+type OmitUndefined<T> = T extends undefined ? never : T;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type ComposedTuple<S extends CVAComponentShape | undefined, L extends readonly CVAComponentShape[]> = [S] extends [CVAComponentShape] ? [S] : L;
+type MergedVariants<T extends readonly unknown[]> = UnionToIntersection<{ [K in keyof T]: T[K] extends {
+  config: {
+    variants?: infer V extends CVAVariantShape;
+  };
+} ? V : never; }[number]>;
+type RightMerge<A, B> = { [K in keyof A | keyof B]: K extends keyof B ? B[K] : K extends keyof A ? A[K] : never; };
+type DefaultsOf<Component> = Component extends {
+  config: {
+    defaultVariants?: infer D;
+  };
+} ? D extends undefined ? {} : D : {};
+type MergedDefaultVariants<T extends readonly unknown[]> = T extends readonly [infer Head, ...infer Rest] ? RightMerge<DefaultsOf<Head>, MergedDefaultVariants<Rest>> : {};
+type ComponentProps<Component extends (...args: any) => any> = Omit<OmitUndefined<Parameters<Component>[0]>, "class" | "className">;
+type VariantProps<Component extends (...args: any) => any> = Omit<OmitUndefined<Parameters<Component>[0]>, "class" | "className" | InternalVariantKey>;
+/**
+ * @deprecated Use the `composes` property inside `cva` instead.
+ * @example
+ * // Before
+ * const card = compose(box, stack)
+ * // After
+ * const card = cva({ composes: [box, stack] })
+ */
+interface Compose<T extends ClassValue = ClassValue> {
+  <Components extends readonly unknown[]>(...components: Components & (Components[number] extends CVAComponentShape ? unknown : never)): (props?: (UnionToIntersection<{ [K in keyof Components]: Components[K] extends CVAComponentShape ? ComponentProps<Components[K]> : never; }[number]> | undefined) & CVAClassProp<T>) => string;
+}
+interface CX<T extends ClassValue = ClassValue> {
+  (...inputs: T[]): string;
+}
+type CXOptions = Parameters<CX>;
+type CXReturn = ReturnType<CX>;
+/**
+ * Exported so TypeScript can name this type in your generated declarations
+ * (`declaration: true`) — you shouldn't really use it directly.
+ */
+type CVAVariantShape = Record<string, Record<string, ClassValue>>;
+/**
+ * Exported so TypeScript can name this type in your generated declarations
+ * (`declaration: true`) — you shouldn't really use it directly.
+ */
+interface CVAComponent<Config, Variants, T extends ClassValue = ClassValue> {
+  (props?: Variants extends CVAVariantShape ? CVAVariantSchema<Variants> & CVAClassProp<T> : CVAClassProp<T>): string;
+  /** @internal */
+  config: Config;
+}
+/**
+ * Exported so TypeScript can name this type in your generated declarations
+ * (`declaration: true`) — you shouldn't really use it directly.
+ */
+type CVAComponentShape = CVAComponent<any, any, any>;
+type CVADefaultVariants<Config> = Config extends {
+  defaultVariants?: infer D;
+} ? D : {};
+type AllVariants<Variants, ComposedSingle extends CVAComponentShape | undefined, ComposedList extends readonly CVAComponentShape[]> = [ComposedSingle] extends [undefined] ? [ComposedList] extends [readonly []] ? Variants : Variants & MergedVariants<ComposedList> : Variants & MergedVariants<ComposedTuple<ComposedSingle, ComposedList>>;
+interface CVA<T extends ClassValue = ClassValue> {
+  <_ extends InternalOnlyWarning, Config, Variants, ComposedSingle extends CVAComponentShape | undefined = undefined, ComposedList extends readonly CVAComponentShape[] = []>(config: CVAComponentConfig<Config, Variants, ComposedSingle, ComposedList, T, AllVariants<Variants, ComposedSingle, ComposedList>>): CVAComponent<Omit<Config, "defaultVariants"> & {
+    variants: AllVariants<Variants, ComposedSingle, ComposedList>;
+    defaultVariants: Omit<MergedDefaultVariants<ComposedTuple<ComposedSingle, ComposedList>>, keyof CVADefaultVariants<Config>> & CVADefaultVariants<Config>;
+  }, AllVariants<Variants, ComposedSingle, ComposedList>, T>;
+}
+interface DefineConfigOptions<TCX extends AnyCX = CX> {
+  /**
+   * The class name concatenator used by `cva`, `cx`, and `compose`. It owns
+   * the class name grammar entirely: cva assembles the authored values
+   * (composed component outputs, `base`, matched variant and compound
+   * variant values, `class`/`className`) and passes them through verbatim,
+   * one argument each, without interpreting them.
+   *
+   * The authoring surface adopts the concatenator's own input type
+   * automatically (see {@link CXInput}): pass `twMerge` and your variants
+   * are checked against tailwind-merge's `ClassNameValue`; pass `clsx` (or
+   * any function whose parameters don't narrow further) and you keep the
+   * full clsx-flavored `ClassValue` grammar.
+   */
+  cx: TCX & CXConstraint<TCX>;
+  hooks?: {
+    /**
+     * @deprecated please use the `cx` option instead
+     */
+    "cx:done"?: (className: string) => string;
+    /**
+     * @deprecated please use the `cx` option instead
+     */
+    onComplete?: (className: string) => string;
+  };
+}
+interface DefineConfig {
+  <TCX extends AnyCX>(options: DefineConfigOptions<TCX>): {
+    /**
+     * @deprecated Use the `composes` property inside `cva` instead.
+     * @example
+     * // Before
+     * const card = compose(box, stack)
+     * // After
+     * const card = cva({ composes: [box, stack] })
+     */
+    compose: Compose<CXInput<TCX>>;
+    cx: CX<CXInput<TCX>>;
+    cva: CVA<CXInput<TCX>>;
+  };
+}
+declare const defineConfig: DefineConfig;
+//#endregion
+export { defineConfig as _, CVAVariantShape as a, InternalVariantKey as b, CXOptions as c, ClassDictionary as d, ClassValue as f, VariantProps as g, DefineConfigOptions as h, CVAComponentShape as i, CXReturn as l, DefineConfig as m, CVA as n, CX as o, Compose as p, CVAComponent as r, CXInput as s, AnyCX as t, ClassArray as u, CVAComponentConfig as v, StringToBoolean as x, InternalOnlyWarning as y };
+//# sourceMappingURL=config-CE5oXWBq.d.mts.map

package/dist/config.cjs

@@ -0,0 +1,265 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/config.ts
+const falsyToString = (value) => typeof value === "boolean" ? `${value}` : value === 0 ? "0" : value;
+const empty = {};
+const noValues = [];
+const hasOwn = Object.prototype.hasOwnProperty;
+const ownEnumerable = Object.prototype.propertyIsEnumerable;
+const definedProps = (props, seed) => {
+	let merged = { ...seed };
+	for (const key in props) if (hasOwn.call(props, key)) {
+		const value = props[key];
+		if (key !== "class" && key !== "className" && value !== void 0) if (key === "__proto__") merged = {
+			...merged,
+			[key]: value
+		};
+		else merged[key] = value;
+	}
+	return merged;
+};
+const pushDefined = (out, value) => {
+	if (value !== void 0) out.push(value);
+};
+const pushClassProps = (out, source) => {
+	pushDefined(out, source.class);
+	pushDefined(out, source.className);
+	return out;
+};
+const mergeInto = (merged, source) => {
+	const variants = source && source.variants;
+	for (const key in variants) if (hasOwn.call(variants, key)) {
+		const values = {
+			...merged.variants[key],
+			...variants[key]
+		};
+		if (key === "__proto__") merged.variants = {
+			...merged.variants,
+			[key]: values
+		};
+		else merged.variants[key] = values;
+	}
+	merged.defaults = {
+		...merged.defaults,
+		...source && source.defaultVariants
+	};
+};
+const mergeConfig = (children, definition) => {
+	const merged = {
+		variants: {},
+		defaults: {}
+	};
+	for (let i = 0; i < children.length; i++) mergeInto(merged, children[i].config);
+	mergeInto(merged, definition);
+	return merged;
+};
+const prepareVariants = (localVariants, defaults) => {
+	const names = [];
+	const maps = [];
+	for (const key in localVariants) if (hasOwn.call(localVariants, key)) {
+		names.push(key);
+		maps.push(localVariants[key]);
+	}
+	if (!names.length) return {
+		variantKeys: noValues,
+		variantMaps: noValues,
+		defaultClasses: noValues
+	};
+	return {
+		variantKeys: names.slice(),
+		variantMaps: maps.slice(),
+		defaultClasses: names.map((key, i) => maps[i][falsyToString(defaults[key])])
+	};
+};
+const compoundMatches = (compound, indexes, selectors, values) => {
+	for (let i = compound.start; i < compound.end; i++) {
+		const selector = selectors[i];
+		const value = values[indexes[i]];
+		if (Array.isArray(selector) ? !selector.includes(value) : value !== selector) return false;
+	}
+	return true;
+};
+const prepareCompounds = (compoundVariants, variantKeys, defaults) => {
+	const keys = variantKeys.slice();
+	const compounds = [];
+	const indexes = [];
+	const selectors = [];
+	for (let i = 0; i < compoundVariants.length; i++) {
+		const compound = compoundVariants[i];
+		const start = indexes.length;
+		let mask = 0;
+		for (const key in compound) if (hasOwn.call(compound, key)) {
+			const selector = compound[key];
+			if (key !== "class" && key !== "className") {
+				let index = keys.indexOf(key);
+				if (index === -1) index = keys.push(key) - 1;
+				indexes.push(index);
+				selectors.push(selector);
+				mask |= 1 << index;
+			}
+		}
+		compounds.push({
+			start,
+			end: indexes.length,
+			mask,
+			matchesDefaults: false,
+			class: compound.class,
+			className: compound.className
+		});
+	}
+	const defaultValues = keys.map((key) => defaults[key]);
+	for (let i = 0; i < compounds.length; i++) compounds[i].matchesDefaults = compoundMatches(compounds[i], indexes, selectors, defaultValues);
+	return {
+		keys: keys.slice(),
+		defaultValues,
+		compounds: compounds.slice(),
+		indexes: indexes.slice(),
+		selectors: selectors.slice()
+	};
+};
+const createPlainComponent = (cxArray, defaultOut, singleDefaultClass) => (input) => {
+	const props = input || empty;
+	const classValue = props.class;
+	const classNameValue = props.className;
+	if (classValue === void 0 && singleDefaultClass !== void 0) return cxArray(classNameValue === void 0 ? [singleDefaultClass] : [singleDefaultClass, classNameValue]);
+	const out = defaultOut.slice();
+	pushDefined(out, classValue);
+	pushDefined(out, classNameValue);
+	return cxArray(out);
+};
+const defineConfig = ((options) => {
+	const cxArray = (inputs) => {
+		const className = Reflect.apply(options.cx, options, inputs);
+		const hooks = options.hooks || empty;
+		let hook = hooks["cx:done"];
+		if (hook == null) hook = hooks.onComplete;
+		return hook ? hook(className) : className;
+	};
+	const cx = (...inputs) => cxArray(inputs.filter((input) => input !== void 0));
+	const cva = ((config) => {
+		const definition = config || empty;
+		const composes = definition.composes;
+		const base = definition.base;
+		const children = composes == null ? noValues : Array.isArray(composes) ? composes.slice() : [composes];
+		const childCount = children.length;
+		const { variants: mergedVariants, defaults } = mergeConfig(children, definition);
+		const { variantKeys, variantMaps, defaultClasses } = prepareVariants(definition.variants, defaults);
+		const variantCount = variantKeys.length;
+		const prepared = definition.compoundVariants ? prepareCompounds(definition.compoundVariants, variantKeys, defaults) : void 0;
+		const keys = prepared ? prepared.keys : variantKeys;
+		const keyCount = keys.length;
+		const compounds = prepared ? prepared.compounds : noValues;
+		const compoundCount = compounds.length;
+		const indexes = prepared ? prepared.indexes : noValues;
+		const selectors = prepared ? prepared.selectors : noValues;
+		const defaultValues = prepared ? prepared.defaultValues : noValues;
+		const onlyBase = !variantCount && !compoundCount;
+		const assembled = onlyBase && base !== void 0 ? [base] : [];
+		if (!onlyBase) pushDefined(assembled, base);
+		for (let i = 0; i < variantCount; i++) pushDefined(assembled, defaultClasses[i]);
+		for (let i = 0; i < compoundCount; i++) {
+			const compound = compounds[i];
+			if (compound.matchesDefaults) pushClassProps(assembled, compound);
+		}
+		const defaultOut = onlyBase ? assembled : assembled.slice();
+		const singleDefaultClass = defaultOut.length === 1 ? defaultOut[0] : void 0;
+		const component = !keyCount && !childCount ? createPlainComponent(cxArray, defaultOut, singleDefaultClass) : (input) => {
+			const props = input || empty;
+			const classValue = props.class;
+			const classNameValue = props.className;
+			let supplied = 0;
+			const variantClasses = variantCount ? new Array(variantCount) : void 0;
+			const resolved = compoundCount ? new Array(keyCount) : void 0;
+			for (let i = 0; i < keyCount; i++) {
+				const key = keys[i];
+				const own = compoundCount !== 0 && ownEnumerable.call(props, key);
+				const value = i < variantCount || own ? props[key] : void 0;
+				if (value !== void 0) supplied |= i < 31 ? 1 << i : -1;
+				if (variantClasses && i < variantCount) {
+					const variantKey = falsyToString(value);
+					variantClasses[i] = variantKey ? variantMaps[i][variantKey] : defaultClasses[i];
+				}
+				if (resolved) resolved[i] = own && value !== void 0 ? value : defaultValues[i];
+			}
+			if (!childCount && !supplied) {
+				if (classValue === void 0) {
+					if (singleDefaultClass !== void 0) return cxArray(classNameValue === void 0 ? [singleDefaultClass] : [singleDefaultClass, classNameValue]);
+					if (classNameValue === void 0) return cxArray(defaultOut);
+				}
+				const out = defaultOut.slice();
+				pushDefined(out, classValue);
+				pushDefined(out, classNameValue);
+				return cxArray(out);
+			}
+			const out = [];
+			if (childCount) {
+				const forwarded = definedProps(props, defaults);
+				for (let i = 0; i < childCount; i++) {
+					const child = children[i];
+					pushDefined(out, child({ ...forwarded }));
+				}
+			}
+			pushDefined(out, base);
+			if (variantClasses) for (let i = 0; i < variantCount; i++) pushDefined(out, variantClasses[i]);
+			if (resolved) for (let i = 0; i < compoundCount; i++) {
+				const compound = compounds[i];
+				let matched = compound.matchesDefaults;
+				if (supplied & compound.mask) {
+					matched = true;
+					for (let j = compound.start; j < compound.end; j++) {
+						const selector = selectors[j];
+						const value = resolved[indexes[j]];
+						if (Array.isArray(selector) ? !selector.includes(value) : value !== selector) {
+							matched = false;
+							break;
+						}
+					}
+				}
+				if (matched) pushClassProps(out, compound);
+			}
+			pushDefined(out, classValue);
+			pushDefined(out, classNameValue);
+			return cxArray(out);
+		};
+		component.config = {
+			...config,
+			variants: mergedVariants,
+			defaultVariants: defaults
+		};
+		return component;
+	});
+	const compose = (...components) => {
+		const composed = components;
+		const config = {};
+		for (let i = 0; i < composed.length; i++) {
+			const source = composed[i].config;
+			for (const key in source) if (hasOwn.call(source, key)) {
+				const value = source[key];
+				config[key] = value && typeof value === "object" && !Array.isArray(value) ? {
+					...config[key],
+					...value
+				} : value;
+			}
+		}
+		const component = (input) => {
+			const props = input || empty;
+			const forwarded = definedProps(props);
+			const out = [];
+			for (let i = 0; i < composed.length; i++) {
+				const child = composed[i];
+				pushDefined(out, child(forwarded));
+			}
+			return cxArray(pushClassProps(out, props));
+		};
+		component.config = config;
+		return component;
+	};
+	return {
+		compose,
+		cva,
+		cx
+	};
+});
+//#endregion
+exports.defineConfig = defineConfig;
+
+//# sourceMappingURL=config.cjs.map