shadcn-ui/apps/v4/examples/__index__.tsx

// @ts-nocheck
// This file is autogenerated by scripts/build-registry.mts
// Do not edit this file directly.
import "server-only"

import * as React from "react"

export const ExamplesIndex: Record<string, Record<string, any>> = {
  radix: {
    "accordion-basic": {
      name: "accordion-basic",
      filePath: "examples/radix/accordion-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/accordion-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "accordion-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "accordion-borders": {
      name: "accordion-borders",
      filePath: "examples/radix/accordion-borders.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/accordion-borders")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "accordion-borders"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "accordion-card": {
      name: "accordion-card",
      filePath: "examples/radix/accordion-card.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/accordion-card")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "accordion-card"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "accordion-demo": {
      name: "accordion-demo",
      filePath: "examples/radix/accordion-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/accordion-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "accordion-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "accordion-disabled": {
      name: "accordion-disabled",
      filePath: "examples/radix/accordion-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/accordion-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "accordion-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "accordion-multiple": {
      name: "accordion-multiple",
      filePath: "examples/radix/accordion-multiple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/accordion-multiple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "accordion-multiple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "accordion-rtl": {
      name: "accordion-rtl",
      filePath: "examples/radix/accordion-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/accordion-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "accordion-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-action": {
      name: "alert-action",
      filePath: "examples/radix/alert-action.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/alert-action")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-action"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-basic": {
      name: "alert-basic",
      filePath: "examples/radix/alert-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/alert-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-colors": {
      name: "alert-colors",
      filePath: "examples/radix/alert-colors.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/alert-colors")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-colors"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-demo": {
      name: "alert-demo",
      filePath: "examples/radix/alert-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/alert-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-destructive": {
      name: "alert-destructive",
      filePath: "examples/radix/alert-destructive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/alert-destructive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-destructive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-dialog-basic": {
      name: "alert-dialog-basic",
      filePath: "examples/radix/alert-dialog-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/alert-dialog-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-dialog-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-dialog-demo": {
      name: "alert-dialog-demo",
      filePath: "examples/radix/alert-dialog-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/alert-dialog-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-dialog-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-dialog-destructive": {
      name: "alert-dialog-destructive",
      filePath: "examples/radix/alert-dialog-destructive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/alert-dialog-destructive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-dialog-destructive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-dialog-media": {
      name: "alert-dialog-media",
      filePath: "examples/radix/alert-dialog-media.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/alert-dialog-media")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-dialog-media"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-dialog-rtl": {
      name: "alert-dialog-rtl",
      filePath: "examples/radix/alert-dialog-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/alert-dialog-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-dialog-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-dialog-small-media": {
      name: "alert-dialog-small-media",
      filePath: "examples/radix/alert-dialog-small-media.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/alert-dialog-small-media")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-dialog-small-media"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-dialog-small": {
      name: "alert-dialog-small",
      filePath: "examples/radix/alert-dialog-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/alert-dialog-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-dialog-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-rtl": {
      name: "alert-rtl",
      filePath: "examples/radix/alert-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/alert-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "aspect-ratio-demo": {
      name: "aspect-ratio-demo",
      filePath: "examples/radix/aspect-ratio-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/aspect-ratio-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "aspect-ratio-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "aspect-ratio-portrait": {
      name: "aspect-ratio-portrait",
      filePath: "examples/radix/aspect-ratio-portrait.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/aspect-ratio-portrait")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "aspect-ratio-portrait"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "aspect-ratio-rtl": {
      name: "aspect-ratio-rtl",
      filePath: "examples/radix/aspect-ratio-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/aspect-ratio-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "aspect-ratio-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "aspect-ratio-square": {
      name: "aspect-ratio-square",
      filePath: "examples/radix/aspect-ratio-square.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/aspect-ratio-square")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "aspect-ratio-square"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-badge-icon": {
      name: "avatar-badge-icon",
      filePath: "examples/radix/avatar-badge-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/avatar-badge-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-badge-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-badge": {
      name: "avatar-badge",
      filePath: "examples/radix/avatar-badge.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/avatar-badge")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-badge"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-basic": {
      name: "avatar-basic",
      filePath: "examples/radix/avatar-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/avatar-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-demo": {
      name: "avatar-demo",
      filePath: "examples/radix/avatar-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/avatar-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-dropdown": {
      name: "avatar-dropdown",
      filePath: "examples/radix/avatar-dropdown.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/avatar-dropdown")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-dropdown"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-group-count-icon": {
      name: "avatar-group-count-icon",
      filePath: "examples/radix/avatar-group-count-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/avatar-group-count-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-group-count-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-group-count": {
      name: "avatar-group-count",
      filePath: "examples/radix/avatar-group-count.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/avatar-group-count")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-group-count"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-group": {
      name: "avatar-group",
      filePath: "examples/radix/avatar-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/avatar-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-rtl": {
      name: "avatar-rtl",
      filePath: "examples/radix/avatar-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/avatar-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-size": {
      name: "avatar-size",
      filePath: "examples/radix/avatar-size.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/avatar-size")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-size"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "badge-colors": {
      name: "badge-colors",
      filePath: "examples/radix/badge-colors.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/badge-colors")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "badge-colors"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "badge-demo": {
      name: "badge-demo",
      filePath: "examples/radix/badge-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/badge-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "badge-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "badge-icon": {
      name: "badge-icon",
      filePath: "examples/radix/badge-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/badge-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "badge-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "badge-link": {
      name: "badge-link",
      filePath: "examples/radix/badge-link.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/badge-link")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "badge-link"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "badge-rtl": {
      name: "badge-rtl",
      filePath: "examples/radix/badge-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/badge-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "badge-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "badge-spinner": {
      name: "badge-spinner",
      filePath: "examples/radix/badge-spinner.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/badge-spinner")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "badge-spinner"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "badge-variants": {
      name: "badge-variants",
      filePath: "examples/radix/badge-variants.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/badge-variants")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "badge-variants"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "breadcrumb-basic": {
      name: "breadcrumb-basic",
      filePath: "examples/radix/breadcrumb-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/breadcrumb-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "breadcrumb-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "breadcrumb-demo": {
      name: "breadcrumb-demo",
      filePath: "examples/radix/breadcrumb-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/breadcrumb-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "breadcrumb-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "breadcrumb-dropdown": {
      name: "breadcrumb-dropdown",
      filePath: "examples/radix/breadcrumb-dropdown.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/breadcrumb-dropdown")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "breadcrumb-dropdown"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "breadcrumb-ellipsis": {
      name: "breadcrumb-ellipsis",
      filePath: "examples/radix/breadcrumb-ellipsis.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/breadcrumb-ellipsis")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "breadcrumb-ellipsis"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "breadcrumb-link": {
      name: "breadcrumb-link",
      filePath: "examples/radix/breadcrumb-link.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/breadcrumb-link")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "breadcrumb-link"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "breadcrumb-rtl": {
      name: "breadcrumb-rtl",
      filePath: "examples/radix/breadcrumb-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/breadcrumb-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "breadcrumb-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "breadcrumb-separator": {
      name: "breadcrumb-separator",
      filePath: "examples/radix/breadcrumb-separator.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/breadcrumb-separator")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "breadcrumb-separator"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-aschild": {
      name: "button-aschild",
      filePath: "examples/radix/button-aschild.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-aschild")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-aschild"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-default": {
      name: "button-default",
      filePath: "examples/radix/button-default.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-default")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-default"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-demo": {
      name: "button-demo",
      filePath: "examples/radix/button-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-destructive": {
      name: "button-destructive",
      filePath: "examples/radix/button-destructive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-destructive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-destructive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-ghost": {
      name: "button-ghost",
      filePath: "examples/radix/button-ghost.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-ghost")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-ghost"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-demo": {
      name: "button-group-demo",
      filePath: "examples/radix/button-group-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-dropdown": {
      name: "button-group-dropdown",
      filePath: "examples/radix/button-group-dropdown.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-dropdown")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-dropdown"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-input-group": {
      name: "button-group-input-group",
      filePath: "examples/radix/button-group-input-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-input-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-input-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-input": {
      name: "button-group-input",
      filePath: "examples/radix/button-group-input.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-input")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-input"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-nested": {
      name: "button-group-nested",
      filePath: "examples/radix/button-group-nested.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-nested")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-nested"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-orientation": {
      name: "button-group-orientation",
      filePath: "examples/radix/button-group-orientation.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-orientation")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-orientation"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-popover": {
      name: "button-group-popover",
      filePath: "examples/radix/button-group-popover.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-popover")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-popover"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-rtl": {
      name: "button-group-rtl",
      filePath: "examples/radix/button-group-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-select": {
      name: "button-group-select",
      filePath: "examples/radix/button-group-select.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-select")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-select"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-separator": {
      name: "button-group-separator",
      filePath: "examples/radix/button-group-separator.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-separator")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-separator"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-size": {
      name: "button-group-size",
      filePath: "examples/radix/button-group-size.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-size")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-size"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-split": {
      name: "button-group-split",
      filePath: "examples/radix/button-group-split.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-split")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-split"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-icon": {
      name: "button-icon",
      filePath: "examples/radix/button-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-link": {
      name: "button-link",
      filePath: "examples/radix/button-link.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-link")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-link"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-outline": {
      name: "button-outline",
      filePath: "examples/radix/button-outline.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-outline")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-outline"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-rounded": {
      name: "button-rounded",
      filePath: "examples/radix/button-rounded.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-rounded")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-rounded"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-rtl": {
      name: "button-rtl",
      filePath: "examples/radix/button-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-secondary": {
      name: "button-secondary",
      filePath: "examples/radix/button-secondary.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-secondary")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-secondary"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-size": {
      name: "button-size",
      filePath: "examples/radix/button-size.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-size")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-size"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-spinner": {
      name: "button-spinner",
      filePath: "examples/radix/button-spinner.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-spinner")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-spinner"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-with-icon": {
      name: "button-with-icon",
      filePath: "examples/radix/button-with-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-with-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-with-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-basic": {
      name: "calendar-basic",
      filePath: "examples/radix/calendar-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/calendar-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-booked-dates": {
      name: "calendar-booked-dates",
      filePath: "examples/radix/calendar-booked-dates.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/calendar-booked-dates")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-booked-dates"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-caption": {
      name: "calendar-caption",
      filePath: "examples/radix/calendar-caption.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/calendar-caption")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-caption"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-custom-days": {
      name: "calendar-custom-days",
      filePath: "examples/radix/calendar-custom-days.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/calendar-custom-days")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-custom-days"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-demo": {
      name: "calendar-demo",
      filePath: "examples/radix/calendar-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/calendar-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-hijri": {
      name: "calendar-hijri",
      filePath: "examples/radix/calendar-hijri.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/calendar-hijri")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-hijri"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-multiple": {
      name: "calendar-multiple",
      filePath: "examples/radix/calendar-multiple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/calendar-multiple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-multiple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-presets": {
      name: "calendar-presets",
      filePath: "examples/radix/calendar-presets.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/calendar-presets")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-presets"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-range": {
      name: "calendar-range",
      filePath: "examples/radix/calendar-range.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/calendar-range")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-range"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-rtl": {
      name: "calendar-rtl",
      filePath: "examples/radix/calendar-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/calendar-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-time": {
      name: "calendar-time",
      filePath: "examples/radix/calendar-time.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/calendar-time")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-time"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-week-numbers": {
      name: "calendar-week-numbers",
      filePath: "examples/radix/calendar-week-numbers.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/calendar-week-numbers")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-week-numbers"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-demo": {
      name: "card-demo",
      filePath: "examples/radix/card-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/card-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-edge-to-edge": {
      name: "card-edge-to-edge",
      filePath: "examples/radix/card-edge-to-edge.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/card-edge-to-edge")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-edge-to-edge"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-image": {
      name: "card-image",
      filePath: "examples/radix/card-image.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/card-image")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-image"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-rtl": {
      name: "card-rtl",
      filePath: "examples/radix/card-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/card-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-small": {
      name: "card-small",
      filePath: "examples/radix/card-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/card-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-spacing": {
      name: "card-spacing",
      filePath: "examples/radix/card-spacing.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/card-spacing")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-spacing"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "carousel-api": {
      name: "carousel-api",
      filePath: "examples/radix/carousel-api.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/carousel-api")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-api"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "carousel-demo": {
      name: "carousel-demo",
      filePath: "examples/radix/carousel-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/carousel-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "carousel-multiple": {
      name: "carousel-multiple",
      filePath: "examples/radix/carousel-multiple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/carousel-multiple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-multiple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "carousel-orientation": {
      name: "carousel-orientation",
      filePath: "examples/radix/carousel-orientation.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/carousel-orientation")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-orientation"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "carousel-plugin": {
      name: "carousel-plugin",
      filePath: "examples/radix/carousel-plugin.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/carousel-plugin")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-plugin"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "carousel-rtl": {
      name: "carousel-rtl",
      filePath: "examples/radix/carousel-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/carousel-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "carousel-size": {
      name: "carousel-size",
      filePath: "examples/radix/carousel-size.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/carousel-size")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-size"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "carousel-spacing": {
      name: "carousel-spacing",
      filePath: "examples/radix/carousel-spacing.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/carousel-spacing")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-spacing"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-demo": {
      name: "chart-demo",
      filePath: "examples/radix/chart-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-example-axis": {
      name: "chart-example-axis",
      filePath: "examples/radix/chart-example-axis.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-example-axis")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-example-axis"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-example-grid": {
      name: "chart-example-grid",
      filePath: "examples/radix/chart-example-grid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-example-grid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-example-grid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-example-legend": {
      name: "chart-example-legend",
      filePath: "examples/radix/chart-example-legend.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-example-legend")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-example-legend"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-example-tooltip": {
      name: "chart-example-tooltip",
      filePath: "examples/radix/chart-example-tooltip.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-example-tooltip")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-example-tooltip"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-example": {
      name: "chart-example",
      filePath: "examples/radix/chart-example.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-example")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-example"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-rtl": {
      name: "chart-rtl",
      filePath: "examples/radix/chart-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-tooltip": {
      name: "chart-tooltip",
      filePath: "examples/radix/chart-tooltip.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-tooltip")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-tooltip"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-basic": {
      name: "checkbox-basic",
      filePath: "examples/radix/checkbox-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/checkbox-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-demo": {
      name: "checkbox-demo",
      filePath: "examples/radix/checkbox-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/checkbox-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-description": {
      name: "checkbox-description",
      filePath: "examples/radix/checkbox-description.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/checkbox-description")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-description"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-disabled": {
      name: "checkbox-disabled",
      filePath: "examples/radix/checkbox-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/checkbox-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-group": {
      name: "checkbox-group",
      filePath: "examples/radix/checkbox-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/checkbox-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-invalid": {
      name: "checkbox-invalid",
      filePath: "examples/radix/checkbox-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/checkbox-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-rtl": {
      name: "checkbox-rtl",
      filePath: "examples/radix/checkbox-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/checkbox-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-table": {
      name: "checkbox-table",
      filePath: "examples/radix/checkbox-table.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/checkbox-table")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-table"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "collapsible-basic": {
      name: "collapsible-basic",
      filePath: "examples/radix/collapsible-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/collapsible-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "collapsible-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "collapsible-demo": {
      name: "collapsible-demo",
      filePath: "examples/radix/collapsible-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/collapsible-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "collapsible-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "collapsible-file-tree": {
      name: "collapsible-file-tree",
      filePath: "examples/radix/collapsible-file-tree.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/collapsible-file-tree")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "collapsible-file-tree"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "collapsible-rtl": {
      name: "collapsible-rtl",
      filePath: "examples/radix/collapsible-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/collapsible-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "collapsible-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "collapsible-settings": {
      name: "collapsible-settings",
      filePath: "examples/radix/collapsible-settings.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/collapsible-settings")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "collapsible-settings"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-auto-highlight": {
      name: "combobox-auto-highlight",
      filePath: "examples/radix/combobox-auto-highlight.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-auto-highlight")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-auto-highlight"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-basic": {
      name: "combobox-basic",
      filePath: "examples/radix/combobox-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-clear": {
      name: "combobox-clear",
      filePath: "examples/radix/combobox-clear.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-clear")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-clear"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-custom": {
      name: "combobox-custom",
      filePath: "examples/radix/combobox-custom.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-custom")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-custom"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-demo": {
      name: "combobox-demo",
      filePath: "examples/radix/combobox-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-disabled": {
      name: "combobox-disabled",
      filePath: "examples/radix/combobox-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-groups": {
      name: "combobox-groups",
      filePath: "examples/radix/combobox-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-groups"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-input-group": {
      name: "combobox-input-group",
      filePath: "examples/radix/combobox-input-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-input-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-input-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-invalid": {
      name: "combobox-invalid",
      filePath: "examples/radix/combobox-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-multiple": {
      name: "combobox-multiple",
      filePath: "examples/radix/combobox-multiple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-multiple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-multiple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-popup": {
      name: "combobox-popup",
      filePath: "examples/radix/combobox-popup.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-popup")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-popup"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-rtl": {
      name: "combobox-rtl",
      filePath: "examples/radix/combobox-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "command-basic": {
      name: "command-basic",
      filePath: "examples/radix/command-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/command-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "command-demo": {
      name: "command-demo",
      filePath: "examples/radix/command-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/command-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "command-dialog": {
      name: "command-dialog",
      filePath: "examples/radix/command-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/command-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-dialog"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "command-groups": {
      name: "command-groups",
      filePath: "examples/radix/command-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/command-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-groups"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "command-rtl": {
      name: "command-rtl",
      filePath: "examples/radix/command-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/command-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "command-scrollable": {
      name: "command-scrollable",
      filePath: "examples/radix/command-scrollable.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/command-scrollable")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-scrollable"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "command-shortcuts": {
      name: "command-shortcuts",
      filePath: "examples/radix/command-shortcuts.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/command-shortcuts")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-shortcuts"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-basic": {
      name: "context-menu-basic",
      filePath: "examples/radix/context-menu-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-checkboxes": {
      name: "context-menu-checkboxes",
      filePath: "examples/radix/context-menu-checkboxes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-checkboxes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-checkboxes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-demo": {
      name: "context-menu-demo",
      filePath: "examples/radix/context-menu-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-destructive": {
      name: "context-menu-destructive",
      filePath: "examples/radix/context-menu-destructive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-destructive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-destructive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-groups": {
      name: "context-menu-groups",
      filePath: "examples/radix/context-menu-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-groups"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-icons": {
      name: "context-menu-icons",
      filePath: "examples/radix/context-menu-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-radio": {
      name: "context-menu-radio",
      filePath: "examples/radix/context-menu-radio.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-radio")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-radio"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-rtl": {
      name: "context-menu-rtl",
      filePath: "examples/radix/context-menu-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-shortcuts": {
      name: "context-menu-shortcuts",
      filePath: "examples/radix/context-menu-shortcuts.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-shortcuts")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-shortcuts"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-sides": {
      name: "context-menu-sides",
      filePath: "examples/radix/context-menu-sides.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-sides")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-sides"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-submenu": {
      name: "context-menu-submenu",
      filePath: "examples/radix/context-menu-submenu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-submenu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-submenu"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "data-picker-with-dropdowns": {
      name: "data-picker-with-dropdowns",
      filePath: "examples/radix/data-picker-with-dropdowns.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/data-picker-with-dropdowns")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "data-picker-with-dropdowns"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "data-table-demo": {
      name: "data-table-demo",
      filePath: "examples/radix/data-table-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/data-table-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "data-table-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "data-table-rtl": {
      name: "data-table-rtl",
      filePath: "examples/radix/data-table-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/data-table-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "data-table-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-basic": {
      name: "date-picker-basic",
      filePath: "examples/radix/date-picker-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/date-picker-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-demo": {
      name: "date-picker-demo",
      filePath: "examples/radix/date-picker-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/date-picker-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-dob": {
      name: "date-picker-dob",
      filePath: "examples/radix/date-picker-dob.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/date-picker-dob")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-dob"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-input": {
      name: "date-picker-input",
      filePath: "examples/radix/date-picker-input.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/date-picker-input")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-input"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-natural-language": {
      name: "date-picker-natural-language",
      filePath: "examples/radix/date-picker-natural-language.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/date-picker-natural-language")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-natural-language"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-range": {
      name: "date-picker-range",
      filePath: "examples/radix/date-picker-range.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/date-picker-range")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-range"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-rtl": {
      name: "date-picker-rtl",
      filePath: "examples/radix/date-picker-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/date-picker-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-time": {
      name: "date-picker-time",
      filePath: "examples/radix/date-picker-time.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/date-picker-time")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-time"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dialog-close-button": {
      name: "dialog-close-button",
      filePath: "examples/radix/dialog-close-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dialog-close-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dialog-close-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dialog-demo": {
      name: "dialog-demo",
      filePath: "examples/radix/dialog-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dialog-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dialog-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dialog-no-close-button": {
      name: "dialog-no-close-button",
      filePath: "examples/radix/dialog-no-close-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dialog-no-close-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dialog-no-close-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dialog-rtl": {
      name: "dialog-rtl",
      filePath: "examples/radix/dialog-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dialog-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dialog-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dialog-scrollable-content": {
      name: "dialog-scrollable-content",
      filePath: "examples/radix/dialog-scrollable-content.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dialog-scrollable-content")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dialog-scrollable-content"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dialog-sticky-footer": {
      name: "dialog-sticky-footer",
      filePath: "examples/radix/dialog-sticky-footer.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dialog-sticky-footer")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dialog-sticky-footer"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "drawer-demo": {
      name: "drawer-demo",
      filePath: "examples/radix/drawer-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/drawer-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "drawer-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "drawer-dialog": {
      name: "drawer-dialog",
      filePath: "examples/radix/drawer-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/drawer-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "drawer-dialog"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "drawer-rtl": {
      name: "drawer-rtl",
      filePath: "examples/radix/drawer-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/drawer-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "drawer-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "drawer-scrollable-content": {
      name: "drawer-scrollable-content",
      filePath: "examples/radix/drawer-scrollable-content.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/drawer-scrollable-content")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "drawer-scrollable-content"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "drawer-sides": {
      name: "drawer-sides",
      filePath: "examples/radix/drawer-sides.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/drawer-sides")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "drawer-sides"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-avatar": {
      name: "dropdown-menu-avatar",
      filePath: "examples/radix/dropdown-menu-avatar.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-avatar")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-avatar"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-basic": {
      name: "dropdown-menu-basic",
      filePath: "examples/radix/dropdown-menu-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-checkboxes-icons": {
      name: "dropdown-menu-checkboxes-icons",
      filePath: "examples/radix/dropdown-menu-checkboxes-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-checkboxes-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-checkboxes-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-checkboxes": {
      name: "dropdown-menu-checkboxes",
      filePath: "examples/radix/dropdown-menu-checkboxes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-checkboxes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-checkboxes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-complex": {
      name: "dropdown-menu-complex",
      filePath: "examples/radix/dropdown-menu-complex.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-complex")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-complex"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-demo": {
      name: "dropdown-menu-demo",
      filePath: "examples/radix/dropdown-menu-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-destructive": {
      name: "dropdown-menu-destructive",
      filePath: "examples/radix/dropdown-menu-destructive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-destructive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-destructive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-icons": {
      name: "dropdown-menu-icons",
      filePath: "examples/radix/dropdown-menu-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-radio-group": {
      name: "dropdown-menu-radio-group",
      filePath: "examples/radix/dropdown-menu-radio-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-radio-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-radio-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-radio-icons": {
      name: "dropdown-menu-radio-icons",
      filePath: "examples/radix/dropdown-menu-radio-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-radio-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-radio-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-rtl": {
      name: "dropdown-menu-rtl",
      filePath: "examples/radix/dropdown-menu-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-shortcuts": {
      name: "dropdown-menu-shortcuts",
      filePath: "examples/radix/dropdown-menu-shortcuts.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-shortcuts")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-shortcuts"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-submenu": {
      name: "dropdown-menu-submenu",
      filePath: "examples/radix/dropdown-menu-submenu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-submenu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-submenu"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-avatar-group": {
      name: "empty-avatar-group",
      filePath: "examples/radix/empty-avatar-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/empty-avatar-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-avatar-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-avatar": {
      name: "empty-avatar",
      filePath: "examples/radix/empty-avatar.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/empty-avatar")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-avatar"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-background": {
      name: "empty-background",
      filePath: "examples/radix/empty-background.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/empty-background")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-background"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-card": {
      name: "empty-card",
      filePath: "examples/radix/empty-card.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/empty-card")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-card"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-demo": {
      name: "empty-demo",
      filePath: "examples/radix/empty-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/empty-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-input-group": {
      name: "empty-input-group",
      filePath: "examples/radix/empty-input-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/empty-input-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-input-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-outline": {
      name: "empty-outline",
      filePath: "examples/radix/empty-outline.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/empty-outline")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-outline"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-rtl": {
      name: "empty-rtl",
      filePath: "examples/radix/empty-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/empty-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-checkbox": {
      name: "field-checkbox",
      filePath: "examples/radix/field-checkbox.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/field-checkbox")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-checkbox"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-choice-card": {
      name: "field-choice-card",
      filePath: "examples/radix/field-choice-card.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/field-choice-card")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-choice-card"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-demo": {
      name: "field-demo",
      filePath: "examples/radix/field-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/field-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-fieldset": {
      name: "field-fieldset",
      filePath: "examples/radix/field-fieldset.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/field-fieldset")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-fieldset"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-group": {
      name: "field-group",
      filePath: "examples/radix/field-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/field-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-input": {
      name: "field-input",
      filePath: "examples/radix/field-input.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/field-input")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-input"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-radio": {
      name: "field-radio",
      filePath: "examples/radix/field-radio.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/field-radio")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-radio"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-responsive": {
      name: "field-responsive",
      filePath: "examples/radix/field-responsive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/field-responsive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-responsive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-rtl": {
      name: "field-rtl",
      filePath: "examples/radix/field-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/field-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-select": {
      name: "field-select",
      filePath: "examples/radix/field-select.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/field-select")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-select"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-slider": {
      name: "field-slider",
      filePath: "examples/radix/field-slider.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/field-slider")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-slider"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-switch": {
      name: "field-switch",
      filePath: "examples/radix/field-switch.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/field-switch")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-switch"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-textarea": {
      name: "field-textarea",
      filePath: "examples/radix/field-textarea.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/field-textarea")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-textarea"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "file-upload-list": {
      name: "file-upload-list",
      filePath: "examples/radix/file-upload-list.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/file-upload-list")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "file-upload-list"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "hover-card-demo": {
      name: "hover-card-demo",
      filePath: "examples/radix/hover-card-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/hover-card-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "hover-card-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "hover-card-rtl": {
      name: "hover-card-rtl",
      filePath: "examples/radix/hover-card-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/hover-card-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "hover-card-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "hover-card-sides": {
      name: "hover-card-sides",
      filePath: "examples/radix/hover-card-sides.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/hover-card-sides")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "hover-card-sides"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-badge": {
      name: "input-badge",
      filePath: "examples/radix/input-badge.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-badge")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-badge"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-basic": {
      name: "input-basic",
      filePath: "examples/radix/input-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-button-group": {
      name: "input-button-group",
      filePath: "examples/radix/input-button-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-button-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-button-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-demo": {
      name: "input-demo",
      filePath: "examples/radix/input-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-disabled": {
      name: "input-disabled",
      filePath: "examples/radix/input-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-field": {
      name: "input-field",
      filePath: "examples/radix/input-field.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-field")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-field"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-fieldgroup": {
      name: "input-fieldgroup",
      filePath: "examples/radix/input-fieldgroup.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-fieldgroup")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-fieldgroup"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-file": {
      name: "input-file",
      filePath: "examples/radix/input-file.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-file")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-file"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-form": {
      name: "input-form",
      filePath: "examples/radix/input-form.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-form")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-form"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-grid": {
      name: "input-grid",
      filePath: "examples/radix/input-grid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-grid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-grid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-basic": {
      name: "input-group-basic",
      filePath: "examples/radix/input-group-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-block-end": {
      name: "input-group-block-end",
      filePath: "examples/radix/input-group-block-end.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-block-end")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-block-end"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-block-start": {
      name: "input-group-block-start",
      filePath: "examples/radix/input-group-block-start.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-block-start")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-block-start"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-button-group": {
      name: "input-group-button-group",
      filePath: "examples/radix/input-group-button-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-button-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-button-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-button": {
      name: "input-group-button",
      filePath: "examples/radix/input-group-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-custom": {
      name: "input-group-custom",
      filePath: "examples/radix/input-group-custom.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-custom")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-custom"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-demo": {
      name: "input-group-demo",
      filePath: "examples/radix/input-group-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-dropdown": {
      name: "input-group-dropdown",
      filePath: "examples/radix/input-group-dropdown.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-dropdown")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-dropdown"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-icon": {
      name: "input-group-icon",
      filePath: "examples/radix/input-group-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-in-card": {
      name: "input-group-in-card",
      filePath: "examples/radix/input-group-in-card.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-in-card")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-in-card"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-inline-end": {
      name: "input-group-inline-end",
      filePath: "examples/radix/input-group-inline-end.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-inline-end")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-inline-end"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-inline-start": {
      name: "input-group-inline-start",
      filePath: "examples/radix/input-group-inline-start.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-inline-start")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-inline-start"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-kbd": {
      name: "input-group-kbd",
      filePath: "examples/radix/input-group-kbd.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-kbd")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-kbd"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-label": {
      name: "input-group-label",
      filePath: "examples/radix/input-group-label.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-label")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-label"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-rtl": {
      name: "input-group-rtl",
      filePath: "examples/radix/input-group-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-spinner": {
      name: "input-group-spinner",
      filePath: "examples/radix/input-group-spinner.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-spinner")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-spinner"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-text": {
      name: "input-group-text",
      filePath: "examples/radix/input-group-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-text"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-textarea-examples": {
      name: "input-group-textarea-examples",
      filePath: "examples/radix/input-group-textarea-examples.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-textarea-examples")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-textarea-examples"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-textarea": {
      name: "input-group-textarea",
      filePath: "examples/radix/input-group-textarea.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-textarea")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-textarea"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-tooltip": {
      name: "input-group-tooltip",
      filePath: "examples/radix/input-group-tooltip.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-tooltip")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-tooltip"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-with-addons": {
      name: "input-group-with-addons",
      filePath: "examples/radix/input-group-with-addons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-with-addons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-with-addons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-with-buttons": {
      name: "input-group-with-buttons",
      filePath: "examples/radix/input-group-with-buttons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-with-buttons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-with-buttons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-with-kbd": {
      name: "input-group-with-kbd",
      filePath: "examples/radix/input-group-with-kbd.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-with-kbd")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-with-kbd"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-with-tooltip": {
      name: "input-group-with-tooltip",
      filePath: "examples/radix/input-group-with-tooltip.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-group-with-tooltip")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-with-tooltip"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-inline": {
      name: "input-inline",
      filePath: "examples/radix/input-inline.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-inline")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-inline"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-input-group": {
      name: "input-input-group",
      filePath: "examples/radix/input-input-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-input-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-input-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-invalid": {
      name: "input-invalid",
      filePath: "examples/radix/input-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-alphanumeric": {
      name: "input-otp-alphanumeric",
      filePath: "examples/radix/input-otp-alphanumeric.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-otp-alphanumeric")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-alphanumeric"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-controlled": {
      name: "input-otp-controlled",
      filePath: "examples/radix/input-otp-controlled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-otp-controlled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-controlled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-demo": {
      name: "input-otp-demo",
      filePath: "examples/radix/input-otp-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-otp-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-disabled": {
      name: "input-otp-disabled",
      filePath: "examples/radix/input-otp-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-otp-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-form": {
      name: "input-otp-form",
      filePath: "examples/radix/input-otp-form.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-otp-form")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-form"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-four-digits": {
      name: "input-otp-four-digits",
      filePath: "examples/radix/input-otp-four-digits.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-otp-four-digits")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-four-digits"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-invalid": {
      name: "input-otp-invalid",
      filePath: "examples/radix/input-otp-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-otp-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-pattern": {
      name: "input-otp-pattern",
      filePath: "examples/radix/input-otp-pattern.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-otp-pattern")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-pattern"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-rtl": {
      name: "input-otp-rtl",
      filePath: "examples/radix/input-otp-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-otp-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-separator": {
      name: "input-otp-separator",
      filePath: "examples/radix/input-otp-separator.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-otp-separator")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-separator"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-required": {
      name: "input-required",
      filePath: "examples/radix/input-required.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-required")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-required"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-rtl": {
      name: "input-rtl",
      filePath: "examples/radix/input-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-avatar": {
      name: "item-avatar",
      filePath: "examples/radix/item-avatar.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-avatar")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-avatar"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-demo": {
      name: "item-demo",
      filePath: "examples/radix/item-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-dropdown": {
      name: "item-dropdown",
      filePath: "examples/radix/item-dropdown.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-dropdown")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-dropdown"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-group": {
      name: "item-group",
      filePath: "examples/radix/item-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-header": {
      name: "item-header",
      filePath: "examples/radix/item-header.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-header")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-header"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-icon": {
      name: "item-icon",
      filePath: "examples/radix/item-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-image": {
      name: "item-image",
      filePath: "examples/radix/item-image.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-image")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-image"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-link": {
      name: "item-link",
      filePath: "examples/radix/item-link.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-link")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-link"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-rtl": {
      name: "item-rtl",
      filePath: "examples/radix/item-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-size": {
      name: "item-size",
      filePath: "examples/radix/item-size.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-size")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-size"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-variant": {
      name: "item-variant",
      filePath: "examples/radix/item-variant.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-variant")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-variant"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-button": {
      name: "kbd-button",
      filePath: "examples/radix/kbd-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/kbd-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-demo": {
      name: "kbd-demo",
      filePath: "examples/radix/kbd-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/kbd-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-group": {
      name: "kbd-group",
      filePath: "examples/radix/kbd-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/kbd-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-input-group": {
      name: "kbd-input-group",
      filePath: "examples/radix/kbd-input-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/kbd-input-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-input-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-rtl": {
      name: "kbd-rtl",
      filePath: "examples/radix/kbd-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/kbd-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-tooltip": {
      name: "kbd-tooltip",
      filePath: "examples/radix/kbd-tooltip.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/kbd-tooltip")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-tooltip"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "label-demo": {
      name: "label-demo",
      filePath: "examples/radix/label-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/label-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "label-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "label-rtl": {
      name: "label-rtl",
      filePath: "examples/radix/label-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/label-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "label-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-checkbox": {
      name: "menubar-checkbox",
      filePath: "examples/radix/menubar-checkbox.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/menubar-checkbox")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-checkbox"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-demo": {
      name: "menubar-demo",
      filePath: "examples/radix/menubar-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/menubar-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-icons": {
      name: "menubar-icons",
      filePath: "examples/radix/menubar-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/menubar-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-radio": {
      name: "menubar-radio",
      filePath: "examples/radix/menubar-radio.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/menubar-radio")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-radio"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-rtl": {
      name: "menubar-rtl",
      filePath: "examples/radix/menubar-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/menubar-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-submenu": {
      name: "menubar-submenu",
      filePath: "examples/radix/menubar-submenu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/menubar-submenu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-submenu"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "muted-item-group": {
      name: "muted-item-group",
      filePath: "examples/radix/muted-item-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/muted-item-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "muted-item-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "native-select-demo": {
      name: "native-select-demo",
      filePath: "examples/radix/native-select-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/native-select-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "native-select-disabled": {
      name: "native-select-disabled",
      filePath: "examples/radix/native-select-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/native-select-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "native-select-groups": {
      name: "native-select-groups",
      filePath: "examples/radix/native-select-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/native-select-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-groups"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "native-select-invalid": {
      name: "native-select-invalid",
      filePath: "examples/radix/native-select-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/native-select-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "native-select-rtl": {
      name: "native-select-rtl",
      filePath: "examples/radix/native-select-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/native-select-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "navigation-menu-demo": {
      name: "navigation-menu-demo",
      filePath: "examples/radix/navigation-menu-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/navigation-menu-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "navigation-menu-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "navigation-menu-rtl": {
      name: "navigation-menu-rtl",
      filePath: "examples/radix/navigation-menu-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/navigation-menu-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "navigation-menu-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "outline-item-group": {
      name: "outline-item-group",
      filePath: "examples/radix/outline-item-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/outline-item-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "outline-item-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "pagination-demo": {
      name: "pagination-demo",
      filePath: "examples/radix/pagination-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/pagination-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "pagination-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "pagination-icons-only": {
      name: "pagination-icons-only",
      filePath: "examples/radix/pagination-icons-only.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/pagination-icons-only")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "pagination-icons-only"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "pagination-rtl": {
      name: "pagination-rtl",
      filePath: "examples/radix/pagination-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/pagination-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "pagination-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "pagination-simple": {
      name: "pagination-simple",
      filePath: "examples/radix/pagination-simple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/pagination-simple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "pagination-simple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "popover-alignments": {
      name: "popover-alignments",
      filePath: "examples/radix/popover-alignments.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/popover-alignments")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "popover-alignments"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "popover-basic": {
      name: "popover-basic",
      filePath: "examples/radix/popover-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/popover-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "popover-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "popover-demo": {
      name: "popover-demo",
      filePath: "examples/radix/popover-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/popover-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "popover-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "popover-form": {
      name: "popover-form",
      filePath: "examples/radix/popover-form.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/popover-form")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "popover-form"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "popover-rtl": {
      name: "popover-rtl",
      filePath: "examples/radix/popover-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/popover-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "popover-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "progress-controlled": {
      name: "progress-controlled",
      filePath: "examples/radix/progress-controlled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/progress-controlled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "progress-controlled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "progress-demo": {
      name: "progress-demo",
      filePath: "examples/radix/progress-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/progress-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "progress-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "progress-label": {
      name: "progress-label",
      filePath: "examples/radix/progress-label.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/progress-label")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "progress-label"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "progress-rtl": {
      name: "progress-rtl",
      filePath: "examples/radix/progress-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/progress-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "progress-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "radio-fields": {
      name: "radio-fields",
      filePath: "examples/radix/radio-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/radio-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-fields"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "radio-group-choice-card": {
      name: "radio-group-choice-card",
      filePath: "examples/radix/radio-group-choice-card.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/radio-group-choice-card")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-choice-card"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "radio-group-demo": {
      name: "radio-group-demo",
      filePath: "examples/radix/radio-group-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/radio-group-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "radio-group-description": {
      name: "radio-group-description",
      filePath: "examples/radix/radio-group-description.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/radio-group-description")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-description"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "radio-group-disabled": {
      name: "radio-group-disabled",
      filePath: "examples/radix/radio-group-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/radio-group-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "radio-group-fieldset": {
      name: "radio-group-fieldset",
      filePath: "examples/radix/radio-group-fieldset.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/radio-group-fieldset")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-fieldset"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "radio-group-invalid": {
      name: "radio-group-invalid",
      filePath: "examples/radix/radio-group-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/radio-group-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "radio-group-rtl": {
      name: "radio-group-rtl",
      filePath: "examples/radix/radio-group-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/radio-group-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "resizable-demo": {
      name: "resizable-demo",
      filePath: "examples/radix/resizable-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/resizable-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "resizable-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "resizable-handle": {
      name: "resizable-handle",
      filePath: "examples/radix/resizable-handle.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/resizable-handle")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "resizable-handle"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "resizable-rtl": {
      name: "resizable-rtl",
      filePath: "examples/radix/resizable-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/resizable-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "resizable-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "resizable-vertical": {
      name: "resizable-vertical",
      filePath: "examples/radix/resizable-vertical.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/resizable-vertical")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "resizable-vertical"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "scroll-area-demo": {
      name: "scroll-area-demo",
      filePath: "examples/radix/scroll-area-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/scroll-area-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "scroll-area-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "scroll-area-horizontal-demo": {
      name: "scroll-area-horizontal-demo",
      filePath: "examples/radix/scroll-area-horizontal-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/scroll-area-horizontal-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "scroll-area-horizontal-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "scroll-area-rtl": {
      name: "scroll-area-rtl",
      filePath: "examples/radix/scroll-area-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/scroll-area-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "scroll-area-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-align-item": {
      name: "select-align-item",
      filePath: "examples/radix/select-align-item.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/select-align-item")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-align-item"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-demo": {
      name: "select-demo",
      filePath: "examples/radix/select-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/select-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-disabled": {
      name: "select-disabled",
      filePath: "examples/radix/select-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/select-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-groups": {
      name: "select-groups",
      filePath: "examples/radix/select-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/select-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-groups"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-invalid": {
      name: "select-invalid",
      filePath: "examples/radix/select-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/select-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-rtl": {
      name: "select-rtl",
      filePath: "examples/radix/select-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/select-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-scrollable": {
      name: "select-scrollable",
      filePath: "examples/radix/select-scrollable.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/select-scrollable")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-scrollable"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "separator-demo": {
      name: "separator-demo",
      filePath: "examples/radix/separator-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/separator-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "separator-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "separator-list": {
      name: "separator-list",
      filePath: "examples/radix/separator-list.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/separator-list")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "separator-list"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "separator-menu": {
      name: "separator-menu",
      filePath: "examples/radix/separator-menu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/separator-menu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "separator-menu"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "separator-rtl": {
      name: "separator-rtl",
      filePath: "examples/radix/separator-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/separator-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "separator-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "separator-vertical": {
      name: "separator-vertical",
      filePath: "examples/radix/separator-vertical.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/separator-vertical")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "separator-vertical"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sheet-demo": {
      name: "sheet-demo",
      filePath: "examples/radix/sheet-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sheet-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sheet-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sheet-no-close-button": {
      name: "sheet-no-close-button",
      filePath: "examples/radix/sheet-no-close-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sheet-no-close-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sheet-no-close-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sheet-rtl": {
      name: "sheet-rtl",
      filePath: "examples/radix/sheet-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sheet-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sheet-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sheet-side": {
      name: "sheet-side",
      filePath: "examples/radix/sheet-side.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sheet-side")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sheet-side"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-controlled": {
      name: "sidebar-controlled",
      filePath: "examples/radix/sidebar-controlled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sidebar-controlled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-controlled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-demo": {
      name: "sidebar-demo",
      filePath: "examples/radix/sidebar-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sidebar-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-footer": {
      name: "sidebar-footer",
      filePath: "examples/radix/sidebar-footer.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sidebar-footer")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-footer"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-group-action": {
      name: "sidebar-group-action",
      filePath: "examples/radix/sidebar-group-action.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sidebar-group-action")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-group-action"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-group-collapsible": {
      name: "sidebar-group-collapsible",
      filePath: "examples/radix/sidebar-group-collapsible.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sidebar-group-collapsible")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-group-collapsible"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-group": {
      name: "sidebar-group",
      filePath: "examples/radix/sidebar-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sidebar-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-header": {
      name: "sidebar-header",
      filePath: "examples/radix/sidebar-header.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sidebar-header")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-header"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-menu-action": {
      name: "sidebar-menu-action",
      filePath: "examples/radix/sidebar-menu-action.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sidebar-menu-action")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-menu-action"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-menu-badge": {
      name: "sidebar-menu-badge",
      filePath: "examples/radix/sidebar-menu-badge.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sidebar-menu-badge")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-menu-badge"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-menu-collapsible": {
      name: "sidebar-menu-collapsible",
      filePath: "examples/radix/sidebar-menu-collapsible.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sidebar-menu-collapsible")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-menu-collapsible"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-menu-sub": {
      name: "sidebar-menu-sub",
      filePath: "examples/radix/sidebar-menu-sub.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sidebar-menu-sub")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-menu-sub"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-menu": {
      name: "sidebar-menu",
      filePath: "examples/radix/sidebar-menu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sidebar-menu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-menu"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-rsc": {
      name: "sidebar-rsc",
      filePath: "examples/radix/sidebar-rsc.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sidebar-rsc")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-rsc"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-rtl": {
      name: "sidebar-rtl",
      filePath: "examples/radix/sidebar-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sidebar-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "skeleton-avatar": {
      name: "skeleton-avatar",
      filePath: "examples/radix/skeleton-avatar.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/skeleton-avatar")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "skeleton-avatar"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "skeleton-card": {
      name: "skeleton-card",
      filePath: "examples/radix/skeleton-card.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/skeleton-card")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "skeleton-card"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "skeleton-demo": {
      name: "skeleton-demo",
      filePath: "examples/radix/skeleton-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/skeleton-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "skeleton-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "skeleton-form": {
      name: "skeleton-form",
      filePath: "examples/radix/skeleton-form.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/skeleton-form")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "skeleton-form"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "skeleton-rtl": {
      name: "skeleton-rtl",
      filePath: "examples/radix/skeleton-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/skeleton-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "skeleton-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "skeleton-table": {
      name: "skeleton-table",
      filePath: "examples/radix/skeleton-table.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/skeleton-table")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "skeleton-table"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "skeleton-text": {
      name: "skeleton-text",
      filePath: "examples/radix/skeleton-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/skeleton-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "skeleton-text"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "slider-controlled": {
      name: "slider-controlled",
      filePath: "examples/radix/slider-controlled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/slider-controlled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "slider-controlled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "slider-demo": {
      name: "slider-demo",
      filePath: "examples/radix/slider-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/slider-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "slider-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "slider-disabled": {
      name: "slider-disabled",
      filePath: "examples/radix/slider-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/slider-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "slider-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "slider-multiple": {
      name: "slider-multiple",
      filePath: "examples/radix/slider-multiple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/slider-multiple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "slider-multiple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "slider-range": {
      name: "slider-range",
      filePath: "examples/radix/slider-range.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/slider-range")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "slider-range"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "slider-rtl": {
      name: "slider-rtl",
      filePath: "examples/radix/slider-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/slider-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "slider-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "slider-vertical": {
      name: "slider-vertical",
      filePath: "examples/radix/slider-vertical.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/slider-vertical")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "slider-vertical"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sonner-demo": {
      name: "sonner-demo",
      filePath: "examples/radix/sonner-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sonner-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sonner-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sonner-description": {
      name: "sonner-description",
      filePath: "examples/radix/sonner-description.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sonner-description")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sonner-description"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sonner-position": {
      name: "sonner-position",
      filePath: "examples/radix/sonner-position.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sonner-position")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sonner-position"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sonner-types": {
      name: "sonner-types",
      filePath: "examples/radix/sonner-types.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sonner-types")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sonner-types"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-badge": {
      name: "spinner-badge",
      filePath: "examples/radix/spinner-badge.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/spinner-badge")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-badge"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-button": {
      name: "spinner-button",
      filePath: "examples/radix/spinner-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/spinner-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-custom": {
      name: "spinner-custom",
      filePath: "examples/radix/spinner-custom.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/spinner-custom")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-custom"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-demo": {
      name: "spinner-demo",
      filePath: "examples/radix/spinner-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/spinner-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-empty": {
      name: "spinner-empty",
      filePath: "examples/radix/spinner-empty.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/spinner-empty")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-empty"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-input-group": {
      name: "spinner-input-group",
      filePath: "examples/radix/spinner-input-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/spinner-input-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-input-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-rtl": {
      name: "spinner-rtl",
      filePath: "examples/radix/spinner-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/spinner-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-size": {
      name: "spinner-size",
      filePath: "examples/radix/spinner-size.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/spinner-size")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-size"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "switch-choice-card": {
      name: "switch-choice-card",
      filePath: "examples/radix/switch-choice-card.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/switch-choice-card")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-choice-card"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "switch-demo": {
      name: "switch-demo",
      filePath: "examples/radix/switch-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/switch-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "switch-description": {
      name: "switch-description",
      filePath: "examples/radix/switch-description.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/switch-description")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-description"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "switch-disabled": {
      name: "switch-disabled",
      filePath: "examples/radix/switch-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/switch-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "switch-invalid": {
      name: "switch-invalid",
      filePath: "examples/radix/switch-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/switch-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "switch-rtl": {
      name: "switch-rtl",
      filePath: "examples/radix/switch-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/switch-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "switch-sizes": {
      name: "switch-sizes",
      filePath: "examples/radix/switch-sizes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/switch-sizes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-sizes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-actions": {
      name: "table-actions",
      filePath: "examples/radix/table-actions.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/table-actions")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-actions"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-demo": {
      name: "table-demo",
      filePath: "examples/radix/table-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/table-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-footer": {
      name: "table-footer",
      filePath: "examples/radix/table-footer.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/table-footer")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-footer"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-rtl": {
      name: "table-rtl",
      filePath: "examples/radix/table-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/table-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-demo": {
      name: "tabs-demo",
      filePath: "examples/radix/tabs-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tabs-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-disabled": {
      name: "tabs-disabled",
      filePath: "examples/radix/tabs-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tabs-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-icons": {
      name: "tabs-icons",
      filePath: "examples/radix/tabs-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tabs-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-line": {
      name: "tabs-line",
      filePath: "examples/radix/tabs-line.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tabs-line")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-line"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-rtl": {
      name: "tabs-rtl",
      filePath: "examples/radix/tabs-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tabs-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-vertical": {
      name: "tabs-vertical",
      filePath: "examples/radix/tabs-vertical.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tabs-vertical")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-vertical"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-button": {
      name: "textarea-button",
      filePath: "examples/radix/textarea-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/textarea-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-demo": {
      name: "textarea-demo",
      filePath: "examples/radix/textarea-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/textarea-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-disabled": {
      name: "textarea-disabled",
      filePath: "examples/radix/textarea-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/textarea-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-field": {
      name: "textarea-field",
      filePath: "examples/radix/textarea-field.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/textarea-field")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-field"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-invalid": {
      name: "textarea-invalid",
      filePath: "examples/radix/textarea-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/textarea-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-rtl": {
      name: "textarea-rtl",
      filePath: "examples/radix/textarea-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/textarea-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-demo": {
      name: "toggle-demo",
      filePath: "examples/radix/toggle-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-disabled": {
      name: "toggle-disabled",
      filePath: "examples/radix/toggle-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-demo": {
      name: "toggle-group-demo",
      filePath: "examples/radix/toggle-group-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-disabled": {
      name: "toggle-group-disabled",
      filePath: "examples/radix/toggle-group-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-font-weight-selector": {
      name: "toggle-group-font-weight-selector",
      filePath: "examples/radix/toggle-group-font-weight-selector.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-font-weight-selector")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-font-weight-selector"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-outline": {
      name: "toggle-group-outline",
      filePath: "examples/radix/toggle-group-outline.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-outline")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-outline"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-rtl": {
      name: "toggle-group-rtl",
      filePath: "examples/radix/toggle-group-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-sizes": {
      name: "toggle-group-sizes",
      filePath: "examples/radix/toggle-group-sizes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-sizes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-sizes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-spacing": {
      name: "toggle-group-spacing",
      filePath: "examples/radix/toggle-group-spacing.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-spacing")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-spacing"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-vertical": {
      name: "toggle-group-vertical",
      filePath: "examples/radix/toggle-group-vertical.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-vertical")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-vertical"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-outline": {
      name: "toggle-outline",
      filePath: "examples/radix/toggle-outline.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-outline")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-outline"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-rtl": {
      name: "toggle-rtl",
      filePath: "examples/radix/toggle-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-sizes": {
      name: "toggle-sizes",
      filePath: "examples/radix/toggle-sizes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-sizes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-sizes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-text": {
      name: "toggle-text",
      filePath: "examples/radix/toggle-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-text"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tooltip-demo": {
      name: "tooltip-demo",
      filePath: "examples/radix/tooltip-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tooltip-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tooltip-disabled": {
      name: "tooltip-disabled",
      filePath: "examples/radix/tooltip-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tooltip-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tooltip-keyboard": {
      name: "tooltip-keyboard",
      filePath: "examples/radix/tooltip-keyboard.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tooltip-keyboard")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-keyboard"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tooltip-rtl": {
      name: "tooltip-rtl",
      filePath: "examples/radix/tooltip-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tooltip-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tooltip-sides": {
      name: "tooltip-sides",
      filePath: "examples/radix/tooltip-sides.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tooltip-sides")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-sides"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-blockquote": {
      name: "typography-blockquote",
      filePath: "examples/radix/typography-blockquote.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/typography-blockquote")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-blockquote"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-demo": {
      name: "typography-demo",
      filePath: "examples/radix/typography-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/typography-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-h1": {
      name: "typography-h1",
      filePath: "examples/radix/typography-h1.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/typography-h1")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-h1"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-h2": {
      name: "typography-h2",
      filePath: "examples/radix/typography-h2.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/typography-h2")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-h2"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-h3": {
      name: "typography-h3",
      filePath: "examples/radix/typography-h3.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/typography-h3")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-h3"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-h4": {
      name: "typography-h4",
      filePath: "examples/radix/typography-h4.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/typography-h4")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-h4"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-inline-code": {
      name: "typography-inline-code",
      filePath: "examples/radix/typography-inline-code.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/typography-inline-code")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-inline-code"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-large": {
      name: "typography-large",
      filePath: "examples/radix/typography-large.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/typography-large")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-large"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-lead": {
      name: "typography-lead",
      filePath: "examples/radix/typography-lead.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/typography-lead")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-lead"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-list": {
      name: "typography-list",
      filePath: "examples/radix/typography-list.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/typography-list")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-list"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-muted": {
      name: "typography-muted",
      filePath: "examples/radix/typography-muted.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/typography-muted")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-muted"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-p": {
      name: "typography-p",
      filePath: "examples/radix/typography-p.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/typography-p")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-p"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-rtl": {
      name: "typography-rtl",
      filePath: "examples/radix/typography-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/typography-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-small": {
      name: "typography-small",
      filePath: "examples/radix/typography-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/typography-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-table": {
      name: "typography-table",
      filePath: "examples/radix/typography-table.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/typography-table")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-table"
        return { default: mod.default || mod[exportName] }
      }),
    },
  },
  base: {
    "accordion-basic": {
      name: "accordion-basic",
      filePath: "examples/base/accordion-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/accordion-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "accordion-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "accordion-borders": {
      name: "accordion-borders",
      filePath: "examples/base/accordion-borders.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/accordion-borders")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "accordion-borders"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "accordion-card": {
      name: "accordion-card",
      filePath: "examples/base/accordion-card.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/accordion-card")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "accordion-card"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "accordion-demo": {
      name: "accordion-demo",
      filePath: "examples/base/accordion-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/accordion-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "accordion-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "accordion-disabled": {
      name: "accordion-disabled",
      filePath: "examples/base/accordion-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/accordion-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "accordion-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "accordion-multiple": {
      name: "accordion-multiple",
      filePath: "examples/base/accordion-multiple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/accordion-multiple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "accordion-multiple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "accordion-rtl": {
      name: "accordion-rtl",
      filePath: "examples/base/accordion-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/accordion-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "accordion-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-action": {
      name: "alert-action",
      filePath: "examples/base/alert-action.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/alert-action")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-action"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-basic": {
      name: "alert-basic",
      filePath: "examples/base/alert-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/alert-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-colors": {
      name: "alert-colors",
      filePath: "examples/base/alert-colors.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/alert-colors")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-colors"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-demo": {
      name: "alert-demo",
      filePath: "examples/base/alert-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/alert-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-destructive": {
      name: "alert-destructive",
      filePath: "examples/base/alert-destructive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/alert-destructive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-destructive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-dialog-basic": {
      name: "alert-dialog-basic",
      filePath: "examples/base/alert-dialog-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/alert-dialog-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-dialog-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-dialog-demo": {
      name: "alert-dialog-demo",
      filePath: "examples/base/alert-dialog-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/alert-dialog-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-dialog-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-dialog-destructive": {
      name: "alert-dialog-destructive",
      filePath: "examples/base/alert-dialog-destructive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/alert-dialog-destructive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-dialog-destructive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-dialog-media": {
      name: "alert-dialog-media",
      filePath: "examples/base/alert-dialog-media.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/alert-dialog-media")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-dialog-media"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-dialog-rtl": {
      name: "alert-dialog-rtl",
      filePath: "examples/base/alert-dialog-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/alert-dialog-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-dialog-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-dialog-small-media": {
      name: "alert-dialog-small-media",
      filePath: "examples/base/alert-dialog-small-media.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/alert-dialog-small-media")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-dialog-small-media"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-dialog-small": {
      name: "alert-dialog-small",
      filePath: "examples/base/alert-dialog-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/alert-dialog-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-dialog-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "alert-rtl": {
      name: "alert-rtl",
      filePath: "examples/base/alert-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/alert-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "alert-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "aspect-ratio-demo": {
      name: "aspect-ratio-demo",
      filePath: "examples/base/aspect-ratio-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/aspect-ratio-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "aspect-ratio-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "aspect-ratio-portrait": {
      name: "aspect-ratio-portrait",
      filePath: "examples/base/aspect-ratio-portrait.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/aspect-ratio-portrait")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "aspect-ratio-portrait"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "aspect-ratio-rtl": {
      name: "aspect-ratio-rtl",
      filePath: "examples/base/aspect-ratio-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/aspect-ratio-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "aspect-ratio-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "aspect-ratio-square": {
      name: "aspect-ratio-square",
      filePath: "examples/base/aspect-ratio-square.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/aspect-ratio-square")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "aspect-ratio-square"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-badge-icon": {
      name: "avatar-badge-icon",
      filePath: "examples/base/avatar-badge-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/avatar-badge-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-badge-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-badge": {
      name: "avatar-badge",
      filePath: "examples/base/avatar-badge.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/avatar-badge")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-badge"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-basic": {
      name: "avatar-basic",
      filePath: "examples/base/avatar-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/avatar-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-demo": {
      name: "avatar-demo",
      filePath: "examples/base/avatar-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/avatar-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-dropdown": {
      name: "avatar-dropdown",
      filePath: "examples/base/avatar-dropdown.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/avatar-dropdown")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-dropdown"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-group-count-icon": {
      name: "avatar-group-count-icon",
      filePath: "examples/base/avatar-group-count-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/avatar-group-count-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-group-count-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-group-count": {
      name: "avatar-group-count",
      filePath: "examples/base/avatar-group-count.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/avatar-group-count")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-group-count"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-group": {
      name: "avatar-group",
      filePath: "examples/base/avatar-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/avatar-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-rtl": {
      name: "avatar-rtl",
      filePath: "examples/base/avatar-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/avatar-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "avatar-size": {
      name: "avatar-size",
      filePath: "examples/base/avatar-size.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/avatar-size")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "avatar-size"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "badge-colors": {
      name: "badge-colors",
      filePath: "examples/base/badge-colors.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/badge-colors")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "badge-colors"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "badge-demo": {
      name: "badge-demo",
      filePath: "examples/base/badge-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/badge-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "badge-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "badge-icon": {
      name: "badge-icon",
      filePath: "examples/base/badge-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/badge-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "badge-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "badge-link": {
      name: "badge-link",
      filePath: "examples/base/badge-link.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/badge-link")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "badge-link"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "badge-rtl": {
      name: "badge-rtl",
      filePath: "examples/base/badge-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/badge-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "badge-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "badge-spinner": {
      name: "badge-spinner",
      filePath: "examples/base/badge-spinner.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/badge-spinner")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "badge-spinner"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "badge-variants": {
      name: "badge-variants",
      filePath: "examples/base/badge-variants.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/badge-variants")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "badge-variants"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "breadcrumb-basic": {
      name: "breadcrumb-basic",
      filePath: "examples/base/breadcrumb-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/breadcrumb-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "breadcrumb-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "breadcrumb-demo": {
      name: "breadcrumb-demo",
      filePath: "examples/base/breadcrumb-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/breadcrumb-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "breadcrumb-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "breadcrumb-dropdown": {
      name: "breadcrumb-dropdown",
      filePath: "examples/base/breadcrumb-dropdown.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/breadcrumb-dropdown")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "breadcrumb-dropdown"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "breadcrumb-ellipsis": {
      name: "breadcrumb-ellipsis",
      filePath: "examples/base/breadcrumb-ellipsis.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/breadcrumb-ellipsis")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "breadcrumb-ellipsis"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "breadcrumb-link": {
      name: "breadcrumb-link",
      filePath: "examples/base/breadcrumb-link.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/breadcrumb-link")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "breadcrumb-link"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "breadcrumb-rtl": {
      name: "breadcrumb-rtl",
      filePath: "examples/base/breadcrumb-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/breadcrumb-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "breadcrumb-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "breadcrumb-separator": {
      name: "breadcrumb-separator",
      filePath: "examples/base/breadcrumb-separator.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/breadcrumb-separator")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "breadcrumb-separator"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-default": {
      name: "button-default",
      filePath: "examples/base/button-default.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-default")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-default"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-demo": {
      name: "button-demo",
      filePath: "examples/base/button-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-destructive": {
      name: "button-destructive",
      filePath: "examples/base/button-destructive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-destructive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-destructive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-ghost": {
      name: "button-ghost",
      filePath: "examples/base/button-ghost.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-ghost")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-ghost"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-demo": {
      name: "button-group-demo",
      filePath: "examples/base/button-group-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-dropdown": {
      name: "button-group-dropdown",
      filePath: "examples/base/button-group-dropdown.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-dropdown")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-dropdown"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-input-group": {
      name: "button-group-input-group",
      filePath: "examples/base/button-group-input-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-input-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-input-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-input": {
      name: "button-group-input",
      filePath: "examples/base/button-group-input.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-input")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-input"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-nested": {
      name: "button-group-nested",
      filePath: "examples/base/button-group-nested.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-nested")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-nested"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-orientation": {
      name: "button-group-orientation",
      filePath: "examples/base/button-group-orientation.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-orientation")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-orientation"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-popover": {
      name: "button-group-popover",
      filePath: "examples/base/button-group-popover.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-popover")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-popover"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-rtl": {
      name: "button-group-rtl",
      filePath: "examples/base/button-group-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-select": {
      name: "button-group-select",
      filePath: "examples/base/button-group-select.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-select")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-select"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-separator": {
      name: "button-group-separator",
      filePath: "examples/base/button-group-separator.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-separator")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-separator"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-size": {
      name: "button-group-size",
      filePath: "examples/base/button-group-size.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-size")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-size"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-split": {
      name: "button-group-split",
      filePath: "examples/base/button-group-split.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-split")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-split"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-icon": {
      name: "button-icon",
      filePath: "examples/base/button-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-link": {
      name: "button-link",
      filePath: "examples/base/button-link.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-link")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-link"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-outline": {
      name: "button-outline",
      filePath: "examples/base/button-outline.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-outline")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-outline"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-render": {
      name: "button-render",
      filePath: "examples/base/button-render.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-render")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-render"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-rounded": {
      name: "button-rounded",
      filePath: "examples/base/button-rounded.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-rounded")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-rounded"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-rtl": {
      name: "button-rtl",
      filePath: "examples/base/button-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-secondary": {
      name: "button-secondary",
      filePath: "examples/base/button-secondary.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-secondary")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-secondary"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-size": {
      name: "button-size",
      filePath: "examples/base/button-size.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-size")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-size"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-spinner": {
      name: "button-spinner",
      filePath: "examples/base/button-spinner.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-spinner")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-spinner"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-with-icon": {
      name: "button-with-icon",
      filePath: "examples/base/button-with-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-with-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-with-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-basic": {
      name: "calendar-basic",
      filePath: "examples/base/calendar-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/calendar-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-booked-dates": {
      name: "calendar-booked-dates",
      filePath: "examples/base/calendar-booked-dates.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/calendar-booked-dates")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-booked-dates"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-caption": {
      name: "calendar-caption",
      filePath: "examples/base/calendar-caption.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/calendar-caption")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-caption"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-custom-days": {
      name: "calendar-custom-days",
      filePath: "examples/base/calendar-custom-days.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/calendar-custom-days")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-custom-days"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-demo": {
      name: "calendar-demo",
      filePath: "examples/base/calendar-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/calendar-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-hijri": {
      name: "calendar-hijri",
      filePath: "examples/base/calendar-hijri.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/calendar-hijri")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-hijri"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-multiple": {
      name: "calendar-multiple",
      filePath: "examples/base/calendar-multiple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/calendar-multiple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-multiple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-presets": {
      name: "calendar-presets",
      filePath: "examples/base/calendar-presets.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/calendar-presets")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-presets"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-range": {
      name: "calendar-range",
      filePath: "examples/base/calendar-range.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/calendar-range")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-range"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-rtl": {
      name: "calendar-rtl",
      filePath: "examples/base/calendar-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/calendar-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-time": {
      name: "calendar-time",
      filePath: "examples/base/calendar-time.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/calendar-time")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-time"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-week-numbers": {
      name: "calendar-week-numbers",
      filePath: "examples/base/calendar-week-numbers.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/calendar-week-numbers")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-week-numbers"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-demo": {
      name: "card-demo",
      filePath: "examples/base/card-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/card-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-edge-to-edge": {
      name: "card-edge-to-edge",
      filePath: "examples/base/card-edge-to-edge.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/card-edge-to-edge")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-edge-to-edge"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-image": {
      name: "card-image",
      filePath: "examples/base/card-image.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/card-image")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-image"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-rtl": {
      name: "card-rtl",
      filePath: "examples/base/card-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/card-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-small": {
      name: "card-small",
      filePath: "examples/base/card-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/card-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-spacing": {
      name: "card-spacing",
      filePath: "examples/base/card-spacing.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/card-spacing")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-spacing"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "carousel-api": {
      name: "carousel-api",
      filePath: "examples/base/carousel-api.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/carousel-api")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-api"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "carousel-demo": {
      name: "carousel-demo",
      filePath: "examples/base/carousel-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/carousel-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "carousel-multiple": {
      name: "carousel-multiple",
      filePath: "examples/base/carousel-multiple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/carousel-multiple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-multiple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "carousel-orientation": {
      name: "carousel-orientation",
      filePath: "examples/base/carousel-orientation.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/carousel-orientation")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-orientation"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "carousel-plugin": {
      name: "carousel-plugin",
      filePath: "examples/base/carousel-plugin.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/carousel-plugin")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-plugin"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "carousel-rtl": {
      name: "carousel-rtl",
      filePath: "examples/base/carousel-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/carousel-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "carousel-size": {
      name: "carousel-size",
      filePath: "examples/base/carousel-size.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/carousel-size")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-size"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "carousel-spacing": {
      name: "carousel-spacing",
      filePath: "examples/base/carousel-spacing.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/carousel-spacing")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-spacing"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-demo": {
      name: "chart-demo",
      filePath: "examples/base/chart-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-example-axis": {
      name: "chart-example-axis",
      filePath: "examples/base/chart-example-axis.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-example-axis")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-example-axis"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-example-grid": {
      name: "chart-example-grid",
      filePath: "examples/base/chart-example-grid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-example-grid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-example-grid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-example-legend": {
      name: "chart-example-legend",
      filePath: "examples/base/chart-example-legend.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-example-legend")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-example-legend"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-example-tooltip": {
      name: "chart-example-tooltip",
      filePath: "examples/base/chart-example-tooltip.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-example-tooltip")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-example-tooltip"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-example": {
      name: "chart-example",
      filePath: "examples/base/chart-example.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-example")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-example"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-rtl": {
      name: "chart-rtl",
      filePath: "examples/base/chart-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-tooltip": {
      name: "chart-tooltip",
      filePath: "examples/base/chart-tooltip.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-tooltip")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-tooltip"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-basic": {
      name: "checkbox-basic",
      filePath: "examples/base/checkbox-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/checkbox-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-demo": {
      name: "checkbox-demo",
      filePath: "examples/base/checkbox-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/checkbox-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-description": {
      name: "checkbox-description",
      filePath: "examples/base/checkbox-description.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/checkbox-description")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-description"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-disabled": {
      name: "checkbox-disabled",
      filePath: "examples/base/checkbox-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/checkbox-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-group": {
      name: "checkbox-group",
      filePath: "examples/base/checkbox-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/checkbox-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-invalid": {
      name: "checkbox-invalid",
      filePath: "examples/base/checkbox-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/checkbox-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-rtl": {
      name: "checkbox-rtl",
      filePath: "examples/base/checkbox-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/checkbox-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-table": {
      name: "checkbox-table",
      filePath: "examples/base/checkbox-table.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/checkbox-table")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-table"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "collapsible-basic": {
      name: "collapsible-basic",
      filePath: "examples/base/collapsible-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/collapsible-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "collapsible-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "collapsible-demo": {
      name: "collapsible-demo",
      filePath: "examples/base/collapsible-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/collapsible-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "collapsible-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "collapsible-file-tree": {
      name: "collapsible-file-tree",
      filePath: "examples/base/collapsible-file-tree.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/collapsible-file-tree")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "collapsible-file-tree"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "collapsible-rtl": {
      name: "collapsible-rtl",
      filePath: "examples/base/collapsible-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/collapsible-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "collapsible-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "collapsible-settings": {
      name: "collapsible-settings",
      filePath: "examples/base/collapsible-settings.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/collapsible-settings")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "collapsible-settings"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-auto-highlight": {
      name: "combobox-auto-highlight",
      filePath: "examples/base/combobox-auto-highlight.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-auto-highlight")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-auto-highlight"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-basic": {
      name: "combobox-basic",
      filePath: "examples/base/combobox-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-clear": {
      name: "combobox-clear",
      filePath: "examples/base/combobox-clear.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-clear")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-clear"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-custom": {
      name: "combobox-custom",
      filePath: "examples/base/combobox-custom.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-custom")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-custom"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-demo": {
      name: "combobox-demo",
      filePath: "examples/base/combobox-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-disabled": {
      name: "combobox-disabled",
      filePath: "examples/base/combobox-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-groups": {
      name: "combobox-groups",
      filePath: "examples/base/combobox-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-groups"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-input-group": {
      name: "combobox-input-group",
      filePath: "examples/base/combobox-input-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-input-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-input-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-invalid": {
      name: "combobox-invalid",
      filePath: "examples/base/combobox-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-multiple": {
      name: "combobox-multiple",
      filePath: "examples/base/combobox-multiple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-multiple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-multiple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-popup": {
      name: "combobox-popup",
      filePath: "examples/base/combobox-popup.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-popup")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-popup"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-rtl": {
      name: "combobox-rtl",
      filePath: "examples/base/combobox-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "command-basic": {
      name: "command-basic",
      filePath: "examples/base/command-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/command-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "command-demo": {
      name: "command-demo",
      filePath: "examples/base/command-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/command-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "command-dialog": {
      name: "command-dialog",
      filePath: "examples/base/command-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/command-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-dialog"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "command-groups": {
      name: "command-groups",
      filePath: "examples/base/command-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/command-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-groups"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "command-rtl": {
      name: "command-rtl",
      filePath: "examples/base/command-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/command-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "command-scrollable": {
      name: "command-scrollable",
      filePath: "examples/base/command-scrollable.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/command-scrollable")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-scrollable"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "command-shortcuts": {
      name: "command-shortcuts",
      filePath: "examples/base/command-shortcuts.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/command-shortcuts")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-shortcuts"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-basic": {
      name: "context-menu-basic",
      filePath: "examples/base/context-menu-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-checkboxes": {
      name: "context-menu-checkboxes",
      filePath: "examples/base/context-menu-checkboxes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-checkboxes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-checkboxes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-demo": {
      name: "context-menu-demo",
      filePath: "examples/base/context-menu-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-destructive": {
      name: "context-menu-destructive",
      filePath: "examples/base/context-menu-destructive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-destructive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-destructive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-groups": {
      name: "context-menu-groups",
      filePath: "examples/base/context-menu-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-groups"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-icons": {
      name: "context-menu-icons",
      filePath: "examples/base/context-menu-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-radio": {
      name: "context-menu-radio",
      filePath: "examples/base/context-menu-radio.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-radio")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-radio"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-rtl": {
      name: "context-menu-rtl",
      filePath: "examples/base/context-menu-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-shortcuts": {
      name: "context-menu-shortcuts",
      filePath: "examples/base/context-menu-shortcuts.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-shortcuts")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-shortcuts"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-sides": {
      name: "context-menu-sides",
      filePath: "examples/base/context-menu-sides.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-sides")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-sides"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-submenu": {
      name: "context-menu-submenu",
      filePath: "examples/base/context-menu-submenu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-submenu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-submenu"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "data-picker-with-dropdowns": {
      name: "data-picker-with-dropdowns",
      filePath: "examples/base/data-picker-with-dropdowns.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/data-picker-with-dropdowns")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "data-picker-with-dropdowns"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "data-table-demo": {
      name: "data-table-demo",
      filePath: "examples/base/data-table-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/data-table-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "data-table-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "data-table-rtl": {
      name: "data-table-rtl",
      filePath: "examples/base/data-table-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/data-table-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "data-table-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-basic": {
      name: "date-picker-basic",
      filePath: "examples/base/date-picker-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/date-picker-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-demo": {
      name: "date-picker-demo",
      filePath: "examples/base/date-picker-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/date-picker-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-dob": {
      name: "date-picker-dob",
      filePath: "examples/base/date-picker-dob.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/date-picker-dob")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-dob"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-input": {
      name: "date-picker-input",
      filePath: "examples/base/date-picker-input.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/date-picker-input")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-input"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-natural-language": {
      name: "date-picker-natural-language",
      filePath: "examples/base/date-picker-natural-language.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/date-picker-natural-language")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-natural-language"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-range": {
      name: "date-picker-range",
      filePath: "examples/base/date-picker-range.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/date-picker-range")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-range"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-rtl": {
      name: "date-picker-rtl",
      filePath: "examples/base/date-picker-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/date-picker-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-time": {
      name: "date-picker-time",
      filePath: "examples/base/date-picker-time.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/date-picker-time")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-time"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dialog-close-button": {
      name: "dialog-close-button",
      filePath: "examples/base/dialog-close-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dialog-close-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dialog-close-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dialog-demo": {
      name: "dialog-demo",
      filePath: "examples/base/dialog-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dialog-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dialog-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dialog-no-close-button": {
      name: "dialog-no-close-button",
      filePath: "examples/base/dialog-no-close-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dialog-no-close-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dialog-no-close-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dialog-rtl": {
      name: "dialog-rtl",
      filePath: "examples/base/dialog-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dialog-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dialog-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dialog-scrollable-content": {
      name: "dialog-scrollable-content",
      filePath: "examples/base/dialog-scrollable-content.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dialog-scrollable-content")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dialog-scrollable-content"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dialog-sticky-footer": {
      name: "dialog-sticky-footer",
      filePath: "examples/base/dialog-sticky-footer.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dialog-sticky-footer")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dialog-sticky-footer"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "drawer-demo": {
      name: "drawer-demo",
      filePath: "examples/base/drawer-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/drawer-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "drawer-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "drawer-dialog": {
      name: "drawer-dialog",
      filePath: "examples/base/drawer-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/drawer-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "drawer-dialog"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "drawer-rtl": {
      name: "drawer-rtl",
      filePath: "examples/base/drawer-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/drawer-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "drawer-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "drawer-scrollable-content": {
      name: "drawer-scrollable-content",
      filePath: "examples/base/drawer-scrollable-content.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/drawer-scrollable-content")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "drawer-scrollable-content"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "drawer-sides": {
      name: "drawer-sides",
      filePath: "examples/base/drawer-sides.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/drawer-sides")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "drawer-sides"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-avatar": {
      name: "dropdown-menu-avatar",
      filePath: "examples/base/dropdown-menu-avatar.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-avatar")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-avatar"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-basic": {
      name: "dropdown-menu-basic",
      filePath: "examples/base/dropdown-menu-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-checkboxes-icons": {
      name: "dropdown-menu-checkboxes-icons",
      filePath: "examples/base/dropdown-menu-checkboxes-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-checkboxes-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-checkboxes-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-checkboxes": {
      name: "dropdown-menu-checkboxes",
      filePath: "examples/base/dropdown-menu-checkboxes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-checkboxes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-checkboxes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-complex": {
      name: "dropdown-menu-complex",
      filePath: "examples/base/dropdown-menu-complex.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-complex")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-complex"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-demo": {
      name: "dropdown-menu-demo",
      filePath: "examples/base/dropdown-menu-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-destructive": {
      name: "dropdown-menu-destructive",
      filePath: "examples/base/dropdown-menu-destructive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-destructive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-destructive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-icons": {
      name: "dropdown-menu-icons",
      filePath: "examples/base/dropdown-menu-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-radio-group": {
      name: "dropdown-menu-radio-group",
      filePath: "examples/base/dropdown-menu-radio-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-radio-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-radio-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-radio-icons": {
      name: "dropdown-menu-radio-icons",
      filePath: "examples/base/dropdown-menu-radio-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-radio-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-radio-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-rtl": {
      name: "dropdown-menu-rtl",
      filePath: "examples/base/dropdown-menu-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-shortcuts": {
      name: "dropdown-menu-shortcuts",
      filePath: "examples/base/dropdown-menu-shortcuts.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-shortcuts")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-shortcuts"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-submenu": {
      name: "dropdown-menu-submenu",
      filePath: "examples/base/dropdown-menu-submenu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-submenu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-submenu"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-avatar-group": {
      name: "empty-avatar-group",
      filePath: "examples/base/empty-avatar-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/empty-avatar-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-avatar-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-avatar": {
      name: "empty-avatar",
      filePath: "examples/base/empty-avatar.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/empty-avatar")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-avatar"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-background": {
      name: "empty-background",
      filePath: "examples/base/empty-background.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/empty-background")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-background"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-card": {
      name: "empty-card",
      filePath: "examples/base/empty-card.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/empty-card")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-card"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-demo": {
      name: "empty-demo",
      filePath: "examples/base/empty-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/empty-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-input-group": {
      name: "empty-input-group",
      filePath: "examples/base/empty-input-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/empty-input-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-input-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-outline": {
      name: "empty-outline",
      filePath: "examples/base/empty-outline.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/empty-outline")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-outline"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-rtl": {
      name: "empty-rtl",
      filePath: "examples/base/empty-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/empty-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-checkbox": {
      name: "field-checkbox",
      filePath: "examples/base/field-checkbox.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/field-checkbox")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-checkbox"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-choice-card": {
      name: "field-choice-card",
      filePath: "examples/base/field-choice-card.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/field-choice-card")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-choice-card"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-demo": {
      name: "field-demo",
      filePath: "examples/base/field-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/field-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-fieldset": {
      name: "field-fieldset",
      filePath: "examples/base/field-fieldset.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/field-fieldset")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-fieldset"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-group": {
      name: "field-group",
      filePath: "examples/base/field-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/field-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-input": {
      name: "field-input",
      filePath: "examples/base/field-input.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/field-input")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-input"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-radio": {
      name: "field-radio",
      filePath: "examples/base/field-radio.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/field-radio")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-radio"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-responsive": {
      name: "field-responsive",
      filePath: "examples/base/field-responsive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/field-responsive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-responsive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-rtl": {
      name: "field-rtl",
      filePath: "examples/base/field-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/field-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-select": {
      name: "field-select",
      filePath: "examples/base/field-select.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/field-select")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-select"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-slider": {
      name: "field-slider",
      filePath: "examples/base/field-slider.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/field-slider")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-slider"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-switch": {
      name: "field-switch",
      filePath: "examples/base/field-switch.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/field-switch")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-switch"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "field-textarea": {
      name: "field-textarea",
      filePath: "examples/base/field-textarea.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/field-textarea")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "field-textarea"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "file-upload-list": {
      name: "file-upload-list",
      filePath: "examples/base/file-upload-list.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/file-upload-list")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "file-upload-list"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "hover-card-demo": {
      name: "hover-card-demo",
      filePath: "examples/base/hover-card-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/hover-card-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "hover-card-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "hover-card-rtl": {
      name: "hover-card-rtl",
      filePath: "examples/base/hover-card-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/hover-card-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "hover-card-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "hover-card-sides": {
      name: "hover-card-sides",
      filePath: "examples/base/hover-card-sides.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/hover-card-sides")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "hover-card-sides"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-badge": {
      name: "input-badge",
      filePath: "examples/base/input-badge.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-badge")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-badge"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-basic": {
      name: "input-basic",
      filePath: "examples/base/input-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-button-group": {
      name: "input-button-group",
      filePath: "examples/base/input-button-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-button-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-button-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-demo": {
      name: "input-demo",
      filePath: "examples/base/input-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-disabled": {
      name: "input-disabled",
      filePath: "examples/base/input-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-field": {
      name: "input-field",
      filePath: "examples/base/input-field.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-field")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-field"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-fieldgroup": {
      name: "input-fieldgroup",
      filePath: "examples/base/input-fieldgroup.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-fieldgroup")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-fieldgroup"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-file": {
      name: "input-file",
      filePath: "examples/base/input-file.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-file")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-file"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-form": {
      name: "input-form",
      filePath: "examples/base/input-form.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-form")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-form"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-grid": {
      name: "input-grid",
      filePath: "examples/base/input-grid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-grid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-grid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-basic": {
      name: "input-group-basic",
      filePath: "examples/base/input-group-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-block-end": {
      name: "input-group-block-end",
      filePath: "examples/base/input-group-block-end.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-block-end")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-block-end"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-block-start": {
      name: "input-group-block-start",
      filePath: "examples/base/input-group-block-start.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-block-start")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-block-start"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-button-group": {
      name: "input-group-button-group",
      filePath: "examples/base/input-group-button-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-button-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-button-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-button": {
      name: "input-group-button",
      filePath: "examples/base/input-group-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-custom": {
      name: "input-group-custom",
      filePath: "examples/base/input-group-custom.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-custom")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-custom"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-demo": {
      name: "input-group-demo",
      filePath: "examples/base/input-group-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-dropdown": {
      name: "input-group-dropdown",
      filePath: "examples/base/input-group-dropdown.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-dropdown")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-dropdown"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-icon": {
      name: "input-group-icon",
      filePath: "examples/base/input-group-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-in-card": {
      name: "input-group-in-card",
      filePath: "examples/base/input-group-in-card.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-in-card")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-in-card"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-inline-end": {
      name: "input-group-inline-end",
      filePath: "examples/base/input-group-inline-end.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-inline-end")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-inline-end"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-inline-start": {
      name: "input-group-inline-start",
      filePath: "examples/base/input-group-inline-start.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-inline-start")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-inline-start"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-kbd": {
      name: "input-group-kbd",
      filePath: "examples/base/input-group-kbd.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-kbd")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-kbd"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-label": {
      name: "input-group-label",
      filePath: "examples/base/input-group-label.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-label")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-label"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-rtl": {
      name: "input-group-rtl",
      filePath: "examples/base/input-group-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-spinner": {
      name: "input-group-spinner",
      filePath: "examples/base/input-group-spinner.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-spinner")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-spinner"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-text": {
      name: "input-group-text",
      filePath: "examples/base/input-group-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-text"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-textarea-examples": {
      name: "input-group-textarea-examples",
      filePath: "examples/base/input-group-textarea-examples.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-textarea-examples")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-textarea-examples"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-textarea": {
      name: "input-group-textarea",
      filePath: "examples/base/input-group-textarea.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-textarea")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-textarea"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-tooltip": {
      name: "input-group-tooltip",
      filePath: "examples/base/input-group-tooltip.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-tooltip")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-tooltip"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-with-addons": {
      name: "input-group-with-addons",
      filePath: "examples/base/input-group-with-addons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-with-addons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-with-addons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-with-buttons": {
      name: "input-group-with-buttons",
      filePath: "examples/base/input-group-with-buttons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-with-buttons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-with-buttons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-with-kbd": {
      name: "input-group-with-kbd",
      filePath: "examples/base/input-group-with-kbd.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-with-kbd")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-with-kbd"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-group-with-tooltip": {
      name: "input-group-with-tooltip",
      filePath: "examples/base/input-group-with-tooltip.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-group-with-tooltip")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-group-with-tooltip"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-inline": {
      name: "input-inline",
      filePath: "examples/base/input-inline.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-inline")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-inline"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-input-group": {
      name: "input-input-group",
      filePath: "examples/base/input-input-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-input-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-input-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-invalid": {
      name: "input-invalid",
      filePath: "examples/base/input-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-alphanumeric": {
      name: "input-otp-alphanumeric",
      filePath: "examples/base/input-otp-alphanumeric.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-otp-alphanumeric")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-alphanumeric"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-controlled": {
      name: "input-otp-controlled",
      filePath: "examples/base/input-otp-controlled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-otp-controlled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-controlled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-demo": {
      name: "input-otp-demo",
      filePath: "examples/base/input-otp-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-otp-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-disabled": {
      name: "input-otp-disabled",
      filePath: "examples/base/input-otp-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-otp-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-form": {
      name: "input-otp-form",
      filePath: "examples/base/input-otp-form.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-otp-form")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-form"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-four-digits": {
      name: "input-otp-four-digits",
      filePath: "examples/base/input-otp-four-digits.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-otp-four-digits")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-four-digits"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-invalid": {
      name: "input-otp-invalid",
      filePath: "examples/base/input-otp-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-otp-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-pattern": {
      name: "input-otp-pattern",
      filePath: "examples/base/input-otp-pattern.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-otp-pattern")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-pattern"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-rtl": {
      name: "input-otp-rtl",
      filePath: "examples/base/input-otp-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-otp-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-separator": {
      name: "input-otp-separator",
      filePath: "examples/base/input-otp-separator.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-otp-separator")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-separator"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-required": {
      name: "input-required",
      filePath: "examples/base/input-required.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-required")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-required"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-rtl": {
      name: "input-rtl",
      filePath: "examples/base/input-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-avatar": {
      name: "item-avatar",
      filePath: "examples/base/item-avatar.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-avatar")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-avatar"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-demo": {
      name: "item-demo",
      filePath: "examples/base/item-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-dropdown": {
      name: "item-dropdown",
      filePath: "examples/base/item-dropdown.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-dropdown")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-dropdown"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-group": {
      name: "item-group",
      filePath: "examples/base/item-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-header": {
      name: "item-header",
      filePath: "examples/base/item-header.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-header")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-header"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-icon": {
      name: "item-icon",
      filePath: "examples/base/item-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-image": {
      name: "item-image",
      filePath: "examples/base/item-image.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-image")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-image"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-link": {
      name: "item-link",
      filePath: "examples/base/item-link.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-link")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-link"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-rtl": {
      name: "item-rtl",
      filePath: "examples/base/item-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-size": {
      name: "item-size",
      filePath: "examples/base/item-size.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-size")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-size"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-variant": {
      name: "item-variant",
      filePath: "examples/base/item-variant.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-variant")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-variant"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-button": {
      name: "kbd-button",
      filePath: "examples/base/kbd-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/kbd-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-demo": {
      name: "kbd-demo",
      filePath: "examples/base/kbd-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/kbd-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-group": {
      name: "kbd-group",
      filePath: "examples/base/kbd-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/kbd-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-input-group": {
      name: "kbd-input-group",
      filePath: "examples/base/kbd-input-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/kbd-input-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-input-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-rtl": {
      name: "kbd-rtl",
      filePath: "examples/base/kbd-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/kbd-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-tooltip": {
      name: "kbd-tooltip",
      filePath: "examples/base/kbd-tooltip.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/kbd-tooltip")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-tooltip"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "label-demo": {
      name: "label-demo",
      filePath: "examples/base/label-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/label-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "label-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "label-rtl": {
      name: "label-rtl",
      filePath: "examples/base/label-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/label-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "label-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-checkbox": {
      name: "menubar-checkbox",
      filePath: "examples/base/menubar-checkbox.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/menubar-checkbox")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-checkbox"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-demo": {
      name: "menubar-demo",
      filePath: "examples/base/menubar-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/menubar-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-icons": {
      name: "menubar-icons",
      filePath: "examples/base/menubar-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/menubar-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-radio": {
      name: "menubar-radio",
      filePath: "examples/base/menubar-radio.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/menubar-radio")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-radio"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-rtl": {
      name: "menubar-rtl",
      filePath: "examples/base/menubar-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/menubar-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-submenu": {
      name: "menubar-submenu",
      filePath: "examples/base/menubar-submenu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/menubar-submenu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-submenu"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "muted-item-group": {
      name: "muted-item-group",
      filePath: "examples/base/muted-item-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/muted-item-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "muted-item-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "native-select-demo": {
      name: "native-select-demo",
      filePath: "examples/base/native-select-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/native-select-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "native-select-disabled": {
      name: "native-select-disabled",
      filePath: "examples/base/native-select-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/native-select-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "native-select-groups": {
      name: "native-select-groups",
      filePath: "examples/base/native-select-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/native-select-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-groups"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "native-select-invalid": {
      name: "native-select-invalid",
      filePath: "examples/base/native-select-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/native-select-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "native-select-rtl": {
      name: "native-select-rtl",
      filePath: "examples/base/native-select-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/native-select-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "navigation-menu-demo": {
      name: "navigation-menu-demo",
      filePath: "examples/base/navigation-menu-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/navigation-menu-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "navigation-menu-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "navigation-menu-rtl": {
      name: "navigation-menu-rtl",
      filePath: "examples/base/navigation-menu-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/navigation-menu-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "navigation-menu-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "outline-item-group": {
      name: "outline-item-group",
      filePath: "examples/base/outline-item-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/outline-item-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "outline-item-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "pagination-demo": {
      name: "pagination-demo",
      filePath: "examples/base/pagination-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/pagination-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "pagination-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "pagination-icons-only": {
      name: "pagination-icons-only",
      filePath: "examples/base/pagination-icons-only.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/pagination-icons-only")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "pagination-icons-only"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "pagination-rtl": {
      name: "pagination-rtl",
      filePath: "examples/base/pagination-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/pagination-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "pagination-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "pagination-simple": {
      name: "pagination-simple",
      filePath: "examples/base/pagination-simple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/pagination-simple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "pagination-simple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "popover-alignments": {
      name: "popover-alignments",
      filePath: "examples/base/popover-alignments.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/popover-alignments")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "popover-alignments"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "popover-basic": {
      name: "popover-basic",
      filePath: "examples/base/popover-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/popover-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "popover-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "popover-demo": {
      name: "popover-demo",
      filePath: "examples/base/popover-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/popover-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "popover-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "popover-form": {
      name: "popover-form",
      filePath: "examples/base/popover-form.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/popover-form")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "popover-form"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "popover-rtl": {
      name: "popover-rtl",
      filePath: "examples/base/popover-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/popover-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "popover-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "progress-controlled": {
      name: "progress-controlled",
      filePath: "examples/base/progress-controlled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/progress-controlled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "progress-controlled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "progress-demo": {
      name: "progress-demo",
      filePath: "examples/base/progress-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/progress-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "progress-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "progress-label": {
      name: "progress-label",
      filePath: "examples/base/progress-label.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/progress-label")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "progress-label"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "progress-rtl": {
      name: "progress-rtl",
      filePath: "examples/base/progress-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/progress-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "progress-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "radio-fields": {
      name: "radio-fields",
      filePath: "examples/base/radio-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/radio-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-fields"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "radio-group-choice-card": {
      name: "radio-group-choice-card",
      filePath: "examples/base/radio-group-choice-card.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/radio-group-choice-card")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-choice-card"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "radio-group-demo": {
      name: "radio-group-demo",
      filePath: "examples/base/radio-group-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/radio-group-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "radio-group-description": {
      name: "radio-group-description",
      filePath: "examples/base/radio-group-description.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/radio-group-description")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-description"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "radio-group-disabled": {
      name: "radio-group-disabled",
      filePath: "examples/base/radio-group-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/radio-group-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "radio-group-fieldset": {
      name: "radio-group-fieldset",
      filePath: "examples/base/radio-group-fieldset.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/radio-group-fieldset")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-fieldset"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "radio-group-invalid": {
      name: "radio-group-invalid",
      filePath: "examples/base/radio-group-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/radio-group-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "radio-group-rtl": {
      name: "radio-group-rtl",
      filePath: "examples/base/radio-group-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/radio-group-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "resizable-demo": {
      name: "resizable-demo",
      filePath: "examples/base/resizable-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/resizable-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "resizable-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "resizable-handle": {
      name: "resizable-handle",
      filePath: "examples/base/resizable-handle.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/resizable-handle")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "resizable-handle"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "resizable-rtl": {
      name: "resizable-rtl",
      filePath: "examples/base/resizable-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/resizable-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "resizable-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "resizable-vertical": {
      name: "resizable-vertical",
      filePath: "examples/base/resizable-vertical.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/resizable-vertical")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "resizable-vertical"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "scroll-area-demo": {
      name: "scroll-area-demo",
      filePath: "examples/base/scroll-area-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/scroll-area-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "scroll-area-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "scroll-area-horizontal-demo": {
      name: "scroll-area-horizontal-demo",
      filePath: "examples/base/scroll-area-horizontal-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/scroll-area-horizontal-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "scroll-area-horizontal-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "scroll-area-rtl": {
      name: "scroll-area-rtl",
      filePath: "examples/base/scroll-area-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/scroll-area-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "scroll-area-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-align-item": {
      name: "select-align-item",
      filePath: "examples/base/select-align-item.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-align-item")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-align-item"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-demo": {
      name: "select-demo",
      filePath: "examples/base/select-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-disabled": {
      name: "select-disabled",
      filePath: "examples/base/select-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-groups": {
      name: "select-groups",
      filePath: "examples/base/select-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-groups"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-invalid": {
      name: "select-invalid",
      filePath: "examples/base/select-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-rtl": {
      name: "select-rtl",
      filePath: "examples/base/select-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-scrollable": {
      name: "select-scrollable",
      filePath: "examples/base/select-scrollable.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-scrollable")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-scrollable"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "separator-demo": {
      name: "separator-demo",
      filePath: "examples/base/separator-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/separator-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "separator-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "separator-list": {
      name: "separator-list",
      filePath: "examples/base/separator-list.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/separator-list")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "separator-list"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "separator-menu": {
      name: "separator-menu",
      filePath: "examples/base/separator-menu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/separator-menu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "separator-menu"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "separator-rtl": {
      name: "separator-rtl",
      filePath: "examples/base/separator-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/separator-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "separator-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "separator-vertical": {
      name: "separator-vertical",
      filePath: "examples/base/separator-vertical.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/separator-vertical")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "separator-vertical"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sheet-demo": {
      name: "sheet-demo",
      filePath: "examples/base/sheet-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sheet-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sheet-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sheet-no-close-button": {
      name: "sheet-no-close-button",
      filePath: "examples/base/sheet-no-close-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sheet-no-close-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sheet-no-close-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sheet-rtl": {
      name: "sheet-rtl",
      filePath: "examples/base/sheet-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sheet-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sheet-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sheet-side": {
      name: "sheet-side",
      filePath: "examples/base/sheet-side.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sheet-side")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sheet-side"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-controlled": {
      name: "sidebar-controlled",
      filePath: "examples/base/sidebar-controlled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sidebar-controlled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-controlled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-demo": {
      name: "sidebar-demo",
      filePath: "examples/base/sidebar-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sidebar-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-footer": {
      name: "sidebar-footer",
      filePath: "examples/base/sidebar-footer.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sidebar-footer")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-footer"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-group-action": {
      name: "sidebar-group-action",
      filePath: "examples/base/sidebar-group-action.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sidebar-group-action")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-group-action"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-group-collapsible": {
      name: "sidebar-group-collapsible",
      filePath: "examples/base/sidebar-group-collapsible.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sidebar-group-collapsible")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-group-collapsible"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-group": {
      name: "sidebar-group",
      filePath: "examples/base/sidebar-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sidebar-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-header": {
      name: "sidebar-header",
      filePath: "examples/base/sidebar-header.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sidebar-header")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-header"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-menu-action": {
      name: "sidebar-menu-action",
      filePath: "examples/base/sidebar-menu-action.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sidebar-menu-action")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-menu-action"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-menu-badge": {
      name: "sidebar-menu-badge",
      filePath: "examples/base/sidebar-menu-badge.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sidebar-menu-badge")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-menu-badge"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-menu-collapsible": {
      name: "sidebar-menu-collapsible",
      filePath: "examples/base/sidebar-menu-collapsible.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sidebar-menu-collapsible")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-menu-collapsible"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-menu-sub": {
      name: "sidebar-menu-sub",
      filePath: "examples/base/sidebar-menu-sub.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sidebar-menu-sub")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-menu-sub"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-menu": {
      name: "sidebar-menu",
      filePath: "examples/base/sidebar-menu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sidebar-menu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-menu"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-rsc": {
      name: "sidebar-rsc",
      filePath: "examples/base/sidebar-rsc.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sidebar-rsc")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-rsc"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sidebar-rtl": {
      name: "sidebar-rtl",
      filePath: "examples/base/sidebar-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sidebar-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sidebar-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "skeleton-avatar": {
      name: "skeleton-avatar",
      filePath: "examples/base/skeleton-avatar.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/skeleton-avatar")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "skeleton-avatar"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "skeleton-card": {
      name: "skeleton-card",
      filePath: "examples/base/skeleton-card.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/skeleton-card")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "skeleton-card"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "skeleton-demo": {
      name: "skeleton-demo",
      filePath: "examples/base/skeleton-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/skeleton-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "skeleton-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "skeleton-form": {
      name: "skeleton-form",
      filePath: "examples/base/skeleton-form.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/skeleton-form")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "skeleton-form"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "skeleton-rtl": {
      name: "skeleton-rtl",
      filePath: "examples/base/skeleton-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/skeleton-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "skeleton-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "skeleton-table": {
      name: "skeleton-table",
      filePath: "examples/base/skeleton-table.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/skeleton-table")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "skeleton-table"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "skeleton-text": {
      name: "skeleton-text",
      filePath: "examples/base/skeleton-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/skeleton-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "skeleton-text"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "slider-controlled": {
      name: "slider-controlled",
      filePath: "examples/base/slider-controlled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/slider-controlled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "slider-controlled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "slider-demo": {
      name: "slider-demo",
      filePath: "examples/base/slider-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/slider-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "slider-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "slider-disabled": {
      name: "slider-disabled",
      filePath: "examples/base/slider-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/slider-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "slider-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "slider-multiple": {
      name: "slider-multiple",
      filePath: "examples/base/slider-multiple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/slider-multiple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "slider-multiple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "slider-range": {
      name: "slider-range",
      filePath: "examples/base/slider-range.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/slider-range")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "slider-range"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "slider-rtl": {
      name: "slider-rtl",
      filePath: "examples/base/slider-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/slider-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "slider-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "slider-vertical": {
      name: "slider-vertical",
      filePath: "examples/base/slider-vertical.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/slider-vertical")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "slider-vertical"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sonner-demo": {
      name: "sonner-demo",
      filePath: "examples/base/sonner-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sonner-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sonner-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sonner-description": {
      name: "sonner-description",
      filePath: "examples/base/sonner-description.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sonner-description")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sonner-description"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sonner-position": {
      name: "sonner-position",
      filePath: "examples/base/sonner-position.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sonner-position")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sonner-position"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sonner-types": {
      name: "sonner-types",
      filePath: "examples/base/sonner-types.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sonner-types")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sonner-types"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-badge": {
      name: "spinner-badge",
      filePath: "examples/base/spinner-badge.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/spinner-badge")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-badge"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-button": {
      name: "spinner-button",
      filePath: "examples/base/spinner-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/spinner-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-custom": {
      name: "spinner-custom",
      filePath: "examples/base/spinner-custom.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/spinner-custom")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-custom"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-demo": {
      name: "spinner-demo",
      filePath: "examples/base/spinner-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/spinner-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-empty": {
      name: "spinner-empty",
      filePath: "examples/base/spinner-empty.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/spinner-empty")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-empty"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-input-group": {
      name: "spinner-input-group",
      filePath: "examples/base/spinner-input-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/spinner-input-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-input-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-rtl": {
      name: "spinner-rtl",
      filePath: "examples/base/spinner-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/spinner-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-size": {
      name: "spinner-size",
      filePath: "examples/base/spinner-size.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/spinner-size")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-size"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "switch-choice-card": {
      name: "switch-choice-card",
      filePath: "examples/base/switch-choice-card.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/switch-choice-card")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-choice-card"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "switch-demo": {
      name: "switch-demo",
      filePath: "examples/base/switch-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/switch-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "switch-description": {
      name: "switch-description",
      filePath: "examples/base/switch-description.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/switch-description")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-description"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "switch-disabled": {
      name: "switch-disabled",
      filePath: "examples/base/switch-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/switch-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "switch-invalid": {
      name: "switch-invalid",
      filePath: "examples/base/switch-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/switch-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "switch-rtl": {
      name: "switch-rtl",
      filePath: "examples/base/switch-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/switch-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "switch-sizes": {
      name: "switch-sizes",
      filePath: "examples/base/switch-sizes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/switch-sizes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-sizes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-actions": {
      name: "table-actions",
      filePath: "examples/base/table-actions.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/table-actions")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-actions"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-demo": {
      name: "table-demo",
      filePath: "examples/base/table-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/table-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-footer": {
      name: "table-footer",
      filePath: "examples/base/table-footer.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/table-footer")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-footer"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-rtl": {
      name: "table-rtl",
      filePath: "examples/base/table-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/table-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-demo": {
      name: "tabs-demo",
      filePath: "examples/base/tabs-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tabs-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-disabled": {
      name: "tabs-disabled",
      filePath: "examples/base/tabs-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tabs-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-icons": {
      name: "tabs-icons",
      filePath: "examples/base/tabs-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tabs-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-line": {
      name: "tabs-line",
      filePath: "examples/base/tabs-line.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tabs-line")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-line"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-rtl": {
      name: "tabs-rtl",
      filePath: "examples/base/tabs-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tabs-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-vertical": {
      name: "tabs-vertical",
      filePath: "examples/base/tabs-vertical.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tabs-vertical")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-vertical"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-button": {
      name: "textarea-button",
      filePath: "examples/base/textarea-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/textarea-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-demo": {
      name: "textarea-demo",
      filePath: "examples/base/textarea-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/textarea-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-disabled": {
      name: "textarea-disabled",
      filePath: "examples/base/textarea-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/textarea-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-field": {
      name: "textarea-field",
      filePath: "examples/base/textarea-field.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/textarea-field")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-field"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-invalid": {
      name: "textarea-invalid",
      filePath: "examples/base/textarea-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/textarea-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-rtl": {
      name: "textarea-rtl",
      filePath: "examples/base/textarea-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/textarea-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-demo": {
      name: "toggle-demo",
      filePath: "examples/base/toggle-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-disabled": {
      name: "toggle-disabled",
      filePath: "examples/base/toggle-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-demo": {
      name: "toggle-group-demo",
      filePath: "examples/base/toggle-group-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-disabled": {
      name: "toggle-group-disabled",
      filePath: "examples/base/toggle-group-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-font-weight-selector": {
      name: "toggle-group-font-weight-selector",
      filePath: "examples/base/toggle-group-font-weight-selector.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-font-weight-selector")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-font-weight-selector"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-outline": {
      name: "toggle-group-outline",
      filePath: "examples/base/toggle-group-outline.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-outline")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-outline"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-rtl": {
      name: "toggle-group-rtl",
      filePath: "examples/base/toggle-group-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-sizes": {
      name: "toggle-group-sizes",
      filePath: "examples/base/toggle-group-sizes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-sizes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-sizes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-spacing": {
      name: "toggle-group-spacing",
      filePath: "examples/base/toggle-group-spacing.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-spacing")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-spacing"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-vertical": {
      name: "toggle-group-vertical",
      filePath: "examples/base/toggle-group-vertical.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-vertical")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-vertical"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-outline": {
      name: "toggle-outline",
      filePath: "examples/base/toggle-outline.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-outline")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-outline"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-rtl": {
      name: "toggle-rtl",
      filePath: "examples/base/toggle-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-sizes": {
      name: "toggle-sizes",
      filePath: "examples/base/toggle-sizes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-sizes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-sizes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-text": {
      name: "toggle-text",
      filePath: "examples/base/toggle-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-text"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tooltip-demo": {
      name: "tooltip-demo",
      filePath: "examples/base/tooltip-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tooltip-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tooltip-disabled": {
      name: "tooltip-disabled",
      filePath: "examples/base/tooltip-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tooltip-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tooltip-keyboard": {
      name: "tooltip-keyboard",
      filePath: "examples/base/tooltip-keyboard.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tooltip-keyboard")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-keyboard"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tooltip-rtl": {
      name: "tooltip-rtl",
      filePath: "examples/base/tooltip-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tooltip-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tooltip-sides": {
      name: "tooltip-sides",
      filePath: "examples/base/tooltip-sides.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tooltip-sides")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-sides"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-blockquote": {
      name: "typography-blockquote",
      filePath: "examples/base/typography-blockquote.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/typography-blockquote")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-blockquote"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-demo": {
      name: "typography-demo",
      filePath: "examples/base/typography-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/typography-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-h1": {
      name: "typography-h1",
      filePath: "examples/base/typography-h1.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/typography-h1")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-h1"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-h2": {
      name: "typography-h2",
      filePath: "examples/base/typography-h2.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/typography-h2")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-h2"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-h3": {
      name: "typography-h3",
      filePath: "examples/base/typography-h3.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/typography-h3")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-h3"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-h4": {
      name: "typography-h4",
      filePath: "examples/base/typography-h4.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/typography-h4")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-h4"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-inline-code": {
      name: "typography-inline-code",
      filePath: "examples/base/typography-inline-code.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/typography-inline-code")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-inline-code"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-large": {
      name: "typography-large",
      filePath: "examples/base/typography-large.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/typography-large")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-large"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-lead": {
      name: "typography-lead",
      filePath: "examples/base/typography-lead.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/typography-lead")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-lead"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-list": {
      name: "typography-list",
      filePath: "examples/base/typography-list.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/typography-list")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-list"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-muted": {
      name: "typography-muted",
      filePath: "examples/base/typography-muted.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/typography-muted")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-muted"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-p": {
      name: "typography-p",
      filePath: "examples/base/typography-p.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/typography-p")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-p"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-rtl": {
      name: "typography-rtl",
      filePath: "examples/base/typography-rtl.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/typography-rtl")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-rtl"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-small": {
      name: "typography-small",
      filePath: "examples/base/typography-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/typography-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "typography-table": {
      name: "typography-table",
      filePath: "examples/base/typography-table.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/typography-table")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "typography-table"
        return { default: mod.default || mod[exportName] }
      }),
    },
  },
}