@dilipod/ui 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var React4 = require('react');
+var React37 = require('react');
 var reactSlot = require('@radix-ui/react-slot');
 var classVarianceAuthority = require('class-variance-authority');
 var clsx = require('clsx');
@@ -8,6 +8,7 @@ var tailwindMerge = require('tailwind-merge');
 var jsxRuntime = require('react/jsx-runtime');
 var SheetPrimitive = require('@radix-ui/react-dialog');
 var react = require('@phosphor-icons/react');
+var ReactDOM2 = require('react-dom');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -27,8 +28,9 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var React4__namespace = /*#__PURE__*/_interopNamespace(React4);
+var React37__namespace = /*#__PURE__*/_interopNamespace(React37);
 var SheetPrimitive__namespace = /*#__PURE__*/_interopNamespace(SheetPrimitive);
+var ReactDOM2__namespace = /*#__PURE__*/_interopNamespace(ReactDOM2);
 
 // src/components/button.tsx
 function cn(...inputs) {
@@ -60,7 +62,7 @@ var buttonVariants = classVarianceAuthority.cva(
     }
   }
 );
-var Button = React4__namespace.forwardRef(
+var Button = React37__namespace.forwardRef(
   ({ className, variant, size, asChild = false, ...props }, ref) => {
     const Comp = asChild ? reactSlot.Slot : "button";
     return /* @__PURE__ */ jsxRuntime.jsx(
@@ -78,16 +80,19 @@ var Sheet = SheetPrimitive__namespace.Root;
 var SheetTrigger = SheetPrimitive__namespace.Trigger;
 var SheetClose = SheetPrimitive__namespace.Close;
 var SheetPortal = SheetPrimitive__namespace.Portal;
-var SheetOverlay = React4__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
-  SheetPrimitive__namespace.Overlay,
-  {
-    className: cn(
-      "fixed inset-0 z-50 bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
-      className
-    ),
-    ...props,
-    ref
-  }
+var SheetOverlay = React37__namespace.forwardRef(({ className, ...props }, ref) => (
+  // @ts-ignore - Radix Dialog Overlay accepts className at runtime
+  /* @__PURE__ */ jsxRuntime.jsx(
+    SheetPrimitive__namespace.Overlay,
+    {
+      className: cn(
+        "fixed inset-0 z-50 bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
+        className
+      ),
+      ...props,
+      ref
+    }
+  )
 ));
 SheetOverlay.displayName = SheetPrimitive__namespace.Overlay.displayName;
 var sheetVariants = classVarianceAuthority.cva(
@@ -106,7 +111,7 @@ var sheetVariants = classVarianceAuthority.cva(
     }
   }
 );
-var SheetContent = React4__namespace.forwardRef(({ side = "right", className, children, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsxs(SheetPortal, { children: [
+var SheetContent = React37__namespace.forwardRef(({ side = "right", className, children, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsxs(SheetPortal, { children: [
   /* @__PURE__ */ jsxRuntime.jsx(SheetOverlay, {}),
   /* @__PURE__ */ jsxRuntime.jsxs(
     SheetPrimitive__namespace.Content,
@@ -153,22 +158,28 @@ var SheetFooter = ({
   }
 );
 SheetFooter.displayName = "SheetFooter";
-var SheetTitle = React4__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
-  SheetPrimitive__namespace.Title,
-  {
-    ref,
-    className: cn("text-lg font-semibold text-[var(--black)]", className),
-    ...props
-  }
+var SheetTitle = React37__namespace.forwardRef(({ className, ...props }, ref) => (
+  // @ts-ignore - Radix Dialog Title accepts className at runtime
+  /* @__PURE__ */ jsxRuntime.jsx(
+    SheetPrimitive__namespace.Title,
+    {
+      ref,
+      className: cn("text-lg font-semibold text-[var(--black)]", className),
+      ...props
+    }
+  )
 ));
 SheetTitle.displayName = SheetPrimitive__namespace.Title.displayName;
-var SheetDescription = React4__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
-  SheetPrimitive__namespace.Description,
-  {
-    ref,
-    className: cn("text-sm text-gray-500", className),
-    ...props
-  }
+var SheetDescription = React37__namespace.forwardRef(({ className, ...props }, ref) => (
+  // @ts-ignore - Radix Dialog Description accepts className at runtime
+  /* @__PURE__ */ jsxRuntime.jsx(
+    SheetPrimitive__namespace.Description,
+    {
+      ref,
+      className: cn("text-sm text-gray-500", className),
+      ...props
+    }
+  )
 ));
 SheetDescription.displayName = SheetPrimitive__namespace.Description.displayName;
 var sizes = {
@@ -179,7 +190,7 @@ var sizes = {
 function Logo({
   variant = "dark",
   size = "md",
-  href,
+  href = "/",
   className
 }) {
   const s = sizes[size];
@@ -230,8 +241,8 @@ function Logo({
       ]
     }
   );
-  if (href) {
-    return /* @__PURE__ */ jsxRuntime.jsx("a", { href, className: "inline-flex items-center group", children: svgContent });
+  if (href !== null) {
+    return /* @__PURE__ */ jsxRuntime.jsx("a", { href, "aria-label": "Go to homepage", className: "inline-flex items-center group", children: svgContent });
   }
   return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "inline-flex items-center", children: svgContent });
 }
@@ -259,7 +270,7 @@ var badgeVariants = classVarianceAuthority.cva(
     }
   }
 );
-var Badge = React4__namespace.forwardRef(
+var Badge = React37__namespace.forwardRef(
   ({ className, variant, size, pulse, pulseColor: pulseColorProp, children, ...props }, ref) => {
     const pulseColorMap = {
       default: "bg-gray-500",
@@ -304,7 +315,7 @@ var Badge = React4__namespace.forwardRef(
   }
 );
 Badge.displayName = "Badge";
-var Card = React4__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+var Card = React37__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
   "div",
   {
     ref,
@@ -316,7 +327,7 @@ var Card = React4__namespace.forwardRef(({ className, ...props }, ref) => /* @__
   }
 ));
 Card.displayName = "Card";
-var CardHeader = React4__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+var CardHeader = React37__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
   "div",
   {
     ref,
@@ -325,7 +336,7 @@ var CardHeader = React4__namespace.forwardRef(({ className, ...props }, ref) =>
   }
 ));
 CardHeader.displayName = "CardHeader";
-var CardTitle = React4__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+var CardTitle = React37__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
   "h3",
   {
     ref,
@@ -337,7 +348,7 @@ var CardTitle = React4__namespace.forwardRef(({ className, ...props }, ref) => /
   }
 ));
 CardTitle.displayName = "CardTitle";
-var CardDescription = React4__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+var CardDescription = React37__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
   "p",
   {
     ref,
@@ -346,9 +357,9 @@ var CardDescription = React4__namespace.forwardRef(({ className, ...props }, ref
   }
 ));
 CardDescription.displayName = "CardDescription";
-var CardContent = React4__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("div", { ref, className: cn("p-6 pt-0", className), ...props }));
+var CardContent = React37__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("div", { ref, className: cn("p-6 pt-0", className), ...props }));
 CardContent.displayName = "CardContent";
-var CardFooter = React4__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+var CardFooter = React37__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
   "div",
   {
     ref,
@@ -371,7 +382,7 @@ var progressVariants = classVarianceAuthority.cva("h-full rounded-full transitio
     variant: "default"
   }
 });
-var Progress = React4__namespace.forwardRef(
+var Progress = React37__namespace.forwardRef(
   ({ className, value, variant, showLabel, label = "Progress", size = "default", ...props }, ref) => {
     const clampedValue = Math.min(100, Math.max(0, value));
     const heightClass = {
@@ -437,7 +448,7 @@ var iconBoxVariants = classVarianceAuthority.cva(
     }
   }
 );
-var IconBox = React4__namespace.forwardRef(
+var IconBox = React37__namespace.forwardRef(
   ({ className, variant, size, rounded, children, ...props }, ref) => {
     return /* @__PURE__ */ jsxRuntime.jsx(
       "div",
@@ -473,7 +484,7 @@ var tagVariants = classVarianceAuthority.cva(
     }
   }
 );
-var Tag = React4__namespace.forwardRef(
+var Tag = React37__namespace.forwardRef(
   ({ className, variant, size, icon, children, ...props }, ref) => {
     return /* @__PURE__ */ jsxRuntime.jsxs(
       "span",
@@ -510,8 +521,8 @@ var statVariants = classVarianceAuthority.cva("", {
 var valueVariants = classVarianceAuthority.cva("font-bold", {
   variants: {
     size: {
-      sm: "text-xl",
-      default: "text-3xl md:text-4xl",
+      sm: "text-lg",
+      default: "text-2xl",
       lg: "text-4xl md:text-5xl",
       xl: "text-5xl md:text-6xl"
     },
@@ -527,7 +538,7 @@ var valueVariants = classVarianceAuthority.cva("font-bold", {
     color: "default"
   }
 });
-var Stat = React4__namespace.forwardRef(
+var Stat = React37__namespace.forwardRef(
   ({
     className,
     variant,
@@ -551,10 +562,10 @@ var Stat = React4__namespace.forwardRef(
         className: cn(statVariants({ variant, align }), className),
         ...props,
         children: [
-          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: cn("flex items-baseline gap-2", justifyClass), children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: cn("flex flex-wrap lg:flex-nowrap items-baseline gap-x-2", justifyClass), children: [
             /* @__PURE__ */ jsxRuntime.jsx("span", { className: cn(valueVariants({ size: valueSize, color: valueColor })), children: value }),
             suffix && /* @__PURE__ */ jsxRuntime.jsx("span", { className: cn(
-              "font-medium text-[var(--cyan)]",
+              "font-medium text-[var(--cyan)] shrink-0",
               valueSize === "lg" || valueSize === "xl" ? "text-lg md:text-xl" : "text-base md:text-lg"
             ), children: suffix })
           ] }),
@@ -568,6 +579,2141 @@ var Stat = React4__namespace.forwardRef(
   }
 );
 Stat.displayName = "Stat";
+var Input = React37__namespace.forwardRef(
+  ({ className, type, ...props }, ref) => {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        type,
+        className: cn(
+          "flex h-10 w-full rounded-md border border-gray-300 bg-white px-3 py-2 text-base text-[var(--black)] ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-[var(--black)] placeholder:text-gray-500 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--cyan)] focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 md:text-sm transition-colors",
+          className
+        ),
+        ref,
+        ...props
+      }
+    );
+  }
+);
+Input.displayName = "Input";
+var NODES = [
+  "a",
+  "button",
+  "div",
+  "form",
+  "h2",
+  "h3",
+  "img",
+  "input",
+  "label",
+  "li",
+  "nav",
+  "ol",
+  "p",
+  "select",
+  "span",
+  "svg",
+  "ul"
+];
+var Primitive = NODES.reduce((primitive, node) => {
+  const Slot2 = reactSlot.createSlot(`Primitive.${node}`);
+  const Node2 = React37__namespace.forwardRef((props, forwardedRef) => {
+    const { asChild, ...primitiveProps } = props;
+    const Comp = asChild ? Slot2 : node;
+    if (typeof window !== "undefined") {
+      window[/* @__PURE__ */ Symbol.for("radix-ui")] = true;
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(Comp, { ...primitiveProps, ref: forwardedRef });
+  });
+  Node2.displayName = `Primitive.${node}`;
+  return { ...primitive, [node]: Node2 };
+}, {});
+var NAME = "Label";
+var Label = React37__namespace.forwardRef((props, forwardedRef) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    Primitive.label,
+    {
+      ...props,
+      ref: forwardedRef,
+      onMouseDown: (event) => {
+        const target = event.target;
+        if (target.closest("button, input, select, textarea")) return;
+        props.onMouseDown?.(event);
+        if (!event.defaultPrevented && event.detail > 1) event.preventDefault();
+      }
+    }
+  );
+});
+Label.displayName = NAME;
+var Root2 = Label;
+var labelVariants = classVarianceAuthority.cva(
+  "text-sm font-medium leading-none text-[var(--black)] peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
+);
+var Label2 = React37__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  Root2,
+  {
+    ref,
+    className: cn(labelVariants(), className),
+    ...props
+  }
+));
+Label2.displayName = Root2.displayName;
+var Textarea = React37__namespace.forwardRef(
+  ({ className, ...props }, ref) => {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "textarea",
+      {
+        className: cn(
+          "flex min-h-[80px] w-full rounded-md border border-gray-300 bg-white px-3 py-2 text-base text-[var(--black)] ring-offset-background placeholder:text-gray-500 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--cyan)] focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 md:text-sm transition-colors",
+          className
+        ),
+        ref,
+        ...props
+      }
+    );
+  }
+);
+Textarea.displayName = "Textarea";
+function createContextScope(scopeName, createContextScopeDeps = []) {
+  let defaultContexts = [];
+  function createContext32(rootComponentName, defaultContext) {
+    const BaseContext = React37__namespace.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 = React37__namespace.useMemo(() => context, Object.values(context));
+      return /* @__PURE__ */ jsxRuntime.jsx(Context.Provider, { value, children });
+    };
+    Provider.displayName = rootComponentName + "Provider";
+    function useContext22(consumerName, scope) {
+      const Context = scope?.[scopeName]?.[index] || BaseContext;
+      const context = React37__namespace.useContext(Context);
+      if (context) return context;
+      if (defaultContext !== void 0) return defaultContext;
+      throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+    }
+    return [Provider, useContext22];
+  }
+  const createScope = () => {
+    const scopeContexts = defaultContexts.map((defaultContext) => {
+      return React37__namespace.createContext(defaultContext);
+    });
+    return function useScope(scope) {
+      const contexts = scope?.[scopeName] || scopeContexts;
+      return React37__namespace.useMemo(
+        () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),
+        [scope, contexts]
+      );
+    };
+  };
+  createScope.scopeName = scopeName;
+  return [createContext32, 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 scopeProps = useScope(overrideScopes);
+        const currentScope = scopeProps[`__scope${scopeName}`];
+        return { ...nextScopes2, ...currentScope };
+      }, {});
+      return React37__namespace.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);
+    };
+  };
+  createScope.scopeName = baseScope.scopeName;
+  return createScope;
+}
+function setRef(ref, value) {
+  if (typeof ref === "function") {
+    return ref(value);
+  } else if (ref !== null && ref !== void 0) {
+    ref.current = value;
+  }
+}
+function composeRefs(...refs) {
+  return (node) => {
+    let hasCleanup = false;
+    const cleanups = refs.map((ref) => {
+      const cleanup = setRef(ref, node);
+      if (!hasCleanup && typeof cleanup == "function") {
+        hasCleanup = true;
+      }
+      return cleanup;
+    });
+    if (hasCleanup) {
+      return () => {
+        for (let i = 0; i < cleanups.length; i++) {
+          const cleanup = cleanups[i];
+          if (typeof cleanup == "function") {
+            cleanup();
+          } else {
+            setRef(refs[i], null);
+          }
+        }
+      };
+    }
+  };
+}
+function useComposedRefs(...refs) {
+  return React37__namespace.useCallback(composeRefs(...refs), refs);
+}
+function createCollection(name) {
+  const PROVIDER_NAME = name + "CollectionProvider";
+  const [createCollectionContext, createCollectionScope3] = createContextScope(PROVIDER_NAME);
+  const [CollectionProviderImpl, useCollectionContext] = createCollectionContext(
+    PROVIDER_NAME,
+    { collectionRef: { current: null }, itemMap: /* @__PURE__ */ new Map() }
+  );
+  const CollectionProvider = (props) => {
+    const { scope, children } = props;
+    const ref = React37__namespace.default.useRef(null);
+    const itemMap = React37__namespace.default.useRef(/* @__PURE__ */ new Map()).current;
+    return /* @__PURE__ */ jsxRuntime.jsx(CollectionProviderImpl, { scope, itemMap, collectionRef: ref, children });
+  };
+  CollectionProvider.displayName = PROVIDER_NAME;
+  const COLLECTION_SLOT_NAME = name + "CollectionSlot";
+  const CollectionSlotImpl = reactSlot.createSlot(COLLECTION_SLOT_NAME);
+  const CollectionSlot = React37__namespace.default.forwardRef(
+    (props, forwardedRef) => {
+      const { scope, children } = props;
+      const context = useCollectionContext(COLLECTION_SLOT_NAME, scope);
+      const composedRefs = useComposedRefs(forwardedRef, context.collectionRef);
+      return /* @__PURE__ */ jsxRuntime.jsx(CollectionSlotImpl, { ref: composedRefs, children });
+    }
+  );
+  CollectionSlot.displayName = COLLECTION_SLOT_NAME;
+  const ITEM_SLOT_NAME = name + "CollectionItemSlot";
+  const ITEM_DATA_ATTR = "data-radix-collection-item";
+  const CollectionItemSlotImpl = reactSlot.createSlot(ITEM_SLOT_NAME);
+  const CollectionItemSlot = React37__namespace.default.forwardRef(
+    (props, forwardedRef) => {
+      const { scope, children, ...itemData } = props;
+      const ref = React37__namespace.default.useRef(null);
+      const composedRefs = useComposedRefs(forwardedRef, ref);
+      const context = useCollectionContext(ITEM_SLOT_NAME, scope);
+      React37__namespace.default.useEffect(() => {
+        context.itemMap.set(ref, { ref, ...itemData });
+        return () => void context.itemMap.delete(ref);
+      });
+      return /* @__PURE__ */ jsxRuntime.jsx(CollectionItemSlotImpl, { ...{ [ITEM_DATA_ATTR]: "" }, ref: composedRefs, children });
+    }
+  );
+  CollectionItemSlot.displayName = ITEM_SLOT_NAME;
+  function useCollection3(scope) {
+    const context = useCollectionContext(name + "CollectionConsumer", scope);
+    const getItems = React37__namespace.default.useCallback(() => {
+      const collectionNode = context.collectionRef.current;
+      if (!collectionNode) return [];
+      const orderedNodes = Array.from(collectionNode.querySelectorAll(`[${ITEM_DATA_ATTR}]`));
+      const items = Array.from(context.itemMap.values());
+      const orderedItems = items.sort(
+        (a, b) => orderedNodes.indexOf(a.ref.current) - orderedNodes.indexOf(b.ref.current)
+      );
+      return orderedItems;
+    }, [context.collectionRef, context.itemMap]);
+    return getItems;
+  }
+  return [
+    { Provider: CollectionProvider, Slot: CollectionSlot, ItemSlot: CollectionItemSlot },
+    useCollection3,
+    createCollectionScope3
+  ];
+}
+function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
+  return function handleEvent(event) {
+    originalEventHandler?.(event);
+    if (checkForDefaultPrevented === false || !event.defaultPrevented) {
+      return ourEventHandler?.(event);
+    }
+  };
+}
+var useLayoutEffect2 = globalThis?.document ? React37__namespace.useLayoutEffect : () => {
+};
+var useInsertionEffect = React37__namespace[" useInsertionEffect ".trim().toString()] || useLayoutEffect2;
+function useControllableState({
+  prop,
+  defaultProp,
+  onChange = () => {
+  },
+  caller
+}) {
+  const [uncontrolledProp, setUncontrolledProp, onChangeRef] = useUncontrolledState({
+    defaultProp,
+    onChange
+  });
+  const isControlled = prop !== void 0;
+  const value = isControlled ? prop : uncontrolledProp;
+  {
+    const isControlledRef = React37__namespace.useRef(prop !== void 0);
+    React37__namespace.useEffect(() => {
+      const wasControlled = isControlledRef.current;
+      if (wasControlled !== isControlled) {
+        const from = wasControlled ? "controlled" : "uncontrolled";
+        const to = isControlled ? "controlled" : "uncontrolled";
+        console.warn(
+          `${caller} is changing from ${from} to ${to}. Components should not switch from controlled to uncontrolled (or vice versa). Decide between using a controlled or uncontrolled value for the lifetime of the component.`
+        );
+      }
+      isControlledRef.current = isControlled;
+    }, [isControlled, caller]);
+  }
+  const setValue = React37__namespace.useCallback(
+    (nextValue) => {
+      if (isControlled) {
+        const value2 = isFunction(nextValue) ? nextValue(prop) : nextValue;
+        if (value2 !== prop) {
+          onChangeRef.current?.(value2);
+        }
+      } else {
+        setUncontrolledProp(nextValue);
+      }
+    },
+    [isControlled, prop, setUncontrolledProp, onChangeRef]
+  );
+  return [value, setValue];
+}
+function useUncontrolledState({
+  defaultProp,
+  onChange
+}) {
+  const [value, setValue] = React37__namespace.useState(defaultProp);
+  const prevValueRef = React37__namespace.useRef(value);
+  const onChangeRef = React37__namespace.useRef(onChange);
+  useInsertionEffect(() => {
+    onChangeRef.current = onChange;
+  }, [onChange]);
+  React37__namespace.useEffect(() => {
+    if (prevValueRef.current !== value) {
+      onChangeRef.current?.(value);
+      prevValueRef.current = value;
+    }
+  }, [value, prevValueRef]);
+  return [value, setValue, onChangeRef];
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+var NODES2 = [
+  "a",
+  "button",
+  "div",
+  "form",
+  "h2",
+  "h3",
+  "img",
+  "input",
+  "label",
+  "li",
+  "nav",
+  "ol",
+  "p",
+  "select",
+  "span",
+  "svg",
+  "ul"
+];
+var Primitive2 = NODES2.reduce((primitive, node) => {
+  const Slot2 = reactSlot.createSlot(`Primitive.${node}`);
+  const Node2 = React37__namespace.forwardRef((props, forwardedRef) => {
+    const { asChild, ...primitiveProps } = props;
+    const Comp = asChild ? Slot2 : node;
+    if (typeof window !== "undefined") {
+      window[/* @__PURE__ */ Symbol.for("radix-ui")] = true;
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(Comp, { ...primitiveProps, ref: forwardedRef });
+  });
+  Node2.displayName = `Primitive.${node}`;
+  return { ...primitive, [node]: Node2 };
+}, {});
+function dispatchDiscreteCustomEvent(target, event) {
+  if (target) ReactDOM2__namespace.flushSync(() => target.dispatchEvent(event));
+}
+function useStateMachine(initialState, machine) {
+  return React37__namespace.useReducer((state, event) => {
+    const nextState = machine[state][event];
+    return nextState ?? state;
+  }, initialState);
+}
+var Presence = (props) => {
+  const { present, children } = props;
+  const presence = usePresence(present);
+  const child = typeof children === "function" ? children({ present: presence.isPresent }) : React37__namespace.Children.only(children);
+  const ref = useComposedRefs(presence.ref, getElementRef(child));
+  const forceMount = typeof children === "function";
+  return forceMount || presence.isPresent ? React37__namespace.cloneElement(child, { ref }) : null;
+};
+Presence.displayName = "Presence";
+function usePresence(present) {
+  const [node, setNode] = React37__namespace.useState();
+  const stylesRef = React37__namespace.useRef(null);
+  const prevPresentRef = React37__namespace.useRef(present);
+  const prevAnimationNameRef = React37__namespace.useRef("none");
+  const initialState = present ? "mounted" : "unmounted";
+  const [state, send] = useStateMachine(initialState, {
+    mounted: {
+      UNMOUNT: "unmounted",
+      ANIMATION_OUT: "unmountSuspended"
+    },
+    unmountSuspended: {
+      MOUNT: "mounted",
+      ANIMATION_END: "unmounted"
+    },
+    unmounted: {
+      MOUNT: "mounted"
+    }
+  });
+  React37__namespace.useEffect(() => {
+    const currentAnimationName = getAnimationName(stylesRef.current);
+    prevAnimationNameRef.current = state === "mounted" ? currentAnimationName : "none";
+  }, [state]);
+  useLayoutEffect2(() => {
+    const styles = stylesRef.current;
+    const wasPresent = prevPresentRef.current;
+    const hasPresentChanged = wasPresent !== present;
+    if (hasPresentChanged) {
+      const prevAnimationName = prevAnimationNameRef.current;
+      const currentAnimationName = getAnimationName(styles);
+      if (present) {
+        send("MOUNT");
+      } else if (currentAnimationName === "none" || styles?.display === "none") {
+        send("UNMOUNT");
+      } else {
+        const isAnimating = prevAnimationName !== currentAnimationName;
+        if (wasPresent && isAnimating) {
+          send("ANIMATION_OUT");
+        } else {
+          send("UNMOUNT");
+        }
+      }
+      prevPresentRef.current = present;
+    }
+  }, [present, send]);
+  useLayoutEffect2(() => {
+    if (node) {
+      let timeoutId;
+      const ownerWindow = node.ownerDocument.defaultView ?? window;
+      const handleAnimationEnd = (event) => {
+        const currentAnimationName = getAnimationName(stylesRef.current);
+        const isCurrentAnimation = currentAnimationName.includes(CSS.escape(event.animationName));
+        if (event.target === node && isCurrentAnimation) {
+          send("ANIMATION_END");
+          if (!prevPresentRef.current) {
+            const currentFillMode = node.style.animationFillMode;
+            node.style.animationFillMode = "forwards";
+            timeoutId = ownerWindow.setTimeout(() => {
+              if (node.style.animationFillMode === "forwards") {
+                node.style.animationFillMode = currentFillMode;
+              }
+            });
+          }
+        }
+      };
+      const handleAnimationStart = (event) => {
+        if (event.target === node) {
+          prevAnimationNameRef.current = getAnimationName(stylesRef.current);
+        }
+      };
+      node.addEventListener("animationstart", handleAnimationStart);
+      node.addEventListener("animationcancel", handleAnimationEnd);
+      node.addEventListener("animationend", handleAnimationEnd);
+      return () => {
+        ownerWindow.clearTimeout(timeoutId);
+        node.removeEventListener("animationstart", handleAnimationStart);
+        node.removeEventListener("animationcancel", handleAnimationEnd);
+        node.removeEventListener("animationend", handleAnimationEnd);
+      };
+    } else {
+      send("ANIMATION_END");
+    }
+  }, [node, send]);
+  return {
+    isPresent: ["mounted", "unmountSuspended"].includes(state),
+    ref: React37__namespace.useCallback((node2) => {
+      stylesRef.current = node2 ? getComputedStyle(node2) : null;
+      setNode(node2);
+    }, [])
+  };
+}
+function getAnimationName(styles) {
+  return styles?.animationName || "none";
+}
+function getElementRef(element) {
+  let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
+  let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+  if (mayWarn) {
+    return element.ref;
+  }
+  getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
+  mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+  if (mayWarn) {
+    return element.props.ref;
+  }
+  return element.props.ref || element.ref;
+}
+var useReactId = React37__namespace[" useId ".trim().toString()] || (() => void 0);
+var count = 0;
+function useId(deterministicId) {
+  const [id, setId] = React37__namespace.useState(useReactId());
+  useLayoutEffect2(() => {
+    setId((reactId) => reactId ?? String(count++));
+  }, [deterministicId]);
+  return deterministicId || (id ? `radix-${id}` : "");
+}
+var COLLAPSIBLE_NAME = "Collapsible";
+var [createCollapsibleContext, createCollapsibleScope] = createContextScope(COLLAPSIBLE_NAME);
+var [CollapsibleProvider, useCollapsibleContext] = createCollapsibleContext(COLLAPSIBLE_NAME);
+var Collapsible = React37__namespace.forwardRef(
+  (props, forwardedRef) => {
+    const {
+      __scopeCollapsible,
+      open: openProp,
+      defaultOpen,
+      disabled,
+      onOpenChange,
+      ...collapsibleProps
+    } = props;
+    const [open, setOpen] = useControllableState({
+      prop: openProp,
+      defaultProp: defaultOpen ?? false,
+      onChange: onOpenChange,
+      caller: COLLAPSIBLE_NAME
+    });
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      CollapsibleProvider,
+      {
+        scope: __scopeCollapsible,
+        disabled,
+        contentId: useId(),
+        open,
+        onOpenToggle: React37__namespace.useCallback(() => setOpen((prevOpen) => !prevOpen), [setOpen]),
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          Primitive2.div,
+          {
+            "data-state": getState(open),
+            "data-disabled": disabled ? "" : void 0,
+            ...collapsibleProps,
+            ref: forwardedRef
+          }
+        )
+      }
+    );
+  }
+);
+Collapsible.displayName = COLLAPSIBLE_NAME;
+var TRIGGER_NAME = "CollapsibleTrigger";
+var CollapsibleTrigger = React37__namespace.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeCollapsible, ...triggerProps } = props;
+    const context = useCollapsibleContext(TRIGGER_NAME, __scopeCollapsible);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      Primitive2.button,
+      {
+        type: "button",
+        "aria-controls": context.contentId,
+        "aria-expanded": context.open || false,
+        "data-state": getState(context.open),
+        "data-disabled": context.disabled ? "" : void 0,
+        disabled: context.disabled,
+        ...triggerProps,
+        ref: forwardedRef,
+        onClick: composeEventHandlers(props.onClick, context.onOpenToggle)
+      }
+    );
+  }
+);
+CollapsibleTrigger.displayName = TRIGGER_NAME;
+var CONTENT_NAME = "CollapsibleContent";
+var CollapsibleContent = React37__namespace.forwardRef(
+  (props, forwardedRef) => {
+    const { forceMount, ...contentProps } = props;
+    const context = useCollapsibleContext(CONTENT_NAME, props.__scopeCollapsible);
+    return /* @__PURE__ */ jsxRuntime.jsx(Presence, { present: forceMount || context.open, children: ({ present }) => /* @__PURE__ */ jsxRuntime.jsx(CollapsibleContentImpl, { ...contentProps, ref: forwardedRef, present }) });
+  }
+);
+CollapsibleContent.displayName = CONTENT_NAME;
+var CollapsibleContentImpl = React37__namespace.forwardRef((props, forwardedRef) => {
+  const { __scopeCollapsible, present, children, ...contentProps } = props;
+  const context = useCollapsibleContext(CONTENT_NAME, __scopeCollapsible);
+  const [isPresent, setIsPresent] = React37__namespace.useState(present);
+  const ref = React37__namespace.useRef(null);
+  const composedRefs = useComposedRefs(forwardedRef, ref);
+  const heightRef = React37__namespace.useRef(0);
+  const height = heightRef.current;
+  const widthRef = React37__namespace.useRef(0);
+  const width = widthRef.current;
+  const isOpen = context.open || isPresent;
+  const isMountAnimationPreventedRef = React37__namespace.useRef(isOpen);
+  const originalStylesRef = React37__namespace.useRef(void 0);
+  React37__namespace.useEffect(() => {
+    const rAF = requestAnimationFrame(() => isMountAnimationPreventedRef.current = false);
+    return () => cancelAnimationFrame(rAF);
+  }, []);
+  useLayoutEffect2(() => {
+    const node = ref.current;
+    if (node) {
+      originalStylesRef.current = originalStylesRef.current || {
+        transitionDuration: node.style.transitionDuration,
+        animationName: node.style.animationName
+      };
+      node.style.transitionDuration = "0s";
+      node.style.animationName = "none";
+      const rect = node.getBoundingClientRect();
+      heightRef.current = rect.height;
+      widthRef.current = rect.width;
+      if (!isMountAnimationPreventedRef.current) {
+        node.style.transitionDuration = originalStylesRef.current.transitionDuration;
+        node.style.animationName = originalStylesRef.current.animationName;
+      }
+      setIsPresent(present);
+    }
+  }, [context.open, present]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    Primitive2.div,
+    {
+      "data-state": getState(context.open),
+      "data-disabled": context.disabled ? "" : void 0,
+      id: context.contentId,
+      hidden: !isOpen,
+      ...contentProps,
+      ref: composedRefs,
+      style: {
+        [`--radix-collapsible-content-height`]: height ? `${height}px` : void 0,
+        [`--radix-collapsible-content-width`]: width ? `${width}px` : void 0,
+        ...props.style
+      },
+      children: isOpen && children
+    }
+  );
+});
+function getState(open) {
+  return open ? "open" : "closed";
+}
+var Root3 = Collapsible;
+var Trigger2 = CollapsibleTrigger;
+var Content2 = CollapsibleContent;
+var DirectionContext = React37__namespace.createContext(void 0);
+function useDirection(localDir) {
+  const globalDir = React37__namespace.useContext(DirectionContext);
+  return localDir || globalDir || "ltr";
+}
+var ACCORDION_NAME = "Accordion";
+var ACCORDION_KEYS = ["Home", "End", "ArrowDown", "ArrowUp", "ArrowLeft", "ArrowRight"];
+var [Collection, useCollection, createCollectionScope] = createCollection(ACCORDION_NAME);
+var [createAccordionContext] = createContextScope(ACCORDION_NAME, [
+  createCollectionScope,
+  createCollapsibleScope
+]);
+var useCollapsibleScope = createCollapsibleScope();
+var Accordion = React37__namespace.default.forwardRef(
+  (props, forwardedRef) => {
+    const { type, ...accordionProps } = props;
+    const singleProps = accordionProps;
+    const multipleProps = accordionProps;
+    return /* @__PURE__ */ jsxRuntime.jsx(Collection.Provider, { scope: props.__scopeAccordion, children: type === "multiple" ? /* @__PURE__ */ jsxRuntime.jsx(AccordionImplMultiple, { ...multipleProps, ref: forwardedRef }) : /* @__PURE__ */ jsxRuntime.jsx(AccordionImplSingle, { ...singleProps, ref: forwardedRef }) });
+  }
+);
+Accordion.displayName = ACCORDION_NAME;
+var [AccordionValueProvider, useAccordionValueContext] = createAccordionContext(ACCORDION_NAME);
+var [AccordionCollapsibleProvider, useAccordionCollapsibleContext] = createAccordionContext(
+  ACCORDION_NAME,
+  { collapsible: false }
+);
+var AccordionImplSingle = React37__namespace.default.forwardRef(
+  (props, forwardedRef) => {
+    const {
+      value: valueProp,
+      defaultValue,
+      onValueChange = () => {
+      },
+      collapsible = false,
+      ...accordionSingleProps
+    } = props;
+    const [value, setValue] = useControllableState({
+      prop: valueProp,
+      defaultProp: defaultValue ?? "",
+      onChange: onValueChange,
+      caller: ACCORDION_NAME
+    });
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      AccordionValueProvider,
+      {
+        scope: props.__scopeAccordion,
+        value: React37__namespace.default.useMemo(() => value ? [value] : [], [value]),
+        onItemOpen: setValue,
+        onItemClose: React37__namespace.default.useCallback(() => collapsible && setValue(""), [collapsible, setValue]),
+        children: /* @__PURE__ */ jsxRuntime.jsx(AccordionCollapsibleProvider, { scope: props.__scopeAccordion, collapsible, children: /* @__PURE__ */ jsxRuntime.jsx(AccordionImpl, { ...accordionSingleProps, ref: forwardedRef }) })
+      }
+    );
+  }
+);
+var AccordionImplMultiple = React37__namespace.default.forwardRef((props, forwardedRef) => {
+  const {
+    value: valueProp,
+    defaultValue,
+    onValueChange = () => {
+    },
+    ...accordionMultipleProps
+  } = props;
+  const [value, setValue] = useControllableState({
+    prop: valueProp,
+    defaultProp: defaultValue ?? [],
+    onChange: onValueChange,
+    caller: ACCORDION_NAME
+  });
+  const handleItemOpen = React37__namespace.default.useCallback(
+    (itemValue) => setValue((prevValue = []) => [...prevValue, itemValue]),
+    [setValue]
+  );
+  const handleItemClose = React37__namespace.default.useCallback(
+    (itemValue) => setValue((prevValue = []) => prevValue.filter((value2) => value2 !== itemValue)),
+    [setValue]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    AccordionValueProvider,
+    {
+      scope: props.__scopeAccordion,
+      value,
+      onItemOpen: handleItemOpen,
+      onItemClose: handleItemClose,
+      children: /* @__PURE__ */ jsxRuntime.jsx(AccordionCollapsibleProvider, { scope: props.__scopeAccordion, collapsible: true, children: /* @__PURE__ */ jsxRuntime.jsx(AccordionImpl, { ...accordionMultipleProps, ref: forwardedRef }) })
+    }
+  );
+});
+var [AccordionImplProvider, useAccordionContext] = createAccordionContext(ACCORDION_NAME);
+var AccordionImpl = React37__namespace.default.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeAccordion, disabled, dir, orientation = "vertical", ...accordionProps } = props;
+    const accordionRef = React37__namespace.default.useRef(null);
+    const composedRefs = useComposedRefs(accordionRef, forwardedRef);
+    const getItems = useCollection(__scopeAccordion);
+    const direction = useDirection(dir);
+    const isDirectionLTR = direction === "ltr";
+    const handleKeyDown = composeEventHandlers(props.onKeyDown, (event) => {
+      if (!ACCORDION_KEYS.includes(event.key)) return;
+      const target = event.target;
+      const triggerCollection = getItems().filter((item) => !item.ref.current?.disabled);
+      const triggerIndex = triggerCollection.findIndex((item) => item.ref.current === target);
+      const triggerCount = triggerCollection.length;
+      if (triggerIndex === -1) return;
+      event.preventDefault();
+      let nextIndex = triggerIndex;
+      const homeIndex = 0;
+      const endIndex = triggerCount - 1;
+      const moveNext = () => {
+        nextIndex = triggerIndex + 1;
+        if (nextIndex > endIndex) {
+          nextIndex = homeIndex;
+        }
+      };
+      const movePrev = () => {
+        nextIndex = triggerIndex - 1;
+        if (nextIndex < homeIndex) {
+          nextIndex = endIndex;
+        }
+      };
+      switch (event.key) {
+        case "Home":
+          nextIndex = homeIndex;
+          break;
+        case "End":
+          nextIndex = endIndex;
+          break;
+        case "ArrowRight":
+          if (orientation === "horizontal") {
+            if (isDirectionLTR) {
+              moveNext();
+            } else {
+              movePrev();
+            }
+          }
+          break;
+        case "ArrowDown":
+          if (orientation === "vertical") {
+            moveNext();
+          }
+          break;
+        case "ArrowLeft":
+          if (orientation === "horizontal") {
+            if (isDirectionLTR) {
+              movePrev();
+            } else {
+              moveNext();
+            }
+          }
+          break;
+        case "ArrowUp":
+          if (orientation === "vertical") {
+            movePrev();
+          }
+          break;
+      }
+      const clampedIndex = nextIndex % triggerCount;
+      triggerCollection[clampedIndex].ref.current?.focus();
+    });
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      AccordionImplProvider,
+      {
+        scope: __scopeAccordion,
+        disabled,
+        direction: dir,
+        orientation,
+        children: /* @__PURE__ */ jsxRuntime.jsx(Collection.Slot, { scope: __scopeAccordion, children: /* @__PURE__ */ jsxRuntime.jsx(
+          Primitive2.div,
+          {
+            ...accordionProps,
+            "data-orientation": orientation,
+            ref: composedRefs,
+            onKeyDown: disabled ? void 0 : handleKeyDown
+          }
+        ) })
+      }
+    );
+  }
+);
+var ITEM_NAME = "AccordionItem";
+var [AccordionItemProvider, useAccordionItemContext] = createAccordionContext(ITEM_NAME);
+var AccordionItem = React37__namespace.default.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeAccordion, value, ...accordionItemProps } = props;
+    const accordionContext = useAccordionContext(ITEM_NAME, __scopeAccordion);
+    const valueContext = useAccordionValueContext(ITEM_NAME, __scopeAccordion);
+    const collapsibleScope = useCollapsibleScope(__scopeAccordion);
+    const triggerId = useId();
+    const open = value && valueContext.value.includes(value) || false;
+    const disabled = accordionContext.disabled || props.disabled;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      AccordionItemProvider,
+      {
+        scope: __scopeAccordion,
+        open,
+        disabled,
+        triggerId,
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          Root3,
+          {
+            "data-orientation": accordionContext.orientation,
+            "data-state": getState2(open),
+            ...collapsibleScope,
+            ...accordionItemProps,
+            ref: forwardedRef,
+            disabled,
+            open,
+            onOpenChange: (open2) => {
+              if (open2) {
+                valueContext.onItemOpen(value);
+              } else {
+                valueContext.onItemClose(value);
+              }
+            }
+          }
+        )
+      }
+    );
+  }
+);
+AccordionItem.displayName = ITEM_NAME;
+var HEADER_NAME = "AccordionHeader";
+var AccordionHeader = React37__namespace.default.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeAccordion, ...headerProps } = props;
+    const accordionContext = useAccordionContext(ACCORDION_NAME, __scopeAccordion);
+    const itemContext = useAccordionItemContext(HEADER_NAME, __scopeAccordion);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      Primitive2.h3,
+      {
+        "data-orientation": accordionContext.orientation,
+        "data-state": getState2(itemContext.open),
+        "data-disabled": itemContext.disabled ? "" : void 0,
+        ...headerProps,
+        ref: forwardedRef
+      }
+    );
+  }
+);
+AccordionHeader.displayName = HEADER_NAME;
+var TRIGGER_NAME2 = "AccordionTrigger";
+var AccordionTrigger = React37__namespace.default.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeAccordion, ...triggerProps } = props;
+    const accordionContext = useAccordionContext(ACCORDION_NAME, __scopeAccordion);
+    const itemContext = useAccordionItemContext(TRIGGER_NAME2, __scopeAccordion);
+    const collapsibleContext = useAccordionCollapsibleContext(TRIGGER_NAME2, __scopeAccordion);
+    const collapsibleScope = useCollapsibleScope(__scopeAccordion);
+    return /* @__PURE__ */ jsxRuntime.jsx(Collection.ItemSlot, { scope: __scopeAccordion, children: /* @__PURE__ */ jsxRuntime.jsx(
+      Trigger2,
+      {
+        "aria-disabled": itemContext.open && !collapsibleContext.collapsible || void 0,
+        "data-orientation": accordionContext.orientation,
+        id: itemContext.triggerId,
+        ...collapsibleScope,
+        ...triggerProps,
+        ref: forwardedRef
+      }
+    ) });
+  }
+);
+AccordionTrigger.displayName = TRIGGER_NAME2;
+var CONTENT_NAME2 = "AccordionContent";
+var AccordionContent = React37__namespace.default.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeAccordion, ...contentProps } = props;
+    const accordionContext = useAccordionContext(ACCORDION_NAME, __scopeAccordion);
+    const itemContext = useAccordionItemContext(CONTENT_NAME2, __scopeAccordion);
+    const collapsibleScope = useCollapsibleScope(__scopeAccordion);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      Content2,
+      {
+        role: "region",
+        "aria-labelledby": itemContext.triggerId,
+        "data-orientation": accordionContext.orientation,
+        ...collapsibleScope,
+        ...contentProps,
+        ref: forwardedRef,
+        style: {
+          ["--radix-accordion-content-height"]: "var(--radix-collapsible-content-height)",
+          ["--radix-accordion-content-width"]: "var(--radix-collapsible-content-width)",
+          ...props.style
+        }
+      }
+    );
+  }
+);
+AccordionContent.displayName = CONTENT_NAME2;
+function getState2(open) {
+  return open ? "open" : "closed";
+}
+var Root22 = Accordion;
+var Item = AccordionItem;
+var Header = AccordionHeader;
+var Trigger22 = AccordionTrigger;
+var Content22 = AccordionContent;
+var Accordion2 = Root22;
+var AccordionItem2 = React37__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  Item,
+  {
+    ref,
+    className: cn("border-b border-gray-200", className),
+    ...props
+  }
+));
+AccordionItem2.displayName = "AccordionItem";
+var AccordionTrigger2 = React37__namespace.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(Header, { className: "flex", children: /* @__PURE__ */ jsxRuntime.jsxs(
+  Trigger22,
+  {
+    ref,
+    className: cn(
+      "flex flex-1 items-center justify-between py-4 font-medium text-[var(--black)] transition-all hover:underline [&[data-state=open]>svg]:rotate-180",
+      className
+    ),
+    ...props,
+    children: [
+      children,
+      /* @__PURE__ */ jsxRuntime.jsx(react.CaretDown, { className: "h-4 w-4 shrink-0 text-gray-500 transition-transform duration-200" })
+    ]
+  }
+) }));
+AccordionTrigger2.displayName = Trigger22.displayName;
+var AccordionContent2 = React37__namespace.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  Content22,
+  {
+    ref,
+    className: "overflow-hidden text-sm transition-all data-[state=closed]:animate-accordion-up data-[state=open]:animate-accordion-down",
+    ...props,
+    children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn("pb-4 pt-0", className), children })
+  }
+));
+AccordionContent2.displayName = Content22.displayName;
+var NODES3 = [
+  "a",
+  "button",
+  "div",
+  "form",
+  "h2",
+  "h3",
+  "img",
+  "input",
+  "label",
+  "li",
+  "nav",
+  "ol",
+  "p",
+  "select",
+  "span",
+  "svg",
+  "ul"
+];
+var Primitive3 = NODES3.reduce((primitive, node) => {
+  const Slot2 = reactSlot.createSlot(`Primitive.${node}`);
+  const Node2 = React37__namespace.forwardRef((props, forwardedRef) => {
+    const { asChild, ...primitiveProps } = props;
+    const Comp = asChild ? Slot2 : node;
+    if (typeof window !== "undefined") {
+      window[/* @__PURE__ */ Symbol.for("radix-ui")] = true;
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(Comp, { ...primitiveProps, ref: forwardedRef });
+  });
+  Node2.displayName = `Primitive.${node}`;
+  return { ...primitive, [node]: Node2 };
+}, {});
+var NAME2 = "Separator";
+var DEFAULT_ORIENTATION = "horizontal";
+var ORIENTATIONS = ["horizontal", "vertical"];
+var Separator = React37__namespace.forwardRef((props, forwardedRef) => {
+  const { decorative, orientation: orientationProp = DEFAULT_ORIENTATION, ...domProps } = props;
+  const orientation = isValidOrientation(orientationProp) ? orientationProp : DEFAULT_ORIENTATION;
+  const ariaOrientation = orientation === "vertical" ? orientation : void 0;
+  const semanticProps = decorative ? { role: "none" } : { "aria-orientation": ariaOrientation, role: "separator" };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    Primitive3.div,
+    {
+      "data-orientation": orientation,
+      ...semanticProps,
+      ...domProps,
+      ref: forwardedRef
+    }
+  );
+});
+Separator.displayName = NAME2;
+function isValidOrientation(orientation) {
+  return ORIENTATIONS.includes(orientation);
+}
+var Root4 = Separator;
+var Separator2 = React37__namespace.forwardRef(
+  ({ className, orientation = "horizontal", decorative = true, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+    Root4,
+    {
+      ref,
+      decorative,
+      orientation,
+      className: cn(
+        "shrink-0 bg-gray-200",
+        orientation === "horizontal" ? "h-[1px] w-full" : "h-full w-[1px]",
+        className
+      ),
+      ...props
+    }
+  )
+);
+Separator2.displayName = Root4.displayName;
+function useCallbackRef(callback) {
+  const callbackRef = React37__namespace.useRef(callback);
+  React37__namespace.useEffect(() => {
+    callbackRef.current = callback;
+  });
+  return React37__namespace.useMemo(() => (...args) => callbackRef.current?.(...args), []);
+}
+function useEscapeKeydown(onEscapeKeyDownProp, ownerDocument = globalThis?.document) {
+  const onEscapeKeyDown = useCallbackRef(onEscapeKeyDownProp);
+  React37__namespace.useEffect(() => {
+    const handleKeyDown = (event) => {
+      if (event.key === "Escape") {
+        onEscapeKeyDown(event);
+      }
+    };
+    ownerDocument.addEventListener("keydown", handleKeyDown, { capture: true });
+    return () => ownerDocument.removeEventListener("keydown", handleKeyDown, { capture: true });
+  }, [onEscapeKeyDown, ownerDocument]);
+}
+var DISMISSABLE_LAYER_NAME = "DismissableLayer";
+var CONTEXT_UPDATE = "dismissableLayer.update";
+var POINTER_DOWN_OUTSIDE = "dismissableLayer.pointerDownOutside";
+var FOCUS_OUTSIDE = "dismissableLayer.focusOutside";
+var originalBodyPointerEvents;
+var DismissableLayerContext = React37__namespace.createContext({
+  layers: /* @__PURE__ */ new Set(),
+  layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
+  branches: /* @__PURE__ */ new Set()
+});
+var DismissableLayer = React37__namespace.forwardRef(
+  (props, forwardedRef) => {
+    const {
+      disableOutsidePointerEvents = false,
+      onEscapeKeyDown,
+      onPointerDownOutside,
+      onFocusOutside,
+      onInteractOutside,
+      onDismiss,
+      ...layerProps
+    } = props;
+    const context = React37__namespace.useContext(DismissableLayerContext);
+    const [node, setNode] = React37__namespace.useState(null);
+    const ownerDocument = node?.ownerDocument ?? globalThis?.document;
+    const [, force] = React37__namespace.useState({});
+    const composedRefs = useComposedRefs(forwardedRef, (node2) => setNode(node2));
+    const layers = Array.from(context.layers);
+    const [highestLayerWithOutsidePointerEventsDisabled] = [...context.layersWithOutsidePointerEventsDisabled].slice(-1);
+    const highestLayerWithOutsidePointerEventsDisabledIndex = layers.indexOf(highestLayerWithOutsidePointerEventsDisabled);
+    const index = node ? layers.indexOf(node) : -1;
+    const isBodyPointerEventsDisabled = context.layersWithOutsidePointerEventsDisabled.size > 0;
+    const isPointerEventsEnabled = index >= highestLayerWithOutsidePointerEventsDisabledIndex;
+    const pointerDownOutside = usePointerDownOutside((event) => {
+      const target = event.target;
+      const isPointerDownOnBranch = [...context.branches].some((branch) => branch.contains(target));
+      if (!isPointerEventsEnabled || isPointerDownOnBranch) return;
+      onPointerDownOutside?.(event);
+      onInteractOutside?.(event);
+      if (!event.defaultPrevented) onDismiss?.();
+    }, ownerDocument);
+    const focusOutside = useFocusOutside((event) => {
+      const target = event.target;
+      const isFocusInBranch = [...context.branches].some((branch) => branch.contains(target));
+      if (isFocusInBranch) return;
+      onFocusOutside?.(event);
+      onInteractOutside?.(event);
+      if (!event.defaultPrevented) onDismiss?.();
+    }, ownerDocument);
+    useEscapeKeydown((event) => {
+      const isHighestLayer = index === context.layers.size - 1;
+      if (!isHighestLayer) return;
+      onEscapeKeyDown?.(event);
+      if (!event.defaultPrevented && onDismiss) {
+        event.preventDefault();
+        onDismiss();
+      }
+    }, ownerDocument);
+    React37__namespace.useEffect(() => {
+      if (!node) return;
+      if (disableOutsidePointerEvents) {
+        if (context.layersWithOutsidePointerEventsDisabled.size === 0) {
+          originalBodyPointerEvents = ownerDocument.body.style.pointerEvents;
+          ownerDocument.body.style.pointerEvents = "none";
+        }
+        context.layersWithOutsidePointerEventsDisabled.add(node);
+      }
+      context.layers.add(node);
+      dispatchUpdate();
+      return () => {
+        if (disableOutsidePointerEvents && context.layersWithOutsidePointerEventsDisabled.size === 1) {
+          ownerDocument.body.style.pointerEvents = originalBodyPointerEvents;
+        }
+      };
+    }, [node, ownerDocument, disableOutsidePointerEvents, context]);
+    React37__namespace.useEffect(() => {
+      return () => {
+        if (!node) return;
+        context.layers.delete(node);
+        context.layersWithOutsidePointerEventsDisabled.delete(node);
+        dispatchUpdate();
+      };
+    }, [node, context]);
+    React37__namespace.useEffect(() => {
+      const handleUpdate = () => force({});
+      document.addEventListener(CONTEXT_UPDATE, handleUpdate);
+      return () => document.removeEventListener(CONTEXT_UPDATE, handleUpdate);
+    }, []);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      Primitive2.div,
+      {
+        ...layerProps,
+        ref: composedRefs,
+        style: {
+          pointerEvents: isBodyPointerEventsDisabled ? isPointerEventsEnabled ? "auto" : "none" : void 0,
+          ...props.style
+        },
+        onFocusCapture: composeEventHandlers(props.onFocusCapture, focusOutside.onFocusCapture),
+        onBlurCapture: composeEventHandlers(props.onBlurCapture, focusOutside.onBlurCapture),
+        onPointerDownCapture: composeEventHandlers(
+          props.onPointerDownCapture,
+          pointerDownOutside.onPointerDownCapture
+        )
+      }
+    );
+  }
+);
+DismissableLayer.displayName = DISMISSABLE_LAYER_NAME;
+var BRANCH_NAME = "DismissableLayerBranch";
+var DismissableLayerBranch = React37__namespace.forwardRef((props, forwardedRef) => {
+  const context = React37__namespace.useContext(DismissableLayerContext);
+  const ref = React37__namespace.useRef(null);
+  const composedRefs = useComposedRefs(forwardedRef, ref);
+  React37__namespace.useEffect(() => {
+    const node = ref.current;
+    if (node) {
+      context.branches.add(node);
+      return () => {
+        context.branches.delete(node);
+      };
+    }
+  }, [context.branches]);
+  return /* @__PURE__ */ jsxRuntime.jsx(Primitive2.div, { ...props, ref: composedRefs });
+});
+DismissableLayerBranch.displayName = BRANCH_NAME;
+function usePointerDownOutside(onPointerDownOutside, ownerDocument = globalThis?.document) {
+  const handlePointerDownOutside = useCallbackRef(onPointerDownOutside);
+  const isPointerInsideReactTreeRef = React37__namespace.useRef(false);
+  const handleClickRef = React37__namespace.useRef(() => {
+  });
+  React37__namespace.useEffect(() => {
+    const handlePointerDown = (event) => {
+      if (event.target && !isPointerInsideReactTreeRef.current) {
+        let handleAndDispatchPointerDownOutsideEvent2 = function() {
+          handleAndDispatchCustomEvent(
+            POINTER_DOWN_OUTSIDE,
+            handlePointerDownOutside,
+            eventDetail,
+            { discrete: true }
+          );
+        };
+        const eventDetail = { originalEvent: event };
+        if (event.pointerType === "touch") {
+          ownerDocument.removeEventListener("click", handleClickRef.current);
+          handleClickRef.current = handleAndDispatchPointerDownOutsideEvent2;
+          ownerDocument.addEventListener("click", handleClickRef.current, { once: true });
+        } else {
+          handleAndDispatchPointerDownOutsideEvent2();
+        }
+      } else {
+        ownerDocument.removeEventListener("click", handleClickRef.current);
+      }
+      isPointerInsideReactTreeRef.current = false;
+    };
+    const timerId = window.setTimeout(() => {
+      ownerDocument.addEventListener("pointerdown", handlePointerDown);
+    }, 0);
+    return () => {
+      window.clearTimeout(timerId);
+      ownerDocument.removeEventListener("pointerdown", handlePointerDown);
+      ownerDocument.removeEventListener("click", handleClickRef.current);
+    };
+  }, [ownerDocument, handlePointerDownOutside]);
+  return {
+    // ensures we check React component tree (not just DOM tree)
+    onPointerDownCapture: () => isPointerInsideReactTreeRef.current = true
+  };
+}
+function useFocusOutside(onFocusOutside, ownerDocument = globalThis?.document) {
+  const handleFocusOutside = useCallbackRef(onFocusOutside);
+  const isFocusInsideReactTreeRef = React37__namespace.useRef(false);
+  React37__namespace.useEffect(() => {
+    const handleFocus = (event) => {
+      if (event.target && !isFocusInsideReactTreeRef.current) {
+        const eventDetail = { originalEvent: event };
+        handleAndDispatchCustomEvent(FOCUS_OUTSIDE, handleFocusOutside, eventDetail, {
+          discrete: false
+        });
+      }
+    };
+    ownerDocument.addEventListener("focusin", handleFocus);
+    return () => ownerDocument.removeEventListener("focusin", handleFocus);
+  }, [ownerDocument, handleFocusOutside]);
+  return {
+    onFocusCapture: () => isFocusInsideReactTreeRef.current = true,
+    onBlurCapture: () => isFocusInsideReactTreeRef.current = false
+  };
+}
+function dispatchUpdate() {
+  const event = new CustomEvent(CONTEXT_UPDATE);
+  document.dispatchEvent(event);
+}
+function handleAndDispatchCustomEvent(name, handler, detail, { discrete }) {
+  const target = detail.originalEvent.target;
+  const event = new CustomEvent(name, { bubbles: false, cancelable: true, detail });
+  if (handler) target.addEventListener(name, handler, { once: true });
+  if (discrete) {
+    dispatchDiscreteCustomEvent(target, event);
+  } else {
+    target.dispatchEvent(event);
+  }
+}
+function usePrevious(value) {
+  const ref = React37__namespace.useRef({ value, previous: value });
+  return React37__namespace.useMemo(() => {
+    if (ref.current.value !== value) {
+      ref.current.previous = ref.current.value;
+      ref.current.value = value;
+    }
+    return ref.current.previous;
+  }, [value]);
+}
+var VISUALLY_HIDDEN_STYLES = Object.freeze({
+  // See: https://github.com/twbs/bootstrap/blob/main/scss/mixins/_visually-hidden.scss
+  position: "absolute",
+  border: 0,
+  width: 1,
+  height: 1,
+  padding: 0,
+  margin: -1,
+  overflow: "hidden",
+  clip: "rect(0, 0, 0, 0)",
+  whiteSpace: "nowrap",
+  wordWrap: "normal"
+});
+var NAME3 = "VisuallyHidden";
+var VisuallyHidden = React37__namespace.forwardRef(
+  (props, forwardedRef) => {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      Primitive2.span,
+      {
+        ...props,
+        ref: forwardedRef,
+        style: { ...VISUALLY_HIDDEN_STYLES, ...props.style }
+      }
+    );
+  }
+);
+VisuallyHidden.displayName = NAME3;
+var Root5 = VisuallyHidden;
+var NAVIGATION_MENU_NAME = "NavigationMenu";
+var [Collection2, useCollection2, createCollectionScope2] = createCollection(NAVIGATION_MENU_NAME);
+var [FocusGroupCollection, useFocusGroupCollection, createFocusGroupCollectionScope] = createCollection(NAVIGATION_MENU_NAME);
+var [createNavigationMenuContext] = createContextScope(
+  NAVIGATION_MENU_NAME,
+  [createCollectionScope2, createFocusGroupCollectionScope]
+);
+var [NavigationMenuProviderImpl, useNavigationMenuContext] = createNavigationMenuContext(NAVIGATION_MENU_NAME);
+var [ViewportContentProvider, useViewportContentContext] = createNavigationMenuContext(NAVIGATION_MENU_NAME);
+var NavigationMenu = React37__namespace.forwardRef(
+  (props, forwardedRef) => {
+    const {
+      __scopeNavigationMenu,
+      value: valueProp,
+      onValueChange,
+      defaultValue,
+      delayDuration = 200,
+      skipDelayDuration = 300,
+      orientation = "horizontal",
+      dir,
+      ...NavigationMenuProps
+    } = props;
+    const [navigationMenu, setNavigationMenu] = React37__namespace.useState(null);
+    const composedRef = useComposedRefs(forwardedRef, (node) => setNavigationMenu(node));
+    const direction = useDirection(dir);
+    const openTimerRef = React37__namespace.useRef(0);
+    const closeTimerRef = React37__namespace.useRef(0);
+    const skipDelayTimerRef = React37__namespace.useRef(0);
+    const [isOpenDelayed, setIsOpenDelayed] = React37__namespace.useState(true);
+    const [value, setValue] = useControllableState({
+      prop: valueProp,
+      onChange: (value2) => {
+        const isOpen = value2 !== "";
+        const hasSkipDelayDuration = skipDelayDuration > 0;
+        if (isOpen) {
+          window.clearTimeout(skipDelayTimerRef.current);
+          if (hasSkipDelayDuration) setIsOpenDelayed(false);
+        } else {
+          window.clearTimeout(skipDelayTimerRef.current);
+          skipDelayTimerRef.current = window.setTimeout(
+            () => setIsOpenDelayed(true),
+            skipDelayDuration
+          );
+        }
+        onValueChange?.(value2);
+      },
+      defaultProp: defaultValue ?? "",
+      caller: NAVIGATION_MENU_NAME
+    });
+    const startCloseTimer = React37__namespace.useCallback(() => {
+      window.clearTimeout(closeTimerRef.current);
+      closeTimerRef.current = window.setTimeout(() => setValue(""), 150);
+    }, [setValue]);
+    const handleOpen = React37__namespace.useCallback(
+      (itemValue) => {
+        window.clearTimeout(closeTimerRef.current);
+        setValue(itemValue);
+      },
+      [setValue]
+    );
+    const handleDelayedOpen = React37__namespace.useCallback(
+      (itemValue) => {
+        const isOpenItem = value === itemValue;
+        if (isOpenItem) {
+          window.clearTimeout(closeTimerRef.current);
+        } else {
+          openTimerRef.current = window.setTimeout(() => {
+            window.clearTimeout(closeTimerRef.current);
+            setValue(itemValue);
+          }, delayDuration);
+        }
+      },
+      [value, setValue, delayDuration]
+    );
+    React37__namespace.useEffect(() => {
+      return () => {
+        window.clearTimeout(openTimerRef.current);
+        window.clearTimeout(closeTimerRef.current);
+        window.clearTimeout(skipDelayTimerRef.current);
+      };
+    }, []);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      NavigationMenuProvider,
+      {
+        scope: __scopeNavigationMenu,
+        isRootMenu: true,
+        value,
+        dir: direction,
+        orientation,
+        rootNavigationMenu: navigationMenu,
+        onTriggerEnter: (itemValue) => {
+          window.clearTimeout(openTimerRef.current);
+          if (isOpenDelayed) handleDelayedOpen(itemValue);
+          else handleOpen(itemValue);
+        },
+        onTriggerLeave: () => {
+          window.clearTimeout(openTimerRef.current);
+          startCloseTimer();
+        },
+        onContentEnter: () => window.clearTimeout(closeTimerRef.current),
+        onContentLeave: startCloseTimer,
+        onItemSelect: (itemValue) => {
+          setValue((prevValue) => prevValue === itemValue ? "" : itemValue);
+        },
+        onItemDismiss: () => setValue(""),
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          Primitive2.nav,
+          {
+            "aria-label": "Main",
+            "data-orientation": orientation,
+            dir: direction,
+            ...NavigationMenuProps,
+            ref: composedRef
+          }
+        )
+      }
+    );
+  }
+);
+NavigationMenu.displayName = NAVIGATION_MENU_NAME;
+var SUB_NAME = "NavigationMenuSub";
+var NavigationMenuSub = React37__namespace.forwardRef(
+  (props, forwardedRef) => {
+    const {
+      __scopeNavigationMenu,
+      value: valueProp,
+      onValueChange,
+      defaultValue,
+      orientation = "horizontal",
+      ...subProps
+    } = props;
+    const context = useNavigationMenuContext(SUB_NAME, __scopeNavigationMenu);
+    const [value, setValue] = useControllableState({
+      prop: valueProp,
+      onChange: onValueChange,
+      defaultProp: defaultValue ?? "",
+      caller: SUB_NAME
+    });
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      NavigationMenuProvider,
+      {
+        scope: __scopeNavigationMenu,
+        isRootMenu: false,
+        value,
+        dir: context.dir,
+        orientation,
+        rootNavigationMenu: context.rootNavigationMenu,
+        onTriggerEnter: (itemValue) => setValue(itemValue),
+        onItemSelect: (itemValue) => setValue(itemValue),
+        onItemDismiss: () => setValue(""),
+        children: /* @__PURE__ */ jsxRuntime.jsx(Primitive2.div, { "data-orientation": orientation, ...subProps, ref: forwardedRef })
+      }
+    );
+  }
+);
+NavigationMenuSub.displayName = SUB_NAME;
+var NavigationMenuProvider = (props) => {
+  const {
+    scope,
+    isRootMenu,
+    rootNavigationMenu,
+    dir,
+    orientation,
+    children,
+    value,
+    onItemSelect,
+    onItemDismiss,
+    onTriggerEnter,
+    onTriggerLeave,
+    onContentEnter,
+    onContentLeave
+  } = props;
+  const [viewport, setViewport] = React37__namespace.useState(null);
+  const [viewportContent, setViewportContent] = React37__namespace.useState(/* @__PURE__ */ new Map());
+  const [indicatorTrack, setIndicatorTrack] = React37__namespace.useState(null);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    NavigationMenuProviderImpl,
+    {
+      scope,
+      isRootMenu,
+      rootNavigationMenu,
+      value,
+      previousValue: usePrevious(value),
+      baseId: useId(),
+      dir,
+      orientation,
+      viewport,
+      onViewportChange: setViewport,
+      indicatorTrack,
+      onIndicatorTrackChange: setIndicatorTrack,
+      onTriggerEnter: useCallbackRef(onTriggerEnter),
+      onTriggerLeave: useCallbackRef(onTriggerLeave),
+      onContentEnter: useCallbackRef(onContentEnter),
+      onContentLeave: useCallbackRef(onContentLeave),
+      onItemSelect: useCallbackRef(onItemSelect),
+      onItemDismiss: useCallbackRef(onItemDismiss),
+      onViewportContentChange: React37__namespace.useCallback((contentValue, contentData) => {
+        setViewportContent((prevContent) => {
+          prevContent.set(contentValue, contentData);
+          return new Map(prevContent);
+        });
+      }, []),
+      onViewportContentRemove: React37__namespace.useCallback((contentValue) => {
+        setViewportContent((prevContent) => {
+          if (!prevContent.has(contentValue)) return prevContent;
+          prevContent.delete(contentValue);
+          return new Map(prevContent);
+        });
+      }, []),
+      children: /* @__PURE__ */ jsxRuntime.jsx(Collection2.Provider, { scope, children: /* @__PURE__ */ jsxRuntime.jsx(ViewportContentProvider, { scope, items: viewportContent, children }) })
+    }
+  );
+};
+var LIST_NAME = "NavigationMenuList";
+var NavigationMenuList = React37__namespace.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeNavigationMenu, ...listProps } = props;
+    const context = useNavigationMenuContext(LIST_NAME, __scopeNavigationMenu);
+    const list = /* @__PURE__ */ jsxRuntime.jsx(Primitive2.ul, { "data-orientation": context.orientation, ...listProps, ref: forwardedRef });
+    return /* @__PURE__ */ jsxRuntime.jsx(Primitive2.div, { style: { position: "relative" }, ref: context.onIndicatorTrackChange, children: /* @__PURE__ */ jsxRuntime.jsx(Collection2.Slot, { scope: __scopeNavigationMenu, children: context.isRootMenu ? /* @__PURE__ */ jsxRuntime.jsx(FocusGroup, { asChild: true, children: list }) : list }) });
+  }
+);
+NavigationMenuList.displayName = LIST_NAME;
+var ITEM_NAME2 = "NavigationMenuItem";
+var [NavigationMenuItemContextProvider, useNavigationMenuItemContext] = createNavigationMenuContext(ITEM_NAME2);
+var NavigationMenuItem = React37__namespace.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeNavigationMenu, value: valueProp, ...itemProps } = props;
+    const autoValue = useId();
+    const value = valueProp || autoValue || "LEGACY_REACT_AUTO_VALUE";
+    const contentRef = React37__namespace.useRef(null);
+    const triggerRef = React37__namespace.useRef(null);
+    const focusProxyRef = React37__namespace.useRef(null);
+    const restoreContentTabOrderRef = React37__namespace.useRef(() => {
+    });
+    const wasEscapeCloseRef = React37__namespace.useRef(false);
+    const handleContentEntry = React37__namespace.useCallback((side = "start") => {
+      if (contentRef.current) {
+        restoreContentTabOrderRef.current();
+        const candidates = getTabbableCandidates(contentRef.current);
+        if (candidates.length) focusFirst(side === "start" ? candidates : candidates.reverse());
+      }
+    }, []);
+    const handleContentExit = React37__namespace.useCallback(() => {
+      if (contentRef.current) {
+        const candidates = getTabbableCandidates(contentRef.current);
+        if (candidates.length) restoreContentTabOrderRef.current = removeFromTabOrder(candidates);
+      }
+    }, []);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      NavigationMenuItemContextProvider,
+      {
+        scope: __scopeNavigationMenu,
+        value,
+        triggerRef,
+        contentRef,
+        focusProxyRef,
+        wasEscapeCloseRef,
+        onEntryKeyDown: handleContentEntry,
+        onFocusProxyEnter: handleContentEntry,
+        onRootContentClose: handleContentExit,
+        onContentFocusOutside: handleContentExit,
+        children: /* @__PURE__ */ jsxRuntime.jsx(Primitive2.li, { ...itemProps, ref: forwardedRef })
+      }
+    );
+  }
+);
+NavigationMenuItem.displayName = ITEM_NAME2;
+var TRIGGER_NAME3 = "NavigationMenuTrigger";
+var NavigationMenuTrigger = React37__namespace.forwardRef((props, forwardedRef) => {
+  const { __scopeNavigationMenu, disabled, ...triggerProps } = props;
+  const context = useNavigationMenuContext(TRIGGER_NAME3, props.__scopeNavigationMenu);
+  const itemContext = useNavigationMenuItemContext(TRIGGER_NAME3, props.__scopeNavigationMenu);
+  const ref = React37__namespace.useRef(null);
+  const composedRefs = useComposedRefs(ref, itemContext.triggerRef, forwardedRef);
+  const triggerId = makeTriggerId(context.baseId, itemContext.value);
+  const contentId = makeContentId(context.baseId, itemContext.value);
+  const hasPointerMoveOpenedRef = React37__namespace.useRef(false);
+  const wasClickCloseRef = React37__namespace.useRef(false);
+  const open = itemContext.value === context.value;
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(Collection2.ItemSlot, { scope: __scopeNavigationMenu, value: itemContext.value, children: /* @__PURE__ */ jsxRuntime.jsx(FocusGroupItem, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(
+      Primitive2.button,
+      {
+        id: triggerId,
+        disabled,
+        "data-disabled": disabled ? "" : void 0,
+        "data-state": getOpenState(open),
+        "aria-expanded": open,
+        "aria-controls": contentId,
+        ...triggerProps,
+        ref: composedRefs,
+        onPointerEnter: composeEventHandlers(props.onPointerEnter, () => {
+          wasClickCloseRef.current = false;
+          itemContext.wasEscapeCloseRef.current = false;
+        }),
+        onPointerMove: composeEventHandlers(
+          props.onPointerMove,
+          whenMouse(() => {
+            if (disabled || wasClickCloseRef.current || itemContext.wasEscapeCloseRef.current || hasPointerMoveOpenedRef.current)
+              return;
+            context.onTriggerEnter(itemContext.value);
+            hasPointerMoveOpenedRef.current = true;
+          })
+        ),
+        onPointerLeave: composeEventHandlers(
+          props.onPointerLeave,
+          whenMouse(() => {
+            if (disabled) return;
+            context.onTriggerLeave();
+            hasPointerMoveOpenedRef.current = false;
+          })
+        ),
+        onClick: composeEventHandlers(props.onClick, () => {
+          context.onItemSelect(itemContext.value);
+          wasClickCloseRef.current = open;
+        }),
+        onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {
+          const verticalEntryKey = context.dir === "rtl" ? "ArrowLeft" : "ArrowRight";
+          const entryKey = { horizontal: "ArrowDown", vertical: verticalEntryKey }[context.orientation];
+          if (open && event.key === entryKey) {
+            itemContext.onEntryKeyDown();
+            event.preventDefault();
+          }
+        })
+      }
+    ) }) }),
+    open && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        Root5,
+        {
+          "aria-hidden": true,
+          tabIndex: 0,
+          ref: itemContext.focusProxyRef,
+          onFocus: (event) => {
+            const content = itemContext.contentRef.current;
+            const prevFocusedElement = event.relatedTarget;
+            const wasTriggerFocused = prevFocusedElement === ref.current;
+            const wasFocusFromContent = content?.contains(prevFocusedElement);
+            if (wasTriggerFocused || !wasFocusFromContent) {
+              itemContext.onFocusProxyEnter(wasTriggerFocused ? "start" : "end");
+            }
+          }
+        }
+      ),
+      context.viewport && /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-owns": contentId })
+    ] })
+  ] });
+});
+NavigationMenuTrigger.displayName = TRIGGER_NAME3;
+var LINK_NAME = "NavigationMenuLink";
+var LINK_SELECT = "navigationMenu.linkSelect";
+var NavigationMenuLink = React37__namespace.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeNavigationMenu, active, onSelect, ...linkProps } = props;
+    return /* @__PURE__ */ jsxRuntime.jsx(FocusGroupItem, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(
+      Primitive2.a,
+      {
+        "data-active": active ? "" : void 0,
+        "aria-current": active ? "page" : void 0,
+        ...linkProps,
+        ref: forwardedRef,
+        onClick: composeEventHandlers(
+          props.onClick,
+          (event) => {
+            const target = event.target;
+            const linkSelectEvent = new CustomEvent(LINK_SELECT, {
+              bubbles: true,
+              cancelable: true
+            });
+            target.addEventListener(LINK_SELECT, (event2) => onSelect?.(event2), { once: true });
+            dispatchDiscreteCustomEvent(target, linkSelectEvent);
+            if (!linkSelectEvent.defaultPrevented && !event.metaKey) {
+              const rootContentDismissEvent = new CustomEvent(ROOT_CONTENT_DISMISS, {
+                bubbles: true,
+                cancelable: true
+              });
+              dispatchDiscreteCustomEvent(target, rootContentDismissEvent);
+            }
+          },
+          { checkForDefaultPrevented: false }
+        )
+      }
+    ) });
+  }
+);
+NavigationMenuLink.displayName = LINK_NAME;
+var INDICATOR_NAME = "NavigationMenuIndicator";
+var NavigationMenuIndicator = React37__namespace.forwardRef((props, forwardedRef) => {
+  const { forceMount, ...indicatorProps } = props;
+  const context = useNavigationMenuContext(INDICATOR_NAME, props.__scopeNavigationMenu);
+  const isVisible = Boolean(context.value);
+  return context.indicatorTrack ? ReactDOM2__namespace.default.createPortal(
+    /* @__PURE__ */ jsxRuntime.jsx(Presence, { present: forceMount || isVisible, children: /* @__PURE__ */ jsxRuntime.jsx(NavigationMenuIndicatorImpl, { ...indicatorProps, ref: forwardedRef }) }),
+    context.indicatorTrack
+  ) : null;
+});
+NavigationMenuIndicator.displayName = INDICATOR_NAME;
+var NavigationMenuIndicatorImpl = React37__namespace.forwardRef((props, forwardedRef) => {
+  const { __scopeNavigationMenu, ...indicatorProps } = props;
+  const context = useNavigationMenuContext(INDICATOR_NAME, __scopeNavigationMenu);
+  const getItems = useCollection2(__scopeNavigationMenu);
+  const [activeTrigger, setActiveTrigger] = React37__namespace.useState(
+    null
+  );
+  const [position, setPosition] = React37__namespace.useState(null);
+  const isHorizontal = context.orientation === "horizontal";
+  const isVisible = Boolean(context.value);
+  React37__namespace.useEffect(() => {
+    const items = getItems();
+    const triggerNode = items.find((item) => item.value === context.value)?.ref.current;
+    if (triggerNode) setActiveTrigger(triggerNode);
+  }, [getItems, context.value]);
+  const handlePositionChange = () => {
+    if (activeTrigger) {
+      setPosition({
+        size: isHorizontal ? activeTrigger.offsetWidth : activeTrigger.offsetHeight,
+        offset: isHorizontal ? activeTrigger.offsetLeft : activeTrigger.offsetTop
+      });
+    }
+  };
+  useResizeObserver(activeTrigger, handlePositionChange);
+  useResizeObserver(context.indicatorTrack, handlePositionChange);
+  return position ? /* @__PURE__ */ jsxRuntime.jsx(
+    Primitive2.div,
+    {
+      "aria-hidden": true,
+      "data-state": isVisible ? "visible" : "hidden",
+      "data-orientation": context.orientation,
+      ...indicatorProps,
+      ref: forwardedRef,
+      style: {
+        position: "absolute",
+        ...isHorizontal ? {
+          left: 0,
+          width: position.size + "px",
+          transform: `translateX(${position.offset}px)`
+        } : {
+          top: 0,
+          height: position.size + "px",
+          transform: `translateY(${position.offset}px)`
+        },
+        ...indicatorProps.style
+      }
+    }
+  ) : null;
+});
+var CONTENT_NAME3 = "NavigationMenuContent";
+var NavigationMenuContent = React37__namespace.forwardRef((props, forwardedRef) => {
+  const { forceMount, ...contentProps } = props;
+  const context = useNavigationMenuContext(CONTENT_NAME3, props.__scopeNavigationMenu);
+  const itemContext = useNavigationMenuItemContext(CONTENT_NAME3, props.__scopeNavigationMenu);
+  const composedRefs = useComposedRefs(itemContext.contentRef, forwardedRef);
+  const open = itemContext.value === context.value;
+  const commonProps = {
+    value: itemContext.value,
+    triggerRef: itemContext.triggerRef,
+    focusProxyRef: itemContext.focusProxyRef,
+    wasEscapeCloseRef: itemContext.wasEscapeCloseRef,
+    onContentFocusOutside: itemContext.onContentFocusOutside,
+    onRootContentClose: itemContext.onRootContentClose,
+    ...contentProps
+  };
+  return !context.viewport ? /* @__PURE__ */ jsxRuntime.jsx(Presence, { present: forceMount || open, children: /* @__PURE__ */ jsxRuntime.jsx(
+    NavigationMenuContentImpl,
+    {
+      "data-state": getOpenState(open),
+      ...commonProps,
+      ref: composedRefs,
+      onPointerEnter: composeEventHandlers(props.onPointerEnter, context.onContentEnter),
+      onPointerLeave: composeEventHandlers(
+        props.onPointerLeave,
+        whenMouse(context.onContentLeave)
+      ),
+      style: {
+        // Prevent interaction when animating out
+        pointerEvents: !open && context.isRootMenu ? "none" : void 0,
+        ...commonProps.style
+      }
+    }
+  ) }) : /* @__PURE__ */ jsxRuntime.jsx(ViewportContentMounter, { forceMount, ...commonProps, ref: composedRefs });
+});
+NavigationMenuContent.displayName = CONTENT_NAME3;
+var ViewportContentMounter = React37__namespace.forwardRef((props, forwardedRef) => {
+  const context = useNavigationMenuContext(CONTENT_NAME3, props.__scopeNavigationMenu);
+  const { onViewportContentChange, onViewportContentRemove } = context;
+  useLayoutEffect2(() => {
+    onViewportContentChange(props.value, {
+      ref: forwardedRef,
+      ...props
+    });
+  }, [props, forwardedRef, onViewportContentChange]);
+  useLayoutEffect2(() => {
+    return () => onViewportContentRemove(props.value);
+  }, [props.value, onViewportContentRemove]);
+  return null;
+});
+var ROOT_CONTENT_DISMISS = "navigationMenu.rootContentDismiss";
+var NavigationMenuContentImpl = React37__namespace.forwardRef((props, forwardedRef) => {
+  const {
+    __scopeNavigationMenu,
+    value,
+    triggerRef,
+    focusProxyRef,
+    wasEscapeCloseRef,
+    onRootContentClose,
+    onContentFocusOutside,
+    ...contentProps
+  } = props;
+  const context = useNavigationMenuContext(CONTENT_NAME3, __scopeNavigationMenu);
+  const ref = React37__namespace.useRef(null);
+  const composedRefs = useComposedRefs(ref, forwardedRef);
+  const triggerId = makeTriggerId(context.baseId, value);
+  const contentId = makeContentId(context.baseId, value);
+  const getItems = useCollection2(__scopeNavigationMenu);
+  const prevMotionAttributeRef = React37__namespace.useRef(null);
+  const { onItemDismiss } = context;
+  React37__namespace.useEffect(() => {
+    const content = ref.current;
+    if (context.isRootMenu && content) {
+      const handleClose = () => {
+        onItemDismiss();
+        onRootContentClose();
+        if (content.contains(document.activeElement)) triggerRef.current?.focus();
+      };
+      content.addEventListener(ROOT_CONTENT_DISMISS, handleClose);
+      return () => content.removeEventListener(ROOT_CONTENT_DISMISS, handleClose);
+    }
+  }, [context.isRootMenu, props.value, triggerRef, onItemDismiss, onRootContentClose]);
+  const motionAttribute = React37__namespace.useMemo(() => {
+    const items = getItems();
+    const values = items.map((item) => item.value);
+    if (context.dir === "rtl") values.reverse();
+    const index = values.indexOf(context.value);
+    const prevIndex = values.indexOf(context.previousValue);
+    const isSelected = value === context.value;
+    const wasSelected = prevIndex === values.indexOf(value);
+    if (!isSelected && !wasSelected) return prevMotionAttributeRef.current;
+    const attribute = (() => {
+      if (index !== prevIndex) {
+        if (isSelected && prevIndex !== -1) return index > prevIndex ? "from-end" : "from-start";
+        if (wasSelected && index !== -1) return index > prevIndex ? "to-start" : "to-end";
+      }
+      return null;
+    })();
+    prevMotionAttributeRef.current = attribute;
+    return attribute;
+  }, [context.previousValue, context.value, context.dir, getItems, value]);
+  return /* @__PURE__ */ jsxRuntime.jsx(FocusGroup, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(
+    DismissableLayer,
+    {
+      id: contentId,
+      "aria-labelledby": triggerId,
+      "data-motion": motionAttribute,
+      "data-orientation": context.orientation,
+      ...contentProps,
+      ref: composedRefs,
+      disableOutsidePointerEvents: false,
+      onDismiss: () => {
+        const rootContentDismissEvent = new Event(ROOT_CONTENT_DISMISS, {
+          bubbles: true,
+          cancelable: true
+        });
+        ref.current?.dispatchEvent(rootContentDismissEvent);
+      },
+      onFocusOutside: composeEventHandlers(props.onFocusOutside, (event) => {
+        onContentFocusOutside();
+        const target = event.target;
+        if (context.rootNavigationMenu?.contains(target)) event.preventDefault();
+      }),
+      onPointerDownOutside: composeEventHandlers(props.onPointerDownOutside, (event) => {
+        const target = event.target;
+        const isTrigger = getItems().some((item) => item.ref.current?.contains(target));
+        const isRootViewport = context.isRootMenu && context.viewport?.contains(target);
+        if (isTrigger || isRootViewport || !context.isRootMenu) event.preventDefault();
+      }),
+      onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {
+        const isMetaKey = event.altKey || event.ctrlKey || event.metaKey;
+        const isTabKey = event.key === "Tab" && !isMetaKey;
+        if (isTabKey) {
+          const candidates = getTabbableCandidates(event.currentTarget);
+          const focusedElement = document.activeElement;
+          const index = candidates.findIndex((candidate) => candidate === focusedElement);
+          const isMovingBackwards = event.shiftKey;
+          const nextCandidates = isMovingBackwards ? candidates.slice(0, index).reverse() : candidates.slice(index + 1, candidates.length);
+          if (focusFirst(nextCandidates)) {
+            event.preventDefault();
+          } else {
+            focusProxyRef.current?.focus();
+          }
+        }
+      }),
+      onEscapeKeyDown: composeEventHandlers(props.onEscapeKeyDown, (_event) => {
+        wasEscapeCloseRef.current = true;
+      })
+    }
+  ) });
+});
+var VIEWPORT_NAME = "NavigationMenuViewport";
+var NavigationMenuViewport = React37__namespace.forwardRef((props, forwardedRef) => {
+  const { forceMount, ...viewportProps } = props;
+  const context = useNavigationMenuContext(VIEWPORT_NAME, props.__scopeNavigationMenu);
+  const open = Boolean(context.value);
+  return /* @__PURE__ */ jsxRuntime.jsx(Presence, { present: forceMount || open, children: /* @__PURE__ */ jsxRuntime.jsx(NavigationMenuViewportImpl, { ...viewportProps, ref: forwardedRef }) });
+});
+NavigationMenuViewport.displayName = VIEWPORT_NAME;
+var NavigationMenuViewportImpl = React37__namespace.forwardRef((props, forwardedRef) => {
+  const { __scopeNavigationMenu, children, ...viewportImplProps } = props;
+  const context = useNavigationMenuContext(VIEWPORT_NAME, __scopeNavigationMenu);
+  const composedRefs = useComposedRefs(forwardedRef, context.onViewportChange);
+  const viewportContentContext = useViewportContentContext(
+    CONTENT_NAME3,
+    props.__scopeNavigationMenu
+  );
+  const [size, setSize] = React37__namespace.useState(null);
+  const [content, setContent] = React37__namespace.useState(null);
+  const viewportWidth = size ? size?.width + "px" : void 0;
+  const viewportHeight = size ? size?.height + "px" : void 0;
+  const open = Boolean(context.value);
+  const activeContentValue = open ? context.value : context.previousValue;
+  const handleSizeChange = () => {
+    if (content) setSize({ width: content.offsetWidth, height: content.offsetHeight });
+  };
+  useResizeObserver(content, handleSizeChange);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    Primitive2.div,
+    {
+      "data-state": getOpenState(open),
+      "data-orientation": context.orientation,
+      ...viewportImplProps,
+      ref: composedRefs,
+      style: {
+        // Prevent interaction when animating out
+        pointerEvents: !open && context.isRootMenu ? "none" : void 0,
+        ["--radix-navigation-menu-viewport-width"]: viewportWidth,
+        ["--radix-navigation-menu-viewport-height"]: viewportHeight,
+        ...viewportImplProps.style
+      },
+      onPointerEnter: composeEventHandlers(props.onPointerEnter, context.onContentEnter),
+      onPointerLeave: composeEventHandlers(props.onPointerLeave, whenMouse(context.onContentLeave)),
+      children: Array.from(viewportContentContext.items).map(([value, { ref, forceMount, ...props2 }]) => {
+        const isActive = activeContentValue === value;
+        return /* @__PURE__ */ jsxRuntime.jsx(Presence, { present: forceMount || isActive, children: /* @__PURE__ */ jsxRuntime.jsx(
+          NavigationMenuContentImpl,
+          {
+            ...props2,
+            ref: composeRefs(ref, (node) => {
+              if (isActive && node) setContent(node);
+            })
+          }
+        ) }, value);
+      })
+    }
+  );
+});
+var FOCUS_GROUP_NAME = "FocusGroup";
+var FocusGroup = React37__namespace.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeNavigationMenu, ...groupProps } = props;
+    const context = useNavigationMenuContext(FOCUS_GROUP_NAME, __scopeNavigationMenu);
+    return /* @__PURE__ */ jsxRuntime.jsx(FocusGroupCollection.Provider, { scope: __scopeNavigationMenu, children: /* @__PURE__ */ jsxRuntime.jsx(FocusGroupCollection.Slot, { scope: __scopeNavigationMenu, children: /* @__PURE__ */ jsxRuntime.jsx(Primitive2.div, { dir: context.dir, ...groupProps, ref: forwardedRef }) }) });
+  }
+);
+var ARROW_KEYS = ["ArrowRight", "ArrowLeft", "ArrowUp", "ArrowDown"];
+var FOCUS_GROUP_ITEM_NAME = "FocusGroupItem";
+var FocusGroupItem = React37__namespace.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeNavigationMenu, ...groupProps } = props;
+    const getItems = useFocusGroupCollection(__scopeNavigationMenu);
+    const context = useNavigationMenuContext(FOCUS_GROUP_ITEM_NAME, __scopeNavigationMenu);
+    return /* @__PURE__ */ jsxRuntime.jsx(FocusGroupCollection.ItemSlot, { scope: __scopeNavigationMenu, children: /* @__PURE__ */ jsxRuntime.jsx(
+      Primitive2.button,
+      {
+        ...groupProps,
+        ref: forwardedRef,
+        onKeyDown: composeEventHandlers(props.onKeyDown, (event) => {
+          const isFocusNavigationKey = ["Home", "End", ...ARROW_KEYS].includes(event.key);
+          if (isFocusNavigationKey) {
+            let candidateNodes = getItems().map((item) => item.ref.current);
+            const prevItemKey = context.dir === "rtl" ? "ArrowRight" : "ArrowLeft";
+            const prevKeys = [prevItemKey, "ArrowUp", "End"];
+            if (prevKeys.includes(event.key)) candidateNodes.reverse();
+            if (ARROW_KEYS.includes(event.key)) {
+              const currentIndex = candidateNodes.indexOf(event.currentTarget);
+              candidateNodes = candidateNodes.slice(currentIndex + 1);
+            }
+            setTimeout(() => focusFirst(candidateNodes));
+            event.preventDefault();
+          }
+        })
+      }
+    ) });
+  }
+);
+function getTabbableCandidates(container) {
+  const nodes = [];
+  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
+    acceptNode: (node) => {
+      const isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
+      if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP;
+      return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+    }
+  });
+  while (walker.nextNode()) nodes.push(walker.currentNode);
+  return nodes;
+}
+function focusFirst(candidates) {
+  const previouslyFocusedElement = document.activeElement;
+  return candidates.some((candidate) => {
+    if (candidate === previouslyFocusedElement) return true;
+    candidate.focus();
+    return document.activeElement !== previouslyFocusedElement;
+  });
+}
+function removeFromTabOrder(candidates) {
+  candidates.forEach((candidate) => {
+    candidate.dataset.tabindex = candidate.getAttribute("tabindex") || "";
+    candidate.setAttribute("tabindex", "-1");
+  });
+  return () => {
+    candidates.forEach((candidate) => {
+      const prevTabIndex = candidate.dataset.tabindex;
+      candidate.setAttribute("tabindex", prevTabIndex);
+    });
+  };
+}
+function useResizeObserver(element, onResize) {
+  const handleResize = useCallbackRef(onResize);
+  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]);
+}
+function getOpenState(open) {
+  return open ? "open" : "closed";
+}
+function makeTriggerId(baseId, value) {
+  return `${baseId}-trigger-${value}`;
+}
+function makeContentId(baseId, value) {
+  return `${baseId}-content-${value}`;
+}
+function whenMouse(handler) {
+  return (event) => event.pointerType === "mouse" ? handler(event) : void 0;
+}
+var Root23 = NavigationMenu;
+var List2 = NavigationMenuList;
+var Item2 = NavigationMenuItem;
+var Trigger3 = NavigationMenuTrigger;
+var Link2 = NavigationMenuLink;
+var Indicator = NavigationMenuIndicator;
+var Content3 = NavigationMenuContent;
+var Viewport = NavigationMenuViewport;
+var NavigationMenu2 = React37__namespace.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsxs(
+  Root23,
+  {
+    ref,
+    className: cn(
+      "relative z-10 flex max-w-max flex-1 items-center justify-center",
+      className
+    ),
+    ...props,
+    children: [
+      children,
+      /* @__PURE__ */ jsxRuntime.jsx(NavigationMenuViewport2, {})
+    ]
+  }
+));
+NavigationMenu2.displayName = Root23.displayName;
+var NavigationMenuList2 = React37__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  List2,
+  {
+    ref,
+    className: cn(
+      "group flex flex-1 list-none items-center justify-center space-x-1",
+      className
+    ),
+    ...props
+  }
+));
+NavigationMenuList2.displayName = List2.displayName;
+var NavigationMenuItem2 = Item2;
+var navigationMenuTriggerStyle = classVarianceAuthority.cva(
+  "group inline-flex h-10 w-max items-center justify-center rounded-md bg-white px-4 py-2 text-sm font-medium text-[var(--black)] transition-colors hover:bg-gray-100 hover:text-[var(--black)] focus:bg-gray-100 focus:text-[var(--black)] focus:outline-none disabled:pointer-events-none disabled:opacity-50 data-[state=open]:text-[var(--black)] data-[state=open]:bg-gray-100/50 data-[state=open]:hover:bg-gray-100 data-[state=open]:focus:bg-gray-100"
+);
+var NavigationMenuTrigger2 = React37__namespace.forwardRef(({ className, children, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsxs(
+  Trigger3,
+  {
+    ref,
+    className: cn(navigationMenuTriggerStyle(), "group", className),
+    ...props,
+    children: [
+      children,
+      " ",
+      /* @__PURE__ */ jsxRuntime.jsx(
+        react.CaretDown,
+        {
+          className: "relative top-[1px] ml-1 h-3 w-3 transition duration-200 group-data-[state=open]:rotate-180",
+          "aria-hidden": "true"
+        }
+      )
+    ]
+  }
+));
+NavigationMenuTrigger2.displayName = Trigger3.displayName;
+var NavigationMenuContent2 = React37__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  Content3,
+  {
+    ref,
+    className: cn(
+      "left-0 top-0 w-full data-[motion^=from-]:animate-in data-[motion^=to-]:animate-out data-[motion^=from-]:fade-in data-[motion^=to-]:fade-out data-[motion=from-end]:slide-in-from-right-52 data-[motion=from-start]:slide-in-from-left-52 data-[motion=to-end]:slide-out-to-right-52 data-[motion=to-start]:slide-out-to-left-52 md:absolute md:w-auto",
+      className
+    ),
+    ...props
+  }
+));
+NavigationMenuContent2.displayName = Content3.displayName;
+var NavigationMenuLink2 = Link2;
+var NavigationMenuViewport2 = React37__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn("absolute left-0 top-full flex justify-center"), children: /* @__PURE__ */ jsxRuntime.jsx(
+  Viewport,
+  {
+    className: cn(
+      "origin-top-center relative mt-1.5 h-[var(--radix-navigation-menu-viewport-height)] w-full overflow-hidden rounded-md border border-gray-200 bg-white text-[var(--black)] shadow-lg data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-90 md:w-[var(--radix-navigation-menu-viewport-width)]",
+      className
+    ),
+    ref,
+    ...props
+  }
+) }));
+NavigationMenuViewport2.displayName = Viewport.displayName;
+var NavigationMenuIndicator2 = React37__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  Indicator,
+  {
+    ref,
+    className: cn(
+      "top-full z-[1] flex h-1.5 items-end justify-center overflow-hidden data-[state=visible]:animate-in data-[state=hidden]:animate-out data-[state=hidden]:fade-out data-[state=visible]:fade-in",
+      className
+    ),
+    ...props,
+    children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "relative top-[60%] h-2 w-2 rotate-45 rounded-tl-sm bg-gray-200 shadow-md" })
+  }
+));
+NavigationMenuIndicator2.displayName = Indicator.displayName;
 
 Object.defineProperty(exports, "AddressBook", {
   enumerable: true,
@@ -853,6 +2999,10 @@ Object.defineProperty(exports, "XLogo", {
   enumerable: true,
   get: function () { return react.XLogo; }
 });
+exports.Accordion = Accordion2;
+exports.AccordionContent = AccordionContent2;
+exports.AccordionItem = AccordionItem2;
+exports.AccordionTrigger = AccordionTrigger2;
 exports.Badge = Badge;
 exports.Button = Button;
 exports.Card = Card;
@@ -862,8 +3012,19 @@ exports.CardFooter = CardFooter;
 exports.CardHeader = CardHeader;
 exports.CardTitle = CardTitle;
 exports.IconBox = IconBox;
+exports.Input = Input;
+exports.Label = Label2;
 exports.Logo = Logo;
+exports.NavigationMenu = NavigationMenu2;
+exports.NavigationMenuContent = NavigationMenuContent2;
+exports.NavigationMenuIndicator = NavigationMenuIndicator2;
+exports.NavigationMenuItem = NavigationMenuItem2;
+exports.NavigationMenuLink = NavigationMenuLink2;
+exports.NavigationMenuList = NavigationMenuList2;
+exports.NavigationMenuTrigger = NavigationMenuTrigger2;
+exports.NavigationMenuViewport = NavigationMenuViewport2;
 exports.Progress = Progress;
+exports.Separator = Separator2;
 exports.Sheet = Sheet;
 exports.SheetClose = SheetClose;
 exports.SheetContent = SheetContent;
@@ -876,10 +3037,12 @@ exports.SheetTitle = SheetTitle;
 exports.SheetTrigger = SheetTrigger;
 exports.Stat = Stat;
 exports.Tag = Tag;
+exports.Textarea = Textarea;
 exports.badgeVariants = badgeVariants;
 exports.buttonVariants = buttonVariants;
 exports.cn = cn;
 exports.iconBoxVariants = iconBoxVariants;
+exports.navigationMenuTriggerStyle = navigationMenuTriggerStyle;
 exports.progressVariants = progressVariants;
 exports.statVariants = statVariants;
 exports.tagVariants = tagVariants;