@fea-ui/react 0.0.0-canary.2

package/dist/index.cjs

@@ -0,0 +1,2356 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let tailwind_variants = require("tailwind-variants");
+let _base_ui_react = require("@base-ui/react");
+let lucide_react = require("lucide-react");
+let react = require("react");
+react = __toESM(react);
+let react_jsx_runtime = require("react/jsx-runtime");
+let _radix_ui_react_slot = require("@radix-ui/react-slot");
+
+//#region src/components/accordion/accordion.context.ts
+const AccordionContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/accordion/accordion.variants.ts
+const accordionVariants = (0, tailwind_variants.tv)({ slots: {
+	content: "accordion__content",
+	header: "accordion__header",
+	item: "accordion__item",
+	panel: "accordion__panel",
+	root: "accordion",
+	trigger: "accordion__trigger",
+	triggerIcon: "accordion__trigger-icon"
+} });
+
+//#endregion
+//#region src/components/accordion/use-accordion.ts
+const useAccordion = () => {
+	const context = (0, react.useContext)(AccordionContext);
+	if (!context) throw new Error("useAccordion must be used within a AccordionProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/accordion/accordion.tsx
+const Accordion = ({ className, ...props }) => {
+	const slots = (0, react.useMemo)(() => accordionVariants({}), []);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(AccordionContext.Provider, {
+		value: { slots },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Accordion.Root, {
+			className: (0, tailwind_variants.cn)(className, slots.root()),
+			...props
+		})
+	});
+};
+const AccordionItem = ({ className, ...props }) => {
+	const { slots } = useAccordion();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Accordion.Item, {
+		className: (0, tailwind_variants.cn)(className, slots.item()),
+		...props
+	});
+};
+const AccordionHeader = ({ className, ...props }) => {
+	const { slots } = useAccordion();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Accordion.Header, {
+		className: (0, tailwind_variants.cn)(className, slots.header()),
+		...props
+	});
+};
+const AccordionTrigger = ({ className, ...props }) => {
+	const { slots } = useAccordion();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Accordion.Trigger, {
+		className: (0, tailwind_variants.cn)(className, slots.trigger()),
+		...props
+	});
+};
+const AccordionTriggerIcon = ({ className, ...props }) => {
+	const { slots } = useAccordion();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(lucide_react.LucideChevronDown, {
+		className: (0, tailwind_variants.cn)(className, slots.triggerIcon()),
+		...props
+	});
+};
+const AccordionPanel = ({ className, ...props }) => {
+	const { slots } = useAccordion();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Accordion.Panel, {
+		className: (0, tailwind_variants.cn)(className, slots.panel()),
+		...props
+	});
+};
+const AccordionContent = ({ className, ...props }) => {
+	const { slots } = useAccordion();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		className: (0, tailwind_variants.cn)(className, slots.content()),
+		...props
+	});
+};
+var accordion_default = Object.assign(Accordion, {
+	Content: AccordionContent,
+	Header: AccordionHeader,
+	Item: AccordionItem,
+	Panel: AccordionPanel,
+	Root: Accordion,
+	Trigger: AccordionTrigger,
+	TriggerIcon: AccordionTriggerIcon
+});
+
+//#endregion
+//#region src/components/alert/alert.context.ts
+const AlertContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/alert/alert.variants.ts
+const alertVariants = (0, tailwind_variants.tv)({
+	defaultVariants: { variant: "info" },
+	slots: {
+		content: "alert__content",
+		description: "alert__description",
+		indicator: "alert__indicator",
+		root: "alert",
+		title: "alert__title"
+	},
+	variants: { variant: {
+		danger: { root: "alert--danger" },
+		info: { root: "alert--info" },
+		primary: { root: "alert--primary" },
+		success: { root: "alert--success" },
+		warning: { root: "alert--warning" }
+	} }
+});
+
+//#endregion
+//#region src/components/alert/use-alert.ts
+const useAlert = () => {
+	const context = (0, react.useContext)(AlertContext);
+	if (!context) throw new Error("useAlert must be used within a AlertProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/alert/alert.tsx
+const Alert = ({ className, variant, ...props }) => {
+	const slots = (0, react.useMemo)(() => alertVariants({
+		className,
+		variant
+	}), [className, variant]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(AlertContext, {
+		value: {
+			slots,
+			variant
+		},
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+			className: (0, tailwind_variants.cn)(className, slots.root()),
+			...props
+		})
+	});
+};
+const AlertIndicator = ({ className, children, ...props }) => {
+	const { slots, variant } = useAlert();
+	const IndicatorIcon = ({ children: children$1 }) => {
+		if (children$1) return children$1;
+		switch (variant) {
+			case "danger": return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(lucide_react.LucideXCircle, {});
+			case "success": return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(lucide_react.LucideCheckCircle, {});
+			case "warning": return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(lucide_react.LucideAlertTriangle, {});
+			default: return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(lucide_react.LucideInfo, {});
+		}
+	};
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		className: (0, tailwind_variants.cn)(className, slots.indicator()),
+		...props,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IndicatorIcon, { children })
+	});
+};
+const AlertContent = ({ className, ...props }) => {
+	const { slots } = useAlert();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		className: (0, tailwind_variants.cn)(className, slots.content()),
+		...props
+	});
+};
+const AlertTitle = ({ className, ...props }) => {
+	const { slots } = useAlert();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		className: (0, tailwind_variants.cn)(className, slots.title()),
+		...props
+	});
+};
+const AlertDescription = ({ className, ...props }) => {
+	const { slots } = useAlert();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		className: (0, tailwind_variants.cn)(className, slots.description()),
+		...props
+	});
+};
+var alert_default = Object.assign(Alert, {
+	Content: AlertContent,
+	Description: AlertDescription,
+	Indicator: AlertIndicator,
+	Root: Alert,
+	Title: AlertTitle
+});
+
+//#endregion
+//#region src/components/alert-dialog/alert-dialog.context.ts
+const AlertDialogContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/alert-dialog/alert-dialog.variants.ts
+const alertDialogVariants = (0, tailwind_variants.tv)({ slots: {
+	backdrop: "alert-dialog__backdrop",
+	close: "alert-dialog__close",
+	description: "alert-dialog__description",
+	popup: "alert-dialog__popup",
+	portal: "alert-dialog__portal",
+	root: "alert-dialog",
+	title: "alert-dialog__title",
+	trigger: "alert-dialog__trigger",
+	viewport: "alert-dialog__viewport"
+} });
+
+//#endregion
+//#region src/components/alert-dialog/use-alert-dialog.ts
+const useAlertDialog = () => {
+	const context = (0, react.useContext)(AlertDialogContext);
+	if (!context) throw new Error("useAlertDialog must be used within a AlertDialogProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/alert-dialog/alert-dialog.tsx
+const AlertDialog = ({ ...props }) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(AlertDialogContext, {
+		value: { slots: (0, react.useMemo)(() => alertDialogVariants(), []) },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.AlertDialog.Root, { ...props })
+	});
+};
+const AlertDialogTrigger = ({ className, ...props }) => {
+	const { slots } = useAlertDialog();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.AlertDialog.Trigger, {
+		className: (0, tailwind_variants.cn)(slots.trigger(), className),
+		...props
+	});
+};
+const AlertDialogPortal = ({ className, ...props }) => {
+	const { slots } = useAlertDialog();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.AlertDialog.Portal, {
+		className: (0, tailwind_variants.cn)(slots.portal(), className),
+		...props
+	});
+};
+const AlertDialogBackdrop = ({ className, ...props }) => {
+	const { slots } = useAlertDialog();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.AlertDialog.Backdrop, {
+		className: (0, tailwind_variants.cn)(slots.backdrop(), className),
+		...props
+	});
+};
+const AlertDialogViewport = ({ className, ...props }) => {
+	const { slots } = useAlertDialog();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.AlertDialog.Viewport, {
+		className: (0, tailwind_variants.cn)(slots.viewport(), className),
+		...props
+	});
+};
+const AlertDialogPopup = ({ className, ...props }) => {
+	const { slots } = useAlertDialog();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.AlertDialog.Popup, {
+		className: (0, tailwind_variants.cn)(slots.popup(), className),
+		...props
+	});
+};
+const AlertDialogTitle = ({ className, ...props }) => {
+	const { slots } = useAlertDialog();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.AlertDialog.Title, {
+		className: (0, tailwind_variants.cn)(slots.title(), className),
+		...props
+	});
+};
+const AlertDialogDescription = ({ className, ...props }) => {
+	const { slots } = useAlertDialog();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.AlertDialog.Description, {
+		className: (0, tailwind_variants.cn)(slots.description(), className),
+		...props
+	});
+};
+const AlertDialogClose = ({ className, children, ...props }) => {
+	const { slots } = useAlertDialog();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.AlertDialog.Close, {
+		className: (0, tailwind_variants.cn)(slots.close(), className),
+		...props,
+		children: children ?? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(lucide_react.LucideX, {})
+	});
+};
+var alert_dialog_default = Object.assign(AlertDialog, {
+	Backdrop: AlertDialogBackdrop,
+	Close: AlertDialogClose,
+	Description: AlertDialogDescription,
+	Popup: AlertDialogPopup,
+	Portal: AlertDialogPortal,
+	Root: AlertDialog,
+	Title: AlertDialogTitle,
+	Trigger: AlertDialogTrigger,
+	Viewport: AlertDialogViewport
+});
+
+//#endregion
+//#region src/components/avatar/avatar.context.ts
+const AvatarContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/avatar/avatar.variants.ts
+const avatarVariants = (0, tailwind_variants.tv)({
+	defaultVariants: { size: "md" },
+	slots: {
+		fallback: "avatar__fallback",
+		image: "avatar__image",
+		root: "avatar"
+	},
+	variants: { size: {
+		lg: { root: "avatar--lg" },
+		md: { root: "avatar--md" },
+		sm: { root: "avatar--sm" }
+	} }
+});
+
+//#endregion
+//#region src/components/avatar/use-avatar.ts
+const useAvatar = () => {
+	const ctx = (0, react.useContext)(AvatarContext);
+	if (!ctx) throw new Error("useAvatar must be used within the Avatar component.");
+	return ctx;
+};
+
+//#endregion
+//#region src/components/avatar/avatar.tsx
+const Avatar = ({ className, size, ...props }) => {
+	const slots = (0, react.useMemo)(() => avatarVariants({ size }), [size]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(AvatarContext.Provider, {
+		value: { slots },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Avatar.Root, {
+			className: (0, tailwind_variants.cn)(className, slots.root()),
+			...props
+		})
+	});
+};
+const AvatarImage = ({ className, ...props }) => {
+	const { slots } = useAvatar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Avatar.Image, {
+		className: (0, tailwind_variants.cn)(className, slots.image()),
+		...props
+	});
+};
+const AvatarFallback = ({ className, ...props }) => {
+	const { slots } = useAvatar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Avatar.Fallback, {
+		className: (0, tailwind_variants.cn)(className, slots.fallback()),
+		...props
+	});
+};
+var avatar_default = Object.assign(Avatar, {
+	Fallback: AvatarFallback,
+	Image: AvatarImage,
+	Root: Avatar
+});
+
+//#endregion
+//#region src/components/button/button.variants.ts
+const buttonVariants = (0, tailwind_variants.tv)({
+	base: "button",
+	defaultVariants: {
+		isIconOnly: false,
+		size: "md",
+		variant: "primary"
+	},
+	variants: {
+		isIconOnly: { true: "button--icon-only" },
+		size: {
+			lg: "button--lg",
+			md: "button--md",
+			sm: "button--sm"
+		},
+		variant: {
+			danger: "button--danger",
+			ghost: "button--ghost",
+			outline: "button--outline",
+			primary: "button--primary",
+			secondary: "button--secondary"
+		}
+	}
+});
+
+//#endregion
+//#region src/components/button/button.tsx
+const Button = ({ className, variant, size, isIconOnly, ...props }) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Button, {
+		className: (0, tailwind_variants.cn)(buttonVariants({
+			isIconOnly,
+			size,
+			variant
+		}), className),
+		...props
+	});
+};
+var button_default = Button;
+
+//#endregion
+//#region src/components/button-group/button-group.variants.ts
+const buttonGroupVariants = (0, tailwind_variants.tv)({ base: "button-group" });
+
+//#endregion
+//#region src/components/button-group/button-group.tsx
+const ButtonGroup = ({ className, ...props }) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		className: (0, tailwind_variants.cn)(className, buttonGroupVariants()),
+		...props
+	});
+};
+var button_group_default = ButtonGroup;
+
+//#endregion
+//#region src/components/card/card.context.ts
+const CardContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/card/card.variants.ts
+const cardVariants = (0, tailwind_variants.tv)({
+	defaultVariants: { variant: "default" },
+	slots: {
+		body: "card__body",
+		description: "card__description",
+		footer: "card__footer",
+		header: "card__header",
+		root: "card",
+		title: "card__title"
+	},
+	variants: { variant: {
+		default: { root: "card--default" },
+		transparent: { root: "card--transparent" }
+	} }
+});
+
+//#endregion
+//#region src/components/card/use-card.ts
+const useCard = () => {
+	const ctx = (0, react.useContext)(CardContext);
+	if (!ctx) throw new Error("CardContext must be used with in the Card component.");
+	return ctx;
+};
+
+//#endregion
+//#region src/components/card/card.tsx
+const Card = ({ className, variant, ...props }) => {
+	const slots = (0, react.useMemo)(() => cardVariants({ variant }), [variant]);
+	console.log(slots);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CardContext.Provider, {
+		value: { slots },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+			className: (0, tailwind_variants.cn)(className, slots.root()),
+			...props
+		})
+	});
+};
+const CardHeader = ({ className, ...props }) => {
+	const { slots } = useCard();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		className: (0, tailwind_variants.cn)(className, slots.header()),
+		...props
+	});
+};
+const CardBody = ({ className, ...props }) => {
+	const { slots } = useCard();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		className: (0, tailwind_variants.cn)(className, slots.body()),
+		...props
+	});
+};
+const CardFooter = ({ className, ...props }) => {
+	const { slots } = useCard();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		className: (0, tailwind_variants.cn)(className, slots.footer()),
+		...props
+	});
+};
+const CardTitle = ({ className, ...props }) => {
+	const { slots } = useCard();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("h2", {
+		className: (0, tailwind_variants.cn)(className, slots.title()),
+		...props
+	});
+};
+const CardDescription = ({ className, ...props }) => {
+	const { slots } = useCard();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+		className: (0, tailwind_variants.cn)(className, slots.description()),
+		...props
+	});
+};
+/** Exports */
+var card_default = Object.assign(Card, {
+	Body: CardBody,
+	Description: CardDescription,
+	Footer: CardFooter,
+	Header: CardHeader,
+	Root: Card,
+	Title: CardTitle
+});
+
+//#endregion
+//#region src/components/checkbox/checkbox.context.ts
+const CheckboxContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/checkbox/checkbox.variants.ts
+const checkboxVariants = (0, tailwind_variants.tv)({ slots: {
+	indicator: "checkbox__indicator",
+	root: "checkbox"
+} });
+
+//#endregion
+//#region src/components/checkbox/use-checkbox.ts
+const useCheckbox = () => {
+	const context = (0, react.useContext)(CheckboxContext);
+	if (!context) throw new Error("useCheckbox must be used within a CheckboxProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/checkbox/checkbox.tsx
+const Checkbox = ({ className, ...props }) => {
+	const slots = (0, react.useMemo)(() => checkboxVariants({}), []);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CheckboxContext, {
+		value: { slots },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Checkbox.Root, {
+			className: (0, tailwind_variants.cn)(className, slots.root()),
+			...props
+		})
+	});
+};
+const CheckboxIndicator = ({ className, children, ...props }) => {
+	const { slots } = useCheckbox();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Checkbox.Indicator, {
+		className: (0, tailwind_variants.cn)(className, slots.indicator()),
+		...props,
+		children: children ?? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(lucide_react.LucideCheck, {})
+	});
+};
+var checkbox_default = Object.assign(Checkbox, {
+	Indicator: CheckboxIndicator,
+	Root: Checkbox
+});
+
+//#endregion
+//#region src/components/checkbox-group/checkbox-group.variants.ts
+const checkboxGroupVariants = (0, tailwind_variants.tv)({ base: "checkbox-group" });
+
+//#endregion
+//#region src/components/checkbox-group/checkbox-group.tsx
+const CheckboxGroup = ({ className, ...props }) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.CheckboxGroup, {
+		className: (0, tailwind_variants.cn)(className, checkboxGroupVariants()),
+		...props
+	});
+};
+var checkbox_group_default = CheckboxGroup;
+
+//#endregion
+//#region src/components/chip/chip.variants.ts
+const chipVariants = (0, tailwind_variants.tv)({
+	base: "chip",
+	defaultVariants: {
+		size: "md",
+		variant: "primary"
+	},
+	variants: {
+		size: {
+			lg: "chip--lg",
+			md: "chip--md",
+			sm: "chip--sm"
+		},
+		variant: {
+			danger: "chip--danger",
+			outline: "chip--outline",
+			primary: "chip--primary",
+			secondary: "chip--secondary",
+			success: "chip--success"
+		}
+	}
+});
+
+//#endregion
+//#region src/components/chip/chip.tsx
+const Chip = ({ className, variant, size, ...props }) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+		className: (0, tailwind_variants.cn)(className, chipVariants({
+			size,
+			variant
+		})),
+		...props
+	});
+};
+var chip_default = Chip;
+
+//#endregion
+//#region src/components/container/container.variants.ts
+const containerVariants = (0, tailwind_variants.tv)({ base: "container" });
+
+//#endregion
+//#region src/components/container/container.tsx
+const Container = ({ className, ...props }) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		className: (0, tailwind_variants.cn)(className, containerVariants()),
+		...props
+	});
+};
+var container_default = Container;
+
+//#endregion
+//#region src/components/dialog/dialog.context.ts
+const DialogContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/dialog/dialog.variants.ts
+const dialogVariants = (0, tailwind_variants.tv)({ slots: {
+	backdrop: "dialog__backdrop",
+	close: "dialog__close",
+	description: "dialog__description",
+	popup: "dialog__popup",
+	portal: "dialog__portal",
+	root: "dialog",
+	title: "dialog__title",
+	trigger: "dialog__trigger",
+	viewport: "dialog__viewport"
+} });
+
+//#endregion
+//#region src/components/dialog/use-dialog.ts
+const useDialog = () => {
+	const context = (0, react.useContext)(DialogContext);
+	if (!context) throw new Error("useDialog must be used within a DialogProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/dialog/dialog.tsx
+const Dialog = ({ ...props }) => {
+	const slots = (0, react.useMemo)(() => dialogVariants(), []);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(DialogContext.Provider, {
+		value: { slots },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Dialog.Root, { ...props })
+	});
+};
+const DialogTrigger = ({ className, ...props }) => {
+	const { slots } = useDialog();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Dialog.Trigger, {
+		className: (0, tailwind_variants.cn)(slots.trigger(), className),
+		...props
+	});
+};
+const DialogPortal = ({ className, ...props }) => {
+	const { slots } = useDialog();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Dialog.Portal, {
+		className: (0, tailwind_variants.cn)(slots.portal(), className),
+		...props
+	});
+};
+const DialogBackdrop = ({ className, ...props }) => {
+	const { slots } = useDialog();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Dialog.Backdrop, {
+		className: (0, tailwind_variants.cn)(slots.backdrop(), className),
+		...props
+	});
+};
+const DialogViewport = ({ className, ...props }) => {
+	const { slots } = useDialog();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Dialog.Viewport, {
+		className: (0, tailwind_variants.cn)(slots.viewport(), className),
+		...props
+	});
+};
+const DialogPopup = ({ className, ...props }) => {
+	const { slots } = useDialog();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Dialog.Popup, {
+		className: (0, tailwind_variants.cn)(slots.popup(), className),
+		...props
+	});
+};
+const DialogTitle = ({ className, ...props }) => {
+	const { slots } = useDialog();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Dialog.Title, {
+		className: (0, tailwind_variants.cn)(slots.title(), className),
+		...props
+	});
+};
+const DialogDescription = ({ className, ...props }) => {
+	const { slots } = useDialog();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Dialog.Description, {
+		className: (0, tailwind_variants.cn)(slots.description(), className),
+		...props
+	});
+};
+const DialogClose = ({ className, ...props }) => {
+	const { slots } = useDialog();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Dialog.Close, {
+		className: (0, tailwind_variants.cn)(slots.close(), className),
+		...props,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(lucide_react.LucideX, {})
+	});
+};
+var dialog_default = Object.assign(Dialog, {
+	Backdrop: DialogBackdrop,
+	Close: DialogClose,
+	Description: DialogDescription,
+	Popup: DialogPopup,
+	Portal: DialogPortal,
+	Root: Dialog,
+	Title: DialogTitle,
+	Trigger: DialogTrigger,
+	Viewport: DialogViewport
+});
+
+//#endregion
+//#region src/components/drawer/drawer.context.ts
+const DrawerContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/drawer/drawer.variants.ts
+const drawerVariants = (0, tailwind_variants.tv)({
+	defaultVariants: { position: "left" },
+	slots: {
+		backdrop: "drawer__backdrop",
+		close: "drawer__close",
+		description: "drawer__description",
+		popup: "drawer__popup",
+		portal: "drawer__portal",
+		root: "drawer",
+		title: "drawer__title",
+		trigger: "drawer__trigger",
+		viewport: "drawer__viewport"
+	},
+	variants: { position: {
+		bottom: { popup: "drawer--bottom" },
+		left: { popup: "drawer--left" },
+		right: { popup: "drawer--right" },
+		top: { popup: "drawer--top" }
+	} }
+});
+
+//#endregion
+//#region src/components/drawer/use-drawer.ts
+const useDrawer = () => {
+	const context = (0, react.useContext)(DrawerContext);
+	if (!context) throw new Error("useDrawer must be used within a DrawerProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/drawer/drawer.tsx
+const Drawer = ({ position, ...props }) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(DrawerContext, {
+		value: { slots: (0, react.useMemo)(() => drawerVariants({ position }), [position]) },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Dialog.Root, { ...props })
+	});
+};
+const DrawerTrigger = ({ className, ...props }) => {
+	const { slots } = useDrawer();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Dialog.Trigger, {
+		className: (0, tailwind_variants.cn)(slots.trigger(), className),
+		...props
+	});
+};
+const DrawerPortal = ({ className, ...props }) => {
+	const { slots } = useDrawer();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Dialog.Portal, {
+		className: (0, tailwind_variants.cn)(slots.portal(), className),
+		...props
+	});
+};
+const DrawerBackdrop = ({ className, ...props }) => {
+	const { slots } = useDrawer();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Dialog.Backdrop, {
+		className: (0, tailwind_variants.cn)(slots.backdrop(), className),
+		...props
+	});
+};
+const DrawerViewport = ({ className, ...props }) => {
+	const { slots } = useDrawer();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Dialog.Viewport, {
+		className: (0, tailwind_variants.cn)(slots.viewport(), className),
+		...props
+	});
+};
+const DrawerPopup = ({ className, ...props }) => {
+	const { slots } = useDrawer();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Dialog.Popup, {
+		className: (0, tailwind_variants.cn)(slots.popup(), className),
+		...props
+	});
+};
+const DrawerTitle = ({ className, ...props }) => {
+	const { slots } = useDrawer();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Dialog.Title, {
+		className: (0, tailwind_variants.cn)(slots.title(), className),
+		...props
+	});
+};
+const DrawerDescription = ({ className, ...props }) => {
+	const { slots } = useDrawer();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Dialog.Description, {
+		className: (0, tailwind_variants.cn)(slots.description(), className),
+		...props
+	});
+};
+const DrawerClose = ({ className, children, ...props }) => {
+	const { slots } = useDrawer();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Dialog.Close, {
+		className: (0, tailwind_variants.cn)(slots.close(), className),
+		...props,
+		children: children ?? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(lucide_react.LucideX, {})
+	});
+};
+var drawer_default = Object.assign(Drawer, {
+	Backdrop: DrawerBackdrop,
+	Close: DrawerClose,
+	Description: DrawerDescription,
+	Popup: DrawerPopup,
+	Portal: DrawerPortal,
+	Root: Drawer,
+	Title: DrawerTitle,
+	Trigger: DrawerTrigger,
+	Viewport: DrawerViewport
+});
+
+//#endregion
+//#region src/components/field/field.context.ts
+const FieldContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/field/field.variants.ts
+const fieldVariants = (0, tailwind_variants.tv)({ slots: {
+	control: "input field__control",
+	description: "field__description",
+	error: "field__error",
+	label: "label field__label",
+	root: "field"
+} });
+
+//#endregion
+//#region src/components/field/use-field.ts
+const useField = () => {
+	const context = (0, react.useContext)(FieldContext);
+	if (!context) throw new Error("useField must be used within a FieldProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/field/field.tsx
+const FieldRoot = ({ className, required, ...props }) => {
+	const slots = (0, react.useMemo)(() => fieldVariants({}), []);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FieldContext, {
+		value: {
+			required,
+			slots
+		},
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Field.Root, {
+			className: (0, tailwind_variants.cn)(className, slots.root()),
+			"data-required": required,
+			...props
+		})
+	});
+};
+const FieldLabel = ({ className, ...props }) => {
+	const { slots } = useField();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Field.Label, {
+		className: (0, tailwind_variants.cn)(className, slots.label()),
+		...props
+	});
+};
+const FieldControl = ({ className, ...props }) => {
+	const { slots, required } = useField();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Field.Control, {
+		className: (0, tailwind_variants.cn)(className, slots.control()),
+		required,
+		...props
+	});
+};
+const FieldDescription = ({ className, ...props }) => {
+	const { slots } = useField();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Field.Description, {
+		className: (0, tailwind_variants.cn)(className, slots.description()),
+		...props
+	});
+};
+const FieldError = ({ className, ...props }) => {
+	const { slots } = useField();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Field.Error, {
+		className: (0, tailwind_variants.cn)(className, slots.error()),
+		...props
+	});
+};
+var field_default = Object.assign(FieldRoot, {
+	Control: FieldControl,
+	Description: FieldDescription,
+	Error: FieldError,
+	Label: FieldLabel,
+	Root: FieldRoot
+});
+
+//#endregion
+//#region src/components/fieldset/fieldset.context.ts
+const FieldsetContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/fieldset/fieldset.variants.ts
+const fieldsetVariants = (0, tailwind_variants.tv)({ slots: {
+	legend: "fieldset__legend",
+	root: "fieldset"
+} });
+
+//#endregion
+//#region src/components/fieldset/use-fieldset.ts
+const useFieldset = () => {
+	const context = (0, react.useContext)(FieldsetContext);
+	if (!context) throw new Error("useFieldset must be used within a FieldsetProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/fieldset/fieldset.tsx
+const Fieldset = ({ className, ...props }) => {
+	const slots = (0, react.useMemo)(() => fieldsetVariants(), []);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FieldsetContext, {
+		value: { slots },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Fieldset.Root, {
+			className: (0, tailwind_variants.cn)(className, slots.root()),
+			...props
+		})
+	});
+};
+const FieldsetLegend = ({ className, ...props }) => {
+	const { slots } = useFieldset();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Fieldset.Legend, {
+		className: (0, tailwind_variants.cn)(slots.legend(), className),
+		...props
+	});
+};
+var fieldset_default = Object.assign(Fieldset, {
+	Legend: FieldsetLegend,
+	Root: Fieldset
+});
+
+//#endregion
+//#region src/components/form/form.variants.ts
+const formVariants = (0, tailwind_variants.tv)({ base: "form" });
+
+//#endregion
+//#region src/components/form/form.tsx
+const Form = ({ className, ...props }) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Form, {
+		className: (0, tailwind_variants.cn)(className, formVariants()),
+		...props
+	});
+};
+var form_default = Form;
+
+//#endregion
+//#region src/components/icon-button/icon-button.variants.ts
+const iconButtonVariants = (0, tailwind_variants.tv)({
+	base: "icon-button",
+	defaultVariants: { isIconOnly: true },
+	extend: buttonVariants
+});
+
+//#endregion
+//#region src/components/icon-button/icon-button.tsx
+const IconButton = ({ className, variant, size, isIconOnly, ...props }) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(button_default, {
+		className: (0, tailwind_variants.cn)(className, iconButtonVariants({
+			isIconOnly,
+			size,
+			variant
+		})),
+		...props
+	});
+};
+var icon_button_default = IconButton;
+
+//#endregion
+//#region src/components/input/input.variants.ts
+const inputVariants = (0, tailwind_variants.tv)({ base: "input" });
+
+//#endregion
+//#region src/components/input/input.tsx
+const Input = ({ className, ...props }) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Input, {
+		className: (0, tailwind_variants.cn)(className, inputVariants()),
+		...props
+	});
+};
+var input_default = Input;
+
+//#endregion
+//#region src/components/label/label.variants.ts
+const labelVariants = (0, tailwind_variants.tv)({ base: "label" });
+
+//#endregion
+//#region src/components/label/label.tsx
+const Label = ({ className, ...props }) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", {
+		className: (0, tailwind_variants.cn)(className, labelVariants()),
+		...props
+	});
+};
+var label_default = Label;
+
+//#endregion
+//#region src/components/link/link.variants.ts
+const linkVariants = (0, tailwind_variants.tv)({
+	base: "link",
+	defaultVariants: { variant: "no-underline" },
+	variants: { variant: {
+		"no-underline": "link--no-underline",
+		underline: "link--underline"
+	} }
+});
+
+//#endregion
+//#region src/components/link/link.tsx
+const Link = ({ className, variant, ...props }) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("a", {
+		className: (0, tailwind_variants.cn)(className, linkVariants({ variant })),
+		...props
+	});
+};
+var link_default = Link;
+
+//#endregion
+//#region src/components/list/list.context.ts
+const ListContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/list/list.variants.ts
+const listVariants = (0, tailwind_variants.tv)({ slots: {
+	item: "list__item",
+	root: "list"
+} });
+
+//#endregion
+//#region src/components/list/use-list.ts
+const useList = () => {
+	const context = (0, react.useContext)(ListContext);
+	if (!context) throw new Error("useList must be used within a ListProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/list/list.tsx
+const List = ({ className, ...props }) => {
+	const slots = (0, react.useMemo)(() => listVariants(), []);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ListContext.Provider, {
+		value: { slots },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("ul", {
+			className: (0, tailwind_variants.cn)(className, slots.root()),
+			...props
+		})
+	});
+};
+const ListItem = ({ className, ...props }) => {
+	const { slots } = useList();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
+		className: (0, tailwind_variants.cn)(className, slots.item()),
+		...props
+	});
+};
+var list_default = Object.assign(List, {
+	Item: ListItem,
+	Root: List
+});
+
+//#endregion
+//#region src/components/menu/menu.context.ts
+const MenuContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/menu/menu.variants.ts
+const menuVariants = (0, tailwind_variants.tv)({ slots: {
+	arrow: "menu__arrow",
+	backdrop: "menu__backdrop",
+	checkboxItem: "menu__checkbox-item",
+	group: "menu__group",
+	groupLabel: "menu__group-label",
+	item: "menu__item",
+	popup: "menu__popup",
+	portal: "menu__portal",
+	positioner: "menu__positioner",
+	radioGroup: "menu__radio-group",
+	radioItem: "menu__radio-item",
+	root: "menu",
+	separator: "menu__separator",
+	submenu: "menu__submenu",
+	submenuTrigger: "menu__submenu__trigger",
+	trigger: "menu__trigger"
+} });
+
+//#endregion
+//#region src/components/menu/use-menu.ts
+const useMenu = () => {
+	const context = (0, react.useContext)(MenuContext);
+	if (!context) throw new Error("useMenu must be used within a MenuProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/menu/menu.tsx
+const Menu = ({ ...props }) => {
+	const slots = (0, react.useMemo)(() => menuVariants(), []);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(MenuContext.Provider, {
+		value: { slots },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Menu.Root, { ...props })
+	});
+};
+const MenuTrigger = ({ className, ...props }) => {
+	const { slots } = useMenu();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Menu.Trigger, {
+		className: (0, tailwind_variants.cn)(slots.trigger(), className),
+		...props
+	});
+};
+const MenuPortal = ({ className, ...props }) => {
+	const { slots } = useMenu();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Menu.Portal, {
+		className: (0, tailwind_variants.cn)(slots.portal(), className),
+		...props
+	});
+};
+const MenuBackdrop = ({ className, ...props }) => {
+	const { slots } = useMenu();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Menu.Backdrop, {
+		className: (0, tailwind_variants.cn)(slots.backdrop(), className),
+		...props
+	});
+};
+const MenuPositioner = ({ className, ...props }) => {
+	const { slots } = useMenu();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Menu.Positioner, {
+		className: (0, tailwind_variants.cn)(slots.positioner(), className),
+		...props
+	});
+};
+const MenuPopup = ({ className, ...props }) => {
+	const { slots } = useMenu();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Menu.Popup, {
+		className: (0, tailwind_variants.cn)(slots.popup(), className),
+		...props
+	});
+};
+const MenuArrow = ({ className, children, ...props }) => {
+	const { slots } = useMenu();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Menu.Arrow, {
+		className: (0, tailwind_variants.cn)(slots.arrow(), className),
+		...props,
+		children: children ?? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(lucide_react.LucideChevronUp, {})
+	});
+};
+const MenuItem = ({ className, ...props }) => {
+	const { slots } = useMenu();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Menu.Item, {
+		className: (0, tailwind_variants.cn)(slots.item(), className),
+		...props
+	});
+};
+const MenuSeparator = ({ className, ...props }) => {
+	const { slots } = useMenu();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Menu.Separator, {
+		className: (0, tailwind_variants.cn)(slots.separator(), className),
+		...props
+	});
+};
+const MenuGroup = ({ className, ...props }) => {
+	const { slots } = useMenu();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Menu.Group, {
+		className: (0, tailwind_variants.cn)(slots.group(), className),
+		...props
+	});
+};
+const MenuGroupLabel = ({ className, ...props }) => {
+	const { slots } = useMenu();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Menu.GroupLabel, {
+		className: (0, tailwind_variants.cn)(slots.groupLabel(), className),
+		...props
+	});
+};
+const MenuRadioGroup = ({ className, ...props }) => {
+	const { slots } = useMenu();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Menu.RadioGroup, {
+		className: (0, tailwind_variants.cn)(slots.radioGroup(), className),
+		...props
+	});
+};
+const MenuRadioItem = ({ className, ...props }) => {
+	const { slots } = useMenu();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Menu.RadioItem, {
+		className: (0, tailwind_variants.cn)(slots.radioItem(), className),
+		...props
+	});
+};
+const MenuCheckboxItem = ({ className, ...props }) => {
+	const { slots } = useMenu();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Menu.CheckboxItem, {
+		className: (0, tailwind_variants.cn)(slots.checkboxItem(), className),
+		...props
+	});
+};
+const MenuSubmenu = ({ ...props }) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Menu.SubmenuRoot, { ...props });
+};
+const MenuSubmenuTrigger = ({ className, ...props }) => {
+	const { slots } = useMenu();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Menu.SubmenuTrigger, {
+		className: (0, tailwind_variants.cn)(slots.submenuTrigger(), className),
+		...props
+	});
+};
+var menu_default = Object.assign(Menu, {
+	Arrow: MenuArrow,
+	Backdrop: MenuBackdrop,
+	CheckboxItem: MenuCheckboxItem,
+	Group: MenuGroup,
+	GroupLabel: MenuGroupLabel,
+	Item: MenuItem,
+	Popup: MenuPopup,
+	Portal: MenuPortal,
+	Positioner: MenuPositioner,
+	RadioGroup: MenuRadioGroup,
+	RadioItem: MenuRadioItem,
+	Root: Menu,
+	Separator: MenuSeparator,
+	Submenu: MenuSubmenu,
+	SubmenuTrigger: MenuSubmenuTrigger,
+	Trigger: MenuTrigger
+});
+
+//#endregion
+//#region src/components/meter/meter.context.ts
+const MeterContext = (0, react.createContext)(void 0);
+
+//#endregion
+//#region src/components/meter/meter.variants.ts
+const meterVariants = (0, tailwind_variants.tv)({
+	slots: {
+		indicator: "meter__indicator",
+		label: "meter__label",
+		root: "meter",
+		track: "meter__track",
+		value: "meter__value"
+	},
+	variants: {
+		size: {
+			lg: { root: "meter--lg" },
+			md: { root: "meter--md" },
+			sm: { root: "meter--sm" }
+		},
+		variant: {
+			danger: { root: "meter--danger" },
+			primary: { root: "meter--primary" },
+			secondary: { root: "meter--secondary" },
+			success: { root: "meter--success" }
+		}
+	}
+});
+
+//#endregion
+//#region src/components/meter/use-meter.ts
+const useMeter = () => {
+	const context = (0, react.useContext)(MeterContext);
+	if (!context) throw new Error("useMeter must be used within a MeterProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/meter/meter.tsx
+const Meter = ({ className, size, variant, ...props }) => {
+	const slots = (0, react.useMemo)(() => meterVariants({
+		size,
+		variant
+	}), [size, variant]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(MeterContext, {
+		value: { slots },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Meter.Root, {
+			className: (0, tailwind_variants.cn)(className, slots.root()),
+			...props
+		})
+	});
+};
+const MeterLabel = ({ className, ...props }) => {
+	const { slots } = useMeter();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Meter.Label, {
+		className: (0, tailwind_variants.cn)(className, slots.label()),
+		...props
+	});
+};
+const MeterValue = ({ className, ...props }) => {
+	const { slots } = useMeter();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Meter.Value, {
+		className: (0, tailwind_variants.cn)(className, slots.value()),
+		...props
+	});
+};
+const MeterTrack = ({ className, ...props }) => {
+	const { slots } = useMeter();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Meter.Track, {
+		className: (0, tailwind_variants.cn)(className, slots.track()),
+		...props
+	});
+};
+const MeterIndicator = ({ className, ...props }) => {
+	const { slots } = useMeter();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Meter.Indicator, {
+		className: (0, tailwind_variants.cn)(className, slots.indicator()),
+		...props
+	});
+};
+var meter_default = Object.assign(Meter, {
+	Indicator: MeterIndicator,
+	Label: MeterLabel,
+	Root: Meter,
+	Track: MeterTrack,
+	Value: MeterValue
+});
+
+//#endregion
+//#region src/components/separator/separator.variants.ts
+const separatorVariants = (0, tailwind_variants.tv)({
+	base: "separator",
+	defaultVariants: { orientation: "horizontal" },
+	variants: { orientation: {
+		horizontal: "separator--horizontal",
+		vertical: "separator--vertical"
+	} }
+});
+
+//#endregion
+//#region src/components/separator/separator.tsx
+const Separator = ({ className, orientation, ...props }) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Separator, {
+		className: (0, tailwind_variants.cn)(className, separatorVariants({ orientation })),
+		...props
+	});
+};
+var separator_default = Separator;
+
+//#endregion
+//#region src/components/navbar/navbar.context.ts
+const NavbarContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/navbar/navbar.variants.ts
+const navbarVariants = (0, tailwind_variants.tv)({ slots: {
+	container: "navbar__container",
+	content: "navbar__content",
+	list: "navbar__list",
+	listItem: "navbar__list-item",
+	menu: "navbar__menu",
+	menuItem: "navbar__menu-item",
+	root: "navbar",
+	toggle: "navbar__toggle"
+} });
+
+//#endregion
+//#region src/components/navbar/use-navbar.ts
+const useNavbar = () => {
+	const context = react.default.useContext(NavbarContext);
+	if (!context) throw new Error("useNavbar must be used within a NavbarProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/navbar/navbar.tsx
+const Navbar = ({ className, isOpen, onOpenChange, ...props }) => {
+	const slots = (0, react.useMemo)(() => navbarVariants(), []);
+	const [internalOpen, setInternalOpen] = (0, react.useState)(false);
+	const open = isOpen ?? internalOpen;
+	const handleOpenChange = (0, react.useCallback)((next) => {
+		if (isOpen === void 0) setInternalOpen(next);
+		onOpenChange?.(next);
+	}, [isOpen, onOpenChange]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NavbarContext.Provider, {
+		value: {
+			isOpen: open,
+			onOpenChange: handleOpenChange,
+			slots
+		},
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("header", {
+			className: (0, tailwind_variants.cn)(slots.root(), className),
+			...props
+		})
+	});
+};
+const NavbarContainer = ({ className, ...props }) => {
+	const { slots } = useNavbar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("nav", {
+		className: (0, tailwind_variants.cn)(slots.container(), className),
+		...props
+	});
+};
+const NavbarContent = ({ className, ...props }) => {
+	const { slots } = useNavbar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		className: (0, tailwind_variants.cn)(slots.content(), className),
+		...props
+	});
+};
+const NavbarList = ({ className, ...props }) => {
+	const { slots } = useNavbar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("ul", {
+		className: (0, tailwind_variants.cn)(slots.list(), className),
+		...props
+	});
+};
+const NavbarListItem = ({ className, ...props }) => {
+	const { slots } = useNavbar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_radix_ui_react_slot.Slot, {
+		className: (0, tailwind_variants.cn)(slots.listItem(), className),
+		...props
+	});
+};
+const NavbarToggle = ({ className, ...props }) => {
+	const { slots, isOpen, onOpenChange } = useNavbar();
+	const Icon = isOpen ? lucide_react.LucideX : lucide_react.LucideMenu;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+		className: (0, tailwind_variants.cn)(className, slots.toggle()),
+		onClick: () => onOpenChange(!isOpen),
+		...props,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Icon, { className: "size-5" })
+	});
+};
+const NavbarMenu = ({ className, header, ...props }) => {
+	const { slots, isOpen, onOpenChange } = useNavbar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(drawer_default, {
+		onOpenChange,
+		open: isOpen,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(drawer_default.Portal, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(drawer_default.Backdrop, {}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(drawer_default.Viewport, { children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(drawer_default.Popup, { children: [
+			header,
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)(drawer_default.Close, {}),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)(separator_default, {}),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)("ul", {
+				className: (0, tailwind_variants.cn)(slots.menu(), className),
+				...props
+			})
+		] }) })] })
+	});
+};
+const NavbarMenuItem = ({ className, ...props }) => {
+	const { slots } = useNavbar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_radix_ui_react_slot.Slot, {
+		className: (0, tailwind_variants.cn)(slots.menuItem(), className),
+		...props
+	});
+};
+var navbar_default = Object.assign(Navbar, {
+	Container: NavbarContainer,
+	Content: NavbarContent,
+	List: NavbarList,
+	ListItem: NavbarListItem,
+	Menu: NavbarMenu,
+	MenuItem: NavbarMenuItem,
+	Root: Navbar,
+	Toggle: NavbarToggle
+});
+
+//#endregion
+//#region src/components/popover/popover.context.ts
+const PopoverContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/popover/popover.variants.ts
+const popoverVariants = (0, tailwind_variants.tv)({ slots: {
+	arrow: "popover__arrow",
+	backdrop: "popover__backdrop",
+	close: "popover__close",
+	content: "popover__content",
+	description: "popover__description",
+	popup: "popover__popup",
+	portal: "popover__portal",
+	positioner: "popover__positioner",
+	root: "popover",
+	title: "popover__title",
+	trigger: "popover__trigger",
+	viewport: "popover__viewport"
+} });
+
+//#endregion
+//#region src/components/popover/use-popover.ts
+const usePopover = () => {
+	const context = (0, react.useContext)(PopoverContext);
+	if (!context) throw new Error("usePopover must be used within a PopoverProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/popover/popover.tsx
+const Popover = ({ ...props }) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(PopoverContext, {
+		value: { slots: (0, react.useMemo)(() => popoverVariants({}), []) },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Popover.Root, { ...props })
+	});
+};
+const PopoverTrigger = ({ className, ...props }) => {
+	const { slots } = usePopover();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Popover.Trigger, {
+		className: (0, tailwind_variants.cn)(className, slots.trigger()),
+		...props
+	});
+};
+const PopoverPortal = ({ className, ...props }) => {
+	const { slots } = usePopover();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Popover.Portal, {
+		className: (0, tailwind_variants.cn)(className, slots.portal()),
+		...props
+	});
+};
+const PopoverBackdrop = ({ className, ...props }) => {
+	const { slots } = usePopover();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Popover.Backdrop, {
+		className: (0, tailwind_variants.cn)(className, slots.backdrop()),
+		...props
+	});
+};
+const PopoverPositioner = ({ className, ...props }) => {
+	const { slots } = usePopover();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Popover.Positioner, {
+		className: (0, tailwind_variants.cn)(className, slots.positioner()),
+		...props
+	});
+};
+const PopoverPopup = ({ className, ...props }) => {
+	const { slots } = usePopover();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Popover.Popup, {
+		className: (0, tailwind_variants.cn)(className, slots.popup()),
+		...props
+	});
+};
+const PopoverArrow = ({ className, ...props }) => {
+	const { slots } = usePopover();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Popover.Arrow, {
+		className: (0, tailwind_variants.cn)(className, slots.arrow()),
+		...props
+	});
+};
+const PopoverViewport = ({ className, ...props }) => {
+	const { slots } = usePopover();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Popover.Viewport, {
+		className: (0, tailwind_variants.cn)(className, slots.viewport()),
+		...props
+	});
+};
+const PopoverTitle = ({ className, ...props }) => {
+	const { slots } = usePopover();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Popover.Title, {
+		className: (0, tailwind_variants.cn)(className, slots.title()),
+		...props
+	});
+};
+const PopoverDescription = ({ className, ...props }) => {
+	const { slots } = usePopover();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Popover.Description, {
+		className: (0, tailwind_variants.cn)(className, slots.description()),
+		...props
+	});
+};
+const PopoverClose = ({ className, children, ...props }) => {
+	const { slots } = usePopover();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Popover.Close, {
+		className: (0, tailwind_variants.cn)(className, slots.close()),
+		...props,
+		children: children ?? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(lucide_react.LucideX, {})
+	});
+};
+var popover_default = Object.assign(Popover, {
+	Arrow: PopoverArrow,
+	Backdrop: PopoverBackdrop,
+	Close: PopoverClose,
+	Description: PopoverDescription,
+	Popup: PopoverPopup,
+	Portal: PopoverPortal,
+	Positioner: PopoverPositioner,
+	Root: Popover,
+	Title: PopoverTitle,
+	Trigger: PopoverTrigger,
+	Viewport: PopoverViewport
+});
+
+//#endregion
+//#region src/components/progress/progress.context.ts
+const ProgressContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/progress/progress.variants.ts
+const progressVariants = (0, tailwind_variants.tv)({
+	defaultVariants: {
+		size: "md",
+		variant: "primary"
+	},
+	slots: {
+		indicator: "progress__indicator",
+		label: "progress__label",
+		root: "progress",
+		track: "progress__track",
+		value: "progress__value"
+	},
+	variants: {
+		size: {
+			lg: { root: "progress--lg" },
+			md: { root: "progress--md" },
+			sm: { root: "progress--sm" }
+		},
+		variant: {
+			danger: { root: "progress--danger" },
+			primary: { root: "progress--primary" },
+			secondary: { root: "progress--secondary" },
+			success: { root: "progress--success" }
+		}
+	}
+});
+
+//#endregion
+//#region src/components/progress/use-progress.ts
+const useProgress = () => {
+	const context = (0, react.useContext)(ProgressContext);
+	if (!context) throw new Error("useProgress must be used within a ProgressProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/progress/progress.tsx
+const Progress = ({ className, variant, size, ...props }) => {
+	const slots = (0, react.useMemo)(() => progressVariants({
+		size,
+		variant
+	}), [variant, size]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ProgressContext, {
+		value: { slots },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Progress.Root, {
+			className: (0, tailwind_variants.cn)(className, slots.root()),
+			...props
+		})
+	});
+};
+const ProgressLabel = ({ className, ...props }) => {
+	const { slots } = useProgress();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Progress.Label, {
+		className: (0, tailwind_variants.cn)(className, slots.label()),
+		...props
+	});
+};
+const ProgressValue = ({ className, ...props }) => {
+	const { slots } = useProgress();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Progress.Value, {
+		className: (0, tailwind_variants.cn)(className, slots.value()),
+		...props
+	});
+};
+const ProgressTrack = ({ className, ...props }) => {
+	const { slots } = useProgress();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Progress.Track, {
+		className: (0, tailwind_variants.cn)(className, slots.track()),
+		...props
+	});
+};
+const ProgressIndicator = ({ className, ...props }) => {
+	const { slots } = useProgress();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Progress.Indicator, {
+		className: (0, tailwind_variants.cn)(className, slots.indicator()),
+		...props
+	});
+};
+var progress_default = Object.assign(Progress, {
+	Indicator: ProgressIndicator,
+	Label: ProgressLabel,
+	Root: Progress,
+	Track: ProgressTrack,
+	Value: ProgressValue
+});
+
+//#endregion
+//#region src/components/radio/radio.context.ts
+const RadioContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/radio/radio.variants.ts
+const radioVariants = (0, tailwind_variants.tv)({ slots: {
+	indicator: "radio__indicator",
+	root: "radio"
+} });
+
+//#endregion
+//#region src/components/radio/use-radio.ts
+const useRadio = () => {
+	const context = (0, react.useContext)(RadioContext);
+	if (!context) throw new Error("useRadio must be used within a RadioProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/radio/radio.tsx
+const Radio = ({ className, ...props }) => {
+	const slots = (0, react.useMemo)(() => radioVariants({}), []);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RadioContext, {
+		value: { slots },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Radio.Root, {
+			className: (0, tailwind_variants.cn)(slots.root(), className),
+			...props
+		})
+	});
+};
+const RadioIndicator = ({ className, ...props }) => {
+	const { slots } = useRadio();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Radio.Indicator, {
+		className: (0, tailwind_variants.cn)(slots.indicator(), className),
+		...props
+	});
+};
+var radio_default = Object.assign(Radio, {
+	Indicator: RadioIndicator,
+	Root: Radio
+});
+
+//#endregion
+//#region src/components/radio-group/radio-group.variants.ts
+const radioGroupVariants = (0, tailwind_variants.tv)({ base: "radio-group" });
+
+//#endregion
+//#region src/components/radio-group/radio-group.tsx
+const RadioGroup = ({ className, ...props }) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.RadioGroup, {
+		className: (0, tailwind_variants.cn)(className, (0, react.useMemo)(() => radioGroupVariants(), [])),
+		...props
+	});
+};
+var radio_group_default = RadioGroup;
+
+//#endregion
+//#region src/components/select/select.context.ts
+const SelectContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/select/select.variants.ts
+const selectVariants = (0, tailwind_variants.tv)({ slots: {
+	control: "select__control",
+	description: "select__description",
+	error: "select__error",
+	label: "select__label",
+	option: "select__option",
+	root: "select"
+} });
+
+//#endregion
+//#region src/components/select/use-select.ts
+const useSelect = () => {
+	const context = (0, react.useContext)(SelectContext);
+	if (!context) throw new Error("useSelect must be used within a SelectProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/select/select.tsx
+const Select = ({ className, ...props }) => {
+	const slots = (0, react.useMemo)(() => selectVariants(), []);
+	const generatedId = (0, react.useId)();
+	const inputId = props.id || generatedId;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SelectContext.Provider, {
+		value: {
+			id: inputId,
+			slots
+		},
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+			className: (0, tailwind_variants.cn)(className, slots.root()),
+			...props
+		})
+	});
+};
+const SelectLabel = ({ className, ...props }) => {
+	const { slots, id } = useSelect();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", {
+		className: (0, tailwind_variants.cn)(className, slots.label()),
+		htmlFor: id,
+		...props
+	});
+};
+const SelectControl = ({ className, ...props }) => {
+	const { slots, id } = useSelect();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("select", {
+		className: (0, tailwind_variants.cn)(className, slots.control()),
+		id,
+		...props
+	});
+};
+const SelectOption = ({ className, ...props }) => {
+	const { slots } = useSelect();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+		className: (0, tailwind_variants.cn)(className, slots.option()),
+		...props
+	});
+};
+const SelectDescription = ({ className, ...props }) => {
+	const { slots } = useSelect();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+		className: (0, tailwind_variants.cn)(className, slots.description()),
+		...props
+	});
+};
+const SelectError = ({ className, ...props }) => {
+	const { slots } = useSelect();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+		className: (0, tailwind_variants.cn)(className, slots.error()),
+		...props
+	});
+};
+var select_default = Object.assign(Select, {
+	Control: SelectControl,
+	Description: SelectDescription,
+	Error: SelectError,
+	Label: SelectLabel,
+	Option: SelectOption,
+	Root: Select
+});
+
+//#endregion
+//#region src/components/sidebar/sidebar.context.ts
+const SidebarContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/sidebar/sidebar.variants.ts
+const sidebarVariants = (0, tailwind_variants.tv)({ slots: {
+	content: "sidebar__content",
+	footer: "sidebar__footer",
+	header: "sidebar__header",
+	menu: "sidebar__menu",
+	menuItem: "sidebar__menu-item",
+	menuLabel: "sidebar__menu-label",
+	outlet: "sidebar__outlet",
+	panel: "sidebar__panel",
+	root: "sidebar",
+	trigger: "sidebar__trigger"
+} });
+
+//#endregion
+//#region src/components/sidebar/use-sidebar.ts
+const useSidebar = () => {
+	const context = (0, react.useContext)(SidebarContext);
+	if (!context) throw new Error("useSidebar must be used within a SidebarProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/sidebar/sidebar.tsx
+const Sidebar = ({ className, isOpen, onOpenChange, ...props }) => {
+	const [internalIsOpen, setInternalIsOpen] = react.default.useState(false);
+	const isOpenState = isOpen !== void 0 ? isOpen : internalIsOpen;
+	const handleOpenChange = onOpenChange || setInternalIsOpen;
+	const slots = (0, react.useMemo)(() => sidebarVariants({ className }), [className]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SidebarContext, {
+		value: {
+			isOpen: isOpenState,
+			onOpenChange: handleOpenChange,
+			slots
+		},
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+			className: slots.root(),
+			"data-open": isOpenState,
+			...props
+		})
+	});
+};
+const SidebarPanel = ({ className, ...props }) => {
+	const { slots } = useSidebar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("aside", {
+		className: (0, tailwind_variants.cn)(slots.panel(), className),
+		...props
+	});
+};
+const SidebarHeader = ({ className, ...props }) => {
+	const { slots } = useSidebar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("header", {
+		className: (0, tailwind_variants.cn)(slots.header(), className),
+		...props
+	});
+};
+const SidebarContent = ({ className, ...props }) => {
+	const { slots } = useSidebar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		className: (0, tailwind_variants.cn)(slots.content(), className),
+		...props
+	});
+};
+const SidebarFooter = ({ className, ...props }) => {
+	const { slots } = useSidebar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("footer", {
+		className: (0, tailwind_variants.cn)(slots.footer(), className),
+		...props
+	});
+};
+const SidebarTrigger = ({ className, children, ...props }) => {
+	const { slots, isOpen, onOpenChange } = useSidebar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+		"aria-expanded": isOpen,
+		className: (0, tailwind_variants.cn)(slots.trigger(), className),
+		onClick: () => onOpenChange(!isOpen),
+		...props,
+		children: children ?? (isOpen ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(lucide_react.LucidePanelLeftClose, {}) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(lucide_react.LucidePanelLeftOpen, {}))
+	});
+};
+const SidebarOutlet = ({ className, ...props }) => {
+	const { slots } = useSidebar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		className: (0, tailwind_variants.cn)(slots.outlet(), className),
+		...props
+	});
+};
+const SidebarMenu = ({ className, ...props }) => {
+	const { slots } = useSidebar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("nav", {
+		className: (0, tailwind_variants.cn)(slots.menu(), className),
+		...props
+	});
+};
+const SidebarMenuItem = ({ className, ...props }) => {
+	const { slots } = useSidebar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_radix_ui_react_slot.Slot, {
+		className: (0, tailwind_variants.cn)(slots.menuItem(), className),
+		...props
+	});
+};
+const SidebarMenuLabel = ({ className, ...props }) => {
+	const { slots } = useSidebar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		className: (0, tailwind_variants.cn)(slots.menuLabel(), className),
+		...props
+	});
+};
+var sidebar_default = Object.assign(Sidebar, {
+	Content: SidebarContent,
+	Footer: SidebarFooter,
+	Header: SidebarHeader,
+	Menu: SidebarMenu,
+	MenuItem: SidebarMenuItem,
+	MenuLabel: SidebarMenuLabel,
+	Outlet: SidebarOutlet,
+	Panel: SidebarPanel,
+	Root: Sidebar,
+	Trigger: SidebarTrigger
+});
+
+//#endregion
+//#region src/components/slider/slider.context.ts
+const SliderContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/slider/slider.variants.ts
+const sliderVariants = (0, tailwind_variants.tv)({ slots: {
+	control: "slider__control",
+	indicator: "slider__indicator",
+	root: "slider",
+	thumb: "slider__thumb",
+	track: "slider__track",
+	value: "slider__value"
+} });
+
+//#endregion
+//#region src/components/slider/use-slider.tsx
+const useSlider = () => {
+	const context = (0, react.useContext)(SliderContext);
+	if (!context) throw new Error("useSlider must be used within a SliderProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/slider/slider.tsx
+const Slider = ({ className, ...props }) => {
+	const slots = (0, react.useMemo)(() => sliderVariants(), []);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SliderContext, {
+		value: { slots },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Slider.Root, {
+			className: (0, tailwind_variants.cn)(className, slots.root()),
+			...props
+		})
+	});
+};
+const SliderValue = ({ className, ...props }) => {
+	const { slots } = useSlider();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Slider.Value, {
+		className: (0, tailwind_variants.cn)(className, slots.value()),
+		...props
+	});
+};
+const SliderControl = ({ className, ...props }) => {
+	const { slots } = useSlider();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Slider.Control, {
+		className: (0, tailwind_variants.cn)(className, slots.control()),
+		...props
+	});
+};
+const SliderTrack = ({ className, ...props }) => {
+	const { slots } = useSlider();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Slider.Track, {
+		className: (0, tailwind_variants.cn)(className, slots.track()),
+		...props
+	});
+};
+const SliderIndicator = ({ className, ...props }) => {
+	const { slots } = useSlider();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Slider.Indicator, {
+		className: (0, tailwind_variants.cn)(className, slots.indicator()),
+		...props
+	});
+};
+const SliderThumb = ({ className, ...props }) => {
+	const { slots } = useSlider();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Slider.Thumb, {
+		className: (0, tailwind_variants.cn)(className, slots.thumb()),
+		...props
+	});
+};
+var slider_default = Object.assign(Slider, {
+	Control: SliderControl,
+	Indicator: SliderIndicator,
+	Root: Slider,
+	Thumb: SliderThumb,
+	Track: SliderTrack,
+	Value: SliderValue
+});
+
+//#endregion
+//#region src/components/switch/switch.context.ts
+const SwitchContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/switch/switch.variants.ts
+const switchVariants = (0, tailwind_variants.tv)({
+	defaultVariants: { size: "md" },
+	slots: {
+		root: "switch",
+		thumb: "switch__thumb"
+	},
+	variants: { size: {
+		lg: { root: "switch--lg" },
+		md: { root: "switch--md" },
+		sm: { root: "switch--sm" }
+	} }
+});
+
+//#endregion
+//#region src/components/switch/use-switch.ts
+const useSwitch = () => {
+	const context = (0, react.useContext)(SwitchContext);
+	if (!context) throw new Error("useSwitch must be used within a SwitchProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/switch/switch.tsx
+const Switch = ({ className, size, ...props }) => {
+	const slots = (0, react.useMemo)(() => switchVariants({ size }), [size]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SwitchContext.Provider, {
+		value: { slots },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Switch.Root, {
+			className: (0, tailwind_variants.cn)(className, slots.root()),
+			...props
+		})
+	});
+};
+const SwitchThumb = ({ className, ...props }) => {
+	const { slots } = useSwitch();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Switch.Thumb, {
+		className: (0, tailwind_variants.cn)(className, slots.thumb()),
+		...props
+	});
+};
+var switch_default = Object.assign(Switch, {
+	Root: Switch,
+	Thumb: SwitchThumb
+});
+
+//#endregion
+//#region src/components/table/table.context.ts
+const TableContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/table/table.variants.ts
+const tableVariants = (0, tailwind_variants.tv)({ slots: {
+	root: "table",
+	tbody: "table__tbody",
+	td: "table__td",
+	tfoot: "table__tfoot",
+	th: "table__th",
+	thead: "table__thead",
+	tr: "table__tr"
+} });
+
+//#endregion
+//#region src/components/table/use-table.ts
+const useTable = () => {
+	const context = (0, react.useContext)(TableContext);
+	if (!context) throw new Error("useTable must be used within a TableProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/table/table.tsx
+const Table = ({ className, ...props }) => {
+	const slots = (0, react.useMemo)(() => tableVariants(), []);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TableContext, {
+		value: { slots },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("table", {
+			className: (0, tailwind_variants.cn)(className, slots.root()),
+			...props
+		})
+	});
+};
+const TableHead = ({ className, ...props }) => {
+	const { slots } = useTable();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("thead", {
+		className: (0, tailwind_variants.cn)(className, slots.thead()),
+		...props
+	});
+};
+const TableRow = ({ className, ...props }) => {
+	const { slots } = useTable();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("tr", {
+		className: (0, tailwind_variants.cn)(className, slots.tr()),
+		...props
+	});
+};
+const TableHeaderCell = ({ className, ...props }) => {
+	const { slots } = useTable();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("th", {
+		className: (0, tailwind_variants.cn)(className, slots.th()),
+		...props
+	});
+};
+const TableBody = ({ className, ...props }) => {
+	const { slots } = useTable();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("tbody", {
+		className: (0, tailwind_variants.cn)(className, slots.tbody()),
+		...props
+	});
+};
+const TableDataCell = ({ className, ...props }) => {
+	const { slots } = useTable();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("td", {
+		className: (0, tailwind_variants.cn)(className, slots.td()),
+		...props
+	});
+};
+const TableFooter = ({ className, ...props }) => {
+	const { slots } = useTable();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("tfoot", {
+		className: (0, tailwind_variants.cn)(className, slots.tfoot()),
+		...props
+	});
+};
+var table_default = Object.assign(Table, {
+	Body: TableBody,
+	DataCell: TableDataCell,
+	Footer: TableFooter,
+	Head: TableHead,
+	HeaderCell: TableHeaderCell,
+	Root: Table,
+	Row: TableRow
+});
+
+//#endregion
+//#region src/components/tabs/tabs.context.ts
+const TabsContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/components/tabs/tabs.variants.ts
+const tabsVariants = (0, tailwind_variants.tv)({ slots: {
+	indicator: "tabs__indicator",
+	list: "tabs__list",
+	panel: "tabs__panel",
+	root: "tabs",
+	tab: "tabs__tab"
+} });
+
+//#endregion
+//#region src/components/tabs/use-tabs.ts
+const useTabs = () => {
+	const context = (0, react.useContext)(TabsContext);
+	if (!context) throw new Error("useTabs must be used within a TabsProvider");
+	return context;
+};
+
+//#endregion
+//#region src/components/tabs/tabs.tsx
+const Tabs = ({ className, ...props }) => {
+	const slots = (0, react.useMemo)(() => tabsVariants(), []);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TabsContext.Provider, {
+		value: { slots },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Tabs.Root, {
+			className: (0, tailwind_variants.cn)(className, slots.root()),
+			...props
+		})
+	});
+};
+const TabsList = ({ className, ...props }) => {
+	const { slots } = useTabs();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Tabs.List, {
+		className: (0, tailwind_variants.cn)(slots.list(), className),
+		...props
+	});
+};
+const TabsTab = ({ className, ...props }) => {
+	const { slots } = useTabs();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Tabs.Tab, {
+		className: (0, tailwind_variants.cn)(slots.tab(), className),
+		...props
+	});
+};
+const TabsIndicator = ({ className, ...props }) => {
+	const { slots } = useTabs();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Tabs.Indicator, {
+		className: (0, tailwind_variants.cn)(slots.indicator(), className),
+		...props
+	});
+};
+const TabsPanel = ({ className, ...props }) => {
+	const { slots } = useTabs();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Tabs.Panel, {
+		className: (0, tailwind_variants.cn)(slots.panel(), className),
+		...props
+	});
+};
+var tabs_default = Object.assign(Tabs, {
+	Indicator: TabsIndicator,
+	List: TabsList,
+	Panel: TabsPanel,
+	Root: Tabs,
+	Tab: TabsTab
+});
+
+//#endregion
+//#region src/components/toggle-button/toggle-button.variants.ts
+const toggleButtonVariants = (0, tailwind_variants.tv)({
+	base: "toggle-button",
+	extend: buttonVariants
+});
+
+//#endregion
+//#region src/components/toggle-button/toggle-button.tsx
+const ToggleButton = ({ className, variant, size, ...props }) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_base_ui_react.Toggle, {
+		className: (0, tailwind_variants.cn)(className, toggleButtonVariants({
+			size,
+			variant
+		})),
+		...props
+	});
+};
+var toggle_button_default = ToggleButton;
+
+//#endregion
+exports.Accordion = accordion_default;
+exports.Alert = alert_default;
+exports.AlertDialog = alert_dialog_default;
+exports.Avatar = avatar_default;
+exports.Button = button_default;
+exports.ButtonGroup = button_group_default;
+exports.Card = card_default;
+exports.Checkbox = checkbox_default;
+exports.CheckboxGroup = checkbox_group_default;
+exports.Chip = chip_default;
+exports.Container = container_default;
+exports.Dialog = dialog_default;
+exports.Drawer = drawer_default;
+exports.Field = field_default;
+exports.Fieldset = fieldset_default;
+exports.Form = form_default;
+exports.IconButton = icon_button_default;
+exports.Input = input_default;
+exports.Label = label_default;
+exports.Link = link_default;
+exports.List = list_default;
+exports.Menu = menu_default;
+exports.Meter = meter_default;
+exports.Navbar = navbar_default;
+exports.Popover = popover_default;
+exports.Progress = progress_default;
+exports.Radio = radio_default;
+exports.RadioGroup = radio_group_default;
+exports.Select = select_default;
+exports.Separator = separator_default;
+exports.Sidebar = sidebar_default;
+exports.Slider = slider_default;
+exports.Switch = switch_default;
+exports.Table = table_default;
+exports.Tabs = tabs_default;
+exports.ToggleButton = toggle_button_default;
+exports.accordionVariants = accordionVariants;
+exports.alertDialogVariants = alertDialogVariants;
+exports.alertVariants = alertVariants;
+exports.avatarVariants = avatarVariants;
+exports.buttonGroupVariants = buttonGroupVariants;
+exports.buttonVariants = buttonVariants;
+exports.cardVariants = cardVariants;
+exports.checkboxGroupVariants = checkboxGroupVariants;
+exports.checkboxVariants = checkboxVariants;
+exports.chipVariants = chipVariants;
+Object.defineProperty(exports, 'cn', {
+  enumerable: true,
+  get: function () {
+    return tailwind_variants.cn;
+  }
+});
+exports.containerVariants = containerVariants;
+exports.dialogVariants = dialogVariants;
+exports.drawerVariants = drawerVariants;
+exports.fieldVariants = fieldVariants;
+exports.fieldsetVariants = fieldsetVariants;
+exports.formVariants = formVariants;
+exports.iconButtonVariants = iconButtonVariants;
+exports.inputVariants = inputVariants;
+exports.labelVariants = labelVariants;
+exports.linkVariants = linkVariants;
+exports.listVariants = listVariants;
+exports.menuVariants = menuVariants;
+exports.meterVariants = meterVariants;
+exports.navbarVariants = navbarVariants;
+exports.popoverVariants = popoverVariants;
+exports.progressVariants = progressVariants;
+exports.radioGroupVariants = radioGroupVariants;
+exports.radioVariants = radioVariants;
+exports.selectVariants = selectVariants;
+exports.separatorVariants = separatorVariants;
+exports.sidebarVariants = sidebarVariants;
+exports.sliderVariants = sliderVariants;
+exports.switchVariants = switchVariants;
+exports.tableVariants = tableVariants;
+exports.tabsVariants = tabsVariants;
+exports.toggleButtonVariants = toggleButtonVariants;
+//# sourceMappingURL=index.cjs.map