@salesmind-ai/design-system 0.3.4 → 0.3.6

package/dist/chunk-MU6GW5ZV.js

@@ -0,0 +1,2317 @@
+import { Dialog, DialogContent, DialogTitle } from './chunk-HRENHNDJ.js';
+import { Box } from './chunk-HN4PHABT.js';
+import React20, { forwardRef, useId, createContext, useContext, useState, useRef, useEffect, useCallback } from 'react';
+import clsx18 from 'clsx';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { Switch as Switch$1 } from '@base-ui/react/switch';
+import ReactDOM, { createPortal } from 'react-dom';
+import { Slot } from '@radix-ui/react-slot';
+
+var Card = React20.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", { ref, className: clsx18("ds-card", className), ...props })
+);
+Card.displayName = "Card";
+var CardHeader = React20.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", { ref, className: clsx18("ds-card__header", className), ...props })
+);
+CardHeader.displayName = "CardHeader";
+var CardTitle = React20.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("h3", { ref, className: clsx18("ds-card__title", className), ...props }));
+CardTitle.displayName = "CardTitle";
+var CardDescription = React20.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("p", { ref, className: clsx18("ds-card__description", className), ...props }));
+CardDescription.displayName = "CardDescription";
+var CardContent = React20.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", { ref, className: clsx18("ds-card__content", className), ...props })
+);
+CardContent.displayName = "CardContent";
+var CardFooter = React20.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", { ref, className: clsx18("ds-card__footer", className), ...props })
+);
+CardFooter.displayName = "CardFooter";
+var ButtonGroup = React20.forwardRef(
+  ({ orientation = "horizontal", fullWidth = false, size = "md", className, children, ...props }, ref) => {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        role: "group",
+        className: clsx18(
+          "ds-button-group",
+          `ds-button-group--${orientation}`,
+          fullWidth && "ds-button-group--full-width",
+          className
+        ),
+        "data-size": size,
+        ...props,
+        children
+      }
+    );
+  }
+);
+ButtonGroup.displayName = "ButtonGroup";
+var TextArea = forwardRef(
+  ({ className, label, error, helperText, id, ...props }, ref) => {
+    const generatedId = useId();
+    const inputId = id || generatedId;
+    return /* @__PURE__ */ jsxs("div", { className: clsx18("ds-textarea", className), children: [
+      label && /* @__PURE__ */ jsx("label", { htmlFor: inputId, className: "ds-textarea__label", children: label }),
+      /* @__PURE__ */ jsx("div", { className: "ds-textarea__input-wrapper", children: /* @__PURE__ */ jsx(
+        "textarea",
+        {
+          id: inputId,
+          ref,
+          className: clsx18("ds-textarea__input", error && "ds-textarea__input--error"),
+          ...props
+        }
+      ) }),
+      helperText && /* @__PURE__ */ jsx("span", { className: clsx18("ds-textarea__helper", error && "ds-textarea__helper--error"), children: helperText })
+    ] });
+  }
+);
+TextArea.displayName = "TextArea";
+var RadioGroupContext = createContext(null);
+var RadioGroup = forwardRef(
+  ({
+    className,
+    name,
+    value,
+    onValueChange,
+    orientation = "vertical",
+    children,
+    ...props
+  }, ref) => {
+    const generatedName = useId();
+    const groupName = name || generatedName;
+    return /* @__PURE__ */ jsx(RadioGroupContext.Provider, { value: { name: groupName, value, onChange: onValueChange }, children: /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        role: "radiogroup",
+        className: clsx18(
+          "ds-radio-group",
+          orientation === "horizontal" && "ds-radio-group--horizontal",
+          className
+        ),
+        ...props,
+        children
+      }
+    ) });
+  }
+);
+RadioGroup.displayName = "RadioGroup";
+var Radio = forwardRef(
+  ({ className, label, value, disabled, id, onChange, ...props }, ref) => {
+    const context = useContext(RadioGroupContext);
+    const generatedId = useId();
+    const radioId = id || generatedId;
+    const name = context?.name || props.name;
+    const isChecked = context?.value !== void 0 ? context.value === value : props.checked;
+    const handleChange = (e) => {
+      onChange?.(e);
+      context?.onChange?.(value);
+    };
+    return /* @__PURE__ */ jsxs(
+      "label",
+      {
+        className: clsx18("ds-radio-wrapper", disabled && "ds-radio-wrapper--disabled", className),
+        children: [
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              ref,
+              type: "radio",
+              className: "ds-radio-input",
+              id: radioId,
+              name,
+              value,
+              checked: isChecked,
+              onChange: handleChange,
+              disabled,
+              ...props
+            }
+          ),
+          /* @__PURE__ */ jsx("div", { className: clsx18("ds-radio", isChecked && "ds-radio--checked"), children: /* @__PURE__ */ jsx("div", { className: "ds-radio__indicator" }) }),
+          label && /* @__PURE__ */ jsx("span", { className: "ds-radio__label", children: label })
+        ]
+      }
+    );
+  }
+);
+Radio.displayName = "Radio";
+var Switch = React20.forwardRef(
+  ({ className, label, id, ...props }, ref) => {
+    const generatedId = React20.useId();
+    const switchId = id || generatedId;
+    return /* @__PURE__ */ jsxs("div", { className: clsx18("ds-switch-wrapper", className), children: [
+      /* @__PURE__ */ jsx(Switch$1.Root, { id: switchId, ref, className: "ds-switch", ...props, children: /* @__PURE__ */ jsx(Switch$1.Thumb, { className: "ds-switch__thumb" }) }),
+      label && /* @__PURE__ */ jsx("label", { htmlFor: switchId, className: "ds-switch__label", children: label })
+    ] });
+  }
+);
+Switch.displayName = "Switch";
+var AccordionContext = React20.createContext(null);
+function useAccordionContext() {
+  const ctx = React20.useContext(AccordionContext);
+  if (!ctx) {
+    throw new Error("Accordion compound components must be used within <Accordion>");
+  }
+  return ctx;
+}
+var AccordionItemContext = React20.createContext(null);
+function useAccordionItemContext() {
+  const ctx = React20.useContext(AccordionItemContext);
+  if (!ctx) {
+    throw new Error("AccordionTrigger/AccordionContent must be used within <AccordionItem>");
+  }
+  return ctx;
+}
+var Accordion = React20.forwardRef(
+  ({ className, type = "single", defaultValue = [], collapsible: _collapsible, children, ...props }, ref) => {
+    const [openItems, setOpenItems] = React20.useState(
+      () => new Set(defaultValue)
+    );
+    const toggle = React20.useCallback(
+      (value) => {
+        setOpenItems((prev) => {
+          const next = new Set(prev);
+          if (next.has(value)) {
+            next.delete(value);
+          } else {
+            if (type === "single") {
+              next.clear();
+            }
+            next.add(value);
+          }
+          return next;
+        });
+      },
+      [type]
+    );
+    const contextValue = React20.useMemo(
+      () => ({ openItems, toggle }),
+      [openItems, toggle]
+    );
+    return /* @__PURE__ */ jsx(AccordionContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx("div", { ref, className: clsx18("ds-accordion", className), ...props, children }) });
+  }
+);
+Accordion.displayName = "Accordion";
+var AccordionItem = React20.forwardRef(
+  ({ className, value, children, ...props }, ref) => {
+    const { openItems } = useAccordionContext();
+    const isOpen = openItems.has(value);
+    const contextValue = React20.useMemo(
+      () => ({ value, isOpen }),
+      [value, isOpen]
+    );
+    return /* @__PURE__ */ jsx(AccordionItemContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        className: clsx18("ds-accordion__item", className),
+        "data-state": isOpen ? "open" : "closed",
+        ...props,
+        children
+      }
+    ) });
+  }
+);
+AccordionItem.displayName = "AccordionItem";
+var AccordionTrigger = React20.forwardRef(({ className, children, ...props }, ref) => {
+  const { toggle } = useAccordionContext();
+  const { value, isOpen } = useAccordionItemContext();
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      ref,
+      type: "button",
+      className: clsx18("ds-accordion__trigger", className),
+      "aria-expanded": isOpen,
+      onClick: () => toggle(value),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx("span", { className: "ds-accordion__trigger-text", children }),
+        /* @__PURE__ */ jsx(
+          "svg",
+          {
+            className: "ds-accordion__chevron",
+            width: "16",
+            height: "16",
+            viewBox: "0 0 24 24",
+            fill: "none",
+            stroke: "currentColor",
+            strokeWidth: "2",
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            "aria-hidden": "true",
+            children: /* @__PURE__ */ jsx("polyline", { points: "6 9 12 15 18 9" })
+          }
+        )
+      ]
+    }
+  );
+});
+AccordionTrigger.displayName = "AccordionTrigger";
+var AccordionContent = React20.forwardRef(({ className, children, ...props }, ref) => {
+  const { isOpen } = useAccordionItemContext();
+  const contentRef = React20.useRef(null);
+  const [height, setHeight] = React20.useState(
+    isOpen ? void 0 : 0
+  );
+  React20.useEffect(() => {
+    const el = contentRef.current;
+    if (!el) return;
+    if (isOpen) {
+      const scrollHeight = el.scrollHeight;
+      setHeight(scrollHeight);
+      const timer = setTimeout(() => setHeight(void 0), 200);
+      return () => clearTimeout(timer);
+    } else {
+      const scrollHeight = el.scrollHeight;
+      setHeight(scrollHeight);
+      requestAnimationFrame(() => {
+        requestAnimationFrame(() => {
+          setHeight(0);
+        });
+      });
+    }
+  }, [isOpen]);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref: contentRef,
+      className: clsx18("ds-accordion__content", className),
+      style: {
+        height: height !== void 0 ? `${height}px` : "auto"
+      },
+      hidden: !isOpen && height === 0,
+      ...props,
+      children: /* @__PURE__ */ jsx("div", { ref, className: "ds-accordion__content-inner", children })
+    }
+  );
+});
+AccordionContent.displayName = "AccordionContent";
+var Label = React20.forwardRef(
+  ({ className, disabled, ...props }, ref) => {
+    return /* @__PURE__ */ jsx(
+      "label",
+      {
+        ref,
+        className: clsx18("ds-label", disabled && "ds-label--disabled", className),
+        "data-disabled": disabled || void 0,
+        ...props
+      }
+    );
+  }
+);
+Label.displayName = "Label";
+var Skeleton = React20.forwardRef(
+  ({ className, ...props }, ref) => {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        className: clsx18("ds-skeleton", className),
+        ...props
+      }
+    );
+  }
+);
+Skeleton.displayName = "Skeleton";
+var Separator = React20.forwardRef(
+  ({ className, orientation = "horizontal", ...props }, ref) => {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        role: "separator",
+        "aria-orientation": orientation,
+        className: clsx18(
+          "ds-separator",
+          `ds-separator--${orientation}`,
+          className
+        ),
+        ...props
+      }
+    );
+  }
+);
+Separator.displayName = "Separator";
+var SheetContext = React20.createContext(void 0);
+function useSheetContext() {
+  const ctx = React20.useContext(SheetContext);
+  if (!ctx) {
+    throw new Error("Sheet compound components must be used within a <Sheet> parent.");
+  }
+  return ctx;
+}
+var Sheet = ({ open: controlledOpen, onOpenChange, children }) => {
+  const [uncontrolledOpen, setUncontrolledOpen] = React20.useState(false);
+  const isControlled = controlledOpen !== void 0;
+  const open = isControlled ? controlledOpen : uncontrolledOpen;
+  const handleOpenChange = React20.useCallback(
+    (next) => {
+      if (!isControlled) {
+        setUncontrolledOpen(next);
+      }
+      onOpenChange?.(next);
+    },
+    [isControlled, onOpenChange]
+  );
+  return /* @__PURE__ */ jsx(SheetContext.Provider, { value: { open, onOpenChange: handleOpenChange }, children });
+};
+Sheet.displayName = "Sheet";
+var SheetTrigger = React20.forwardRef(
+  ({ onClick, asChild = false, ...props }, ref) => {
+    const { onOpenChange } = useSheetContext();
+    const handleClick = (e) => {
+      onOpenChange(true);
+      onClick?.(e);
+    };
+    const Comp = asChild ? Slot : "button";
+    return /* @__PURE__ */ jsx(Comp, { ref, type: "button", onClick: handleClick, ...props });
+  }
+);
+SheetTrigger.displayName = "SheetTrigger";
+var SheetClose = React20.forwardRef(
+  ({ onClick, asChild = false, ...props }, ref) => {
+    const { onOpenChange } = useSheetContext();
+    const handleClick = (e) => {
+      onOpenChange(false);
+      onClick?.(e);
+    };
+    const Comp = asChild ? Slot : "button";
+    return /* @__PURE__ */ jsx(Comp, { ref, type: "button", onClick: handleClick, ...props });
+  }
+);
+SheetClose.displayName = "SheetClose";
+var SheetContent = React20.forwardRef(
+  ({ side = "right", className, children, ...props }, ref) => {
+    const { open, onOpenChange } = useSheetContext();
+    if (!open) return null;
+    return createPortal(
+      /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: "ds-sheet__backdrop",
+            onClick: () => onOpenChange(false),
+            "aria-hidden": "true"
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            ref,
+            role: "dialog",
+            className: clsx18("ds-sheet__content", `ds-sheet__content--${side}`, className),
+            ...props,
+            children
+          }
+        )
+      ] }),
+      document.body
+    );
+  }
+);
+SheetContent.displayName = "SheetContent";
+var SheetHeader = React20.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", { ref, className: clsx18("ds-sheet__header", className), ...props })
+);
+SheetHeader.displayName = "SheetHeader";
+var SheetTitle = React20.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("h2", { ref, className: clsx18("ds-sheet__title", className), ...props }));
+SheetTitle.displayName = "SheetTitle";
+var SheetDescription = React20.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("p", { ref, className: clsx18("ds-sheet__description", className), ...props }));
+SheetDescription.displayName = "SheetDescription";
+var SheetFooter = React20.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", { ref, className: clsx18("ds-sheet__footer", className), ...props })
+);
+SheetFooter.displayName = "SheetFooter";
+var PopoverContext = React20.createContext(null);
+function usePopoverContext() {
+  const context = React20.useContext(PopoverContext);
+  if (!context) {
+    throw new Error("Popover compound components must be used within <Popover>");
+  }
+  return context;
+}
+var Popover = ({ open: controlledOpen, onOpenChange, children }) => {
+  const [uncontrolledOpen, setUncontrolledOpen] = React20.useState(false);
+  const isControlled = controlledOpen !== void 0;
+  const open = isControlled ? controlledOpen : uncontrolledOpen;
+  const setOpen = React20.useCallback(
+    (value) => {
+      if (!isControlled) {
+        setUncontrolledOpen(value);
+      }
+      onOpenChange?.(value);
+    },
+    [isControlled, onOpenChange]
+  );
+  const toggle = React20.useCallback(() => {
+    setOpen(!open);
+  }, [open, setOpen]);
+  const contextValue = React20.useMemo(
+    () => ({ open, setOpen, toggle }),
+    [open, setOpen, toggle]
+  );
+  return /* @__PURE__ */ jsx(PopoverContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx("div", { className: "ds-popover", children }) });
+};
+Popover.displayName = "Popover";
+var PopoverTrigger = React20.forwardRef(
+  ({ className, onClick, asChild = false, ...props }, ref) => {
+    const { toggle } = usePopoverContext();
+    const handleClick = (e) => {
+      toggle();
+      onClick?.(e);
+    };
+    const Comp = asChild ? Slot : "button";
+    return /* @__PURE__ */ jsx(
+      Comp,
+      {
+        ref,
+        type: "button",
+        className: clsx18("ds-popover__trigger", className),
+        onClick: handleClick,
+        ...props
+      }
+    );
+  }
+);
+PopoverTrigger.displayName = "PopoverTrigger";
+var PopoverContent = React20.forwardRef(
+  ({ className, side = "bottom", align = "center", ...props }, ref) => {
+    const { open } = usePopoverContext();
+    if (!open) return null;
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        className: clsx18(
+          "ds-popover__content",
+          `ds-popover__content--${side}`,
+          `ds-popover__content--align-${align}`,
+          className
+        ),
+        ...props
+      }
+    );
+  }
+);
+PopoverContent.displayName = "PopoverContent";
+var PopoverClose = React20.forwardRef(({ className, onClick, ...props }, ref) => {
+  const { setOpen } = usePopoverContext();
+  const handleClick = (e) => {
+    setOpen(false);
+    onClick?.(e);
+  };
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      ref,
+      type: "button",
+      className: clsx18("ds-popover__close", className),
+      onClick: handleClick,
+      ...props
+    }
+  );
+});
+PopoverClose.displayName = "PopoverClose";
+var Progress = React20.forwardRef(
+  ({ className, value = 0, max = 100, ...props }, ref) => {
+    const percentage = max > 0 ? Math.min(100, Math.max(0, value / max * 100)) : 0;
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        role: "progressbar",
+        "aria-valuenow": value,
+        "aria-valuemin": 0,
+        "aria-valuemax": max,
+        className: clsx18("ds-progress", className),
+        ...props,
+        children: /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: "ds-progress__indicator",
+            style: { width: `${percentage}%` }
+          }
+        )
+      }
+    );
+  }
+);
+Progress.displayName = "Progress";
+var ScrollArea = React20.forwardRef(
+  ({ className, children, ...props }, ref) => {
+    return /* @__PURE__ */ jsx("div", { ref, className: clsx18("ds-scroll-area", className), ...props, children: /* @__PURE__ */ jsx("div", { className: "ds-scroll-area__viewport", children }) });
+  }
+);
+ScrollArea.displayName = "ScrollArea";
+var ScrollBar = React20.forwardRef(
+  ({ className, orientation = "vertical", ...props }, ref) => {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        className: clsx18(
+          "ds-scroll-area__scrollbar",
+          `ds-scroll-area__scrollbar--${orientation}`,
+          className
+        ),
+        ...props
+      }
+    );
+  }
+);
+ScrollBar.displayName = "ScrollBar";
+var Toggle = React20.forwardRef(
+  ({
+    className,
+    pressed: controlledPressed,
+    onPressedChange,
+    variant = "default",
+    size = "md",
+    onClick,
+    ...props
+  }, ref) => {
+    const [uncontrolledPressed, setUncontrolledPressed] = React20.useState(false);
+    const isControlled = controlledPressed !== void 0;
+    const pressed = isControlled ? controlledPressed : uncontrolledPressed;
+    const handleClick = (e) => {
+      const next = !pressed;
+      if (!isControlled) {
+        setUncontrolledPressed(next);
+      }
+      onPressedChange?.(next);
+      onClick?.(e);
+    };
+    return /* @__PURE__ */ jsx(
+      "button",
+      {
+        ref,
+        type: "button",
+        className: clsx18(
+          "ds-toggle",
+          `ds-toggle--${variant}`,
+          `ds-toggle--${size}`,
+          className
+        ),
+        "aria-pressed": pressed,
+        "data-state": pressed ? "on" : "off",
+        onClick: handleClick,
+        ...props
+      }
+    );
+  }
+);
+Toggle.displayName = "Toggle";
+var CollapsibleContext = React20.createContext(null);
+function useCollapsibleContext() {
+  const context = React20.useContext(CollapsibleContext);
+  if (!context) {
+    throw new Error("Collapsible compound components must be used within <Collapsible>");
+  }
+  return context;
+}
+var Collapsible = React20.forwardRef(
+  ({ className, open: controlledOpen, onOpenChange, children, ...props }, ref) => {
+    const [uncontrolledOpen, setUncontrolledOpen] = React20.useState(false);
+    const isControlled = controlledOpen !== void 0;
+    const open = isControlled ? controlledOpen : uncontrolledOpen;
+    const toggle = React20.useCallback(() => {
+      const next = !open;
+      if (!isControlled) {
+        setUncontrolledOpen(next);
+      }
+      onOpenChange?.(next);
+    }, [open, isControlled, onOpenChange]);
+    const contextValue = React20.useMemo(
+      () => ({ open, toggle }),
+      [open, toggle]
+    );
+    return /* @__PURE__ */ jsx(CollapsibleContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        className: clsx18("ds-collapsible", className),
+        "data-state": open ? "open" : "closed",
+        ...props,
+        children
+      }
+    ) });
+  }
+);
+Collapsible.displayName = "Collapsible";
+var CollapsibleTrigger = React20.forwardRef(({ className, onClick, ...props }, ref) => {
+  const { toggle } = useCollapsibleContext();
+  const handleClick = (e) => {
+    toggle();
+    onClick?.(e);
+  };
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      ref,
+      type: "button",
+      className: clsx18("ds-collapsible__trigger", className),
+      onClick: handleClick,
+      ...props
+    }
+  );
+});
+CollapsibleTrigger.displayName = "CollapsibleTrigger";
+var CollapsibleContent = React20.forwardRef(({ className, children, ...props }, ref) => {
+  const { open } = useCollapsibleContext();
+  const contentRef = React20.useRef(null);
+  const [maxHeight, setMaxHeight] = React20.useState(
+    open ? void 0 : 0
+  );
+  React20.useEffect(() => {
+    const el = contentRef.current;
+    if (!el) return;
+    if (open) {
+      const scrollHeight = el.scrollHeight;
+      setMaxHeight(scrollHeight);
+      const timer = setTimeout(() => setMaxHeight(void 0), 200);
+      return () => clearTimeout(timer);
+    } else {
+      const scrollHeight = el.scrollHeight;
+      setMaxHeight(scrollHeight);
+      requestAnimationFrame(() => {
+        requestAnimationFrame(() => {
+          setMaxHeight(0);
+        });
+      });
+    }
+  }, [open]);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref: contentRef,
+      className: clsx18("ds-collapsible__content", className),
+      "data-state": open ? "open" : "closed",
+      style: {
+        maxHeight: maxHeight !== void 0 ? `${maxHeight}px` : "none"
+      },
+      hidden: !open && maxHeight === 0,
+      ...props,
+      children: /* @__PURE__ */ jsx("div", { ref, className: "ds-collapsible__content-inner", children })
+    }
+  );
+});
+CollapsibleContent.displayName = "CollapsibleContent";
+var HoverCardContext = React20.createContext(null);
+function useHoverCardContext() {
+  const context = React20.useContext(HoverCardContext);
+  if (!context) {
+    throw new Error("HoverCard compound components must be used within <HoverCard>");
+  }
+  return context;
+}
+var HoverCard = ({
+  openDelay = 200,
+  closeDelay = 100,
+  children
+}) => {
+  const [open, setOpen] = React20.useState(false);
+  const openTimerRef = React20.useRef();
+  const closeTimerRef = React20.useRef();
+  const onOpen = React20.useCallback(() => {
+    clearTimeout(closeTimerRef.current);
+    openTimerRef.current = setTimeout(() => setOpen(true), openDelay);
+  }, [openDelay]);
+  const onClose = React20.useCallback(() => {
+    clearTimeout(openTimerRef.current);
+    closeTimerRef.current = setTimeout(() => setOpen(false), closeDelay);
+  }, [closeDelay]);
+  React20.useEffect(() => {
+    return () => {
+      clearTimeout(openTimerRef.current);
+      clearTimeout(closeTimerRef.current);
+    };
+  }, []);
+  const contextValue = React20.useMemo(
+    () => ({ open, onOpen, onClose }),
+    [open, onOpen, onClose]
+  );
+  return /* @__PURE__ */ jsx(HoverCardContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx("div", { className: "ds-hover-card", children }) });
+};
+HoverCard.displayName = "HoverCard";
+var HoverCardTrigger = React20.forwardRef(({ className, onMouseEnter, onMouseLeave, ...props }, ref) => {
+  const { onOpen, onClose } = useHoverCardContext();
+  const handleMouseEnter = (e) => {
+    onOpen();
+    onMouseEnter?.(e);
+  };
+  const handleMouseLeave = (e) => {
+    onClose();
+    onMouseLeave?.(e);
+  };
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      ref,
+      className: clsx18("ds-hover-card__trigger", className),
+      onMouseEnter: handleMouseEnter,
+      onMouseLeave: handleMouseLeave,
+      ...props
+    }
+  );
+});
+HoverCardTrigger.displayName = "HoverCardTrigger";
+var HoverCardContent = React20.forwardRef(
+  ({ className, side = "bottom", align = "center", onMouseEnter, onMouseLeave, ...props }, ref) => {
+    const { open, onOpen, onClose } = useHoverCardContext();
+    const handleMouseEnter = (e) => {
+      onOpen();
+      onMouseEnter?.(e);
+    };
+    const handleMouseLeave = (e) => {
+      onClose();
+      onMouseLeave?.(e);
+    };
+    if (!open) return null;
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        className: clsx18(
+          "ds-hover-card__content",
+          `ds-hover-card__content--${side}`,
+          `ds-hover-card__content--align-${align}`,
+          className
+        ),
+        onMouseEnter: handleMouseEnter,
+        onMouseLeave: handleMouseLeave,
+        ...props
+      }
+    );
+  }
+);
+HoverCardContent.displayName = "HoverCardContent";
+var AspectRatio = React20.forwardRef(
+  ({ className, ratio = 1, style, children, ...props }, ref) => {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        className: clsx18("ds-aspect-ratio", className),
+        style: { ...style, paddingBottom: `${1 / ratio * 100}%` },
+        ...props,
+        children
+      }
+    );
+  }
+);
+AspectRatio.displayName = "AspectRatio";
+var Pagination = React20.forwardRef(
+  ({ className, "aria-label": ariaLabel = "pagination", ...props }, ref) => {
+    return /* @__PURE__ */ jsx(
+      "nav",
+      {
+        ref,
+        role: "navigation",
+        "aria-label": ariaLabel,
+        className: clsx18("ds-pagination", className),
+        ...props
+      }
+    );
+  }
+);
+Pagination.displayName = "Pagination";
+var PaginationContent = React20.forwardRef(({ className, ...props }, ref) => {
+  return /* @__PURE__ */ jsx(
+    "ul",
+    {
+      ref,
+      className: clsx18("ds-pagination__content", className),
+      ...props
+    }
+  );
+});
+PaginationContent.displayName = "PaginationContent";
+var PaginationItem = React20.forwardRef(({ className, ...props }, ref) => {
+  return /* @__PURE__ */ jsx(
+    "li",
+    {
+      ref,
+      className: clsx18("ds-pagination__item", className),
+      ...props
+    }
+  );
+});
+PaginationItem.displayName = "PaginationItem";
+var PaginationLink = React20.forwardRef(({ className, isActive = false, size = "md", asChild = false, ...props }, ref) => {
+  const Comp = asChild ? Slot : "button";
+  return /* @__PURE__ */ jsx(
+    Comp,
+    {
+      ref,
+      "aria-current": isActive ? "page" : void 0,
+      className: clsx18(
+        "ds-pagination__link",
+        `ds-pagination__link--${size}`,
+        isActive && "ds-pagination__link--active",
+        className
+      ),
+      ...props
+    }
+  );
+});
+PaginationLink.displayName = "PaginationLink";
+var PaginationPrevious = React20.forwardRef(({ className, label = "Previous", "aria-label": ariaLabel = "Go to previous page", ...props }, ref) => {
+  return /* @__PURE__ */ jsxs(
+    PaginationLink,
+    {
+      ref,
+      "aria-label": ariaLabel,
+      className: clsx18("ds-pagination__prev", className),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx(
+          "svg",
+          {
+            xmlns: "http://www.w3.org/2000/svg",
+            width: "16",
+            height: "16",
+            viewBox: "0 0 24 24",
+            fill: "none",
+            stroke: "currentColor",
+            strokeWidth: "2",
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            "aria-hidden": "true",
+            children: /* @__PURE__ */ jsx("path", { d: "m15 18-6-6 6-6" })
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { children: label })
+      ]
+    }
+  );
+});
+PaginationPrevious.displayName = "PaginationPrevious";
+var PaginationNext = React20.forwardRef(({ className, label = "Next", "aria-label": ariaLabel = "Go to next page", ...props }, ref) => {
+  return /* @__PURE__ */ jsxs(
+    PaginationLink,
+    {
+      ref,
+      "aria-label": ariaLabel,
+      className: clsx18("ds-pagination__next", className),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx("span", { children: label }),
+        /* @__PURE__ */ jsx(
+          "svg",
+          {
+            xmlns: "http://www.w3.org/2000/svg",
+            width: "16",
+            height: "16",
+            viewBox: "0 0 24 24",
+            fill: "none",
+            stroke: "currentColor",
+            strokeWidth: "2",
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            "aria-hidden": "true",
+            children: /* @__PURE__ */ jsx("path", { d: "m9 18 6-6-6-6" })
+          }
+        )
+      ]
+    }
+  );
+});
+PaginationNext.displayName = "PaginationNext";
+var PaginationEllipsis = React20.forwardRef(({ className, ...props }, ref) => {
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      ref,
+      "aria-hidden": "true",
+      className: clsx18("ds-pagination__ellipsis", className),
+      ...props,
+      children: "..."
+    }
+  );
+});
+PaginationEllipsis.displayName = "PaginationEllipsis";
+var levelToElement = {
+  display: "h1",
+  h1: "h1",
+  h2: "h2",
+  h3: "h3",
+  h4: "h4",
+  h5: "h5",
+  h6: "h6"
+};
+var Heading = React20.forwardRef(
+  ({ className, level = "h2", as, children, ...props }, ref) => {
+    const Comp = as ?? levelToElement[level];
+    return /* @__PURE__ */ jsx(
+      Comp,
+      {
+        ref,
+        className: clsx18("ds-heading", `ds-heading--${level}`, className),
+        ...props,
+        children
+      }
+    );
+  }
+);
+Heading.displayName = "Heading";
+var Text = React20.forwardRef(
+  ({ className, variant = "body", as = "p", children, ...props }, ref) => {
+    const Comp = as;
+    return /* @__PURE__ */ jsx(
+      Comp,
+      {
+        ref,
+        className: clsx18("ds-text", `ds-text--${variant}`, className),
+        ...props,
+        children
+      }
+    );
+  }
+);
+Text.displayName = "Text";
+var Prose = React20.forwardRef(
+  ({ className, children, ...props }, ref) => {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        className: clsx18("ds-prose", className),
+        ...props,
+        children
+      }
+    );
+  }
+);
+Prose.displayName = "Prose";
+var CarouselContext = React20.createContext(void 0);
+function useCarouselContext() {
+  const ctx = React20.useContext(CarouselContext);
+  if (!ctx) {
+    throw new Error("Carousel compound components must be used within a <Carousel> parent.");
+  }
+  return ctx;
+}
+var Carousel = React20.forwardRef(
+  ({ className, children, ...props }, ref) => {
+    const scrollRef = React20.useRef(null);
+    return /* @__PURE__ */ jsx(CarouselContext.Provider, { value: { scrollRef }, children: /* @__PURE__ */ jsx("div", { ref, className: clsx18("ds-carousel", className), ...props, children }) });
+  }
+);
+Carousel.displayName = "Carousel";
+var CarouselContent = React20.forwardRef(({ className, ...props }, ref) => {
+  const { scrollRef } = useCarouselContext();
+  const mergedRef = React20.useCallback(
+    (node) => {
+      scrollRef.current = node;
+      if (typeof ref === "function") {
+        ref(node);
+      } else if (ref) {
+        ref.current = node;
+      }
+    },
+    [ref, scrollRef]
+  );
+  return /* @__PURE__ */ jsx("div", { ref: mergedRef, className: clsx18("ds-carousel__content", className), ...props });
+});
+CarouselContent.displayName = "CarouselContent";
+var CarouselItem = React20.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", { ref, className: clsx18("ds-carousel__item", className), ...props })
+);
+CarouselItem.displayName = "CarouselItem";
+var CarouselPrevious = React20.forwardRef(({ className, onClick, children, "aria-label": ariaLabel = "Previous slide", ...props }, ref) => {
+  const { scrollRef } = useCarouselContext();
+  const handleClick = (e) => {
+    const container = scrollRef.current;
+    if (container) {
+      const firstItem = container.querySelector(".ds-carousel__item");
+      const scrollAmount = firstItem ? firstItem.clientWidth : container.clientWidth;
+      container.scrollBy({ left: -scrollAmount, behavior: "smooth" });
+    }
+    onClick?.(e);
+  };
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      ref,
+      type: "button",
+      className: clsx18("ds-carousel__prev", className),
+      "aria-label": ariaLabel,
+      onClick: handleClick,
+      ...props,
+      children: children ?? /* @__PURE__ */ jsx("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", "aria-hidden": "true", children: /* @__PURE__ */ jsx(
+        "path",
+        {
+          d: "M10 12L6 8L10 4",
+          stroke: "currentColor",
+          strokeWidth: "1.5",
+          strokeLinecap: "round",
+          strokeLinejoin: "round"
+        }
+      ) })
+    }
+  );
+});
+CarouselPrevious.displayName = "CarouselPrevious";
+var CarouselNext = React20.forwardRef(({ className, onClick, children, "aria-label": ariaLabel = "Next slide", ...props }, ref) => {
+  const { scrollRef } = useCarouselContext();
+  const handleClick = (e) => {
+    const container = scrollRef.current;
+    if (container) {
+      const firstItem = container.querySelector(".ds-carousel__item");
+      const scrollAmount = firstItem ? firstItem.clientWidth : container.clientWidth;
+      container.scrollBy({ left: scrollAmount, behavior: "smooth" });
+    }
+    onClick?.(e);
+  };
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      ref,
+      type: "button",
+      className: clsx18("ds-carousel__next", className),
+      "aria-label": ariaLabel,
+      onClick: handleClick,
+      ...props,
+      children: children ?? /* @__PURE__ */ jsx("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", "aria-hidden": "true", children: /* @__PURE__ */ jsx(
+        "path",
+        {
+          d: "M6 4L10 8L6 12",
+          stroke: "currentColor",
+          strokeWidth: "1.5",
+          strokeLinecap: "round",
+          strokeLinejoin: "round"
+        }
+      ) })
+    }
+  );
+});
+CarouselNext.displayName = "CarouselNext";
+function mergeRefs(...refs) {
+  return (node) => {
+    refs.forEach((ref) => {
+      if (typeof ref === "function") ref(node);
+      else if (ref) ref.current = node;
+    });
+  };
+}
+var CommandContext = React20.createContext(void 0);
+function useCommandContext() {
+  const ctx = React20.useContext(CommandContext);
+  if (!ctx) {
+    throw new Error("Command compound components must be used within a <Command> parent.");
+  }
+  return ctx;
+}
+function getOptionElements(listEl) {
+  if (!listEl) return [];
+  return Array.from(listEl.querySelectorAll('[role="option"]'));
+}
+var Command = React20.forwardRef(
+  ({ className, value: controlledValue, onValueChange, onKeyDown, children, ...props }, ref) => {
+    const [uncontrolledValue, setUncontrolledValue] = React20.useState("");
+    const [activeId, setActiveId] = React20.useState(null);
+    const listRef = React20.useRef(null);
+    const isControlled = controlledValue !== void 0;
+    const search = isControlled ? controlledValue : uncontrolledValue;
+    const inputId = React20.useId();
+    const listId = React20.useId();
+    const setSearch = React20.useCallback(
+      (next) => {
+        if (!isControlled) {
+          setUncontrolledValue(next);
+        }
+        onValueChange?.(next);
+      },
+      [isControlled, onValueChange]
+    );
+    React20.useEffect(() => {
+      const frame = requestAnimationFrame(() => {
+        const items = getOptionElements(listRef.current);
+        if (items.length > 0) {
+          setActiveId(items[0].id);
+        } else {
+          setActiveId(null);
+        }
+      });
+      return () => cancelAnimationFrame(frame);
+    }, [search]);
+    const handleKeyDown = React20.useCallback(
+      (e) => {
+        const items = getOptionElements(listRef.current);
+        if (items.length === 0) {
+          onKeyDown?.(e);
+          return;
+        }
+        const currentIndex = items.findIndex((el) => el.id === activeId);
+        switch (e.key) {
+          case "ArrowDown": {
+            e.preventDefault();
+            const nextIndex = currentIndex < items.length - 1 ? currentIndex + 1 : 0;
+            setActiveId(items[nextIndex].id);
+            items[nextIndex].scrollIntoView?.({ block: "nearest" });
+            break;
+          }
+          case "ArrowUp": {
+            e.preventDefault();
+            const prevIndex = currentIndex > 0 ? currentIndex - 1 : items.length - 1;
+            setActiveId(items[prevIndex].id);
+            items[prevIndex].scrollIntoView?.({ block: "nearest" });
+            break;
+          }
+          case "Home": {
+            e.preventDefault();
+            setActiveId(items[0].id);
+            items[0].scrollIntoView?.({ block: "nearest" });
+            break;
+          }
+          case "End": {
+            e.preventDefault();
+            const lastItem = items[items.length - 1];
+            setActiveId(lastItem.id);
+            lastItem.scrollIntoView?.({ block: "nearest" });
+            break;
+          }
+          case "Enter": {
+            const target = e.target;
+            if (target.getAttribute("role") === "option") break;
+            const activeEl = activeId ? document.getElementById(activeId) : null;
+            if (activeEl) {
+              e.preventDefault();
+              activeEl.click();
+            }
+            break;
+          }
+        }
+        onKeyDown?.(e);
+      },
+      [activeId, onKeyDown]
+    );
+    const ctx = React20.useMemo(
+      () => ({ search, setSearch, activeId, setActiveId, listRef, inputId, listId }),
+      [search, setSearch, activeId, inputId, listId]
+    );
+    return /* @__PURE__ */ jsx(CommandContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        className: clsx18("ds-command", className),
+        onKeyDown: handleKeyDown,
+        ...props,
+        children
+      }
+    ) });
+  }
+);
+Command.displayName = "Command";
+var CommandInput = React20.forwardRef(({ className, onChange, ...props }, ref) => {
+  const { search, setSearch, activeId, inputId, listId } = useCommandContext();
+  const handleChange = (e) => {
+    setSearch(e.target.value);
+    onChange?.(e);
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "ds-command__input-wrapper", children: [
+    /* @__PURE__ */ jsxs(
+      "svg",
+      {
+        className: "ds-command__input-icon",
+        width: "16",
+        height: "16",
+        viewBox: "0 0 16 16",
+        fill: "none",
+        "aria-hidden": "true",
+        children: [
+          /* @__PURE__ */ jsx("circle", { cx: "7", cy: "7", r: "5", stroke: "currentColor", strokeWidth: "1.5" }),
+          /* @__PURE__ */ jsx(
+            "path",
+            {
+              d: "M11 11L14 14",
+              stroke: "currentColor",
+              strokeWidth: "1.5",
+              strokeLinecap: "round"
+            }
+          )
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        ref,
+        id: inputId,
+        type: "text",
+        role: "combobox",
+        "aria-expanded": "true",
+        "aria-controls": listId,
+        "aria-activedescendant": activeId ?? void 0,
+        "aria-autocomplete": "list",
+        autoComplete: "off",
+        className: clsx18("ds-command__input", className),
+        value: search,
+        onChange: handleChange,
+        ...props
+      }
+    )
+  ] });
+});
+CommandInput.displayName = "CommandInput";
+var CommandList = React20.forwardRef(
+  ({ className, ...props }, ref) => {
+    const { listRef, listId } = useCommandContext();
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: mergeRefs(ref, listRef),
+        id: listId,
+        role: "listbox",
+        className: clsx18("ds-command__list", className),
+        ...props
+      }
+    );
+  }
+);
+CommandList.displayName = "CommandList";
+var CommandEmpty = React20.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", { ref, className: clsx18("ds-command__empty", className), ...props })
+);
+CommandEmpty.displayName = "CommandEmpty";
+var CommandGroup = React20.forwardRef(
+  ({ className, heading, children, ...props }, ref) => /* @__PURE__ */ jsxs("div", { ref, className: clsx18("ds-command__group", className), ...props, children: [
+    heading && /* @__PURE__ */ jsx("div", { className: "ds-command__group-heading", children: heading }),
+    children
+  ] })
+);
+CommandGroup.displayName = "CommandGroup";
+var CommandItem = React20.forwardRef(
+  ({ className, onSelect, onClick, onKeyDown, onPointerEnter, id: externalId, ...props }, ref) => {
+    const generatedId = React20.useId();
+    const { activeId, setActiveId } = useCommandContext();
+    const itemId = externalId || generatedId;
+    const isActive = activeId === itemId;
+    const handleClick = (e) => {
+      onSelect?.();
+      onClick?.(e);
+    };
+    const handleKeyDown = (e) => {
+      if (e.key === "Enter") {
+        onSelect?.();
+      }
+      onKeyDown?.(e);
+    };
+    const handlePointerEnter = (e) => {
+      setActiveId(itemId);
+      onPointerEnter?.(e);
+    };
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        id: itemId,
+        role: "option",
+        tabIndex: 0,
+        "aria-selected": isActive,
+        "data-active": isActive || void 0,
+        className: clsx18("ds-command__item", className),
+        onClick: handleClick,
+        onKeyDown: handleKeyDown,
+        onPointerEnter: handlePointerEnter,
+        ...props
+      }
+    );
+  }
+);
+CommandItem.displayName = "CommandItem";
+var CommandSeparator = React20.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", { ref, className: clsx18("ds-command__separator", className), ...props }));
+CommandSeparator.displayName = "CommandSeparator";
+var SIZE_CLASSES = {
+  sm: "ds-dialog__content--sm",
+  lg: "ds-dialog__content--lg",
+  xl: "ds-dialog__content--xl"
+};
+var CommandDialog = ({
+  open,
+  onOpenChange,
+  title = "Search",
+  size = "lg",
+  className,
+  children
+}) => /* @__PURE__ */ jsx(Dialog, { open, onOpenChange, children: /* @__PURE__ */ jsxs(
+  DialogContent,
+  {
+    className: clsx18("ds-command-dialog", SIZE_CLASSES[size], className),
+    children: [
+      /* @__PURE__ */ jsx(DialogTitle, { className: "ds-command-dialog__sr-title", children: title }),
+      children
+    ]
+  }
+) });
+CommandDialog.displayName = "CommandDialog";
+var DrawerContext = React20.createContext(void 0);
+function useDrawerContext() {
+  const ctx = React20.useContext(DrawerContext);
+  if (!ctx) {
+    throw new Error("Drawer compound components must be used within a <Drawer> parent.");
+  }
+  return ctx;
+}
+var Drawer = ({ open: controlledOpen, onOpenChange, children }) => {
+  const [uncontrolledOpen, setUncontrolledOpen] = React20.useState(false);
+  const isControlled = controlledOpen !== void 0;
+  const open = isControlled ? controlledOpen : uncontrolledOpen;
+  const handleOpenChange = React20.useCallback(
+    (next) => {
+      if (!isControlled) {
+        setUncontrolledOpen(next);
+      }
+      onOpenChange?.(next);
+    },
+    [isControlled, onOpenChange]
+  );
+  return /* @__PURE__ */ jsx(DrawerContext.Provider, { value: { open, onOpenChange: handleOpenChange }, children });
+};
+Drawer.displayName = "Drawer";
+var DrawerTrigger = React20.forwardRef(({ onClick, ...props }, ref) => {
+  const { onOpenChange } = useDrawerContext();
+  const handleClick = (e) => {
+    onOpenChange(true);
+    onClick?.(e);
+  };
+  return /* @__PURE__ */ jsx("button", { ref, type: "button", onClick: handleClick, ...props });
+});
+DrawerTrigger.displayName = "DrawerTrigger";
+var DrawerClose = React20.forwardRef(({ onClick, ...props }, ref) => {
+  const { onOpenChange } = useDrawerContext();
+  const handleClick = (e) => {
+    onOpenChange(false);
+    onClick?.(e);
+  };
+  return /* @__PURE__ */ jsx("button", { ref, type: "button", onClick: handleClick, ...props });
+});
+DrawerClose.displayName = "DrawerClose";
+var DrawerContent = React20.forwardRef(
+  ({ className, children, ...props }, ref) => {
+    const { open, onOpenChange } = useDrawerContext();
+    if (!open) return null;
+    return createPortal(
+      /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: "ds-drawer__backdrop",
+            onClick: () => onOpenChange(false),
+            "aria-hidden": "true"
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            ref,
+            role: "dialog",
+            className: clsx18("ds-drawer__content", className),
+            ...props,
+            children: [
+              /* @__PURE__ */ jsx("div", { className: "ds-drawer__handle", "aria-hidden": "true", children: /* @__PURE__ */ jsx("div", { className: "ds-drawer__handle-bar" }) }),
+              children
+            ]
+          }
+        )
+      ] }),
+      document.body
+    );
+  }
+);
+DrawerContent.displayName = "DrawerContent";
+var DrawerHeader = React20.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", { ref, className: clsx18("ds-drawer__header", className), ...props })
+);
+DrawerHeader.displayName = "DrawerHeader";
+var DrawerTitle = React20.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("h2", { ref, className: clsx18("ds-drawer__title", className), ...props }));
+DrawerTitle.displayName = "DrawerTitle";
+var DrawerDescription = React20.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx("p", { ref, className: clsx18("ds-drawer__description", className), ...props }));
+DrawerDescription.displayName = "DrawerDescription";
+var DrawerFooter = React20.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", { ref, className: clsx18("ds-drawer__footer", className), ...props })
+);
+DrawerFooter.displayName = "DrawerFooter";
+var DEFAULT_WEEKDAY_LABELS = ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"];
+var DEFAULT_MONTH_NAMES = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+function isSameDay(a, b) {
+  return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+function getDaysInMonth(year, month) {
+  return new Date(year, month + 1, 0).getDate();
+}
+function getCalendarGrid(year, month) {
+  const firstDay = new Date(year, month, 1).getDay();
+  const daysInMonth = getDaysInMonth(year, month);
+  const daysInPrevMonth = getDaysInMonth(year, month - 1);
+  const days = [];
+  for (let i = firstDay - 1; i >= 0; i--) {
+    days.push(new Date(year, month - 1, daysInPrevMonth - i));
+  }
+  for (let d = 1; d <= daysInMonth; d++) {
+    days.push(new Date(year, month, d));
+  }
+  const remaining = 7 - days.length % 7;
+  if (remaining < 7) {
+    for (let d = 1; d <= remaining; d++) {
+      days.push(new Date(year, month + 1, d));
+    }
+  }
+  const weeks = [];
+  for (let i = 0; i < days.length; i += 7) {
+    weeks.push(days.slice(i, i + 7));
+  }
+  return weeks;
+}
+var Calendar = React20.forwardRef(
+  ({ className, selected, onSelect, month, onMonthChange, labels, ...props }, ref) => {
+    const weekdayLabels = labels?.weekdays ?? DEFAULT_WEEKDAY_LABELS;
+    const monthNames = labels?.months ?? DEFAULT_MONTH_NAMES;
+    const formatDayLabel = labels?.formatDayLabel ?? ((d) => d.toDateString());
+    const today = /* @__PURE__ */ new Date();
+    const [internalMonth, setInternalMonth] = React20.useState(
+      () => month ?? selected ?? /* @__PURE__ */ new Date()
+    );
+    const displayedMonth = month ?? internalMonth;
+    const displayYear = displayedMonth.getFullYear();
+    const displayMonthIndex = displayedMonth.getMonth();
+    const weeks = getCalendarGrid(displayYear, displayMonthIndex);
+    const navigateMonth = (delta) => {
+      const next = new Date(displayYear, displayMonthIndex + delta, 1);
+      if (onMonthChange) {
+        onMonthChange(next);
+      } else {
+        setInternalMonth(next);
+      }
+    };
+    const handleDayClick = (date) => {
+      onSelect?.(date);
+    };
+    return /* @__PURE__ */ jsxs("div", { ref, className: clsx18("ds-calendar", className), ...props, children: [
+      /* @__PURE__ */ jsxs("div", { className: "ds-calendar__header", children: [
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            className: "ds-calendar__nav-button",
+            onClick: () => navigateMonth(-1),
+            "aria-label": labels?.previousMonth ?? "Previous month",
+            children: /* @__PURE__ */ jsx(
+              "svg",
+              {
+                width: "16",
+                height: "16",
+                viewBox: "0 0 24 24",
+                fill: "none",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                children: /* @__PURE__ */ jsx("polyline", { points: "15 18 9 12 15 6" })
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: "ds-calendar__title", children: [
+          monthNames[displayMonthIndex],
+          " ",
+          displayYear
+        ] }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            className: "ds-calendar__nav-button",
+            onClick: () => navigateMonth(1),
+            "aria-label": labels?.nextMonth ?? "Next month",
+            children: /* @__PURE__ */ jsx(
+              "svg",
+              {
+                width: "16",
+                height: "16",
+                viewBox: "0 0 24 24",
+                fill: "none",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                children: /* @__PURE__ */ jsx("polyline", { points: "9 18 15 12 9 6" })
+              }
+            )
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "ds-calendar__grid", role: "grid", children: [
+        /* @__PURE__ */ jsx("div", { className: "ds-calendar__head-row", role: "row", children: weekdayLabels.map((wdLabel) => /* @__PURE__ */ jsx("div", { className: "ds-calendar__head-cell", role: "columnheader", children: wdLabel }, wdLabel)) }),
+        /* @__PURE__ */ jsx("div", { className: "ds-calendar__body", children: weeks.map((week, wi) => /* @__PURE__ */ jsx("div", { className: "ds-calendar__row", role: "row", children: week.map((date, di) => {
+          const isOutside = date.getMonth() !== displayMonthIndex;
+          const isSelected = selected ? isSameDay(date, selected) : false;
+          const isToday = isSameDay(date, today);
+          return /* @__PURE__ */ jsx("div", { className: "ds-calendar__cell", role: "gridcell", children: /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              className: clsx18(
+                "ds-calendar__day",
+                isSelected && "ds-calendar__day--selected",
+                isToday && "ds-calendar__day--today",
+                isOutside && "ds-calendar__day--outside"
+              ),
+              onClick: () => handleDayClick(date),
+              tabIndex: isOutside ? -1 : 0,
+              "aria-label": formatDayLabel(date),
+              children: date.getDate()
+            }
+          ) }, di);
+        }) }, wi)) })
+      ] })
+    ] });
+  }
+);
+Calendar.displayName = "Calendar";
+var InputOTPContext = React20.createContext({
+  value: "",
+  activeIndex: -1
+});
+var InputOTP = React20.forwardRef(
+  ({ className, length = 6, value = "", onChange, children, "aria-label": ariaLabel = "One-time password", ...props }, ref) => {
+    const inputRef = React20.useRef(null);
+    const [activeIndex, setActiveIndex] = React20.useState(-1);
+    const handleChange = (e) => {
+      const newValue = e.target.value.replace(/[^0-9]/g, "").slice(0, length);
+      onChange?.(newValue);
+    };
+    const handleFocus = () => {
+      setActiveIndex(Math.min(value.length, length - 1));
+    };
+    const handleBlur = () => {
+      setActiveIndex(-1);
+    };
+    const handleKeyDown = (e) => {
+      if (e.key === "Backspace" && value.length > 0) {
+        onChange?.(value.slice(0, -1));
+      }
+    };
+    const handleContainerClick = () => {
+      inputRef.current?.focus();
+    };
+    const contextValue = React20.useMemo(
+      () => ({ value, activeIndex }),
+      [value, activeIndex]
+    );
+    return /* @__PURE__ */ jsx(InputOTPContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref,
+        className: clsx18("ds-input-otp", className),
+        onClick: handleContainerClick,
+        ...props,
+        children: [
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              ref: inputRef,
+              type: "text",
+              inputMode: "numeric",
+              autoComplete: "one-time-code",
+              pattern: "[0-9]*",
+              maxLength: length,
+              value,
+              onChange: handleChange,
+              onFocus: handleFocus,
+              onBlur: handleBlur,
+              onKeyDown: handleKeyDown,
+              className: "ds-input-otp__hidden-input",
+              "aria-label": ariaLabel
+            }
+          ),
+          children
+        ]
+      }
+    ) });
+  }
+);
+InputOTP.displayName = "InputOTP";
+var InputOTPGroup = React20.forwardRef(({ className, ...props }, ref) => {
+  return /* @__PURE__ */ jsx("div", { ref, className: clsx18("ds-input-otp__group", className), ...props });
+});
+InputOTPGroup.displayName = "InputOTPGroup";
+var InputOTPSlot = React20.forwardRef(
+  ({ className, index, ...props }, ref) => {
+    const { value, activeIndex } = React20.useContext(InputOTPContext);
+    const char = value[index] ?? "";
+    const isActive = activeIndex === index;
+    const isFilled = char !== "";
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        className: clsx18(
+          "ds-input-otp__slot",
+          isActive && "ds-input-otp__slot--active",
+          isFilled && "ds-input-otp__slot--filled",
+          className
+        ),
+        ...props,
+        children: char
+      }
+    );
+  }
+);
+InputOTPSlot.displayName = "InputOTPSlot";
+var InputOTPSeparator = React20.forwardRef(({ className, ...props }, ref) => {
+  return /* @__PURE__ */ jsx("div", { ref, className: clsx18("ds-input-otp__separator", className), role: "separator", ...props, children: /* @__PURE__ */ jsx(
+    "svg",
+    {
+      width: "8",
+      height: "8",
+      viewBox: "0 0 8 8",
+      fill: "currentColor",
+      children: /* @__PURE__ */ jsx("circle", { cx: "4", cy: "4", r: "2" })
+    }
+  ) });
+});
+InputOTPSeparator.displayName = "InputOTPSeparator";
+var ContextMenuContext = React20.createContext({
+  open: false,
+  position: { x: 0, y: 0 },
+  onClose: () => {
+  }
+});
+function ContextMenu({ children }) {
+  const [open, setOpen] = React20.useState(false);
+  const [position, setPosition] = React20.useState({ x: 0, y: 0 });
+  const handleOpen = React20.useCallback((x, y) => {
+    setPosition({ x, y });
+    setOpen(true);
+  }, []);
+  const handleClose = React20.useCallback(() => {
+    setOpen(false);
+  }, []);
+  const contextValue = React20.useMemo(
+    () => ({ open, position, onClose: handleClose }),
+    [open, position, handleClose]
+  );
+  return /* @__PURE__ */ jsx(ContextMenuInternalContext.Provider, { value: { onOpen: handleOpen }, children: /* @__PURE__ */ jsx(ContextMenuContext.Provider, { value: contextValue, children }) });
+}
+ContextMenu.displayName = "ContextMenu";
+var ContextMenuInternalContext = React20.createContext({ onOpen: () => {
+} });
+var ContextMenuTrigger = React20.forwardRef(({ className, onContextMenu, ...props }, ref) => {
+  const { onOpen } = React20.useContext(ContextMenuInternalContext);
+  const handleContextMenu = (e) => {
+    e.preventDefault();
+    onOpen(e.clientX, e.clientY);
+    onContextMenu?.(e);
+  };
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref,
+      className: clsx18("ds-context-menu__trigger", className),
+      onContextMenu: handleContextMenu,
+      ...props
+    }
+  );
+});
+ContextMenuTrigger.displayName = "ContextMenuTrigger";
+var ContextMenuContent = React20.forwardRef(({ className, ...props }, ref) => {
+  const { open, position, onClose } = React20.useContext(ContextMenuContext);
+  const contentRef = React20.useRef(null);
+  const mergedRef = React20.useCallback(
+    (node) => {
+      contentRef.current = node;
+      if (typeof ref === "function") ref(node);
+      else if (ref) ref.current = node;
+    },
+    [ref]
+  );
+  React20.useEffect(() => {
+    if (!open) return;
+    const handleClickOutside = (e) => {
+      if (contentRef.current && !contentRef.current.contains(e.target)) {
+        onClose();
+      }
+    };
+    const handleEscape = (e) => {
+      if (e.key === "Escape") {
+        onClose();
+      }
+    };
+    const timer = setTimeout(() => {
+      document.addEventListener("mousedown", handleClickOutside);
+    }, 0);
+    document.addEventListener("keydown", handleEscape);
+    return () => {
+      clearTimeout(timer);
+      document.removeEventListener("mousedown", handleClickOutside);
+      document.removeEventListener("keydown", handleEscape);
+    };
+  }, [open, onClose]);
+  if (!open) return null;
+  return ReactDOM.createPortal(
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: mergedRef,
+        role: "menu",
+        className: clsx18("ds-context-menu__content", className),
+        style: { top: position.y, left: position.x },
+        ...props
+      }
+    ),
+    document.body
+  );
+});
+ContextMenuContent.displayName = "ContextMenuContent";
+var ContextMenuItem = React20.forwardRef(
+  ({ className, onSelect, onClick, ...props }, ref) => {
+    const { onClose } = React20.useContext(ContextMenuContext);
+    const handleClick = (e) => {
+      onSelect?.();
+      onClose();
+      onClick?.(e);
+    };
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        role: "menuitem",
+        className: clsx18("ds-context-menu__item", className),
+        onClick: handleClick,
+        ...props
+      }
+    );
+  }
+);
+ContextMenuItem.displayName = "ContextMenuItem";
+var ContextMenuSeparator = React20.forwardRef(({ className, ...props }, ref) => {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref,
+      role: "separator",
+      className: clsx18("ds-context-menu__separator", className),
+      ...props
+    }
+  );
+});
+ContextMenuSeparator.displayName = "ContextMenuSeparator";
+var ContextMenuLabel = React20.forwardRef(({ className, ...props }, ref) => {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref,
+      className: clsx18("ds-context-menu__label", className),
+      ...props
+    }
+  );
+});
+ContextMenuLabel.displayName = "ContextMenuLabel";
+var FormFieldContext = React20.createContext(void 0);
+function useFormField() {
+  const ctx = React20.useContext(FormFieldContext);
+  if (!ctx) {
+    throw new Error("useFormField must be used within a <FormField>");
+  }
+  return ctx;
+}
+var FormItemContext = React20.createContext(void 0);
+function FormField({ name, children, value, onChange, onBlur, error }) {
+  const id = React20.useId();
+  const contextValue = React20.useMemo(
+    () => ({ id: `${id}-form-item`, name, error }),
+    [id, name, error]
+  );
+  const fieldProps = React20.useMemo(
+    () => ({
+      value: value ?? "",
+      onChange: onChange ?? (() => {
+      }),
+      onBlur: onBlur ?? (() => {
+      }),
+      error,
+      id: `${id}-form-item`
+    }),
+    [value, onChange, onBlur, error, id]
+  );
+  return /* @__PURE__ */ jsx(FormFieldContext.Provider, { value: contextValue, children: children(fieldProps) });
+}
+FormField.displayName = "FormField";
+var FormItem = React20.forwardRef(
+  ({ className, ...props }, ref) => {
+    const id = React20.useId();
+    const contextValue = React20.useMemo(() => ({ id }), [id]);
+    return /* @__PURE__ */ jsx(FormItemContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx("div", { ref, className: clsx18("ds-form__item", className), ...props }) });
+  }
+);
+FormItem.displayName = "FormItem";
+var FormLabel = React20.forwardRef(({ className, ...props }, ref) => {
+  const fieldCtx = React20.useContext(FormFieldContext);
+  const hasError = !!fieldCtx?.error;
+  return /* @__PURE__ */ jsx(
+    "label",
+    {
+      ref,
+      htmlFor: fieldCtx?.id,
+      className: clsx18("ds-form__label", hasError && "ds-form__label--error", className),
+      ...props
+    }
+  );
+});
+FormLabel.displayName = "FormLabel";
+var FormControl = React20.forwardRef(
+  ({ className, children, ...props }, ref) => {
+    const fieldCtx = React20.useContext(FormFieldContext);
+    const descriptionId = fieldCtx ? `${fieldCtx.id}-description` : void 0;
+    const messageId = fieldCtx ? `${fieldCtx.id}-message` : void 0;
+    const hasError = !!fieldCtx?.error;
+    return /* @__PURE__ */ jsx("div", { ref, className: clsx18("ds-form__control", className), ...props, children: React20.isValidElement(children) ? React20.cloneElement(children, {
+      id: fieldCtx?.id,
+      "aria-describedby": descriptionId,
+      "aria-invalid": hasError || void 0,
+      "aria-errormessage": hasError ? messageId : void 0
+    }) : children });
+  }
+);
+FormControl.displayName = "FormControl";
+var FormDescription = React20.forwardRef(({ className, ...props }, ref) => {
+  const fieldCtx = React20.useContext(FormFieldContext);
+  return /* @__PURE__ */ jsx(
+    "p",
+    {
+      ref,
+      id: fieldCtx ? `${fieldCtx.id}-description` : void 0,
+      className: clsx18("ds-form__description", className),
+      ...props
+    }
+  );
+});
+FormDescription.displayName = "FormDescription";
+var FormMessage = React20.forwardRef(({ className, children, ...props }, ref) => {
+  const fieldCtx = React20.useContext(FormFieldContext);
+  const message = children ?? fieldCtx?.error;
+  if (!message) return null;
+  return /* @__PURE__ */ jsx(
+    "p",
+    {
+      ref,
+      id: fieldCtx ? `${fieldCtx.id}-message` : void 0,
+      role: "alert",
+      className: clsx18("ds-form__message", className),
+      ...props,
+      children: message
+    }
+  );
+});
+FormMessage.displayName = "FormMessage";
+var MAX_RESPONSIVE_COLS = 6;
+var Grid = forwardRef(
+  ({ columns, rows, align, justify, fixed, className, style, ...props }, ref) => {
+    const useColClass = typeof columns === "number" && columns >= 1 && columns <= MAX_RESPONSIVE_COLS;
+    return /* @__PURE__ */ jsx(
+      Box,
+      {
+        ref,
+        className: clsx18(
+          "ds-grid",
+          useColClass && `ds-grid--cols-${columns}`,
+          fixed && "ds-grid--fixed",
+          className
+        ),
+        style: {
+          gridTemplateColumns: useColClass ? void 0 : typeof columns === "number" ? `repeat(${columns}, 1fr)` : columns,
+          gridTemplateRows: typeof rows === "number" ? `repeat(${rows}, 1fr)` : rows,
+          alignItems: align,
+          justifyItems: justify,
+          ...style
+        },
+        ...props
+      }
+    );
+  }
+);
+Grid.displayName = "Grid";
+var Section = forwardRef(
+  ({ padding = "md", className, children, ...props }, ref) => {
+    return /* @__PURE__ */ jsx(
+      "section",
+      {
+        ref,
+        className: clsx18("ds-section-block", `ds-section-block--${padding}`, className),
+        ...props,
+        children
+      }
+    );
+  }
+);
+Section.displayName = "Section";
+var VisuallyHidden = forwardRef(
+  ({ className, ...props }, ref) => {
+    return /* @__PURE__ */ jsx("span", { ref, className: clsx18("ds-visually-hidden", className), ...props });
+  }
+);
+VisuallyHidden.displayName = "VisuallyHidden";
+var StatusBadge = React20.forwardRef(
+  ({ variant = "default", size = "md", dot = false, className, children }, ref) => {
+    return /* @__PURE__ */ jsxs(
+      "span",
+      {
+        ref,
+        className: clsx18(
+          "ds-status-badge",
+          `ds-status-badge--${variant}`,
+          `ds-status-badge--${size}`,
+          dot && "ds-status-badge--dot",
+          className
+        ),
+        children: [
+          dot && /* @__PURE__ */ jsx("span", { className: "ds-status-badge__dot" }),
+          children
+        ]
+      }
+    );
+  }
+);
+StatusBadge.displayName = "StatusBadge";
+var DefaultIcons = {
+  info: /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      width: "20",
+      height: "20",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: [
+        /* @__PURE__ */ jsx("circle", { cx: "12", cy: "12", r: "10" }),
+        /* @__PURE__ */ jsx("line", { x1: "12", y1: "16", x2: "12", y2: "12" }),
+        /* @__PURE__ */ jsx("line", { x1: "12", y1: "8", x2: "12.01", y2: "8" })
+      ]
+    }
+  ),
+  success: /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      width: "20",
+      height: "20",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: [
+        /* @__PURE__ */ jsx("path", { d: "M22 11.08V12a10 10 0 1 1-5.93-9.14" }),
+        /* @__PURE__ */ jsx("polyline", { points: "22 4 12 14.01 9 11.01" })
+      ]
+    }
+  ),
+  warning: /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      width: "20",
+      height: "20",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: [
+        /* @__PURE__ */ jsx("path", { d: "M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z" }),
+        /* @__PURE__ */ jsx("line", { x1: "12", y1: "9", x2: "12", y2: "13" }),
+        /* @__PURE__ */ jsx("line", { x1: "12", y1: "17", x2: "12.01", y2: "17" })
+      ]
+    }
+  ),
+  error: /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      width: "20",
+      height: "20",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: [
+        /* @__PURE__ */ jsx("circle", { cx: "12", cy: "12", r: "10" }),
+        /* @__PURE__ */ jsx("line", { x1: "15", y1: "9", x2: "9", y2: "15" }),
+        /* @__PURE__ */ jsx("line", { x1: "9", y1: "9", x2: "15", y2: "15" })
+      ]
+    }
+  )
+};
+var Alert = React20.forwardRef(
+  ({ className, variant = "info", title, icon, children, ...props }, ref) => {
+    const renderedIcon = icon || DefaultIcons[variant];
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref,
+        role: "alert",
+        className: clsx18("ds-alert", `ds-alert--${variant}`, className),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsx("div", { className: "ds-alert__icon", "aria-hidden": "true", children: renderedIcon }),
+          /* @__PURE__ */ jsxs("div", { className: "ds-alert__content", children: [
+            title && /* @__PURE__ */ jsx("div", { className: "ds-alert__title", children: title }),
+            children && /* @__PURE__ */ jsx("div", { className: "ds-alert__description", children })
+          ] })
+        ]
+      }
+    );
+  }
+);
+Alert.displayName = "Alert";
+var ToastContext = createContext(void 0);
+var useToast = () => {
+  const context = useContext(ToastContext);
+  if (!context) {
+    throw new Error("useToast must be used within a ToastProvider");
+  }
+  return context;
+};
+var ToastItem = ({
+  title,
+  description,
+  variant = "info",
+  action,
+  onDismiss,
+  dismissLabel = "Close"
+}) => {
+  return /* @__PURE__ */ jsxs("div", { className: clsx18("ds-toast-root", `ds-toast--${variant}`), "data-state": "open", role: "alert", children: [
+    title && /* @__PURE__ */ jsx("div", { className: "ds-toast-title", children: title }),
+    description && /* @__PURE__ */ jsx("div", { className: "ds-toast-description", children: description }),
+    action && /* @__PURE__ */ jsx("div", { className: "ds-toast-action", children: action }),
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        onClick: onDismiss,
+        style: {
+          background: "transparent",
+          border: "none",
+          color: "var(--text-tertiary)",
+          cursor: "pointer",
+          padding: "4px",
+          marginLeft: "auto",
+          gridColumn: "action",
+          alignSelf: "start"
+        },
+        "aria-label": dismissLabel,
+        children: /* @__PURE__ */ jsxs(
+          "svg",
+          {
+            width: "14",
+            height: "14",
+            viewBox: "0 0 24 24",
+            fill: "none",
+            stroke: "currentColor",
+            strokeWidth: "2",
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            children: [
+              /* @__PURE__ */ jsx("line", { x1: "18", y1: "6", x2: "6", y2: "18" }),
+              /* @__PURE__ */ jsx("line", { x1: "6", y1: "6", x2: "18", y2: "18" })
+            ]
+          }
+        )
+      }
+    )
+  ] });
+};
+var ToastProvider = ({ children }) => {
+  const [toasts, setToasts] = useState([]);
+  const [mounted, setMounted] = useState(false);
+  const idCounter = useRef(0);
+  useEffect(() => setMounted(true), []);
+  const removeToast = useCallback((id) => {
+    setToasts((prev) => prev.filter((t) => t.id !== id));
+  }, []);
+  const addToast = useCallback(
+    ({ duration = 5e3, ...props }) => {
+      const id = `toast-${++idCounter.current}`;
+      const newToast = { ...props, id, duration };
+      setToasts((prev) => [...prev, newToast]);
+      if (duration !== Infinity) {
+        setTimeout(() => {
+          removeToast(id);
+        }, duration);
+      }
+    },
+    [removeToast]
+  );
+  return /* @__PURE__ */ jsxs(ToastContext.Provider, { value: { addToast, removeToast }, children: [
+    children,
+    mounted && createPortal(
+      /* @__PURE__ */ jsx("div", { className: "ds-toast-viewport", children: toasts.map((toast) => /* @__PURE__ */ jsx(ToastItem, { ...toast, onDismiss: () => removeToast(toast.id) }, toast.id)) }),
+      document.body
+    )
+  ] });
+};
+var EmptyState = React20.forwardRef(
+  ({ icon, title, description, action, className, ...props }, ref) => {
+    return /* @__PURE__ */ jsxs("div", { ref, className: clsx18("ds-empty-state", className), ...props, children: [
+      icon && /* @__PURE__ */ jsx("div", { className: "ds-empty-state__icon", children: icon }),
+      /* @__PURE__ */ jsx("h3", { className: "ds-empty-state__title", children: title }),
+      description && /* @__PURE__ */ jsx("p", { className: "ds-empty-state__description", children: description }),
+      action && /* @__PURE__ */ jsx("div", { className: "ds-empty-state__action", children: action })
+    ] });
+  }
+);
+EmptyState.displayName = "EmptyState";
+
+// src/tokens/colors.ts
+var COLORS = {
+  text: {
+    primary: "var(--text-primary)",
+    secondary: "var(--text-secondary)",
+    tertiary: "var(--text-tertiary)",
+    disabled: "var(--text-disabled)"
+  },
+  glass: {
+    base: "var(--glass-base)",
+    baseHover: "var(--glass-base-hover)",
+    baseActive: "var(--glass-base-active)",
+    backdrop: "var(--glass-backdrop)"
+  },
+  rim: {
+    top: "var(--rim-light-top)",
+    bottom: "var(--rim-light-bottom)"
+  },
+  brand: {
+    pink: "var(--brand-pink)",
+    yellow: "var(--brand-yellow)",
+    pinkGlow: "var(--brand-pink-glow)"
+  },
+  status: {
+    success: "var(--status-success)",
+    warning: "var(--status-warning)",
+    error: "var(--status-error)",
+    info: "var(--status-info)"
+  },
+  button: {
+    primaryBg: "var(--btn-primary-bg)",
+    primaryBgHover: "var(--btn-primary-bg-hover)",
+    secondaryBg: "var(--btn-secondary-bg)",
+    secondaryBgHover: "var(--btn-secondary-bg-hover)"
+  }
+};
+
+// src/tokens/typography.ts
+var FONT_FAMILY = {
+  sans: "var(--font-family)",
+  mono: "var(--font-family-mono)"
+};
+var FONT_SIZE = {
+  xs: "var(--font-size-xs)",
+  sm: "var(--font-size-sm)",
+  base: "var(--font-size-base)",
+  lg: "var(--font-size-lg)",
+  xl: "var(--font-size-xl)",
+  "2xl": "var(--font-size-2xl)",
+  "3xl": "var(--font-size-3xl)"
+};
+var FONT_WEIGHT = {
+  normal: "var(--font-weight-normal)",
+  medium: "var(--font-weight-medium)",
+  semibold: "var(--font-weight-semibold)",
+  bold: "var(--font-weight-bold)"
+};
+var LINE_HEIGHT = {
+  tight: "var(--line-height-tight)",
+  normal: "var(--line-height-normal)",
+  relaxed: "var(--line-height-relaxed)"
+};
+
+// src/tokens/radius.ts
+var RADIUS = {
+  panel: "var(--radius-panel)",
+  card: "var(--radius-card)",
+  button: "var(--radius-button)",
+  badge: "var(--radius-badge)",
+  pill: "var(--radius-pill)"
+};
+
+// src/tokens/shadows.ts
+var SHADOWS = {
+  glass: {
+    outer: "var(--glass-shadow-outer)",
+    inner: "var(--glass-shadow-inner)",
+    combined: "var(--glass-shadow-combined)",
+    elevated: "var(--glass-shadow-elevated)",
+    elevatedCombined: "var(--glass-shadow-elevated-combined)"
+  },
+  interactive: {
+    rest: "var(--shadow-interactive-rest)",
+    restSubtle: "var(--shadow-interactive-rest-subtle)",
+    restLight: "var(--shadow-interactive-rest-light)",
+    hover: "var(--shadow-interactive-hover)",
+    hoverSubtle: "var(--shadow-interactive-hover-subtle)",
+    active: "var(--shadow-interactive-active)"
+  }
+};
+
+// src/tokens/z-index.ts
+var Z_INDEX = {
+  void: "var(--z-void)",
+  glassPanel: "var(--z-glass-panel)",
+  ornament: "var(--z-ornament)",
+  dropdown: "var(--z-dropdown)",
+  modalBackdrop: "var(--z-modal-backdrop)",
+  modal: "var(--z-modal)",
+  tooltip: "var(--z-tooltip)"
+};
+
+// src/tokens/breakpoints.ts
+var BREAKPOINTS = {
+  "3xs": 320,
+  "2xs": 375,
+  xs: 480,
+  sm: 640,
+  md: 768,
+  lg: 1024,
+  xl: 1280,
+  "2xl": 1536,
+  "3xl": 1920,
+  "4xl": 2560,
+  "5xl": 3840
+};
+var MEDIA_QUERIES = {
+  "3xs": `(min-width: ${BREAKPOINTS["3xs"]}px)`,
+  "2xs": `(min-width: ${BREAKPOINTS["2xs"]}px)`,
+  xs: `(min-width: ${BREAKPOINTS.xs}px)`,
+  sm: `(min-width: ${BREAKPOINTS.sm}px)`,
+  md: `(min-width: ${BREAKPOINTS.md}px)`,
+  lg: `(min-width: ${BREAKPOINTS.lg}px)`,
+  xl: `(min-width: ${BREAKPOINTS.xl}px)`,
+  "2xl": `(min-width: ${BREAKPOINTS["2xl"]}px)`,
+  "3xl": `(min-width: ${BREAKPOINTS["3xl"]}px)`,
+  "4xl": `(min-width: ${BREAKPOINTS["4xl"]}px)`,
+  "5xl": `(min-width: ${BREAKPOINTS["5xl"]}px)`
+};
+
+export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, Alert, AspectRatio, BREAKPOINTS, ButtonGroup, COLORS, Calendar, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Carousel, CarouselContent, CarouselItem, CarouselNext, CarouselPrevious, Collapsible, CollapsibleContent, CollapsibleTrigger, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, ContextMenu, ContextMenuContent, ContextMenuItem, ContextMenuLabel, ContextMenuSeparator, ContextMenuTrigger, Drawer, DrawerClose, DrawerContent, DrawerDescription, DrawerFooter, DrawerHeader, DrawerTitle, DrawerTrigger, EmptyState, FONT_FAMILY, FONT_SIZE, FONT_WEIGHT, FormControl, FormDescription, FormField, FormItem, FormLabel, FormMessage, Grid, Heading, HoverCard, HoverCardContent, HoverCardTrigger, InputOTP, InputOTPGroup, InputOTPSeparator, InputOTPSlot, LINE_HEIGHT, Label, MEDIA_QUERIES, Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, Popover, PopoverClose, PopoverContent, PopoverTrigger, Progress, Prose, RADIUS, Radio, RadioGroup, SHADOWS, ScrollArea, ScrollBar, Section, Separator, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetTitle, SheetTrigger, Skeleton, StatusBadge, Switch, Text, TextArea, ToastContext, ToastItem, ToastProvider, Toggle, VisuallyHidden, Z_INDEX, useFormField, useToast };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=chunk-MU6GW5ZV.js.map