import {
  ActionMenu,
  Button,
  Dialog,
  DropdownMenu,
  Icon,
  IconButton,
  Input,
  InputWithLabel,
  Label,
  Spinner,
  Tooltip,
  buttonTokens,
  destroyAll,
  showConfirm,
  showDialog,
  showError,
  showInfo,
  showWarning
} from "./chunk-RG2HN7M2.mjs";
import "./chunk-NIH5ZMPE.mjs";

// src/card/card.tsx
import { cva } from "class-variance-authority";
import { jsx } from "react/jsx-runtime";
var cardStyles = cva("c-card", {
  variants: {
    variant: {
      default: "",
      elevate: "c-card-elevate"
    }
  },
  defaultVariants: {
    variant: "default"
  }
});
function Card({ children, className, variant, ...delegated }) {
  return /* @__PURE__ */ jsx("section", {
    className: cardStyles({ variant, className }),
    ...delegated,
    children
  });
}

// src/card/index.ts
var cardToken = "c-card";

// src/avatar/avatar.tsx
import { forwardRef } from "react";
import { cva as cva2 } from "class-variance-authority";

// src/avatar/get-initials.ts
var getInitials = (name) => {
  const [first, second] = name.split(" ");
  const initials = `${first?.charAt(0) ?? ""}${second?.charAt(0) ?? ""}`;
  return initials.toUpperCase();
};

// src/avatar/avatar.tsx
import { jsx as jsx2 } from "react/jsx-runtime";
var avatarClassName = cva2(["c-avatar"], {
  variants: {
    size: {
      md: "c-avatar-md",
      lg: "c-avatar-lg",
      xl: "c-avatar-xl",
      "2xl": "c-avatar-2xl"
    }
  },
  defaultVariants: {
    size: "md"
  }
});
var Avatar = forwardRef(({ name, size, className, ...delegated }, ref) => {
  return /* @__PURE__ */ jsx2("div", {
    ref,
    ...delegated,
    title: name,
    className: avatarClassName({ size, className }),
    children: /* @__PURE__ */ jsx2("span", {
      className: "c-avatar-initials",
      children: getInitials(name)
    })
  });
});
Avatar.displayName = "Avatar";

// src/checkbox/checkbox.tsx
import { forwardRef as forwardRef2 } from "react";
import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
import { jsx as jsx3, jsxs } from "react/jsx-runtime";
var Checkbox = forwardRef2((props, ref) => {
  return /* @__PURE__ */ jsx3(CheckboxPrimitive.Root, {
    ...props,
    ref,
    className: "c-checkbox",
    children: /* @__PURE__ */ jsx3(CheckboxPrimitive.Indicator, {
      children: /* @__PURE__ */ jsxs("svg", {
        viewBox: "0 0 9 9",
        fill: "none",
        className: "c-checkbox__svg",
        children: [
          /* @__PURE__ */ jsx3("path", {
            className: "c-checkbox__svg-p1",
            d: "M1.12 5.51a.559.559 0 01.832-.101l2.201 1.953-.427.624a.326.326 0 01-.486.06L1.21 6.245a.559.559 0 01-.09-.734z"
          }),
          /* @__PURE__ */ jsx3("path", {
            className: "c-checkbox__svg-p2",
            d: "M7.883 1.087c.043.03.053.09.023.132L3.669 7.132l-.154-.105L7.754 1.11a.093.093 0 01.129-.023z"
          })
        ]
      })
    })
  });
});
Checkbox.displayName = "Checkbox";

// src/collapsible/collapsible.tsx
import { cx } from "class-variance-authority";
import * as CollapsiblePrimitives from "@radix-ui/react-collapsible";
import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
function Content2({ className, ...delegated }) {
  return /* @__PURE__ */ jsx4(CollapsiblePrimitives.Content, {
    ...delegated,
    className: cx("c-collapsible-content", className)
  });
}
function CollapsibleTrigger({
  children,
  arrowPosition,
  className,
  mode,
  ...delegated
}) {
  return /* @__PURE__ */ jsx4(CollapsiblePrimitives.Trigger, {
    asChild: true,
    ...delegated,
    className: cx(
      "c-collapsible-trigger",
      arrowPosition === "right" ? "arrow-right" : "",
      mode === "tree" ? "c-collapsible-tree" : "",
      className
    ),
    children: /* @__PURE__ */ jsxs2("div", {
      children: [
        arrowPosition && /* @__PURE__ */ jsx4(Icon.Caret, {
          className: "c-collapsible-arrow",
          width: 9,
          height: 9
        }),
        children
      ]
    })
  });
}
var Collapsible = {
  Root: CollapsiblePrimitives.Root,
  Trigger: CollapsibleTrigger,
  Content: Content2
};

// src/inline-radio/inline-radio.tsx
import { cx as cx2, cva as cva3 } from "class-variance-authority";
import * as RadioGroupPrimitive from "@radix-ui/react-radio-group";
import { jsx as jsx5 } from "react/jsx-runtime";
var inlineRadioGroupStyles = cva3("c-inline-radio-group", {
  variants: {
    size: {
      xs: "c-inline-radio-group-xs",
      sm: "c-inline-radio-group-sm",
      md: "c-inline-radio-group-md",
      lg: "c-inline-radio-group-lg"
    }
  },
  defaultVariants: {
    size: "sm"
  }
});
function InlineRadioGroup({ size, className, ...delegated }) {
  return /* @__PURE__ */ jsx5(RadioGroupPrimitive.Root, {
    ...delegated,
    className: inlineRadioGroupStyles({ size, className })
  });
}
function InlineRadioItem({ children, className, ...delegated }) {
  return /* @__PURE__ */ jsx5(RadioGroupPrimitive.Item, {
    ...delegated,
    className: cx2("c-inline-radio", className),
    children: /* @__PURE__ */ jsx5(RadioGroupPrimitive.Indicator, {
      forceMount: true,
      children
    })
  });
}
var InlineRadio = {
  Group: InlineRadioGroup,
  Item: InlineRadioItem
};

// src/popover/popover.tsx
import { cx as cx3 } from "class-variance-authority";
import * as PopoverPrimitive2 from "@radix-ui/react-popover";

// src/popover/popover-close.tsx
import * as PopoverPrimitive from "@radix-ui/react-popover";
import { jsx as jsx6 } from "react/jsx-runtime";
function PopoverClose(props) {
  const { asChild, children } = props;
  return /* @__PURE__ */ jsx6(PopoverPrimitive.Close, {
    asChild,
    className: "c-popover-close",
    children: children ?? /* @__PURE__ */ jsx6(Icon.Cancel, {
      width: 16,
      height: 16
    })
  });
}

// src/popover/popover.tsx
import { jsx as jsx7, jsxs as jsxs3 } from "react/jsx-runtime";
function Popover({
  children,
  closeButton,
  content,
  side,
  open,
  onOpenChange,
  className,
  container,
  hasArrow = true,
  ...delegatedContent
}) {
  return /* @__PURE__ */ jsxs3(PopoverPrimitive2.Root, {
    open,
    onOpenChange,
    children: [
      /* @__PURE__ */ jsx7(PopoverPrimitive2.Trigger, {
        asChild: true,
        children
      }),
      /* @__PURE__ */ jsx7(PopoverPrimitive2.Portal, {
        container,
        children: /* @__PURE__ */ jsxs3(PopoverPrimitive2.Content, {
          ...delegatedContent,
          side,
          className: cx3("c-popover-content", className),
          children: [
            !closeButton ? null : /* @__PURE__ */ jsx7(PopoverClose, {
              asChild: typeof closeButton !== "boolean",
              children: typeof closeButton !== "boolean" ? closeButton : null
            }),
            hasArrow && /* @__PURE__ */ jsx7(PopoverPrimitive2.Arrow, {
              className: "c-popover-arrow",
              offset: 5
            }),
            content
          ]
        })
      })
    ]
  });
}

// src/progress/progress.tsx
import { cx as cx4 } from "class-variance-authority";
import * as ProgressPrimitives from "@radix-ui/react-progress";
import { jsx as jsx8 } from "react/jsx-runtime";
function Progress({ className, value }) {
  return /* @__PURE__ */ jsx8(ProgressPrimitives.Root, {
    className: cx4(className, "c-progress-root"),
    value,
    children: /* @__PURE__ */ jsx8(ProgressPrimitives.Indicator, {
      className: "c-progress-indicator",
      style: { transform: `translateX(-${100 - (value ?? 0)}%)` }
    })
  });
}

// src/radio/radio.tsx
import * as RadioGroupPrimitive2 from "@radix-ui/react-radio-group";
import { jsx as jsx9 } from "react/jsx-runtime";
function RadioGroupItem(props) {
  return /* @__PURE__ */ jsx9(RadioGroupPrimitive2.Item, {
    ...props,
    className: "c-radio-item",
    children: /* @__PURE__ */ jsx9(RadioGroupPrimitive2.Indicator, {
      className: "c-radio-indicator"
    })
  });
}
var Radio = {
  Group: RadioGroupPrimitive2.Root,
  Item: RadioGroupItem
};

// src/select/select-item.tsx
import { forwardRef as forwardRef3 } from "react";
import { cx as cx5 } from "class-variance-authority";
import * as SelectPrimitives from "@radix-ui/react-select";
import { jsx as jsx10, jsxs as jsxs4 } from "react/jsx-runtime";
var SelectItem = forwardRef3((props, ref) => {
  const { children, className, ...delegated } = props;
  return /* @__PURE__ */ jsxs4(SelectPrimitives.Item, {
    className: cx5("c-select-item", className),
    ref,
    ...delegated,
    children: [
      /* @__PURE__ */ jsx10(SelectPrimitives.ItemText, {
        children
      }),
      /* @__PURE__ */ jsx10(SelectPrimitives.ItemIndicator, {})
    ]
  });
});
SelectItem.displayName = "SelectItem";

// src/select/select-root.tsx
import { forwardRef as forwardRef4 } from "react";
import { cva as cva4 } from "class-variance-authority";
import * as SelectPrimitives2 from "@radix-ui/react-select";
import { jsx as jsx11, jsxs as jsxs5 } from "react/jsx-runtime";
var selectTriggerStyles = cva4("c-select-trigger", {
  variants: {
    size: {
      xs: "c-select-trigger-xs",
      sm: "c-select-trigger-sm",
      md: "c-select-trigger-md",
      lg: "c-select-trigger-lg"
    }
  },
  defaultVariants: {
    size: "sm"
  }
});
var SelectContainer = forwardRef4(
  ({ children, id, placeholder, disabled, size, triggerClassName, ...delegated }, ref) => {
    return /* @__PURE__ */ jsxs5(SelectPrimitives2.Root, {
      ...delegated,
      children: [
        /* @__PURE__ */ jsxs5(SelectPrimitives2.Trigger, {
          ref,
          className: selectTriggerStyles({ size, className: triggerClassName }),
          disabled,
          id,
          children: [
            /* @__PURE__ */ jsx11(SelectPrimitives2.Value, {
              placeholder: /* @__PURE__ */ jsx11("span", {
                className: "c-select-value",
                children: placeholder ?? "Select..."
              })
            }),
            /* @__PURE__ */ jsx11(Icon.Arrow, {})
          ]
        }),
        /* @__PURE__ */ jsx11(SelectPrimitives2.Portal, {
          children: /* @__PURE__ */ jsxs5(SelectPrimitives2.Content, {
            className: "c-select-content",
            children: [
              /* @__PURE__ */ jsx11(SelectPrimitives2.ScrollUpButton, {}),
              /* @__PURE__ */ jsx11(SelectPrimitives2.Viewport, {
                className: "c-select-viewport",
                children
              }),
              /* @__PURE__ */ jsx11(SelectPrimitives2.ScrollDownButton, {})
            ]
          })
        })
      ]
    });
  }
);
SelectContainer.displayName = "Select";

// src/select/select.ts
var Select = {
  Container: SelectContainer,
  Item: SelectItem
};

// src/slider/slider.tsx
import { forwardRef as forwardRef5 } from "react";
import { cx as cx6 } from "class-variance-authority";
import * as SliderPrimitive from "@radix-ui/react-slider";
import { jsx as jsx12, jsxs as jsxs6 } from "react/jsx-runtime";
var Slider = forwardRef5(({ className, transparentRange, ...delegated }, ref) => {
  return /* @__PURE__ */ jsxs6(SliderPrimitive.Root, {
    className: cx6("c-slider-root", className),
    ref,
    ...delegated,
    children: [
      /* @__PURE__ */ jsx12(SliderPrimitive.Track, {
        className: "c-slider-track",
        children: /* @__PURE__ */ jsx12(SliderPrimitive.Range, {
          className: `c-slider-range ${transparentRange ? "c-slider-range-transparent" : ""}`
        })
      }),
      /* @__PURE__ */ jsx12(SliderPrimitive.Thumb, {
        className: "c-slider-thumb"
      })
    ]
  });
});

// src/stack-icon/stack-icon.tsx
import { jsx as jsx13, jsxs as jsxs7 } from "react/jsx-runtime";
function StackIcon({ type, children, size = 18 }) {
  return /* @__PURE__ */ jsxs7("span", {
    className: "c-stack-icon",
    children: [
      type === "create" && /* @__PURE__ */ jsx13("span", {
        style: { width: size, height: size },
        className: "c-stack-icon__icon",
        children: /* @__PURE__ */ jsx13(Icon.Add, {
          width: size - 4,
          height: size - 4
        })
      }),
      children
    ]
  });
}

// src/tag/tag.tsx
import { cva as cva5, cx as cx7 } from "class-variance-authority";
import { jsx as jsx14, jsxs as jsxs8 } from "react/jsx-runtime";
var tagStyles = cva5("c-tag", {
  variants: {
    variant: {
      default: "c-tag-default",
      elevate: "c-tag-elevate"
    },
    size: {
      xxs: "c-tag-xxs",
      xs: "c-tag-xs",
      sm: "c-tag-sm",
      md: "c-tag-md",
      lg: "c-tag-lg"
    }
  },
  defaultVariants: {
    variant: "default",
    size: "xs"
  }
});
function Tag({
  children,
  className,
  variant,
  size,
  prepend,
  onRemove,
  showRemoveOnHover,
  ...delegated
}) {
  return /* @__PURE__ */ jsxs8("div", {
    className: tagStyles({ className, variant, size }),
    ...delegated,
    children: [
      !prepend ? null : /* @__PURE__ */ jsx14("span", {
        className: "c-tag__prepend",
        children: prepend
      }),
      children,
      onRemove && /* @__PURE__ */ jsxs8("button", {
        type: "button",
        className: cx7("c-tag__remove-button", showRemoveOnHover ? "c-tag__remove-button--hover" : ""),
        onClick: (e) => {
          e.stopPropagation();
          onRemove();
        },
        children: [
          /* @__PURE__ */ jsx14(Icon.Cancel, {
            width: 12,
            height: 12
          }),
          /* @__PURE__ */ jsx14("span", {
            className: "c-tag__remove-button-text",
            children: "Remove"
          })
        ]
      })
    ]
  });
}

// src/rich-text-editor/index.tsx
import { lazy, Suspense } from "react";
import { jsx as jsx15 } from "react/jsx-runtime";
var LazyRichTextEditor = lazy(() => import("./rich-text-editor-6HVOAV6B.mjs"));
var RichTextEditor = (props) => {
  return /* @__PURE__ */ jsx15(Suspense, {
    fallback: null,
    children: /* @__PURE__ */ jsx15(LazyRichTextEditor, {
      ...props
    })
  });
};

// src/toast/index.ts
import { Toaster } from "sonner";

// src/toast/toast.tsx
import { cva as cva6, cx as cx8 } from "class-variance-authority";
import { toast as sonnerToast } from "sonner";
import { jsx as jsx16, jsxs as jsxs9 } from "react/jsx-runtime";
var toastStyles = cva6("c-toast", {
  variants: {
    type: {
      info: "c-toast-info",
      error: "c-toast-error",
      success: "c-toast-success",
      warning: "c-toast-warning"
    }
  },
  defaultVariants: {
    type: "success"
  }
});
var iconMap = {
  info: Icon.Info,
  error: Icon.Error,
  success: Icon.CheckWithCircle,
  warning: Icon.Warning
};
var toast = ({ title, message, id, type = "success", timeout = 6e3 }) => {
  const ToastIcon = iconMap[type];
  const withMessage = !!message;
  const toastId = id ?? Date.now().toString();
  sonnerToast.custom(
    (id2) => /* @__PURE__ */ jsxs9("div", {
      "data-testid": `toast-${type}`,
      className: cx8(toastStyles({ type }), withMessage ? "c-toast-with-message" : "c-toast-title-only"),
      children: [
        /* @__PURE__ */ jsx16("div", {
          children: /* @__PURE__ */ jsx16(ToastIcon, {
            width: 26,
            height: 26
          })
        }),
        /* @__PURE__ */ jsxs9("div", {
          children: [
            /* @__PURE__ */ jsx16("div", {
              className: "c-toast-title",
              children: title
            }),
            !!message && /* @__PURE__ */ jsx16("div", {
              className: "c-toast-message",
              children: message
            })
          ]
        }),
        /* @__PURE__ */ jsx16("div", {
          className: "c-toast-close",
          "data-testid": "toast-close",
          children: /* @__PURE__ */ jsx16(IconButton, {
            onClick: () => sonnerToast.dismiss(id2),
            size: "xs",
            children: /* @__PURE__ */ jsx16(Icon.Cancel, {
              width: 12,
              height: 12
            })
          })
        })
      ]
    }),
    {
      id: toastId,
      duration: timeout,
      style: { width: "100%" }
    }
  );
  return toastId;
};
toast.dismiss = sonnerToast.dismiss;

// src/switch/switch.tsx
import { cva as cva7, cx as cx9 } from "class-variance-authority";
import * as RadixSwitch from "@radix-ui/react-switch";
import { jsx as jsx17 } from "react/jsx-runtime";
var switchStyles = cva7(["c-switch-root"], {
  variants: {
    size: {
      xs: "c-switch-root-xs",
      sm: "c-switch-root-sm"
    }
  },
  defaultVariants: {
    size: "sm"
  }
});
function Switch({ size, checked, ...props }) {
  return /* @__PURE__ */ jsx17(RadixSwitch.Root, {
    ...props,
    checked: checked === null ? false : checked,
    className: switchStyles({ size }),
    children: /* @__PURE__ */ jsx17(RadixSwitch.Thumb, {
      className: cx9("c-switch-thumb", checked === null ? "middle-position" : "")
    })
  });
}

// src/color-picker/color-picker.tsx
import { useState, useMemo } from "react";

// src/colors/colors.json
var colors_default = {
  cyan: {
    "50": "#eefdfc",
    "100": "#bff6f8",
    "200": "#acf1f5",
    "300": "#73e5ed",
    "400": "#33d0dd",
    "500": "#17b3c3",
    "600": "#1690a4",
    "700": "#197385",
    "800": "#1d5e6d",
    "900": "#1c4e5d"
  },
  pink: {
    "50": "#fef1f9",
    "100": "#fee5f4",
    "200": "#ffccec",
    "300": "#ffa1db",
    "400": "#ff66c0",
    "500": "#fb39a4",
    "600": "#eb1782",
    "700": "#cd0966",
    "800": "#a90b54",
    "900": "#8d0e49"
  },
  gray: {
    "50": "#f5f5f6",
    "100": "#e4e5e9",
    "200": "#cccfd5",
    "300": "#a9aeb7",
    "400": "#7e8592",
    "500": "#626778",
    "600": "#545866",
    "700": "#4c4f5a",
    "800": "#40424a",
    "900": "#393a40"
  },
  purple: {
    "50": "#f7f6f9",
    "100": "#eeecf2",
    "200": "#d8d5e2",
    "300": "#b6b0c9",
    "400": "#8e85ab",
    "500": "#706691",
    "600": "#5b5178",
    "700": "#4b4262",
    "800": "#403953",
    "900": "#393347"
  },
  green: {
    "50": "#f3f8f8",
    "100": "#dfebee",
    "200": "#c3dade",
    "300": "#9abfc6",
    "400": "#699ca7",
    "500": "#528693",
    "600": "#436a77",
    "700": "#3b5863",
    "800": "#374b53",
    "900": "#314148"
  },
  orange: {
    "50": "#fff9eb",
    "100": "#ffedc6",
    "200": "#ffde99",
    "300": "#ffbf4a",
    "400": "#ffa520",
    "500": "#f98107",
    "600": "#dd5c02",
    "700": "#b73d06",
    "800": "#942e0c",
    "900": "#7a270d"
  },
  "s-red": {
    "50": "#fef2f2",
    "100": "#ffe1e1",
    "200": "#ffc8c8",
    "300": "#ffadad",
    "400": "#fd6c6c",
    "500": "#f53e3e",
    "600": "#e22020",
    "700": "#be1717",
    "800": "#9d1717",
    "900": "#821a1a"
  },
  "s-orange": {
    "50": "#fff7ed",
    "100": "#ffedd5",
    "200": "#ffd6a5",
    "300": "#ffbb72",
    "400": "#fd943a",
    "500": "#fc7513",
    "600": "#ed5909",
    "700": "#c4420a",
    "800": "#9c3410",
    "900": "#7d2d11"
  },
  "s-yellow": {
    "50": "#fefee8",
    "100": "#fdffb6",
    "200": "#fffe88",
    "300": "#fff744",
    "400": "#fee911",
    "500": "#eecf04",
    "600": "#cda201",
    "700": "#a47404",
    "800": "#875b0c",
    "900": "#734a10"
  },
  "s-green": {
    "50": "#f2ffee",
    "100": "#deffd8",
    "200": "#caffbf",
    "300": "#8dfd78",
    "400": "#53f236",
    "500": "#2cdb0c",
    "600": "#1eb603",
    "700": "#1b8e07",
    "800": "#1a700b",
    "900": "#165b0c"
  },
  "s-blue": {
    "50": "#eff5ff",
    "100": "#dae7ff",
    "200": "#bed5ff",
    "300": "#a0c4ff",
    "400": "#5d96fd",
    "500": "#376ffa",
    "600": "#214fef",
    "700": "#193adc",
    "800": "#1b31b2",
    "900": "#1c2f8c"
  },
  "s-purple": {
    "50": "#f4f3ff",
    "100": "#ebe8ff",
    "200": "#d9d5ff",
    "300": "#bdb2ff",
    "400": "#9d88fd",
    "500": "#7e58fa",
    "600": "#6f35f2",
    "700": "#6023de",
    "800": "#501dba",
    "900": "#431a98"
  },
  "s-pink": {
    "50": "#fff4ff",
    "100": "#ffe7ff",
    "200": "#ffc6ff",
    "300": "#fea9fa",
    "400": "#fc76f4",
    "500": "#f342e7",
    "600": "#d722c8",
    "700": "#b219a1",
    "800": "#921684",
    "900": "#771869"
  }
};

// src/color-picker/color-picker.tsx
import { jsx as jsx18, jsxs as jsxs10 } from "react/jsx-runtime";
var SHADES = ["200", "300", "400", "500", "600", "700", "800"];
var ORDERED_COLOR_NAMES = [
  "s-green",
  "s-red",
  "orange",
  "s-yellow",
  "purple",
  "gray",
  "green",
  "s-pink",
  "pink",
  "cyan",
  "s-purple",
  "s-blue"
];
function ColorPicker({ value, setValue, children, isOpen, setIsOpen }) {
  const [hoveredColor, setHoveredColor] = useState(null);
  const colorLookupMap = useMemo(() => {
    const map = /* @__PURE__ */ new Map();
    ORDERED_COLOR_NAMES.forEach((colorName) => {
      SHADES.forEach((shade) => {
        const color = colors_default[colorName];
        map.set(color[shade], `${colorName} ${shade}`);
      });
    });
    return map;
  }, []);
  const getColorNameAndHue = (colorValue) => {
    return colorLookupMap.get(colorValue) || "Color Name and Hue not found";
  };
  const displayedColorInfo = hoveredColor || value ? getColorNameAndHue(hoveredColor ?? value) : "Select a color";
  const handleColorSelect = (colorValue) => {
    setValue(colorValue);
    setIsOpen(false);
  };
  const handleMouseEnter = (colorValue) => setHoveredColor(colorValue);
  const handleMouseLeave = () => setHoveredColor(null);
  return /* @__PURE__ */ jsx18(Popover, {
    open: isOpen,
    side: "bottom",
    hasArrow: true,
    onOpenChange: setIsOpen,
    content: /* @__PURE__ */ jsxs10(Card, {
      variant: "elevate",
      className: " border border-solid border-border p-5",
      children: [
        /* @__PURE__ */ jsxs10("div", {
          className: "mb-3",
          children: [
            /* @__PURE__ */ jsx18("span", {
              className: "text-sm font-bold capitalize",
              children: displayedColorInfo
            }),
            /* @__PURE__ */ jsx18("span", {
              className: "ml-4 text-sm italic text-gray-500-400",
              children: hoveredColor ?? value
            })
          ]
        }),
        /* @__PURE__ */ jsx18("div", {
          className: "grid grid-cols-12",
          children: ORDERED_COLOR_NAMES.map((colorName) => /* @__PURE__ */ jsx18("div", {
            children: SHADES.map((shade) => {
              const colorValue = colors_default[colorName][shade];
              return /* @__PURE__ */ jsx18("div", {
                className: "cursor-pointer rounded p-0.5",
                onClick: () => handleColorSelect(colorValue),
                onMouseEnter: () => handleMouseEnter(colorValue),
                onMouseLeave: handleMouseLeave,
                children: /* @__PURE__ */ jsx18("div", {
                  className: "h-5 w-5",
                  style: { backgroundColor: colorValue }
                })
              }, colorValue);
            })
          }, colorName))
        })
      ]
    }),
    children
  });
}

// src/index.ts
var tokens = {
  button: buttonTokens,
  card: cardToken
};
export {
  ActionMenu,
  Avatar,
  Button,
  Card,
  Checkbox,
  Collapsible,
  CollapsibleTrigger,
  ColorPicker,
  Dialog,
  DropdownMenu,
  Icon,
  IconButton,
  InlineRadio,
  Input,
  InputWithLabel,
  Label,
  Popover,
  Progress,
  Radio,
  RichTextEditor,
  Select,
  Slider,
  Spinner,
  StackIcon,
  Switch,
  Tag,
  Toaster,
  Tooltip,
  buttonTokens,
  cardToken,
  destroyAll,
  showConfirm,
  showDialog,
  showError,
  showInfo,
  showWarning,
  toast,
  tokens
};
