shadcn-glass-ui 2.1.2 → 2.1.5

package/dist/index.cjs

@@ -1,15 +1,17 @@
-const require_trust_score_card_glass = require("./trust-score-card-glass-CGXmOIfq.cjs");
-const require_utils = require("./utils-LYxxWvUn.cjs");
-const require_use_focus = require("./use-focus-CeNHOiBa.cjs");
-const require_theme_context = require("./theme-context-BHXYJ4RE.cjs");
-const require_use_wallpaper_tint = require("./use-wallpaper-tint-Bt2G3g1v.cjs");
+const require_trust_score_card_glass = require("./trust-score-card-glass-2rjz00d_.cjs");
+const require_utils = require("./utils-XlyXIhuP.cjs");
+const require_use_focus = require("./use-focus-DbpBEuee.cjs");
+const require_theme_context = require("./theme-context-Y98bGvcm.cjs");
+const require_use_wallpaper_tint = require("./use-wallpaper-tint-DbawS9zh.cjs");
 let react = require("react");
 react = require_trust_score_card_glass.__toESM(react);
 let lucide_react = require("lucide-react");
 let clsx = require("clsx");
 let class_variance_authority = require("class-variance-authority");
 let react_jsx_runtime = require("react/jsx-runtime");
+let __radix_ui_react_slot = require("@radix-ui/react-slot");
 let react_dom = require("react-dom");
+react_dom = require_trust_score_card_glass.__toESM(react_dom);
 const stepperRootVariants = (0, class_variance_authority.cva)("flex w-full", {
 	variants: { orientation: {
 		horizontal: "flex-col",
@@ -370,6 +372,413 @@ const StepperGlass = {
 	Step: StepperStep,
 	Content: StepperContent
 };
+var MOBILE_BREAKPOINT = 768;
+var SIDEBAR_COOKIE_NAME = "sidebar:state";
+var SIDEBAR_COOKIE_MAX_AGE = 3600 * 24 * 7;
+var SidebarContext = (0, react.createContext)(null);
+function useSidebar() {
+	const context = (0, react.useContext)(SidebarContext);
+	if (!context) throw new Error("useSidebar must be used within SidebarGlass.Provider. Wrap your component tree with <SidebarGlass.Provider>.");
+	return context;
+}
+const SidebarProvider = ({ children, open: controlledOpen, onOpenChange, defaultOpen = true, side = "left", variant = "sidebar", collapsible = "offcanvas", cookieName = SIDEBAR_COOKIE_NAME, keyboardShortcut = "b" }) => {
+	const [internalOpen, setInternalOpen] = (0, react.useState)(() => {
+		if (typeof document !== "undefined") {
+			const sidebarCookie = document.cookie.split(";").find((c) => c.trim().startsWith(`${cookieName}=`));
+			if (sidebarCookie) return sidebarCookie.split("=")[1] === "true";
+		}
+		return defaultOpen;
+	});
+	const isControlled = controlledOpen !== void 0;
+	const open = isControlled ? controlledOpen : internalOpen;
+	const setOpen = (0, react.useCallback)((value$1) => {
+		if (!isControlled) setInternalOpen(value$1);
+		onOpenChange?.(value$1);
+		if (typeof document !== "undefined") document.cookie = `${cookieName}=${value$1}; path=/; max-age=${SIDEBAR_COOKIE_MAX_AGE}`;
+	}, [
+		isControlled,
+		onOpenChange,
+		cookieName
+	]);
+	const [openMobile, setOpenMobile] = (0, react.useState)(false);
+	const [isMobile, setIsMobile] = (0, react.useState)(() => {
+		if (typeof window === "undefined") return false;
+		return window.innerWidth < MOBILE_BREAKPOINT;
+	});
+	(0, react.useEffect)(() => {
+		if (typeof window === "undefined") return;
+		const checkMobile = () => {
+			const mobile = window.innerWidth < MOBILE_BREAKPOINT;
+			setIsMobile(mobile);
+			if (!mobile) setOpenMobile(false);
+		};
+		checkMobile();
+		window.addEventListener("resize", checkMobile);
+		return () => window.removeEventListener("resize", checkMobile);
+	}, []);
+	const toggleSidebar = (0, react.useCallback)(() => {
+		if (isMobile) setOpenMobile((prev) => !prev);
+		else setOpen(!open);
+	}, [
+		isMobile,
+		open,
+		setOpen
+	]);
+	(0, react.useEffect)(() => {
+		if (!keyboardShortcut) return;
+		const handleKeyDown = (e) => {
+			if (e.key === keyboardShortcut && (e.metaKey || e.ctrlKey)) {
+				e.preventDefault();
+				toggleSidebar();
+			}
+		};
+		document.addEventListener("keydown", handleKeyDown);
+		return () => document.removeEventListener("keydown", handleKeyDown);
+	}, [keyboardShortcut, toggleSidebar]);
+	const value = (0, react.useMemo)(() => ({
+		state: open ? "expanded" : "collapsed",
+		open,
+		setOpen,
+		openMobile,
+		setOpenMobile,
+		isMobile,
+		toggleSidebar,
+		side,
+		variant,
+		collapsible
+	}), [
+		open,
+		setOpen,
+		openMobile,
+		isMobile,
+		toggleSidebar,
+		side,
+		variant,
+		collapsible
+	]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SidebarContext.Provider, {
+		value,
+		children
+	});
+};
+SidebarProvider.displayName = "SidebarGlass.Provider";
+const SidebarRoot = (0, react.forwardRef)(({ children, side: sideProp, variant: variantProp, collapsible: collapsibleProp, className, ...props }, ref) => {
+	const context = useSidebar();
+	const side = sideProp ?? context.side;
+	const variant = variantProp ?? context.variant;
+	const collapsible = collapsibleProp ?? context.collapsible;
+	const { state, open, openMobile, isMobile, setOpenMobile } = context;
+	if (isMobile) return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(require_trust_score_card_glass.ModalGlass.Root, {
+		open: openMobile,
+		onOpenChange: setOpenMobile,
+		children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_trust_score_card_glass.ModalGlass.Overlay, {}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("aside", {
+			ref,
+			"data-sidebar": "sidebar",
+			"data-side": side,
+			"data-variant": variant,
+			"data-collapsible": collapsible,
+			"data-state": "expanded",
+			"data-mobile": "true",
+			className: require_utils.cn("fixed inset-y-0 z-50 flex flex-col", "w-[var(--sidebar-width-mobile)]", side === "left" ? "left-0" : "right-0", className),
+			style: {
+				background: "var(--sidebar-bg)",
+				color: "var(--sidebar-foreground)",
+				borderRight: side === "left" ? "1px solid var(--sidebar-border)" : void 0,
+				borderLeft: side === "right" ? "1px solid var(--sidebar-border)" : void 0,
+				backdropFilter: "blur(var(--sidebar-backdrop-blur))",
+				WebkitBackdropFilter: "blur(var(--sidebar-backdrop-blur))",
+				boxShadow: "var(--sidebar-glow)"
+			},
+			...props,
+			children
+		})]
+	});
+	const width = !open && collapsible !== "none" && collapsible === "icon" ? "var(--sidebar-width-icon)" : "var(--sidebar-width)";
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("aside", {
+		ref,
+		"data-sidebar": "sidebar",
+		"data-side": side,
+		"data-variant": variant,
+		"data-collapsible": collapsible,
+		"data-state": state,
+		className: require_utils.cn("group/sidebar relative flex flex-col", "transition-[width] duration-300 ease-in-out", collapsible === "offcanvas" && !open && "w-0 overflow-hidden", variant === "floating" && "rounded-xl m-2", variant === "inset" && "rounded-xl", className),
+		style: {
+			width: collapsible === "offcanvas" && !open ? 0 : width,
+			background: "var(--sidebar-bg)",
+			color: "var(--sidebar-foreground)",
+			borderRight: side === "left" && variant !== "floating" ? "1px solid var(--sidebar-border)" : void 0,
+			borderLeft: side === "right" && variant !== "floating" ? "1px solid var(--sidebar-border)" : void 0,
+			border: variant === "floating" ? "1px solid var(--sidebar-border)" : void 0,
+			backdropFilter: "blur(var(--sidebar-backdrop-blur))",
+			WebkitBackdropFilter: "blur(var(--sidebar-backdrop-blur))",
+			boxShadow: variant === "floating" ? "var(--sidebar-glow)" : void 0
+		},
+		...props,
+		children
+	});
+});
+SidebarRoot.displayName = "SidebarGlass.Root";
+const SidebarHeader = (0, react.forwardRef)(({ children, className, ...props }, ref) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		ref,
+		"data-sidebar": "header",
+		className: require_utils.cn("flex shrink-0 flex-col gap-2 p-4", "border-b", className),
+		style: { borderColor: "var(--sidebar-border)" },
+		...props,
+		children
+	});
+});
+SidebarHeader.displayName = "SidebarGlass.Header";
+const SidebarContent = (0, react.forwardRef)(({ children, className, ...props }, ref) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		ref,
+		"data-sidebar": "content",
+		className: require_utils.cn("flex flex-1 flex-col gap-4 overflow-auto p-4", "[&::-webkit-scrollbar]:w-1.5", "[&::-webkit-scrollbar-track]:bg-transparent", "[&::-webkit-scrollbar-thumb]:rounded-full", "[&::-webkit-scrollbar-thumb]:bg-white/10", className),
+		...props,
+		children
+	});
+});
+SidebarContent.displayName = "SidebarGlass.Content";
+const SidebarFooter = (0, react.forwardRef)(({ children, className, ...props }, ref) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		ref,
+		"data-sidebar": "footer",
+		className: require_utils.cn("flex shrink-0 flex-col gap-2 p-4", "border-t", className),
+		style: { borderColor: "var(--sidebar-border)" },
+		...props,
+		children
+	});
+});
+SidebarFooter.displayName = "SidebarGlass.Footer";
+const SidebarRail = (0, react.forwardRef)(({ className, ...props }, ref) => {
+	const { toggleSidebar, side } = useSidebar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+		ref,
+		"data-sidebar": "rail",
+		"aria-label": "Toggle Sidebar",
+		tabIndex: -1,
+		onClick: toggleSidebar,
+		className: require_utils.cn("absolute inset-y-0 z-20 w-4", "hidden group-hover/sidebar:block", "-translate-x-1/2 transition-all ease-linear", "after:absolute after:inset-y-0 after:left-1/2 after:w-[2px]", "hover:after:bg-[var(--sidebar-border)]", "cursor-col-resize", side === "left" ? "-right-2" : "-left-2", className),
+		...props
+	});
+});
+SidebarRail.displayName = "SidebarGlass.Rail";
+const SidebarInset = (0, react.forwardRef)(({ children, className, ...props }, ref) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("main", {
+		ref,
+		"data-sidebar": "inset",
+		className: require_utils.cn("flex flex-1 flex-col", "min-h-screen", className),
+		...props,
+		children
+	});
+});
+SidebarInset.displayName = "SidebarGlass.Inset";
+const SidebarTrigger = (0, react.forwardRef)(({ asChild = false, className, children, ...props }, ref) => {
+	const { toggleSidebar } = useSidebar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(asChild ? __radix_ui_react_slot.Slot : "button", {
+		ref,
+		"data-sidebar": "trigger",
+		onClick: toggleSidebar,
+		className: require_utils.cn("inline-flex items-center justify-center", "h-9 w-9 rounded-lg", "text-sm font-medium", "transition-colors", "text-[var(--sidebar-foreground)]/60", "hover:bg-[var(--sidebar-accent)]", "hover:text-[var(--sidebar-accent-foreground)]", "focus-visible:outline-none focus-visible:ring-2", "focus-visible:ring-[var(--sidebar-ring)]", "disabled:pointer-events-none disabled:opacity-50", className),
+		...props,
+		children: [children ?? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(lucide_react.PanelLeft, { className: "h-6 w-6" }), !children && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+			className: "sr-only",
+			children: "Toggle Sidebar"
+		})]
+	});
+});
+SidebarTrigger.displayName = "SidebarGlass.Trigger";
+const SidebarSeparator = (0, react.forwardRef)(({ className, ...props }, ref) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("hr", {
+		ref,
+		"data-sidebar": "separator",
+		className: require_utils.cn("mx-4 my-2 h-px border-0", className),
+		style: { background: "var(--sidebar-border)" },
+		...props
+	});
+});
+SidebarSeparator.displayName = "SidebarGlass.Separator";
+const SidebarGroup = (0, react.forwardRef)(({ children, className, ...props }, ref) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		ref,
+		"data-sidebar": "group",
+		className: require_utils.cn("flex flex-col gap-2 p-2", className),
+		...props,
+		children
+	});
+});
+SidebarGroup.displayName = "SidebarGlass.Group";
+const SidebarGroupLabel = (0, react.forwardRef)(({ children, asChild = false, className, ...props }, ref) => {
+	const { state } = useSidebar();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(asChild ? __radix_ui_react_slot.Slot : "div", {
+		ref,
+		"data-sidebar": "group-label",
+		"data-state": state,
+		className: require_utils.cn("flex h-8 shrink-0 items-center px-2", "text-xs font-medium text-[var(--sidebar-foreground)]/60", "transition-[margin,opacity] duration-200 ease-linear", "group-data-[state=collapsed]/sidebar:h-0 group-data-[state=collapsed]/sidebar:overflow-hidden", "group-data-[state=collapsed]/sidebar:opacity-0", className),
+		...props,
+		children
+	});
+});
+SidebarGroupLabel.displayName = "SidebarGlass.GroupLabel";
+const SidebarGroupAction = (0, react.forwardRef)(({ asChild = false, className, ...props }, ref) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(asChild ? __radix_ui_react_slot.Slot : "button", {
+		ref,
+		"data-sidebar": "group-action",
+		className: require_utils.cn("absolute right-2 top-2.5", "flex aspect-square w-5 items-center justify-center", "rounded-md p-0 text-[var(--sidebar-foreground)]/60", "ring-[var(--sidebar-ring)]", "transition-transform hover:bg-[var(--sidebar-accent)]", "hover:text-[var(--sidebar-foreground)]", "focus-visible:outline-none focus-visible:ring-2", "[&>svg]:size-4 [&>svg]:shrink-0", "group-data-[state=collapsed]/sidebar:hidden", "after:absolute after:-inset-2 after:md:hidden", className),
+		...props
+	});
+});
+SidebarGroupAction.displayName = "SidebarGlass.GroupAction";
+const SidebarGroupContent = (0, react.forwardRef)(({ children, className, ...props }, ref) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		ref,
+		"data-sidebar": "group-content",
+		className: require_utils.cn("flex flex-col gap-1", className),
+		...props,
+		children
+	});
+});
+SidebarGroupContent.displayName = "SidebarGlass.GroupContent";
+const SidebarMenu = (0, react.forwardRef)(({ children, className, ...props }, ref) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("ul", {
+		ref,
+		"data-sidebar": "menu",
+		className: require_utils.cn("flex w-full flex-col gap-1", className),
+		...props,
+		children
+	});
+});
+SidebarMenu.displayName = "SidebarGlass.Menu";
+const SidebarMenuItem = (0, react.forwardRef)(({ children, className, ...props }, ref) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
+		ref,
+		"data-sidebar": "menu-item",
+		className: require_utils.cn("group/menu-item relative text-[var(--sidebar-foreground)]/60", className),
+		...props,
+		children
+	});
+});
+SidebarMenuItem.displayName = "SidebarGlass.MenuItem";
+var menuButtonSizeClasses = {
+	default: "h-8 text-sm",
+	sm: "h-7 text-xs",
+	lg: "h-10 text-sm group-data-[state=collapsed]/sidebar:!p-0"
+};
+const SidebarMenuButton = (0, react.forwardRef)(({ asChild = false, isActive = false, tooltip, size = "default", variant = "default", className, children, ...props }, ref) => {
+	const { state, isMobile } = useSidebar();
+	const button = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(asChild ? __radix_ui_react_slot.Slot : "button", {
+		ref,
+		"data-sidebar": "menu-button",
+		"data-active": isActive,
+		"data-size": size,
+		className: require_utils.cn("peer/menu-button flex w-full items-center gap-2", "overflow-hidden rounded-md px-2", "ring-[var(--sidebar-ring)]", "transition-[width,height,padding] duration-200 ease-linear", "focus-visible:outline-none focus-visible:ring-2", "active:bg-[var(--sidebar-accent)] active:text-[var(--sidebar-accent-foreground)]", "disabled:pointer-events-none disabled:opacity-50", "aria-disabled:pointer-events-none aria-disabled:opacity-50", "[&>span:last-child]:truncate", "[&>svg]:size-4 [&>svg]:shrink-0", menuButtonSizeClasses[size], variant === "default" && ["hover:bg-[var(--sidebar-accent)] hover:text-[var(--sidebar-accent-foreground)]"], variant === "outline" && [
+			"bg-transparent shadow-none",
+			"hover:bg-[var(--sidebar-accent)] hover:text-[var(--sidebar-accent-foreground)]",
+			"hover:shadow-[0_0_0_1px_var(--sidebar-border)]"
+		], isActive && ["bg-[var(--sidebar-primary)] text-[var(--sidebar-primary-foreground)]", "hover:bg-[var(--sidebar-primary)] hover:text-[var(--sidebar-primary-foreground)]"], "group-data-[state=collapsed]/sidebar:w-8 group-data-[state=collapsed]/sidebar:!px-0", "group-data-[state=collapsed]/sidebar:justify-center", className),
+		...props,
+		children
+	});
+	if (!tooltip || isMobile || state === "expanded") return button;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_trust_score_card_glass.TooltipGlassSimple, {
+		content: typeof tooltip === "string" ? tooltip : String(tooltip),
+		side: "right",
+		children: button
+	});
+});
+SidebarMenuButton.displayName = "SidebarGlass.MenuButton";
+const SidebarMenuAction = (0, react.forwardRef)(({ asChild = false, showOnHover = false, className, ...props }, ref) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(asChild ? __radix_ui_react_slot.Slot : "button", {
+		ref,
+		"data-sidebar": "menu-action",
+		className: require_utils.cn("absolute right-1 top-1.5", "flex aspect-square w-5 items-center justify-center", "rounded-md p-0 text-[var(--sidebar-foreground)]/60", "ring-[var(--sidebar-ring)]", "transition-transform hover:bg-[var(--sidebar-accent)]", "hover:text-[var(--sidebar-foreground)]", "focus-visible:outline-none focus-visible:ring-2", "[&>svg]:size-4 [&>svg]:shrink-0", "group-data-[state=collapsed]/sidebar:hidden", showOnHover && "peer-hover/menu-button:opacity-100 group-focus-within/menu-item:opacity-100", showOnHover && "data-[state=open]:opacity-100 md:opacity-0", "after:absolute after:-inset-2 after:md:hidden", className),
+		...props
+	});
+});
+SidebarMenuAction.displayName = "SidebarGlass.MenuAction";
+const SidebarMenuBadge = (0, react.forwardRef)(({ children, className, ...props }, ref) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		ref,
+		"data-sidebar": "menu-badge",
+		className: require_utils.cn("pointer-events-none absolute right-1 flex h-5 min-w-5", "select-none items-center justify-center", "rounded-md px-1 text-xs font-medium tabular-nums", "text-[var(--sidebar-foreground)]/60", "group-data-[state=collapsed]/sidebar:hidden", className),
+		...props,
+		children
+	});
+});
+SidebarMenuBadge.displayName = "SidebarGlass.MenuBadge";
+const SidebarMenuSkeleton = (0, react.forwardRef)(({ showIcon = false, className, ...props }, ref) => {
+	const width = "70%";
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+		ref,
+		"data-sidebar": "menu-skeleton",
+		className: require_utils.cn("flex h-8 items-center gap-2 rounded-md px-2", className),
+		...props,
+		children: [showIcon && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_trust_score_card_glass.SkeletonGlass, { className: "size-4 rounded-md" }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_trust_score_card_glass.SkeletonGlass, {
+			className: "h-4 max-w-[var(--skeleton-width)] flex-1",
+			style: { "--skeleton-width": width }
+		})]
+	});
+});
+SidebarMenuSkeleton.displayName = "SidebarGlass.MenuSkeleton";
+var SidebarMenuSubContext = (0, react.createContext)(null);
+const SidebarMenuSub = (0, react.forwardRef)(({ children, className, ...props }, ref) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SidebarMenuSubContext.Provider, {
+		value: { open: true },
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("ul", {
+			ref,
+			"data-sidebar": "menu-sub",
+			className: require_utils.cn("flex min-w-0 flex-col gap-1", "mx-3.5 border-l border-[var(--sidebar-border)] px-2.5 py-0.5", "group-data-[state=collapsed]/sidebar:hidden", className),
+			...props,
+			children
+		})
+	});
+});
+SidebarMenuSub.displayName = "SidebarGlass.MenuSub";
+const SidebarMenuSubItem = (0, react.forwardRef)(({ children, className, ...props }, ref) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
+		ref,
+		"data-sidebar": "menu-sub-item",
+		className: require_utils.cn(className),
+		...props,
+		children
+	});
+});
+SidebarMenuSubItem.displayName = "SidebarGlass.MenuSubItem";
+const SidebarMenuSubButton = (0, react.forwardRef)(({ asChild = false, isActive = false, size = "md", className, ...props }, ref) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(asChild ? __radix_ui_react_slot.Slot : "a", {
+		ref,
+		"data-sidebar": "menu-sub-button",
+		"data-active": isActive,
+		"data-size": size,
+		className: require_utils.cn("flex min-w-0 items-center gap-2", "-ml-px rounded-md border-l border-transparent", "text-[var(--sidebar-foreground)]/60", "ring-[var(--sidebar-ring)]", "transition-colors", "hover:border-[var(--sidebar-border)]", "hover:bg-[var(--sidebar-accent)]", "hover:text-[var(--sidebar-accent-foreground)]", "focus-visible:outline-none focus-visible:ring-2", "active:bg-[var(--sidebar-accent)] active:text-[var(--sidebar-accent-foreground)]", "disabled:pointer-events-none disabled:opacity-50", "[&>span:last-child]:truncate", "[&>svg]:size-4 [&>svg]:shrink-0", size === "sm" && "h-7 px-2 text-xs", size === "md" && "h-8 px-2 text-sm", isActive && ["border-[var(--sidebar-primary)]", "text-[var(--sidebar-foreground)]"], className),
+		...props
+	});
+});
+SidebarMenuSubButton.displayName = "SidebarGlass.MenuSubButton";
+const SidebarGlass = {
+	Provider: SidebarProvider,
+	Root: SidebarRoot,
+	Header: SidebarHeader,
+	Content: SidebarContent,
+	Footer: SidebarFooter,
+	Rail: SidebarRail,
+	Inset: SidebarInset,
+	Trigger: SidebarTrigger,
+	Separator: SidebarSeparator,
+	Group: SidebarGroup,
+	GroupLabel: SidebarGroupLabel,
+	GroupAction: SidebarGroupAction,
+	GroupContent: SidebarGroupContent,
+	Menu: SidebarMenu,
+	MenuItem: SidebarMenuItem,
+	MenuButton: SidebarMenuButton,
+	MenuAction: SidebarMenuAction,
+	MenuBadge: SidebarMenuBadge,
+	MenuSkeleton: SidebarMenuSkeleton,
+	MenuSub: SidebarMenuSub,
+	MenuSubItem: SidebarMenuSubItem,
+	MenuSubButton: SidebarMenuSubButton
+};
 function _extends$1() {
 	return _extends$1 = Object.assign ? Object.assign.bind() : function(n) {
 		for (var e = 1; e < arguments.length; e++) {
@@ -705,6 +1114,1245 @@ function Legend(outsideProps) {
 	}))), legendPortal);
 }
 Legend.displayName = "Legend";
+var Primitive = [
+	"a",
+	"button",
+	"div",
+	"form",
+	"h2",
+	"h3",
+	"img",
+	"input",
+	"label",
+	"li",
+	"nav",
+	"ol",
+	"p",
+	"select",
+	"span",
+	"svg",
+	"ul"
+].reduce((primitive, node) => {
+	const Slot$3 = (0, __radix_ui_react_slot.createSlot)(`Primitive.${node}`);
+	const Node = react.forwardRef((props, forwardedRef) => {
+		const { asChild, ...primitiveProps } = props;
+		const Comp = asChild ? Slot$3 : node;
+		if (typeof window !== "undefined") window[Symbol.for("radix-ui")] = true;
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Comp, {
+			...primitiveProps,
+			ref: forwardedRef
+		});
+	});
+	Node.displayName = `Primitive.${node}`;
+	return {
+		...primitive,
+		[node]: Node
+	};
+}, {});
+function createContextScope(scopeName, createContextScopeDeps = []) {
+	let defaultContexts = [];
+	function createContext3(rootComponentName, defaultContext) {
+		const BaseContext = react.createContext(defaultContext);
+		const index = defaultContexts.length;
+		defaultContexts = [...defaultContexts, defaultContext];
+		const Provider = (props) => {
+			const { scope, children, ...context } = props;
+			const Context = scope?.[scopeName]?.[index] || BaseContext;
+			const value = react.useMemo(() => context, Object.values(context));
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Context.Provider, {
+				value,
+				children
+			});
+		};
+		Provider.displayName = rootComponentName + "Provider";
+		function useContext2(consumerName, scope) {
+			const Context = scope?.[scopeName]?.[index] || BaseContext;
+			const context = react.useContext(Context);
+			if (context) return context;
+			if (defaultContext !== void 0) return defaultContext;
+			throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+		}
+		return [Provider, useContext2];
+	}
+	const createScope = () => {
+		const scopeContexts = defaultContexts.map((defaultContext) => {
+			return react.createContext(defaultContext);
+		});
+		return function useScope(scope) {
+			const contexts = scope?.[scopeName] || scopeContexts;
+			return react.useMemo(() => ({ [`__scope${scopeName}`]: {
+				...scope,
+				[scopeName]: contexts
+			} }), [scope, contexts]);
+		};
+	};
+	createScope.scopeName = scopeName;
+	return [createContext3, composeContextScopes(createScope, ...createContextScopeDeps)];
+}
+function composeContextScopes(...scopes) {
+	const baseScope = scopes[0];
+	if (scopes.length === 1) return baseScope;
+	const createScope = () => {
+		const scopeHooks = scopes.map((createScope2) => ({
+			useScope: createScope2(),
+			scopeName: createScope2.scopeName
+		}));
+		return function useComposedScopes(overrideScopes) {
+			const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => {
+				const currentScope = useScope(overrideScopes)[`__scope${scopeName}`];
+				return {
+					...nextScopes2,
+					...currentScope
+				};
+			}, {});
+			return react.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);
+		};
+	};
+	createScope.scopeName = baseScope.scopeName;
+	return createScope;
+}
+function useStateMachine(initialState, machine) {
+	return react.useReducer((state, event) => {
+		return machine[state][event] ?? state;
+	}, initialState);
+}
+var SCROLL_AREA_NAME = "ScrollArea";
+var [createScrollAreaContext, createScrollAreaScope] = createContextScope(SCROLL_AREA_NAME);
+var [ScrollAreaProvider, useScrollAreaContext] = createScrollAreaContext(SCROLL_AREA_NAME);
+var ScrollArea$1 = react.forwardRef((props, forwardedRef) => {
+	const { __scopeScrollArea, type = "hover", dir, scrollHideDelay = 600, ...scrollAreaProps } = props;
+	const [scrollArea, setScrollArea] = react.useState(null);
+	const [viewport, setViewport] = react.useState(null);
+	const [content, setContent] = react.useState(null);
+	const [scrollbarX, setScrollbarX] = react.useState(null);
+	const [scrollbarY, setScrollbarY] = react.useState(null);
+	const [cornerWidth, setCornerWidth] = react.useState(0);
+	const [cornerHeight, setCornerHeight] = react.useState(0);
+	const [scrollbarXEnabled, setScrollbarXEnabled] = react.useState(false);
+	const [scrollbarYEnabled, setScrollbarYEnabled] = react.useState(false);
+	const composedRefs = require_trust_score_card_glass.useComposedRefs(forwardedRef, (node) => setScrollArea(node));
+	const direction = require_trust_score_card_glass.useDirection(dir);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollAreaProvider, {
+		scope: __scopeScrollArea,
+		type,
+		dir: direction,
+		scrollHideDelay,
+		scrollArea,
+		viewport,
+		onViewportChange: setViewport,
+		content,
+		onContentChange: setContent,
+		scrollbarX,
+		onScrollbarXChange: setScrollbarX,
+		scrollbarXEnabled,
+		onScrollbarXEnabledChange: setScrollbarXEnabled,
+		scrollbarY,
+		onScrollbarYChange: setScrollbarY,
+		scrollbarYEnabled,
+		onScrollbarYEnabledChange: setScrollbarYEnabled,
+		onCornerWidthChange: setCornerWidth,
+		onCornerHeightChange: setCornerHeight,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Primitive.div, {
+			dir: direction,
+			...scrollAreaProps,
+			ref: composedRefs,
+			style: {
+				position: "relative",
+				["--radix-scroll-area-corner-width"]: cornerWidth + "px",
+				["--radix-scroll-area-corner-height"]: cornerHeight + "px",
+				...props.style
+			}
+		})
+	});
+});
+ScrollArea$1.displayName = SCROLL_AREA_NAME;
+var VIEWPORT_NAME = "ScrollAreaViewport";
+var ScrollAreaViewport = react.forwardRef((props, forwardedRef) => {
+	const { __scopeScrollArea, children, nonce, ...viewportProps } = props;
+	const context = useScrollAreaContext(VIEWPORT_NAME, __scopeScrollArea);
+	const composedRefs = require_trust_score_card_glass.useComposedRefs(forwardedRef, react.useRef(null), context.onViewportChange);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("style", {
+		dangerouslySetInnerHTML: { __html: `[data-radix-scroll-area-viewport]{scrollbar-width:none;-ms-overflow-style:none;-webkit-overflow-scrolling:touch;}[data-radix-scroll-area-viewport]::-webkit-scrollbar{display:none}` },
+		nonce
+	}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Primitive.div, {
+		"data-radix-scroll-area-viewport": "",
+		...viewportProps,
+		ref: composedRefs,
+		style: {
+			overflowX: context.scrollbarXEnabled ? "scroll" : "hidden",
+			overflowY: context.scrollbarYEnabled ? "scroll" : "hidden",
+			...props.style
+		},
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+			ref: context.onContentChange,
+			style: {
+				minWidth: "100%",
+				display: "table"
+			},
+			children
+		})
+	})] });
+});
+ScrollAreaViewport.displayName = VIEWPORT_NAME;
+var SCROLLBAR_NAME = "ScrollAreaScrollbar";
+var ScrollAreaScrollbar = react.forwardRef((props, forwardedRef) => {
+	const { forceMount, ...scrollbarProps } = props;
+	const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
+	const { onScrollbarXEnabledChange, onScrollbarYEnabledChange } = context;
+	const isHorizontal = props.orientation === "horizontal";
+	react.useEffect(() => {
+		isHorizontal ? onScrollbarXEnabledChange(true) : onScrollbarYEnabledChange(true);
+		return () => {
+			isHorizontal ? onScrollbarXEnabledChange(false) : onScrollbarYEnabledChange(false);
+		};
+	}, [
+		isHorizontal,
+		onScrollbarXEnabledChange,
+		onScrollbarYEnabledChange
+	]);
+	return context.type === "hover" ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollAreaScrollbarHover, {
+		...scrollbarProps,
+		ref: forwardedRef,
+		forceMount
+	}) : context.type === "scroll" ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollAreaScrollbarScroll, {
+		...scrollbarProps,
+		ref: forwardedRef,
+		forceMount
+	}) : context.type === "auto" ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollAreaScrollbarAuto, {
+		...scrollbarProps,
+		ref: forwardedRef,
+		forceMount
+	}) : context.type === "always" ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollAreaScrollbarVisible, {
+		...scrollbarProps,
+		ref: forwardedRef
+	}) : null;
+});
+ScrollAreaScrollbar.displayName = SCROLLBAR_NAME;
+var ScrollAreaScrollbarHover = react.forwardRef((props, forwardedRef) => {
+	const { forceMount, ...scrollbarProps } = props;
+	const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
+	const [visible, setVisible] = react.useState(false);
+	react.useEffect(() => {
+		const scrollArea = context.scrollArea;
+		let hideTimer = 0;
+		if (scrollArea) {
+			const handlePointerEnter = () => {
+				window.clearTimeout(hideTimer);
+				setVisible(true);
+			};
+			const handlePointerLeave = () => {
+				hideTimer = window.setTimeout(() => setVisible(false), context.scrollHideDelay);
+			};
+			scrollArea.addEventListener("pointerenter", handlePointerEnter);
+			scrollArea.addEventListener("pointerleave", handlePointerLeave);
+			return () => {
+				window.clearTimeout(hideTimer);
+				scrollArea.removeEventListener("pointerenter", handlePointerEnter);
+				scrollArea.removeEventListener("pointerleave", handlePointerLeave);
+			};
+		}
+	}, [context.scrollArea, context.scrollHideDelay]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_trust_score_card_glass.Presence, {
+		present: forceMount || visible,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollAreaScrollbarAuto, {
+			"data-state": visible ? "visible" : "hidden",
+			...scrollbarProps,
+			ref: forwardedRef
+		})
+	});
+});
+var ScrollAreaScrollbarScroll = react.forwardRef((props, forwardedRef) => {
+	const { forceMount, ...scrollbarProps } = props;
+	const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
+	const isHorizontal = props.orientation === "horizontal";
+	const debounceScrollEnd = useDebounceCallback(() => send("SCROLL_END"), 100);
+	const [state, send] = useStateMachine("hidden", {
+		hidden: { SCROLL: "scrolling" },
+		scrolling: {
+			SCROLL_END: "idle",
+			POINTER_ENTER: "interacting"
+		},
+		interacting: {
+			SCROLL: "interacting",
+			POINTER_LEAVE: "idle"
+		},
+		idle: {
+			HIDE: "hidden",
+			SCROLL: "scrolling",
+			POINTER_ENTER: "interacting"
+		}
+	});
+	react.useEffect(() => {
+		if (state === "idle") {
+			const hideTimer = window.setTimeout(() => send("HIDE"), context.scrollHideDelay);
+			return () => window.clearTimeout(hideTimer);
+		}
+	}, [
+		state,
+		context.scrollHideDelay,
+		send
+	]);
+	react.useEffect(() => {
+		const viewport = context.viewport;
+		const scrollDirection = isHorizontal ? "scrollLeft" : "scrollTop";
+		if (viewport) {
+			let prevScrollPos = viewport[scrollDirection];
+			const handleScroll = () => {
+				const scrollPos = viewport[scrollDirection];
+				if (prevScrollPos !== scrollPos) {
+					send("SCROLL");
+					debounceScrollEnd();
+				}
+				prevScrollPos = scrollPos;
+			};
+			viewport.addEventListener("scroll", handleScroll);
+			return () => viewport.removeEventListener("scroll", handleScroll);
+		}
+	}, [
+		context.viewport,
+		isHorizontal,
+		send,
+		debounceScrollEnd
+	]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_trust_score_card_glass.Presence, {
+		present: forceMount || state !== "hidden",
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollAreaScrollbarVisible, {
+			"data-state": state === "hidden" ? "hidden" : "visible",
+			...scrollbarProps,
+			ref: forwardedRef,
+			onPointerEnter: require_trust_score_card_glass.composeEventHandlers(props.onPointerEnter, () => send("POINTER_ENTER")),
+			onPointerLeave: require_trust_score_card_glass.composeEventHandlers(props.onPointerLeave, () => send("POINTER_LEAVE"))
+		})
+	});
+});
+var ScrollAreaScrollbarAuto = react.forwardRef((props, forwardedRef) => {
+	const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
+	const { forceMount, ...scrollbarProps } = props;
+	const [visible, setVisible] = react.useState(false);
+	const isHorizontal = props.orientation === "horizontal";
+	const handleResize = useDebounceCallback(() => {
+		if (context.viewport) {
+			const isOverflowX = context.viewport.offsetWidth < context.viewport.scrollWidth;
+			const isOverflowY = context.viewport.offsetHeight < context.viewport.scrollHeight;
+			setVisible(isHorizontal ? isOverflowX : isOverflowY);
+		}
+	}, 10);
+	useResizeObserver(context.viewport, handleResize);
+	useResizeObserver(context.content, handleResize);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_trust_score_card_glass.Presence, {
+		present: forceMount || visible,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollAreaScrollbarVisible, {
+			"data-state": visible ? "visible" : "hidden",
+			...scrollbarProps,
+			ref: forwardedRef
+		})
+	});
+});
+var ScrollAreaScrollbarVisible = react.forwardRef((props, forwardedRef) => {
+	const { orientation = "vertical", ...scrollbarProps } = props;
+	const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
+	const thumbRef = react.useRef(null);
+	const pointerOffsetRef = react.useRef(0);
+	const [sizes, setSizes] = react.useState({
+		content: 0,
+		viewport: 0,
+		scrollbar: {
+			size: 0,
+			paddingStart: 0,
+			paddingEnd: 0
+		}
+	});
+	const thumbRatio = getThumbRatio(sizes.viewport, sizes.content);
+	const commonProps = {
+		...scrollbarProps,
+		sizes,
+		onSizesChange: setSizes,
+		hasThumb: Boolean(thumbRatio > 0 && thumbRatio < 1),
+		onThumbChange: (thumb) => thumbRef.current = thumb,
+		onThumbPointerUp: () => pointerOffsetRef.current = 0,
+		onThumbPointerDown: (pointerPos) => pointerOffsetRef.current = pointerPos
+	};
+	function getScrollPosition(pointerPos, dir) {
+		return getScrollPositionFromPointer(pointerPos, pointerOffsetRef.current, sizes, dir);
+	}
+	if (orientation === "horizontal") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollAreaScrollbarX, {
+		...commonProps,
+		ref: forwardedRef,
+		onThumbPositionChange: () => {
+			if (context.viewport && thumbRef.current) {
+				const scrollPos = context.viewport.scrollLeft;
+				const offset = getThumbOffsetFromScroll(scrollPos, sizes, context.dir);
+				thumbRef.current.style.transform = `translate3d(${offset}px, 0, 0)`;
+			}
+		},
+		onWheelScroll: (scrollPos) => {
+			if (context.viewport) context.viewport.scrollLeft = scrollPos;
+		},
+		onDragScroll: (pointerPos) => {
+			if (context.viewport) context.viewport.scrollLeft = getScrollPosition(pointerPos, context.dir);
+		}
+	});
+	if (orientation === "vertical") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollAreaScrollbarY, {
+		...commonProps,
+		ref: forwardedRef,
+		onThumbPositionChange: () => {
+			if (context.viewport && thumbRef.current) {
+				const scrollPos = context.viewport.scrollTop;
+				const offset = getThumbOffsetFromScroll(scrollPos, sizes);
+				thumbRef.current.style.transform = `translate3d(0, ${offset}px, 0)`;
+			}
+		},
+		onWheelScroll: (scrollPos) => {
+			if (context.viewport) context.viewport.scrollTop = scrollPos;
+		},
+		onDragScroll: (pointerPos) => {
+			if (context.viewport) context.viewport.scrollTop = getScrollPosition(pointerPos);
+		}
+	});
+	return null;
+});
+var ScrollAreaScrollbarX = react.forwardRef((props, forwardedRef) => {
+	const { sizes, onSizesChange, ...scrollbarProps } = props;
+	const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
+	const [computedStyle, setComputedStyle] = react.useState();
+	const ref = react.useRef(null);
+	const composeRefs = require_trust_score_card_glass.useComposedRefs(forwardedRef, ref, context.onScrollbarXChange);
+	react.useEffect(() => {
+		if (ref.current) setComputedStyle(getComputedStyle(ref.current));
+	}, [ref]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollAreaScrollbarImpl, {
+		"data-orientation": "horizontal",
+		...scrollbarProps,
+		ref: composeRefs,
+		sizes,
+		style: {
+			bottom: 0,
+			left: context.dir === "rtl" ? "var(--radix-scroll-area-corner-width)" : 0,
+			right: context.dir === "ltr" ? "var(--radix-scroll-area-corner-width)" : 0,
+			["--radix-scroll-area-thumb-width"]: getThumbSize(sizes) + "px",
+			...props.style
+		},
+		onThumbPointerDown: (pointerPos) => props.onThumbPointerDown(pointerPos.x),
+		onDragScroll: (pointerPos) => props.onDragScroll(pointerPos.x),
+		onWheelScroll: (event, maxScrollPos) => {
+			if (context.viewport) {
+				const scrollPos = context.viewport.scrollLeft + event.deltaX;
+				props.onWheelScroll(scrollPos);
+				if (isScrollingWithinScrollbarBounds(scrollPos, maxScrollPos)) event.preventDefault();
+			}
+		},
+		onResize: () => {
+			if (ref.current && context.viewport && computedStyle) onSizesChange({
+				content: context.viewport.scrollWidth,
+				viewport: context.viewport.offsetWidth,
+				scrollbar: {
+					size: ref.current.clientWidth,
+					paddingStart: toInt(computedStyle.paddingLeft),
+					paddingEnd: toInt(computedStyle.paddingRight)
+				}
+			});
+		}
+	});
+});
+var ScrollAreaScrollbarY = react.forwardRef((props, forwardedRef) => {
+	const { sizes, onSizesChange, ...scrollbarProps } = props;
+	const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
+	const [computedStyle, setComputedStyle] = react.useState();
+	const ref = react.useRef(null);
+	const composeRefs = require_trust_score_card_glass.useComposedRefs(forwardedRef, ref, context.onScrollbarYChange);
+	react.useEffect(() => {
+		if (ref.current) setComputedStyle(getComputedStyle(ref.current));
+	}, [ref]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollAreaScrollbarImpl, {
+		"data-orientation": "vertical",
+		...scrollbarProps,
+		ref: composeRefs,
+		sizes,
+		style: {
+			top: 0,
+			right: context.dir === "ltr" ? 0 : void 0,
+			left: context.dir === "rtl" ? 0 : void 0,
+			bottom: "var(--radix-scroll-area-corner-height)",
+			["--radix-scroll-area-thumb-height"]: getThumbSize(sizes) + "px",
+			...props.style
+		},
+		onThumbPointerDown: (pointerPos) => props.onThumbPointerDown(pointerPos.y),
+		onDragScroll: (pointerPos) => props.onDragScroll(pointerPos.y),
+		onWheelScroll: (event, maxScrollPos) => {
+			if (context.viewport) {
+				const scrollPos = context.viewport.scrollTop + event.deltaY;
+				props.onWheelScroll(scrollPos);
+				if (isScrollingWithinScrollbarBounds(scrollPos, maxScrollPos)) event.preventDefault();
+			}
+		},
+		onResize: () => {
+			if (ref.current && context.viewport && computedStyle) onSizesChange({
+				content: context.viewport.scrollHeight,
+				viewport: context.viewport.offsetHeight,
+				scrollbar: {
+					size: ref.current.clientHeight,
+					paddingStart: toInt(computedStyle.paddingTop),
+					paddingEnd: toInt(computedStyle.paddingBottom)
+				}
+			});
+		}
+	});
+});
+var [ScrollbarProvider, useScrollbarContext] = createScrollAreaContext(SCROLLBAR_NAME);
+var ScrollAreaScrollbarImpl = react.forwardRef((props, forwardedRef) => {
+	const { __scopeScrollArea, sizes, hasThumb, onThumbChange, onThumbPointerUp, onThumbPointerDown, onThumbPositionChange, onDragScroll, onWheelScroll, onResize, ...scrollbarProps } = props;
+	const context = useScrollAreaContext(SCROLLBAR_NAME, __scopeScrollArea);
+	const [scrollbar, setScrollbar] = react.useState(null);
+	const composeRefs = require_trust_score_card_glass.useComposedRefs(forwardedRef, (node) => setScrollbar(node));
+	const rectRef = react.useRef(null);
+	const prevWebkitUserSelectRef = react.useRef("");
+	const viewport = context.viewport;
+	const maxScrollPos = sizes.content - sizes.viewport;
+	const handleWheelScroll = require_trust_score_card_glass.useCallbackRef(onWheelScroll);
+	const handleThumbPositionChange = require_trust_score_card_glass.useCallbackRef(onThumbPositionChange);
+	const handleResize = useDebounceCallback(onResize, 10);
+	function handleDragScroll(event) {
+		if (rectRef.current) onDragScroll({
+			x: event.clientX - rectRef.current.left,
+			y: event.clientY - rectRef.current.top
+		});
+	}
+	react.useEffect(() => {
+		const handleWheel = (event) => {
+			const element = event.target;
+			if (scrollbar?.contains(element)) handleWheelScroll(event, maxScrollPos);
+		};
+		document.addEventListener("wheel", handleWheel, { passive: false });
+		return () => document.removeEventListener("wheel", handleWheel, { passive: false });
+	}, [
+		viewport,
+		scrollbar,
+		maxScrollPos,
+		handleWheelScroll
+	]);
+	react.useEffect(handleThumbPositionChange, [sizes, handleThumbPositionChange]);
+	useResizeObserver(scrollbar, handleResize);
+	useResizeObserver(context.content, handleResize);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollbarProvider, {
+		scope: __scopeScrollArea,
+		scrollbar,
+		hasThumb,
+		onThumbChange: require_trust_score_card_glass.useCallbackRef(onThumbChange),
+		onThumbPointerUp: require_trust_score_card_glass.useCallbackRef(onThumbPointerUp),
+		onThumbPositionChange: handleThumbPositionChange,
+		onThumbPointerDown: require_trust_score_card_glass.useCallbackRef(onThumbPointerDown),
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Primitive.div, {
+			...scrollbarProps,
+			ref: composeRefs,
+			style: {
+				position: "absolute",
+				...scrollbarProps.style
+			},
+			onPointerDown: require_trust_score_card_glass.composeEventHandlers(props.onPointerDown, (event) => {
+				if (event.button === 0) {
+					event.target.setPointerCapture(event.pointerId);
+					rectRef.current = scrollbar.getBoundingClientRect();
+					prevWebkitUserSelectRef.current = document.body.style.webkitUserSelect;
+					document.body.style.webkitUserSelect = "none";
+					if (context.viewport) context.viewport.style.scrollBehavior = "auto";
+					handleDragScroll(event);
+				}
+			}),
+			onPointerMove: require_trust_score_card_glass.composeEventHandlers(props.onPointerMove, handleDragScroll),
+			onPointerUp: require_trust_score_card_glass.composeEventHandlers(props.onPointerUp, (event) => {
+				const element = event.target;
+				if (element.hasPointerCapture(event.pointerId)) element.releasePointerCapture(event.pointerId);
+				document.body.style.webkitUserSelect = prevWebkitUserSelectRef.current;
+				if (context.viewport) context.viewport.style.scrollBehavior = "";
+				rectRef.current = null;
+			})
+		})
+	});
+});
+var THUMB_NAME = "ScrollAreaThumb";
+var ScrollAreaThumb = react.forwardRef((props, forwardedRef) => {
+	const { forceMount, ...thumbProps } = props;
+	const scrollbarContext = useScrollbarContext(THUMB_NAME, props.__scopeScrollArea);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_trust_score_card_glass.Presence, {
+		present: forceMount || scrollbarContext.hasThumb,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollAreaThumbImpl, {
+			ref: forwardedRef,
+			...thumbProps
+		})
+	});
+});
+var ScrollAreaThumbImpl = react.forwardRef((props, forwardedRef) => {
+	const { __scopeScrollArea, style, ...thumbProps } = props;
+	const scrollAreaContext = useScrollAreaContext(THUMB_NAME, __scopeScrollArea);
+	const scrollbarContext = useScrollbarContext(THUMB_NAME, __scopeScrollArea);
+	const { onThumbPositionChange } = scrollbarContext;
+	const composedRef = require_trust_score_card_glass.useComposedRefs(forwardedRef, (node) => scrollbarContext.onThumbChange(node));
+	const removeUnlinkedScrollListenerRef = react.useRef(void 0);
+	const debounceScrollEnd = useDebounceCallback(() => {
+		if (removeUnlinkedScrollListenerRef.current) {
+			removeUnlinkedScrollListenerRef.current();
+			removeUnlinkedScrollListenerRef.current = void 0;
+		}
+	}, 100);
+	react.useEffect(() => {
+		const viewport = scrollAreaContext.viewport;
+		if (viewport) {
+			const handleScroll = () => {
+				debounceScrollEnd();
+				if (!removeUnlinkedScrollListenerRef.current) {
+					removeUnlinkedScrollListenerRef.current = addUnlinkedScrollListener(viewport, onThumbPositionChange);
+					onThumbPositionChange();
+				}
+			};
+			onThumbPositionChange();
+			viewport.addEventListener("scroll", handleScroll);
+			return () => viewport.removeEventListener("scroll", handleScroll);
+		}
+	}, [
+		scrollAreaContext.viewport,
+		debounceScrollEnd,
+		onThumbPositionChange
+	]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Primitive.div, {
+		"data-state": scrollbarContext.hasThumb ? "visible" : "hidden",
+		...thumbProps,
+		ref: composedRef,
+		style: {
+			width: "var(--radix-scroll-area-thumb-width)",
+			height: "var(--radix-scroll-area-thumb-height)",
+			...style
+		},
+		onPointerDownCapture: require_trust_score_card_glass.composeEventHandlers(props.onPointerDownCapture, (event) => {
+			const thumbRect = event.target.getBoundingClientRect();
+			const x = event.clientX - thumbRect.left;
+			const y = event.clientY - thumbRect.top;
+			scrollbarContext.onThumbPointerDown({
+				x,
+				y
+			});
+		}),
+		onPointerUp: require_trust_score_card_glass.composeEventHandlers(props.onPointerUp, scrollbarContext.onThumbPointerUp)
+	});
+});
+ScrollAreaThumb.displayName = THUMB_NAME;
+var CORNER_NAME = "ScrollAreaCorner";
+var ScrollAreaCorner = react.forwardRef((props, forwardedRef) => {
+	const context = useScrollAreaContext(CORNER_NAME, props.__scopeScrollArea);
+	const hasBothScrollbarsVisible = Boolean(context.scrollbarX && context.scrollbarY);
+	return context.type !== "scroll" && hasBothScrollbarsVisible ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollAreaCornerImpl, {
+		...props,
+		ref: forwardedRef
+	}) : null;
+});
+ScrollAreaCorner.displayName = CORNER_NAME;
+var ScrollAreaCornerImpl = react.forwardRef((props, forwardedRef) => {
+	const { __scopeScrollArea, ...cornerProps } = props;
+	const context = useScrollAreaContext(CORNER_NAME, __scopeScrollArea);
+	const [width, setWidth] = react.useState(0);
+	const [height, setHeight] = react.useState(0);
+	const hasSize = Boolean(width && height);
+	useResizeObserver(context.scrollbarX, () => {
+		const height2 = context.scrollbarX?.offsetHeight || 0;
+		context.onCornerHeightChange(height2);
+		setHeight(height2);
+	});
+	useResizeObserver(context.scrollbarY, () => {
+		const width2 = context.scrollbarY?.offsetWidth || 0;
+		context.onCornerWidthChange(width2);
+		setWidth(width2);
+	});
+	return hasSize ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Primitive.div, {
+		...cornerProps,
+		ref: forwardedRef,
+		style: {
+			width,
+			height,
+			position: "absolute",
+			right: context.dir === "ltr" ? 0 : void 0,
+			left: context.dir === "rtl" ? 0 : void 0,
+			bottom: 0,
+			...props.style
+		}
+	}) : null;
+});
+function toInt(value) {
+	return value ? parseInt(value, 10) : 0;
+}
+function getThumbRatio(viewportSize, contentSize) {
+	const ratio = viewportSize / contentSize;
+	return isNaN(ratio) ? 0 : ratio;
+}
+function getThumbSize(sizes) {
+	const ratio = getThumbRatio(sizes.viewport, sizes.content);
+	const scrollbarPadding = sizes.scrollbar.paddingStart + sizes.scrollbar.paddingEnd;
+	const thumbSize = (sizes.scrollbar.size - scrollbarPadding) * ratio;
+	return Math.max(thumbSize, 18);
+}
+function getScrollPositionFromPointer(pointerPos, pointerOffset, sizes, dir = "ltr") {
+	const thumbSizePx = getThumbSize(sizes);
+	const thumbCenter = thumbSizePx / 2;
+	const offset = pointerOffset || thumbCenter;
+	const thumbOffsetFromEnd = thumbSizePx - offset;
+	const minPointerPos = sizes.scrollbar.paddingStart + offset;
+	const maxPointerPos = sizes.scrollbar.size - sizes.scrollbar.paddingEnd - thumbOffsetFromEnd;
+	const maxScrollPos = sizes.content - sizes.viewport;
+	const scrollRange = dir === "ltr" ? [0, maxScrollPos] : [maxScrollPos * -1, 0];
+	return linearScale([minPointerPos, maxPointerPos], scrollRange)(pointerPos);
+}
+function getThumbOffsetFromScroll(scrollPos, sizes, dir = "ltr") {
+	const thumbSizePx = getThumbSize(sizes);
+	const scrollbarPadding = sizes.scrollbar.paddingStart + sizes.scrollbar.paddingEnd;
+	const scrollbar = sizes.scrollbar.size - scrollbarPadding;
+	const maxScrollPos = sizes.content - sizes.viewport;
+	const maxThumbPos = scrollbar - thumbSizePx;
+	const scrollWithoutMomentum = require_trust_score_card_glass.clamp(scrollPos, dir === "ltr" ? [0, maxScrollPos] : [maxScrollPos * -1, 0]);
+	return linearScale([0, maxScrollPos], [0, maxThumbPos])(scrollWithoutMomentum);
+}
+function linearScale(input, output) {
+	return (value) => {
+		if (input[0] === input[1] || output[0] === output[1]) return output[0];
+		const ratio = (output[1] - output[0]) / (input[1] - input[0]);
+		return output[0] + ratio * (value - input[0]);
+	};
+}
+function isScrollingWithinScrollbarBounds(scrollPos, maxScrollPos) {
+	return scrollPos > 0 && scrollPos < maxScrollPos;
+}
+var addUnlinkedScrollListener = (node, handler = () => {}) => {
+	let prevPosition = {
+		left: node.scrollLeft,
+		top: node.scrollTop
+	};
+	let rAF = 0;
+	(function loop() {
+		const position = {
+			left: node.scrollLeft,
+			top: node.scrollTop
+		};
+		const isHorizontalScroll = prevPosition.left !== position.left;
+		const isVerticalScroll = prevPosition.top !== position.top;
+		if (isHorizontalScroll || isVerticalScroll) handler();
+		prevPosition = position;
+		rAF = window.requestAnimationFrame(loop);
+	})();
+	return () => window.cancelAnimationFrame(rAF);
+};
+function useDebounceCallback(callback, delay) {
+	const handleCallback = require_trust_score_card_glass.useCallbackRef(callback);
+	const debounceTimerRef = react.useRef(0);
+	react.useEffect(() => () => window.clearTimeout(debounceTimerRef.current), []);
+	return react.useCallback(() => {
+		window.clearTimeout(debounceTimerRef.current);
+		debounceTimerRef.current = window.setTimeout(handleCallback, delay);
+	}, [handleCallback, delay]);
+}
+function useResizeObserver(element, onResize) {
+	const handleResize = require_trust_score_card_glass.useCallbackRef(onResize);
+	require_trust_score_card_glass.useLayoutEffect2(() => {
+		let rAF = 0;
+		if (element) {
+			const resizeObserver = new ResizeObserver(() => {
+				cancelAnimationFrame(rAF);
+				rAF = window.requestAnimationFrame(handleResize);
+			});
+			resizeObserver.observe(element);
+			return () => {
+				window.cancelAnimationFrame(rAF);
+				resizeObserver.unobserve(element);
+			};
+		}
+	}, [element, handleResize]);
+}
+var Root = ScrollArea$1;
+var Viewport = ScrollAreaViewport;
+var Corner = ScrollAreaCorner;
+function ScrollArea({ className, children, ...props }) {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(Root, {
+		"data-slot": "scroll-area",
+		className: require_utils.cn("relative", className),
+		...props,
+		children: [
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Viewport, {
+				"data-slot": "scroll-area-viewport",
+				className: "focus-visible:ring-ring/50 size-full rounded-[inherit] transition-[color,box-shadow] outline-none focus-visible:ring-[3px] focus-visible:outline-1",
+				children
+			}),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollBar, {}),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Corner, {})
+		]
+	});
+}
+function ScrollBar({ className, orientation = "vertical", ...props }) {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollAreaScrollbar, {
+		"data-slot": "scroll-area-scrollbar",
+		orientation,
+		className: require_utils.cn("flex touch-none p-px transition-colors select-none", orientation === "vertical" && "h-full w-2.5 border-l border-l-transparent", orientation === "horizontal" && "h-2.5 flex-col border-t border-t-transparent", className),
+		...props,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollAreaThumb, {
+			"data-slot": "scroll-area-thumb",
+			className: "bg-border relative flex-1 rounded-full"
+		})
+	});
+}
+var SplitLayoutContext = (0, react.createContext)(null);
+function useSplitLayout() {
+	const context = (0, react.useContext)(SplitLayoutContext);
+	if (!context) throw new Error("useSplitLayout must be used within SplitLayoutGlass.Provider. Wrap your component tree with <SplitLayoutGlass.Provider>.");
+	return context;
+}
+function useSplitLayoutOptional() {
+	return (0, react.useContext)(SplitLayoutContext);
+}
+var BREAKPOINT_VALUES = {
+	sm: 640,
+	md: 768,
+	lg: 1024,
+	xl: 1440,
+	"2xl": 1536
+};
+const SplitLayoutProvider = ({ children, selectedKey: controlledSelectedKey, onSelectedKeyChange, defaultSelectedKey = null, open: controlledOpen, onOpenChange, defaultOpen = true, breakpoint = "md", mobileMode = "stack", intensity = "medium", stickyOffset = 24, urlParamName, keyboardShortcut = "b" }) => {
+	const [internalSelectedKey, setInternalSelectedKey] = (0, react.useState)(() => {
+		if (urlParamName && typeof window !== "undefined") {
+			const urlValue = new URLSearchParams(window.location.search).get(urlParamName);
+			if (urlValue) return urlValue;
+		}
+		return defaultSelectedKey;
+	});
+	const isSelectedKeyControlled = controlledSelectedKey !== void 0;
+	const selectedKey = isSelectedKeyControlled ? controlledSelectedKey : internalSelectedKey;
+	const setSelectedKey = (0, react.useCallback)((key) => {
+		if (!isSelectedKeyControlled) setInternalSelectedKey(key);
+		onSelectedKeyChange?.(key);
+		if (urlParamName && typeof window !== "undefined") {
+			const url = new URL(window.location.href);
+			if (key) url.searchParams.set(urlParamName, key);
+			else url.searchParams.delete(urlParamName);
+			window.history.replaceState({}, "", url.toString());
+		}
+	}, [
+		isSelectedKeyControlled,
+		onSelectedKeyChange,
+		urlParamName
+	]);
+	const [internalOpen, setInternalOpen] = (0, react.useState)(defaultOpen);
+	const isOpenControlled = controlledOpen !== void 0;
+	const isOpen = isOpenControlled ? controlledOpen : internalOpen;
+	const setIsOpen = (0, react.useCallback)((open) => {
+		if (!isOpenControlled) setInternalOpen(open);
+		onOpenChange?.(open);
+	}, [isOpenControlled, onOpenChange]);
+	const [isMobileOpen, setMobileOpen] = (0, react.useState)(false);
+	const [isMobile, setIsMobile] = (0, react.useState)(() => {
+		if (typeof window === "undefined") return false;
+		return window.innerWidth < BREAKPOINT_VALUES[breakpoint];
+	});
+	(0, react.useEffect)(() => {
+		if (typeof window === "undefined") return;
+		const checkMobile = () => {
+			setIsMobile(window.innerWidth < BREAKPOINT_VALUES[breakpoint]);
+		};
+		checkMobile();
+		window.addEventListener("resize", checkMobile);
+		return () => window.removeEventListener("resize", checkMobile);
+	}, [breakpoint]);
+	const toggle = (0, react.useCallback)(() => {
+		if (isMobile) setMobileOpen((prev) => !prev);
+		else setIsOpen(!isOpen);
+	}, [
+		isMobile,
+		isOpen,
+		setIsOpen
+	]);
+	(0, react.useEffect)(() => {
+		if (!keyboardShortcut) return;
+		const handleKeyDown = (e) => {
+			if (e.key === "Escape" && isMobile && isMobileOpen) {
+				e.preventDefault();
+				setMobileOpen(false);
+				return;
+			}
+			if (e.key === keyboardShortcut && (e.metaKey || e.ctrlKey)) {
+				e.preventDefault();
+				toggle();
+			}
+		};
+		document.addEventListener("keydown", handleKeyDown);
+		return () => document.removeEventListener("keydown", handleKeyDown);
+	}, [
+		keyboardShortcut,
+		isMobile,
+		isMobileOpen,
+		toggle
+	]);
+	const value = (0, react.useMemo)(() => ({
+		selectedKey,
+		setSelectedKey,
+		isOpen,
+		setIsOpen,
+		isMobileOpen,
+		setMobileOpen,
+		isMobile,
+		breakpoint,
+		mobileMode,
+		intensity,
+		stickyOffset,
+		toggle,
+		state: isOpen ? "expanded" : "collapsed",
+		open: isOpen,
+		setOpen: setIsOpen,
+		openMobile: isMobileOpen,
+		setOpenMobile: setMobileOpen,
+		toggleSidebar: toggle
+	}), [
+		selectedKey,
+		setSelectedKey,
+		isOpen,
+		setIsOpen,
+		isMobileOpen,
+		isMobile,
+		breakpoint,
+		mobileMode,
+		intensity,
+		stickyOffset,
+		toggle
+	]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SplitLayoutContext.Provider, {
+		value,
+		children
+	});
+};
+SplitLayoutProvider.displayName = "SplitLayoutGlass.Provider";
+var SplitLayoutAccordionRoot = (0, react.forwardRef)(({ children, label = "Content accordion", className, ...props }, ref) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_trust_score_card_glass.GlassCard, {
+		asChild: true,
+		intensity: useSplitLayoutOptional()?.intensity ?? "medium",
+		padding: "none",
+		className: require_utils.cn("divide-y divide-white/10", className),
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+			ref,
+			role: "region",
+			"aria-label": label,
+			"data-split-accordion": "",
+			...props,
+			children
+		})
+	});
+});
+SplitLayoutAccordionRoot.displayName = "SplitLayoutAccordion.Root";
+var SplitLayoutAccordionItem = (0, react.forwardRef)(({ itemKey, trigger, children, disabled = false, className, ...props }, ref) => {
+	const { selectedKey, setSelectedKey } = useSplitLayout();
+	const isExpanded = selectedKey === itemKey;
+	const contentRef = (0, react.useRef)(null);
+	const [contentHeight, setContentHeight] = (0, react.useState)(null);
+	const triggerId = (0, react.useId)();
+	const contentId = (0, react.useId)();
+	(0, react.useEffect)(() => {
+		if (contentRef.current) setContentHeight(contentRef.current.scrollHeight);
+	}, [children, isExpanded]);
+	const handleToggle = (0, react.useCallback)(() => {
+		if (disabled) return;
+		setSelectedKey(isExpanded ? null : itemKey);
+	}, [
+		disabled,
+		isExpanded,
+		itemKey,
+		setSelectedKey
+	]);
+	const handleKeyDown = (0, react.useCallback)((e) => {
+		if (disabled) return;
+		switch (e.key) {
+			case "Enter":
+			case " ":
+				e.preventDefault();
+				handleToggle();
+				break;
+			case "ArrowDown":
+				e.preventDefault();
+				((e.currentTarget.parentElement?.nextElementSibling)?.querySelector("[data-accordion-trigger]"))?.focus();
+				break;
+			case "ArrowUp":
+				e.preventDefault();
+				((e.currentTarget.parentElement?.previousElementSibling)?.querySelector("[data-accordion-trigger]"))?.focus();
+				break;
+			case "Home":
+				e.preventDefault();
+				(e.currentTarget.closest("[data-split-accordion]")?.querySelector("[data-accordion-trigger]"))?.focus();
+				break;
+			case "End": {
+				e.preventDefault();
+				const triggers = e.currentTarget.closest("[data-split-accordion]")?.querySelectorAll("[data-accordion-trigger]");
+				(triggers?.[triggers.length - 1])?.focus();
+				break;
+			}
+		}
+	}, [disabled, handleToggle]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+		ref,
+		"data-accordion-item": "",
+		"data-state": isExpanded ? "open" : "closed",
+		"data-disabled": disabled || void 0,
+		className: require_utils.cn("overflow-hidden", disabled && "opacity-50 cursor-not-allowed", className),
+		...props,
+		children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
+			type: "button",
+			id: triggerId,
+			"data-accordion-trigger": "",
+			"aria-expanded": isExpanded,
+			"aria-controls": contentId,
+			"aria-disabled": disabled,
+			disabled,
+			onClick: handleToggle,
+			onKeyDown: handleKeyDown,
+			className: require_utils.cn("flex w-full items-center justify-between gap-4", "p-4 text-left", "transition-colors duration-200", "hover:bg-white/5 focus-visible:bg-white/5", "focus:outline-none focus-visible:ring-2 focus-visible:ring-white/20 focus-visible:ring-inset", disabled && "pointer-events-none"),
+			children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				className: "flex-1",
+				children: trigger
+			}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(lucide_react.ChevronDown, { className: require_utils.cn("h-4 w-4 shrink-0 text-white/60", "transition-transform duration-300 ease-out", isExpanded && "rotate-180") })]
+		}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+			id: contentId,
+			ref: contentRef,
+			role: "region",
+			"aria-labelledby": triggerId,
+			"data-accordion-content": "",
+			"data-state": isExpanded ? "open" : "closed",
+			className: require_utils.cn("overflow-hidden", "transition-[max-height,opacity] duration-300 ease-out"),
+			style: {
+				maxHeight: isExpanded ? contentHeight ?? "auto" : 0,
+				opacity: isExpanded ? 1 : 0
+			},
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				className: "p-4 pt-0 border-t border-white/5",
+				children
+			})
+		})]
+	});
+});
+SplitLayoutAccordionItem.displayName = "SplitLayoutAccordion.Item";
+const SplitLayoutAccordion = {
+	Root: SplitLayoutAccordionRoot,
+	Item: SplitLayoutAccordionItem
+};
+function useGridStyles(config) {
+	const { ratio = {
+		sidebar: 1,
+		main: 2
+	}, minSidebarWidth = "280px", maxSidebarWidth, gap = {
+		mobile: 16,
+		desktop: 24
+	}, stickyOffset = 24 } = config;
+	const gapMobile = typeof gap === "number" ? gap : gap.mobile ?? 16;
+	const gapDesktop = typeof gap === "number" ? gap : gap.desktop ?? 24;
+	const gridTemplate = maxSidebarWidth ? `minmax(${minSidebarWidth}, ${maxSidebarWidth}) ${ratio.main}fr` : `minmax(${minSidebarWidth}, ${ratio.sidebar}fr) ${ratio.main}fr`;
+	return { cssVars: {
+		"--grid-template": gridTemplate,
+		"--sticky-offset": `${stickyOffset}px`,
+		"--sticky-max-height": `calc(100vh - calc(${stickyOffset}px * 2))`,
+		"--gap-mobile": `${gapMobile}px`,
+		"--gap-desktop": `${gapDesktop}px`
+	} };
+}
+var SplitLayoutRoot = (0, react.forwardRef)(({ children, ratio = {
+	sidebar: 1,
+	main: 2
+}, minSidebarWidth = "300px", maxSidebarWidth, gap = {
+	mobile: 16,
+	desktop: 24
+}, breakpoint: breakpointProp, mobileLayout = "stack", className, ...props }, ref) => {
+	const context = useSplitLayoutOptional();
+	const breakpoint = breakpointProp ?? context?.breakpoint ?? "md";
+	const { cssVars } = useGridStyles({
+		ratio,
+		minSidebarWidth,
+		maxSidebarWidth,
+		gap,
+		stickyOffset: context?.stickyOffset ?? 24
+	});
+	const bp = breakpoint;
+	const gapClasses = {
+		sm: "gap-[var(--gap-mobile)] sm:gap-[var(--gap-desktop)]",
+		md: "gap-[var(--gap-mobile)] md:gap-[var(--gap-desktop)]",
+		lg: "gap-[var(--gap-mobile)] lg:gap-[var(--gap-desktop)]",
+		xl: "gap-[var(--gap-mobile)] xl:gap-[var(--gap-desktop)]",
+		"2xl": "gap-[var(--gap-mobile)] 2xl:gap-[var(--gap-desktop)]"
+	};
+	const gridClasses = {
+		sm: "sm:grid-cols-(--grid-template)",
+		md: "md:grid-cols-(--grid-template)",
+		lg: "lg:grid-cols-(--grid-template)",
+		xl: "xl:grid-cols-(--grid-template)",
+		"2xl": "2xl:grid-cols-(--grid-template)"
+	};
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		ref,
+		"data-split-layout-root": "",
+		"data-state": context?.state ?? "expanded",
+		className: require_utils.cn("grid", "items-start", mobileLayout === "stack" && "grid-cols-1", mobileLayout === "main-only" && "grid-cols-1 *:data-split-sidebar:hidden", mobileLayout === "sidebar-only" && "grid-cols-1 *:data-split-main:hidden", gridClasses[bp], gapClasses[bp], className),
+		style: cssVars,
+		...props,
+		children
+	});
+});
+SplitLayoutRoot.displayName = "SplitLayoutGlass.Root";
+var SplitLayoutSidebar = (0, react.forwardRef)(({ children, label = "Sidebar navigation", className, ...props }, ref) => {
+	const context = useSplitLayoutOptional();
+	const breakpoint = context?.breakpoint ?? "md";
+	const intensity = context?.intensity ?? "medium";
+	const bp = breakpoint;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_trust_score_card_glass.GlassCard, {
+		asChild: true,
+		intensity,
+		padding: "none",
+		className: require_utils.cn("overflow-hidden rounded-xl", `${bp}:sticky`, `${bp}:top-[var(--sticky-offset)]`, `${bp}:max-h-[var(--sticky-max-height)]`, `${bp}:flex`, `${bp}:flex-col`, className),
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("aside", {
+			ref,
+			"data-split-sidebar": "",
+			"aria-label": label,
+			...props,
+			children
+		})
+	});
+});
+SplitLayoutSidebar.displayName = "SplitLayoutGlass.Sidebar";
+var SplitLayoutSidebarHeader = (0, react.forwardRef)(({ children, className, ...props }, ref) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+	ref,
+	"data-split-sidebar-header": "",
+	className: require_utils.cn("shrink-0 p-4 border-b border-white/10", className),
+	...props,
+	children
+}));
+SplitLayoutSidebarHeader.displayName = "SplitLayoutGlass.SidebarHeader";
+var SplitLayoutSidebarContent = (0, react.forwardRef)(({ children, scrollable = true, className, ...props }, ref) => {
+	if (scrollable) {
+		const { dir, ...divProps } = props;
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollArea, {
+			ref,
+			"data-split-sidebar-content": "",
+			className: require_utils.cn("flex-1 min-h-0", className),
+			...divProps,
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				className: "p-4",
+				children
+			})
+		});
+	}
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		ref,
+		"data-split-sidebar-content": "",
+		className: require_utils.cn("flex-1 min-h-0 overflow-auto p-4", className),
+		...props,
+		children
+	});
+});
+SplitLayoutSidebarContent.displayName = "SplitLayoutGlass.SidebarContent";
+var SplitLayoutSidebarFooter = (0, react.forwardRef)(({ children, className, ...props }, ref) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+	ref,
+	"data-split-sidebar-footer": "",
+	className: require_utils.cn("shrink-0 p-4 border-t border-white/10", className),
+	...props,
+	children
+}));
+SplitLayoutSidebarFooter.displayName = "SplitLayoutGlass.SidebarFooter";
+var SplitLayoutMain = (0, react.forwardRef)(({ children, label = "Main content", className, ...props }, ref) => {
+	const context = useSplitLayoutOptional();
+	const breakpoint = context?.breakpoint ?? "md";
+	const intensity = context?.intensity ?? "medium";
+	const bp = breakpoint;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_trust_score_card_glass.GlassCard, {
+		asChild: true,
+		intensity,
+		padding: "none",
+		className: require_utils.cn("overflow-hidden rounded-xl", `${bp}:sticky`, `${bp}:top-[var(--sticky-offset)]`, `${bp}:max-h-[var(--sticky-max-height)]`, `${bp}:flex`, `${bp}:flex-col`, className),
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("main", {
+			ref,
+			"data-split-main": "",
+			"aria-label": label,
+			...props,
+			children
+		})
+	});
+});
+SplitLayoutMain.displayName = "SplitLayoutGlass.Main";
+var SplitLayoutMainHeader = (0, react.forwardRef)(({ children, className, ...props }, ref) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+	ref,
+	"data-split-main-header": "",
+	className: require_utils.cn("shrink-0 p-6 border-b border-white/10", className),
+	...props,
+	children
+}));
+SplitLayoutMainHeader.displayName = "SplitLayoutGlass.MainHeader";
+var SplitLayoutMainContent = (0, react.forwardRef)(({ children, scrollable = true, className, ...props }, ref) => {
+	if (scrollable) {
+		const { dir, ...divProps } = props;
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ScrollArea, {
+			ref,
+			"data-split-main-content": "",
+			className: require_utils.cn("flex-1 min-h-0", className),
+			...divProps,
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				className: "p-6",
+				children
+			})
+		});
+	}
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		ref,
+		"data-split-main-content": "",
+		className: require_utils.cn("flex-1 min-h-0 overflow-auto p-6", className),
+		...props,
+		children
+	});
+});
+SplitLayoutMainContent.displayName = "SplitLayoutGlass.MainContent";
+var SplitLayoutMainFooter = (0, react.forwardRef)(({ children, className, ...props }, ref) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+	ref,
+	"data-split-main-footer": "",
+	className: require_utils.cn("shrink-0 p-6 border-t border-white/10", className),
+	...props,
+	children
+}));
+SplitLayoutMainFooter.displayName = "SplitLayoutGlass.MainFooter";
+var SplitLayoutTrigger = (0, react.forwardRef)(({ asChild = false, showOnDesktop = false, variant = "menu", className, children, ...props }, ref) => {
+	const { toggle, isOpen, isMobileOpen, isMobile, breakpoint } = useSplitLayout();
+	const currentOpen = isMobile ? isMobileOpen : isOpen;
+	const Icon$1 = variant === "menu" ? currentOpen ? lucide_react.X : lucide_react.Menu : currentOpen ? lucide_react.PanelLeftClose : lucide_react.PanelLeftOpen;
+	const visibilityClass = showOnDesktop ? "" : `${breakpoint}:hidden`;
+	if (asChild) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(__radix_ui_react_slot.Slot, {
+		ref,
+		onClick: toggle,
+		"aria-label": currentOpen ? "Close sidebar" : "Open sidebar",
+		"aria-expanded": currentOpen,
+		"data-state": currentOpen ? "open" : "closed",
+		className: require_utils.cn(visibilityClass, className),
+		...props,
+		children
+	});
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_trust_score_card_glass.ButtonGlass, {
+		ref,
+		variant: "ghost",
+		size: "icon",
+		onClick: toggle,
+		"aria-label": currentOpen ? "Close sidebar" : "Open sidebar",
+		"aria-expanded": currentOpen,
+		"data-state": currentOpen ? "open" : "closed",
+		className: require_utils.cn(visibilityClass, className),
+		...props,
+		children: children ?? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Icon$1, { className: "h-5 w-5" })
+	});
+});
+SplitLayoutTrigger.displayName = "SplitLayoutGlass.Trigger";
+const SplitLayoutGlass = {
+	Provider: SplitLayoutProvider,
+	Root: SplitLayoutRoot,
+	Sidebar: SplitLayoutSidebar,
+	SidebarHeader: SplitLayoutSidebarHeader,
+	SidebarContent: SplitLayoutSidebarContent,
+	SidebarFooter: SplitLayoutSidebarFooter,
+	Main: SplitLayoutMain,
+	MainHeader: SplitLayoutMainHeader,
+	MainContent: SplitLayoutMainContent,
+	MainFooter: SplitLayoutMainFooter,
+	Trigger: SplitLayoutTrigger
+};
 var ChartContext = react.createContext(null);
 function useChart() {
 	const context = react.useContext(ChartContext);
@@ -976,10 +2624,13 @@ exports.RepositoryMetadataGlass = require_trust_score_card_glass.RepositoryMetad
 exports.ResponsiveContainer = require_trust_score_card_glass.ResponsiveContainer;
 exports.SearchBoxGlass = require_trust_score_card_glass.SearchBoxGlass;
 exports.SegmentedControlGlass = require_trust_score_card_glass.SegmentedControlGlass;
+exports.SidebarGlass = SidebarGlass;
 exports.SkeletonGlass = require_trust_score_card_glass.SkeletonGlass;
 exports.SliderGlass = require_trust_score_card_glass.SliderGlass;
 exports.SortDropdownGlass = require_trust_score_card_glass.SortDropdownGlass;
 exports.SparklineGlass = require_trust_score_card_glass.SparklineGlass;
+exports.SplitLayoutAccordion = SplitLayoutAccordion;
+exports.SplitLayoutGlass = SplitLayoutGlass;
 exports.StatItemGlass = require_trust_score_card_glass.StatItemGlass;
 exports.StatusIndicatorGlass = require_trust_score_card_glass.StatusIndicatorGlass;
 exports.StepperGlass = StepperGlass;
@@ -1036,6 +2687,9 @@ exports.useChart = useChart;
 exports.useFocus = require_use_focus.useFocus;
 exports.useHover = require_use_focus.useHover;
 exports.useResponsive = require_use_wallpaper_tint.useResponsive;
+exports.useSidebar = useSidebar;
+exports.useSplitLayout = useSplitLayout;
+exports.useSplitLayoutOptional = useSplitLayoutOptional;
 exports.useTheme = require_theme_context.useTheme;
 exports.useWallpaperTint = require_use_wallpaper_tint.useWallpaperTint;