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

// @ts-nocheck
// This file is autogenerated by scripts/build-examples-index.mts
// Do not edit this file directly.
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] }
      }),
    },
    "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-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] }
      }),
    },
    "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-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-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-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-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-basic": {
      name: "button-group-basic",
      filePath: "examples/radix/button-group-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-basic"
        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-navigation": {
      name: "button-group-navigation",
      filePath: "examples/radix/button-group-navigation.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-navigation")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-navigation"
        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-pagination-split": {
      name: "button-group-pagination-split",
      filePath: "examples/radix/button-group-pagination-split.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-pagination-split")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-pagination-split"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-pagination": {
      name: "button-group-pagination",
      filePath: "examples/radix/button-group-pagination.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-pagination")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-pagination"
        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-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-group-text-alignment": {
      name: "button-group-text-alignment",
      filePath: "examples/radix/button-group-text-alignment.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-text-alignment")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-text-alignment"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-vertical-nested": {
      name: "button-group-vertical-nested",
      filePath: "examples/radix/button-group-vertical-nested.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-vertical-nested")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-vertical-nested"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-vertical": {
      name: "button-group-vertical",
      filePath: "examples/radix/button-group-vertical.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-vertical")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-vertical"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-with-dropdown": {
      name: "button-group-with-dropdown",
      filePath: "examples/radix/button-group-with-dropdown.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-with-dropdown")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-with-dropdown"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-with-fields": {
      name: "button-group-with-fields",
      filePath: "examples/radix/button-group-with-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-with-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-with-fields"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-with-icons": {
      name: "button-group-with-icons",
      filePath: "examples/radix/button-group-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-with-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-with-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-with-input-group": {
      name: "button-group-with-input-group",
      filePath: "examples/radix/button-group-with-input-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-with-input-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-with-input-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-with-input": {
      name: "button-group-with-input",
      filePath: "examples/radix/button-group-with-input.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-with-input")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-with-input"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-with-like": {
      name: "button-group-with-like",
      filePath: "examples/radix/button-group-with-like.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-with-like")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-with-like"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-with-select-and-input": {
      name: "button-group-with-select-and-input",
      filePath: "examples/radix/button-group-with-select-and-input.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-with-select-and-input")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-with-select-and-input"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-with-select": {
      name: "button-group-with-select",
      filePath: "examples/radix/button-group-with-select.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-with-select")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-with-select"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-with-text": {
      name: "button-group-with-text",
      filePath: "examples/radix/button-group-with-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/button-group-with-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-with-text"
        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-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-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-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-range-multiple-months": {
      name: "calendar-range-multiple-months",
      filePath: "examples/radix/calendar-range-multiple-months.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/calendar-range-multiple-months")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-range-multiple-months"
        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-single": {
      name: "calendar-single",
      filePath: "examples/radix/calendar-single.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/calendar-single")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-single"
        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] }
      }),
    },
    "calendar-with-presets": {
      name: "calendar-with-presets",
      filePath: "examples/radix/calendar-with-presets.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/calendar-with-presets")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-with-presets"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-with-time": {
      name: "calendar-with-time",
      filePath: "examples/radix/calendar-with-time.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/calendar-with-time")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-with-time"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-default": {
      name: "card-default",
      filePath: "examples/radix/card-default.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/card-default")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-default"
        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-footer-with-border-small": {
      name: "card-footer-with-border-small",
      filePath: "examples/radix/card-footer-with-border-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/card-footer-with-border-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-footer-with-border-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-footer-with-border": {
      name: "card-footer-with-border",
      filePath: "examples/radix/card-footer-with-border.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/card-footer-with-border")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-footer-with-border"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-header-with-border-small": {
      name: "card-header-with-border-small",
      filePath: "examples/radix/card-header-with-border-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/card-header-with-border-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-header-with-border-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-header-with-border": {
      name: "card-header-with-border",
      filePath: "examples/radix/card-header-with-border.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/card-header-with-border")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-header-with-border"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-login": {
      name: "card-login",
      filePath: "examples/radix/card-login.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/card-login")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-login"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-meeting-notes": {
      name: "card-meeting-notes",
      filePath: "examples/radix/card-meeting-notes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/card-meeting-notes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-meeting-notes"
        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-with-image-small": {
      name: "card-with-image-small",
      filePath: "examples/radix/card-with-image-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/card-with-image-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-with-image-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-with-image": {
      name: "card-with-image",
      filePath: "examples/radix/card-with-image.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/card-with-image")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-with-image"
        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-basic": {
      name: "carousel-basic",
      filePath: "examples/radix/carousel-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/carousel-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-basic"
        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-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] }
      }),
    },
    "carousel-with-gap": {
      name: "carousel-with-gap",
      filePath: "examples/radix/carousel-with-gap.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/carousel-with-gap")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-with-gap"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-area-example": {
      name: "chart-area-example",
      filePath: "examples/radix/chart-area-example.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-area-example")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-area-example"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-bar-demo-axis": {
      name: "chart-bar-demo-axis",
      filePath: "examples/radix/chart-bar-demo-axis.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-bar-demo-axis")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-bar-demo-axis"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-bar-demo-grid": {
      name: "chart-bar-demo-grid",
      filePath: "examples/radix/chart-bar-demo-grid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-bar-demo-grid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-bar-demo-grid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-bar-demo-legend": {
      name: "chart-bar-demo-legend",
      filePath: "examples/radix/chart-bar-demo-legend.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-bar-demo-legend")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-bar-demo-legend"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-bar-demo-tooltip": {
      name: "chart-bar-demo-tooltip",
      filePath: "examples/radix/chart-bar-demo-tooltip.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-bar-demo-tooltip")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-bar-demo-tooltip"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-bar-demo": {
      name: "chart-bar-demo",
      filePath: "examples/radix/chart-bar-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-bar-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-bar-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-bar-example": {
      name: "chart-bar-example",
      filePath: "examples/radix/chart-bar-example.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-bar-example")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-bar-example"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-line-example": {
      name: "chart-line-example",
      filePath: "examples/radix/chart-line-example.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-line-example")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-line-example"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-pie-example": {
      name: "chart-pie-example",
      filePath: "examples/radix/chart-pie-example.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-pie-example")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-pie-example"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-radar-example": {
      name: "chart-radar-example",
      filePath: "examples/radix/chart-radar-example.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-radar-example")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-radar-example"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-radial-example": {
      name: "chart-radial-example",
      filePath: "examples/radix/chart-radial-example.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-radial-example")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-radial-example"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-tooltip-demo": {
      name: "chart-tooltip-demo",
      filePath: "examples/radix/chart-tooltip-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/chart-tooltip-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-tooltip-demo"
        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-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-fields": {
      name: "checkbox-fields",
      filePath: "examples/radix/checkbox-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/checkbox-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-fields"
        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-in-table": {
      name: "checkbox-in-table",
      filePath: "examples/radix/checkbox-in-table.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/checkbox-in-table")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-in-table"
        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-with-description": {
      name: "checkbox-with-description",
      filePath: "examples/radix/checkbox-with-description.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/checkbox-with-description")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-with-description"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-with-text": {
      name: "checkbox-with-text",
      filePath: "examples/radix/checkbox-with-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/checkbox-with-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-with-text"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-with-title": {
      name: "checkbox-with-title",
      filePath: "examples/radix/checkbox-with-title.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/checkbox-with-title")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-with-title"
        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-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-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-dropdown-menu": {
      name: "combobox-dropdown-menu",
      filePath: "examples/radix/combobox-dropdown-menu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-dropdown-menu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-dropdown-menu"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-in-dialog": {
      name: "combobox-in-dialog",
      filePath: "examples/radix/combobox-in-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-in-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-in-dialog"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-in-popup": {
      name: "combobox-in-popup",
      filePath: "examples/radix/combobox-in-popup.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-in-popup")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-in-popup"
        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-large-list": {
      name: "combobox-large-list",
      filePath: "examples/radix/combobox-large-list.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-large-list")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-large-list"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-multiple-disabled": {
      name: "combobox-multiple-disabled",
      filePath: "examples/radix/combobox-multiple-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-multiple-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-multiple-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-multiple-invalid": {
      name: "combobox-multiple-invalid",
      filePath: "examples/radix/combobox-multiple-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-multiple-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-multiple-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-multiple-no-remove": {
      name: "combobox-multiple-no-remove",
      filePath: "examples/radix/combobox-multiple-no-remove.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-multiple-no-remove")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-multiple-no-remove"
        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-popover": {
      name: "combobox-popover",
      filePath: "examples/radix/combobox-popover.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-popover")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-popover"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-responsive": {
      name: "combobox-responsive",
      filePath: "examples/radix/combobox-responsive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-responsive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-responsive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-with-clear": {
      name: "combobox-with-clear",
      filePath: "examples/radix/combobox-with-clear.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-with-clear")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-with-clear"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-with-custom-items": {
      name: "combobox-with-custom-items",
      filePath: "examples/radix/combobox-with-custom-items.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-with-custom-items")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-with-custom-items"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-with-form": {
      name: "combobox-with-form",
      filePath: "examples/radix/combobox-with-form.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-with-form")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-with-form"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-with-groups-and-separator": {
      name: "combobox-with-groups-and-separator",
      filePath: "examples/radix/combobox-with-groups-and-separator.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-with-groups-and-separator")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-with-groups-and-separator"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-with-groups": {
      name: "combobox-with-groups",
      filePath: "examples/radix/combobox-with-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-with-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-with-groups"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-with-other-inputs": {
      name: "combobox-with-other-inputs",
      filePath: "examples/radix/combobox-with-other-inputs.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/combobox-with-other-inputs")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-with-other-inputs"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "comboxbox-input-addon": {
      name: "comboxbox-input-addon",
      filePath: "examples/radix/comboxbox-input-addon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/comboxbox-input-addon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "comboxbox-input-addon"
        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-many-items": {
      name: "command-many-items",
      filePath: "examples/radix/command-many-items.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/command-many-items")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-many-items"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "command-with-groups": {
      name: "command-with-groups",
      filePath: "examples/radix/command-with-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/command-with-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-with-groups"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "command-with-shortcuts": {
      name: "command-with-shortcuts",
      filePath: "examples/radix/command-with-shortcuts.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/command-with-shortcuts")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-with-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-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-in-dialog": {
      name: "context-menu-in-dialog",
      filePath: "examples/radix/context-menu-in-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-in-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-in-dialog"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-with-checkboxes": {
      name: "context-menu-with-checkboxes",
      filePath: "examples/radix/context-menu-with-checkboxes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-with-checkboxes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-with-checkboxes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-with-destructive": {
      name: "context-menu-with-destructive",
      filePath: "examples/radix/context-menu-with-destructive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-with-destructive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-with-destructive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-with-groups": {
      name: "context-menu-with-groups",
      filePath: "examples/radix/context-menu-with-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-with-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-with-groups"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-with-icons": {
      name: "context-menu-with-icons",
      filePath: "examples/radix/context-menu-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-with-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-with-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-with-radio": {
      name: "context-menu-with-radio",
      filePath: "examples/radix/context-menu-with-radio.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-with-radio")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-with-radio"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-with-shortcuts": {
      name: "context-menu-with-shortcuts",
      filePath: "examples/radix/context-menu-with-shortcuts.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-with-shortcuts")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-with-shortcuts"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-with-sides": {
      name: "context-menu-with-sides",
      filePath: "examples/radix/context-menu-with-sides.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-with-sides")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-with-sides"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-with-submenu": {
      name: "context-menu-with-submenu",
      filePath: "examples/radix/context-menu-with-submenu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/context-menu-with-submenu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-with-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] }
      }),
    },
    "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-simple": {
      name: "date-picker-simple",
      filePath: "examples/radix/date-picker-simple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/date-picker-simple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-simple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-with-presets": {
      name: "date-picker-with-presets",
      filePath: "examples/radix/date-picker-with-presets.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/date-picker-with-presets")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-with-presets"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-with-range": {
      name: "date-picker-with-range",
      filePath: "examples/radix/date-picker-with-range.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/date-picker-with-range")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-with-range"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "default-item-group": {
      name: "default-item-group",
      filePath: "examples/radix/default-item-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/default-item-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "default-item-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dialog-chat-settings": {
      name: "dialog-chat-settings",
      filePath: "examples/radix/dialog-chat-settings.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dialog-chat-settings")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dialog-chat-settings"
        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-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-with-form": {
      name: "dialog-with-form",
      filePath: "examples/radix/dialog-with-form.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dialog-with-form")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dialog-with-form"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dialog-with-sticky-footer": {
      name: "dialog-with-sticky-footer",
      filePath: "examples/radix/dialog-with-sticky-footer.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dialog-with-sticky-footer")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dialog-with-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-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-with-sides": {
      name: "drawer-with-sides",
      filePath: "examples/radix/drawer-with-sides.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/drawer-with-sides")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "drawer-with-sides"
        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": {
      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-dialog": {
      name: "dropdown-menu-dialog",
      filePath: "examples/radix/dropdown-menu-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-dialog"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-in-dialog": {
      name: "dropdown-menu-in-dialog",
      filePath: "examples/radix/dropdown-menu-in-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-in-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-in-dialog"
        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-with-avatar": {
      name: "dropdown-menu-with-avatar",
      filePath: "examples/radix/dropdown-menu-with-avatar.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-with-avatar")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-with-avatar"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-with-checkboxes-icons": {
      name: "dropdown-menu-with-checkboxes-icons",
      filePath: "examples/radix/dropdown-menu-with-checkboxes-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-with-checkboxes-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-with-checkboxes-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-with-checkboxes": {
      name: "dropdown-menu-with-checkboxes",
      filePath: "examples/radix/dropdown-menu-with-checkboxes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-with-checkboxes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-with-checkboxes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-with-destructive": {
      name: "dropdown-menu-with-destructive",
      filePath: "examples/radix/dropdown-menu-with-destructive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-with-destructive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-with-destructive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-with-icons": {
      name: "dropdown-menu-with-icons",
      filePath: "examples/radix/dropdown-menu-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-with-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-with-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-with-radio-icons": {
      name: "dropdown-menu-with-radio-icons",
      filePath: "examples/radix/dropdown-menu-with-radio-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-with-radio-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-with-radio-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-with-radio": {
      name: "dropdown-menu-with-radio",
      filePath: "examples/radix/dropdown-menu-with-radio.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-with-radio")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-with-radio"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-with-shortcuts": {
      name: "dropdown-menu-with-shortcuts",
      filePath: "examples/radix/dropdown-menu-with-shortcuts.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-with-shortcuts")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-with-shortcuts"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-with-submenu": {
      name: "dropdown-menu-with-submenu",
      filePath: "examples/radix/dropdown-menu-with-submenu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/dropdown-menu-with-submenu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-with-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-basic": {
      name: "empty-basic",
      filePath: "examples/radix/empty-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/empty-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-basic"
        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-icon": {
      name: "empty-icon",
      filePath: "examples/radix/empty-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/empty-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-in-card": {
      name: "empty-in-card",
      filePath: "examples/radix/empty-in-card.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/empty-in-card")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-in-card"
        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-with-border": {
      name: "empty-with-border",
      filePath: "examples/radix/empty-with-border.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/empty-with-border")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-with-border"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-with-icon": {
      name: "empty-with-icon",
      filePath: "examples/radix/empty-with-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/empty-with-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-with-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-with-muted-background-alt": {
      name: "empty-with-muted-background-alt",
      filePath: "examples/radix/empty-with-muted-background-alt.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/empty-with-muted-background-alt")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-with-muted-background-alt"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-with-muted-background": {
      name: "empty-with-muted-background",
      filePath: "examples/radix/empty-with-muted-background.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/empty-with-muted-background")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-with-muted-background"
        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-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-in-dialog": {
      name: "hover-card-in-dialog",
      filePath: "examples/radix/hover-card-in-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/hover-card-in-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "hover-card-in-dialog"
        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-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-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-fields": {
      name: "input-fields",
      filePath: "examples/radix/input-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-fields"
        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-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-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-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-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-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-fields": {
      name: "input-otp-fields",
      filePath: "examples/radix/input-otp-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-otp-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-fields"
        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-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-otp-simple": {
      name: "input-otp-simple",
      filePath: "examples/radix/input-otp-simple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-otp-simple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-simple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-with-separator": {
      name: "input-otp-with-separator",
      filePath: "examples/radix/input-otp-with-separator.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-otp-with-separator")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-with-separator"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-types": {
      name: "input-types",
      filePath: "examples/radix/input-types.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-types")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-types"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-with-button": {
      name: "input-with-button",
      filePath: "examples/radix/input-with-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-with-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-with-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-with-description": {
      name: "input-with-description",
      filePath: "examples/radix/input-with-description.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-with-description")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-with-description"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-with-label": {
      name: "input-with-label",
      filePath: "examples/radix/input-with-label.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-with-label")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-with-label"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-with-native-select": {
      name: "input-with-native-select",
      filePath: "examples/radix/input-with-native-select.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-with-native-select")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-with-native-select"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-with-select": {
      name: "input-with-select",
      filePath: "examples/radix/input-with-select.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-with-select")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-with-select"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-with-text": {
      name: "input-with-text",
      filePath: "examples/radix/input-with-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/input-with-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-with-text"
        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-default-extra-small": {
      name: "item-default-extra-small",
      filePath: "examples/radix/item-default-extra-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-default-extra-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-default-extra-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-default-small": {
      name: "item-default-small",
      filePath: "examples/radix/item-default-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-default-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-default-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-default-with-image": {
      name: "item-default-with-image",
      filePath: "examples/radix/item-default-with-image.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-default-with-image")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-default-with-image"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-default": {
      name: "item-default",
      filePath: "examples/radix/item-default.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-default")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-default"
        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-footer-examples": {
      name: "item-footer-examples",
      filePath: "examples/radix/item-footer-examples.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-footer-examples")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-footer-examples"
        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-and-footer-examples": {
      name: "item-header-and-footer-examples",
      filePath: "examples/radix/item-header-and-footer-examples.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-header-and-footer-examples")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-header-and-footer-examples"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-header-examples": {
      name: "item-header-examples",
      filePath: "examples/radix/item-header-examples.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-header-examples")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-header-examples"
        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-default": {
      name: "item-link-default",
      filePath: "examples/radix/item-link-default.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-link-default")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-link-default"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-link-muted": {
      name: "item-link-muted",
      filePath: "examples/radix/item-link-muted.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-link-muted")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-link-muted"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-link-outline": {
      name: "item-link-outline",
      filePath: "examples/radix/item-link-outline.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-link-outline")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-link-outline"
        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-muted-extra-small": {
      name: "item-muted-extra-small",
      filePath: "examples/radix/item-muted-extra-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-muted-extra-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-muted-extra-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-muted-small": {
      name: "item-muted-small",
      filePath: "examples/radix/item-muted-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-muted-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-muted-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-muted-with-image": {
      name: "item-muted-with-image",
      filePath: "examples/radix/item-muted-with-image.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-muted-with-image")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-muted-with-image"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-muted": {
      name: "item-muted",
      filePath: "examples/radix/item-muted.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-muted")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-muted"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-outline-extra-small": {
      name: "item-outline-extra-small",
      filePath: "examples/radix/item-outline-extra-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-outline-extra-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-outline-extra-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-outline-small": {
      name: "item-outline-small",
      filePath: "examples/radix/item-outline-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-outline-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-outline-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-outline-with-image-extra-small": {
      name: "item-outline-with-image-extra-small",
      filePath: "examples/radix/item-outline-with-image-extra-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-outline-with-image-extra-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-outline-with-image-extra-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-outline-with-image-small": {
      name: "item-outline-with-image-small",
      filePath: "examples/radix/item-outline-with-image-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-outline-with-image-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-outline-with-image-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-outline-with-image": {
      name: "item-outline-with-image",
      filePath: "examples/radix/item-outline-with-image.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-outline-with-image")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-outline-with-image"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-outline": {
      name: "item-outline",
      filePath: "examples/radix/item-outline.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-outline")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-outline"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-separator-example": {
      name: "item-separator-example",
      filePath: "examples/radix/item-separator-example.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/item-separator-example")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-separator-example"
        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-arrow-keys": {
      name: "kbd-arrow-keys",
      filePath: "examples/radix/kbd-arrow-keys.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/kbd-arrow-keys")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-arrow-keys"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-basic": {
      name: "kbd-basic",
      filePath: "examples/radix/kbd-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/kbd-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-basic"
        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-example": {
      name: "kbd-group-example",
      filePath: "examples/radix/kbd-group-example.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/kbd-group-example")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-group-example"
        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-in-input-group": {
      name: "kbd-in-input-group",
      filePath: "examples/radix/kbd-in-input-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/kbd-in-input-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-in-input-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-in-tooltip": {
      name: "kbd-in-tooltip",
      filePath: "examples/radix/kbd-in-tooltip.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/kbd-in-tooltip")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-in-tooltip"
        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-modifier-keys": {
      name: "kbd-modifier-keys",
      filePath: "examples/radix/kbd-modifier-keys.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/kbd-modifier-keys")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-modifier-keys"
        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] }
      }),
    },
    "kbd-with-icons-and-text": {
      name: "kbd-with-icons-and-text",
      filePath: "examples/radix/kbd-with-icons-and-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/kbd-with-icons-and-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-with-icons-and-text"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-with-icons": {
      name: "kbd-with-icons",
      filePath: "examples/radix/kbd-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/kbd-with-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-with-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-with-samp": {
      name: "kbd-with-samp",
      filePath: "examples/radix/kbd-with-samp.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/kbd-with-samp")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-with-samp"
        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-disabled": {
      name: "label-disabled",
      filePath: "examples/radix/label-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/label-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "label-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "label-with-checkbox": {
      name: "label-with-checkbox",
      filePath: "examples/radix/label-with-checkbox.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/label-with-checkbox")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "label-with-checkbox"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "label-with-input": {
      name: "label-with-input",
      filePath: "examples/radix/label-with-input.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/label-with-input")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "label-with-input"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "label-with-textarea": {
      name: "label-with-textarea",
      filePath: "examples/radix/label-with-textarea.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/label-with-textarea")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "label-with-textarea"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-basic": {
      name: "menubar-basic",
      filePath: "examples/radix/menubar-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/menubar-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-basic"
        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-destructive": {
      name: "menubar-destructive",
      filePath: "examples/radix/menubar-destructive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/menubar-destructive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-destructive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-format": {
      name: "menubar-format",
      filePath: "examples/radix/menubar-format.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/menubar-format")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-format"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-in-dialog": {
      name: "menubar-in-dialog",
      filePath: "examples/radix/menubar-in-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/menubar-in-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-in-dialog"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-insert": {
      name: "menubar-insert",
      filePath: "examples/radix/menubar-insert.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/menubar-insert")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-insert"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-with-checkboxes": {
      name: "menubar-with-checkboxes",
      filePath: "examples/radix/menubar-with-checkboxes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/menubar-with-checkboxes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-with-checkboxes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-with-icons": {
      name: "menubar-with-icons",
      filePath: "examples/radix/menubar-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/menubar-with-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-with-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-with-radio": {
      name: "menubar-with-radio",
      filePath: "examples/radix/menubar-with-radio.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/menubar-with-radio")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-with-radio"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-with-shortcuts": {
      name: "menubar-with-shortcuts",
      filePath: "examples/radix/menubar-with-shortcuts.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/menubar-with-shortcuts")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-with-shortcuts"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-with-submenu": {
      name: "menubar-with-submenu",
      filePath: "examples/radix/menubar-with-submenu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/menubar-with-submenu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-with-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-basic": {
      name: "native-select-basic",
      filePath: "examples/radix/native-select-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/native-select-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-basic"
        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-fields": {
      name: "native-select-fields",
      filePath: "examples/radix/native-select-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/native-select-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-fields"
        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-sizes": {
      name: "native-select-sizes",
      filePath: "examples/radix/native-select-sizes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/native-select-sizes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-sizes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "native-select-with-field": {
      name: "native-select-with-field",
      filePath: "examples/radix/native-select-with-field.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/native-select-with-field")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-with-field"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "native-select-with-groups": {
      name: "native-select-with-groups",
      filePath: "examples/radix/native-select-with-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/native-select-with-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-with-groups"
        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-with-viewport": {
      name: "navigation-menu-with-viewport",
      filePath: "examples/radix/navigation-menu-with-viewport.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/navigation-menu-with-viewport")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "navigation-menu-with-viewport"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "navigation-menu-without-viewport": {
      name: "navigation-menu-without-viewport",
      filePath: "examples/radix/navigation-menu-without-viewport.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/navigation-menu-without-viewport")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "navigation-menu-without-viewport"
        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-basic": {
      name: "pagination-basic",
      filePath: "examples/radix/pagination-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/pagination-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "pagination-basic"
        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-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-in-dialog": {
      name: "popover-in-dialog",
      filePath: "examples/radix/popover-in-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/popover-in-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "popover-in-dialog"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "popover-with-form": {
      name: "popover-with-form",
      filePath: "examples/radix/popover-with-form.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/popover-with-form")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "popover-with-form"
        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-values": {
      name: "progress-values",
      filePath: "examples/radix/progress-values.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/progress-values")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "progress-values"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "progress-with-label": {
      name: "progress-with-label",
      filePath: "examples/radix/progress-with-label.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/progress-with-label")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "progress-with-label"
        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-basic": {
      name: "radio-group-basic",
      filePath: "examples/radix/radio-group-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/radio-group-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-basic"
        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-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-grid": {
      name: "radio-group-grid",
      filePath: "examples/radix/radio-group-grid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/radio-group-grid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-grid"
        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-with-descriptions": {
      name: "radio-group-with-descriptions",
      filePath: "examples/radix/radio-group-with-descriptions.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/radio-group-with-descriptions")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-with-descriptions"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "radio-group-with-field-set": {
      name: "radio-group-with-field-set",
      filePath: "examples/radix/radio-group-with-field-set.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/radio-group-with-field-set")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-with-field-set"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "resizable-controlled": {
      name: "resizable-controlled",
      filePath: "examples/radix/resizable-controlled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/resizable-controlled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "resizable-controlled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "resizable-demo-with-handle": {
      name: "resizable-demo-with-handle",
      filePath: "examples/radix/resizable-demo-with-handle.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/resizable-demo-with-handle")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "resizable-demo-with-handle"
        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-horizontal": {
      name: "resizable-horizontal",
      filePath: "examples/radix/resizable-horizontal.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/resizable-horizontal")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "resizable-horizontal"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "resizable-nested": {
      name: "resizable-nested",
      filePath: "examples/radix/resizable-nested.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/resizable-nested")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "resizable-nested"
        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] }
      }),
    },
    "resizable-with-handle": {
      name: "resizable-with-handle",
      filePath: "examples/radix/resizable-with-handle.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/resizable-with-handle")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "resizable-with-handle"
        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-horizontal": {
      name: "scroll-area-horizontal",
      filePath: "examples/radix/scroll-area-horizontal.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/scroll-area-horizontal")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "scroll-area-horizontal"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "scroll-area-vertical": {
      name: "scroll-area-vertical",
      filePath: "examples/radix/scroll-area-vertical.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/scroll-area-vertical")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "scroll-area-vertical"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-basic": {
      name: "select-basic",
      filePath: "examples/radix/select-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/select-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-basic"
        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-fields": {
      name: "select-fields",
      filePath: "examples/radix/select-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/select-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-fields"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-in-dialog": {
      name: "select-in-dialog",
      filePath: "examples/radix/select-in-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/select-in-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-in-dialog"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-inline": {
      name: "select-inline",
      filePath: "examples/radix/select-inline.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/select-inline")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-inline"
        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-item-aligned": {
      name: "select-item-aligned",
      filePath: "examples/radix/select-item-aligned.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/select-item-aligned")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-item-aligned"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-large-list": {
      name: "select-large-list",
      filePath: "examples/radix/select-large-list.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/select-large-list")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-large-list"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-plan": {
      name: "select-plan",
      filePath: "examples/radix/select-plan.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/select-plan")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-plan"
        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] }
      }),
    },
    "select-sizes": {
      name: "select-sizes",
      filePath: "examples/radix/select-sizes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/select-sizes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-sizes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-with-button": {
      name: "select-with-button",
      filePath: "examples/radix/select-with-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/select-with-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-with-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-with-field": {
      name: "select-with-field",
      filePath: "examples/radix/select-with-field.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/select-with-field")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-with-field"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-with-groups": {
      name: "select-with-groups",
      filePath: "examples/radix/select-with-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/select-with-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-with-groups"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-with-icons": {
      name: "select-with-icons",
      filePath: "examples/radix/select-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/select-with-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-with-icons"
        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-horizontal": {
      name: "separator-horizontal",
      filePath: "examples/radix/separator-horizontal.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/separator-horizontal")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "separator-horizontal"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "separator-in-list": {
      name: "separator-in-list",
      filePath: "examples/radix/separator-in-list.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/separator-in-list")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "separator-in-list"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "separator-vertical-menu": {
      name: "separator-vertical-menu",
      filePath: "examples/radix/separator-vertical-menu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/separator-vertical-menu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "separator-vertical-menu"
        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-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] }
      }),
    },
    "sheet-with-form": {
      name: "sheet-with-form",
      filePath: "examples/radix/sheet-with-form.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sheet-with-form")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sheet-with-form"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sheet-with-sides": {
      name: "sheet-with-sides",
      filePath: "examples/radix/sheet-with-sides.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sheet-with-sides")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sheet-with-sides"
        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-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-basic": {
      name: "slider-basic",
      filePath: "examples/radix/slider-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/slider-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "slider-basic"
        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-fields": {
      name: "slider-fields",
      filePath: "examples/radix/slider-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/slider-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "slider-fields"
        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-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-basic": {
      name: "sonner-basic",
      filePath: "examples/radix/sonner-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sonner-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sonner-basic"
        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-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] }
      }),
    },
    "sonner-with-description": {
      name: "sonner-with-description",
      filePath: "examples/radix/sonner-with-description.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/sonner-with-description")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sonner-with-description"
        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-basic": {
      name: "spinner-basic",
      filePath: "examples/radix/spinner-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/spinner-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-basic"
        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-color": {
      name: "spinner-color",
      filePath: "examples/radix/spinner-color.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/spinner-color")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-color"
        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-in-badges": {
      name: "spinner-in-badges",
      filePath: "examples/radix/spinner-in-badges.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/spinner-in-badges")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-in-badges"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-in-buttons": {
      name: "spinner-in-buttons",
      filePath: "examples/radix/spinner-in-buttons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/spinner-in-buttons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-in-buttons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-in-empty": {
      name: "spinner-in-empty",
      filePath: "examples/radix/spinner-in-empty.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/spinner-in-empty")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-in-empty"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-in-input-group": {
      name: "spinner-in-input-group",
      filePath: "examples/radix/spinner-in-input-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/spinner-in-input-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-in-input-group"
        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-item": {
      name: "spinner-item",
      filePath: "examples/radix/spinner-item.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/spinner-item")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-item"
        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-basic": {
      name: "switch-basic",
      filePath: "examples/radix/switch-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/switch-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-basic"
        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-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-fields": {
      name: "switch-fields",
      filePath: "examples/radix/switch-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/switch-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-fields"
        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] }
      }),
    },
    "switch-with-description": {
      name: "switch-with-description",
      filePath: "examples/radix/switch-with-description.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/switch-with-description")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-with-description"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "switch-with-label": {
      name: "switch-with-label",
      filePath: "examples/radix/switch-with-label.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/switch-with-label")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-with-label"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-basic": {
      name: "table-basic",
      filePath: "examples/radix/table-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/table-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-basic"
        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-simple": {
      name: "table-simple",
      filePath: "examples/radix/table-simple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/table-simple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-simple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-with-actions": {
      name: "table-with-actions",
      filePath: "examples/radix/table-with-actions.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/table-with-actions")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-with-actions"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-with-badges": {
      name: "table-with-badges",
      filePath: "examples/radix/table-with-badges.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/table-with-badges")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-with-badges"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-with-footer": {
      name: "table-with-footer",
      filePath: "examples/radix/table-with-footer.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/table-with-footer")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-with-footer"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-with-input": {
      name: "table-with-input",
      filePath: "examples/radix/table-with-input.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/table-with-input")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-with-input"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-with-select": {
      name: "table-with-select",
      filePath: "examples/radix/table-with-select.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/table-with-select")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-with-select"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-basic": {
      name: "tabs-basic",
      filePath: "examples/radix/tabs-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tabs-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-basic"
        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-icon-only": {
      name: "tabs-icon-only",
      filePath: "examples/radix/tabs-icon-only.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tabs-icon-only")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-icon-only"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-line-disabled": {
      name: "tabs-line-disabled",
      filePath: "examples/radix/tabs-line-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tabs-line-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-line-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-line-with-content": {
      name: "tabs-line-with-content",
      filePath: "examples/radix/tabs-line-with-content.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tabs-line-with-content")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-line-with-content"
        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-multiple": {
      name: "tabs-multiple",
      filePath: "examples/radix/tabs-multiple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tabs-multiple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-multiple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-variants-comparison": {
      name: "tabs-variants-comparison",
      filePath: "examples/radix/tabs-variants-comparison.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tabs-variants-comparison")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-variants-comparison"
        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] }
      }),
    },
    "tabs-with-content": {
      name: "tabs-with-content",
      filePath: "examples/radix/tabs-with-content.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tabs-with-content")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-with-content"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-with-dropdown": {
      name: "tabs-with-dropdown",
      filePath: "examples/radix/tabs-with-dropdown.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tabs-with-dropdown")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-with-dropdown"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-with-icons": {
      name: "tabs-with-icons",
      filePath: "examples/radix/tabs-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tabs-with-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-with-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-with-input-and-button": {
      name: "tabs-with-input-and-button",
      filePath: "examples/radix/tabs-with-input-and-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tabs-with-input-and-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-with-input-and-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-basic": {
      name: "textarea-basic",
      filePath: "examples/radix/textarea-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/textarea-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-basic"
        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-fields": {
      name: "textarea-fields",
      filePath: "examples/radix/textarea-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/textarea-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-fields"
        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-with-button": {
      name: "textarea-with-button",
      filePath: "examples/radix/textarea-with-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/textarea-with-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-with-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-with-description": {
      name: "textarea-with-description",
      filePath: "examples/radix/textarea-with-description.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/textarea-with-description")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-with-description"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-with-label": {
      name: "textarea-with-label",
      filePath: "examples/radix/textarea-with-label.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/textarea-with-label")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-with-label"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-with-text": {
      name: "textarea-with-text",
      filePath: "examples/radix/textarea-with-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/textarea-with-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-with-text"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-basic": {
      name: "toggle-basic",
      filePath: "examples/radix/toggle-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-basic"
        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-basic": {
      name: "toggle-group-basic",
      filePath: "examples/radix/toggle-group-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-date-range": {
      name: "toggle-group-date-range",
      filePath: "examples/radix/toggle-group-date-range.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-date-range")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-date-range"
        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-filter": {
      name: "toggle-group-filter",
      filePath: "examples/radix/toggle-group-filter.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-filter")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-filter"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-lg": {
      name: "toggle-group-lg",
      filePath: "examples/radix/toggle-group-lg.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-lg")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-lg"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-outline-with-icons": {
      name: "toggle-group-outline-with-icons",
      filePath: "examples/radix/toggle-group-outline-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-outline-with-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-outline-with-icons"
        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-single": {
      name: "toggle-group-single",
      filePath: "examples/radix/toggle-group-single.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-single")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-single"
        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-sm": {
      name: "toggle-group-sm",
      filePath: "examples/radix/toggle-group-sm.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-sm")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-sm"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-sort": {
      name: "toggle-group-sort",
      filePath: "examples/radix/toggle-group-sort.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-sort")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-sort"
        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-outline-with-icons": {
      name: "toggle-group-vertical-outline-with-icons",
      filePath: "examples/radix/toggle-group-vertical-outline-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import(
          "./radix/toggle-group-vertical-outline-with-icons"
        )
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-vertical-outline-with-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-vertical-outline": {
      name: "toggle-group-vertical-outline",
      filePath: "examples/radix/toggle-group-vertical-outline.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-vertical-outline")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-vertical-outline"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-vertical-with-spacing": {
      name: "toggle-group-vertical-with-spacing",
      filePath: "examples/radix/toggle-group-vertical-with-spacing.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-vertical-with-spacing")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-vertical-with-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-group-with-icons": {
      name: "toggle-group-with-icons",
      filePath: "examples/radix/toggle-group-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-with-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-with-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-with-input-and-select": {
      name: "toggle-group-with-input-and-select",
      filePath: "examples/radix/toggle-group-with-input-and-select.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-group-with-input-and-select")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-with-input-and-select"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-lg": {
      name: "toggle-lg",
      filePath: "examples/radix/toggle-lg.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-lg")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-lg"
        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-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-sm": {
      name: "toggle-sm",
      filePath: "examples/radix/toggle-sm.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-sm")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-sm"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-with-button-icon-text": {
      name: "toggle-with-button-icon-text",
      filePath: "examples/radix/toggle-with-button-icon-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-with-button-icon-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-with-button-icon-text"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-with-button-icon": {
      name: "toggle-with-button-icon",
      filePath: "examples/radix/toggle-with-button-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-with-button-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-with-button-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-with-button-text": {
      name: "toggle-with-button-text",
      filePath: "examples/radix/toggle-with-button-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-with-button-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-with-button-text"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-with-icon": {
      name: "toggle-with-icon",
      filePath: "examples/radix/toggle-with-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-with-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-with-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-with-text": {
      name: "toggle-with-text",
      filePath: "examples/radix/toggle-with-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/toggle-with-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-with-text"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tooltip-basic": {
      name: "tooltip-basic",
      filePath: "examples/radix/tooltip-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tooltip-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-basic"
        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-formatted": {
      name: "tooltip-formatted",
      filePath: "examples/radix/tooltip-formatted.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tooltip-formatted")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-formatted"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tooltip-long-content": {
      name: "tooltip-long-content",
      filePath: "examples/radix/tooltip-long-content.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tooltip-long-content")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-long-content"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tooltip-on-link": {
      name: "tooltip-on-link",
      filePath: "examples/radix/tooltip-on-link.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tooltip-on-link")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-on-link"
        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] }
      }),
    },
    "tooltip-with-icon": {
      name: "tooltip-with-icon",
      filePath: "examples/radix/tooltip-with-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tooltip-with-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-with-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tooltip-with-keyboard": {
      name: "tooltip-with-keyboard",
      filePath: "examples/radix/tooltip-with-keyboard.tsx",
      component: React.lazy(async () => {
        const mod = await import("./radix/tooltip-with-keyboard")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-with-keyboard"
        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-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] }
      }),
    },
    "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-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] }
      }),
    },
    "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-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-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-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-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-basic": {
      name: "button-group-basic",
      filePath: "examples/base/button-group-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-basic"
        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-navigation": {
      name: "button-group-navigation",
      filePath: "examples/base/button-group-navigation.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-navigation")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-navigation"
        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-pagination-split": {
      name: "button-group-pagination-split",
      filePath: "examples/base/button-group-pagination-split.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-pagination-split")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-pagination-split"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-pagination": {
      name: "button-group-pagination",
      filePath: "examples/base/button-group-pagination.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-pagination")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-pagination"
        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-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-group-text-alignment": {
      name: "button-group-text-alignment",
      filePath: "examples/base/button-group-text-alignment.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-text-alignment")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-text-alignment"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-vertical-nested": {
      name: "button-group-vertical-nested",
      filePath: "examples/base/button-group-vertical-nested.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-vertical-nested")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-vertical-nested"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-vertical": {
      name: "button-group-vertical",
      filePath: "examples/base/button-group-vertical.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-vertical")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-vertical"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-with-dropdown": {
      name: "button-group-with-dropdown",
      filePath: "examples/base/button-group-with-dropdown.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-with-dropdown")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-with-dropdown"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-with-fields": {
      name: "button-group-with-fields",
      filePath: "examples/base/button-group-with-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-with-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-with-fields"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-with-icons": {
      name: "button-group-with-icons",
      filePath: "examples/base/button-group-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-with-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-with-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-with-input-group": {
      name: "button-group-with-input-group",
      filePath: "examples/base/button-group-with-input-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-with-input-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-with-input-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-with-input": {
      name: "button-group-with-input",
      filePath: "examples/base/button-group-with-input.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-with-input")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-with-input"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-with-like": {
      name: "button-group-with-like",
      filePath: "examples/base/button-group-with-like.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-with-like")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-with-like"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-with-select-and-input": {
      name: "button-group-with-select-and-input",
      filePath: "examples/base/button-group-with-select-and-input.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-with-select-and-input")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-with-select-and-input"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-with-select": {
      name: "button-group-with-select",
      filePath: "examples/base/button-group-with-select.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-with-select")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-with-select"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "button-group-with-text": {
      name: "button-group-with-text",
      filePath: "examples/base/button-group-with-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/button-group-with-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "button-group-with-text"
        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-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-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-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-range-multiple-months": {
      name: "calendar-range-multiple-months",
      filePath: "examples/base/calendar-range-multiple-months.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/calendar-range-multiple-months")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-range-multiple-months"
        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-single": {
      name: "calendar-single",
      filePath: "examples/base/calendar-single.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/calendar-single")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-single"
        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] }
      }),
    },
    "calendar-with-presets": {
      name: "calendar-with-presets",
      filePath: "examples/base/calendar-with-presets.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/calendar-with-presets")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-with-presets"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "calendar-with-time": {
      name: "calendar-with-time",
      filePath: "examples/base/calendar-with-time.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/calendar-with-time")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "calendar-with-time"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-default": {
      name: "card-default",
      filePath: "examples/base/card-default.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/card-default")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-default"
        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-footer-with-border-small": {
      name: "card-footer-with-border-small",
      filePath: "examples/base/card-footer-with-border-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/card-footer-with-border-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-footer-with-border-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-footer-with-border": {
      name: "card-footer-with-border",
      filePath: "examples/base/card-footer-with-border.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/card-footer-with-border")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-footer-with-border"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-header-with-border-small": {
      name: "card-header-with-border-small",
      filePath: "examples/base/card-header-with-border-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/card-header-with-border-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-header-with-border-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-header-with-border": {
      name: "card-header-with-border",
      filePath: "examples/base/card-header-with-border.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/card-header-with-border")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-header-with-border"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-login": {
      name: "card-login",
      filePath: "examples/base/card-login.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/card-login")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-login"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-meeting-notes": {
      name: "card-meeting-notes",
      filePath: "examples/base/card-meeting-notes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/card-meeting-notes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-meeting-notes"
        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-with-image-small": {
      name: "card-with-image-small",
      filePath: "examples/base/card-with-image-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/card-with-image-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-with-image-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "card-with-image": {
      name: "card-with-image",
      filePath: "examples/base/card-with-image.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/card-with-image")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "card-with-image"
        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-basic": {
      name: "carousel-basic",
      filePath: "examples/base/carousel-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/carousel-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-basic"
        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-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] }
      }),
    },
    "carousel-with-gap": {
      name: "carousel-with-gap",
      filePath: "examples/base/carousel-with-gap.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/carousel-with-gap")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "carousel-with-gap"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-area-example": {
      name: "chart-area-example",
      filePath: "examples/base/chart-area-example.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-area-example")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-area-example"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-bar-demo-axis": {
      name: "chart-bar-demo-axis",
      filePath: "examples/base/chart-bar-demo-axis.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-bar-demo-axis")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-bar-demo-axis"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-bar-demo-grid": {
      name: "chart-bar-demo-grid",
      filePath: "examples/base/chart-bar-demo-grid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-bar-demo-grid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-bar-demo-grid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-bar-demo-legend": {
      name: "chart-bar-demo-legend",
      filePath: "examples/base/chart-bar-demo-legend.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-bar-demo-legend")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-bar-demo-legend"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-bar-demo-tooltip": {
      name: "chart-bar-demo-tooltip",
      filePath: "examples/base/chart-bar-demo-tooltip.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-bar-demo-tooltip")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-bar-demo-tooltip"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-bar-demo": {
      name: "chart-bar-demo",
      filePath: "examples/base/chart-bar-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-bar-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-bar-demo"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-bar-example": {
      name: "chart-bar-example",
      filePath: "examples/base/chart-bar-example.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-bar-example")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-bar-example"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-line-example": {
      name: "chart-line-example",
      filePath: "examples/base/chart-line-example.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-line-example")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-line-example"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-pie-example": {
      name: "chart-pie-example",
      filePath: "examples/base/chart-pie-example.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-pie-example")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-pie-example"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-radar-example": {
      name: "chart-radar-example",
      filePath: "examples/base/chart-radar-example.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-radar-example")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-radar-example"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-radial-example": {
      name: "chart-radial-example",
      filePath: "examples/base/chart-radial-example.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-radial-example")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-radial-example"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "chart-tooltip-demo": {
      name: "chart-tooltip-demo",
      filePath: "examples/base/chart-tooltip-demo.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/chart-tooltip-demo")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "chart-tooltip-demo"
        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-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-fields": {
      name: "checkbox-fields",
      filePath: "examples/base/checkbox-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/checkbox-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-fields"
        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-in-table": {
      name: "checkbox-in-table",
      filePath: "examples/base/checkbox-in-table.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/checkbox-in-table")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-in-table"
        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-with-description": {
      name: "checkbox-with-description",
      filePath: "examples/base/checkbox-with-description.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/checkbox-with-description")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-with-description"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-with-text": {
      name: "checkbox-with-text",
      filePath: "examples/base/checkbox-with-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/checkbox-with-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-with-text"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "checkbox-with-title": {
      name: "checkbox-with-title",
      filePath: "examples/base/checkbox-with-title.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/checkbox-with-title")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "checkbox-with-title"
        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-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-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-dropdown-menu": {
      name: "combobox-dropdown-menu",
      filePath: "examples/base/combobox-dropdown-menu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-dropdown-menu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-dropdown-menu"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-in-dialog": {
      name: "combobox-in-dialog",
      filePath: "examples/base/combobox-in-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-in-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-in-dialog"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-in-popup": {
      name: "combobox-in-popup",
      filePath: "examples/base/combobox-in-popup.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-in-popup")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-in-popup"
        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-large-list": {
      name: "combobox-large-list",
      filePath: "examples/base/combobox-large-list.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-large-list")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-large-list"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-multiple-disabled": {
      name: "combobox-multiple-disabled",
      filePath: "examples/base/combobox-multiple-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-multiple-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-multiple-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-multiple-invalid": {
      name: "combobox-multiple-invalid",
      filePath: "examples/base/combobox-multiple-invalid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-multiple-invalid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-multiple-invalid"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-multiple-no-remove": {
      name: "combobox-multiple-no-remove",
      filePath: "examples/base/combobox-multiple-no-remove.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-multiple-no-remove")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-multiple-no-remove"
        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-popover": {
      name: "combobox-popover",
      filePath: "examples/base/combobox-popover.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-popover")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-popover"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-responsive": {
      name: "combobox-responsive",
      filePath: "examples/base/combobox-responsive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-responsive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-responsive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-with-clear": {
      name: "combobox-with-clear",
      filePath: "examples/base/combobox-with-clear.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-with-clear")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-with-clear"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-with-custom-items": {
      name: "combobox-with-custom-items",
      filePath: "examples/base/combobox-with-custom-items.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-with-custom-items")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-with-custom-items"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-with-form": {
      name: "combobox-with-form",
      filePath: "examples/base/combobox-with-form.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-with-form")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-with-form"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-with-groups-and-separator": {
      name: "combobox-with-groups-and-separator",
      filePath: "examples/base/combobox-with-groups-and-separator.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-with-groups-and-separator")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-with-groups-and-separator"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-with-groups": {
      name: "combobox-with-groups",
      filePath: "examples/base/combobox-with-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-with-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-with-groups"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "combobox-with-other-inputs": {
      name: "combobox-with-other-inputs",
      filePath: "examples/base/combobox-with-other-inputs.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/combobox-with-other-inputs")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "combobox-with-other-inputs"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "comboxbox-input-addon": {
      name: "comboxbox-input-addon",
      filePath: "examples/base/comboxbox-input-addon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/comboxbox-input-addon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "comboxbox-input-addon"
        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-many-items": {
      name: "command-many-items",
      filePath: "examples/base/command-many-items.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/command-many-items")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-many-items"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "command-with-groups": {
      name: "command-with-groups",
      filePath: "examples/base/command-with-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/command-with-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-with-groups"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "command-with-shortcuts": {
      name: "command-with-shortcuts",
      filePath: "examples/base/command-with-shortcuts.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/command-with-shortcuts")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "command-with-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-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-in-dialog": {
      name: "context-menu-in-dialog",
      filePath: "examples/base/context-menu-in-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-in-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-in-dialog"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-with-checkboxes": {
      name: "context-menu-with-checkboxes",
      filePath: "examples/base/context-menu-with-checkboxes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-with-checkboxes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-with-checkboxes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-with-destructive": {
      name: "context-menu-with-destructive",
      filePath: "examples/base/context-menu-with-destructive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-with-destructive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-with-destructive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-with-groups": {
      name: "context-menu-with-groups",
      filePath: "examples/base/context-menu-with-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-with-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-with-groups"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-with-icons": {
      name: "context-menu-with-icons",
      filePath: "examples/base/context-menu-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-with-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-with-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-with-radio": {
      name: "context-menu-with-radio",
      filePath: "examples/base/context-menu-with-radio.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-with-radio")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-with-radio"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-with-shortcuts": {
      name: "context-menu-with-shortcuts",
      filePath: "examples/base/context-menu-with-shortcuts.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-with-shortcuts")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-with-shortcuts"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-with-sides": {
      name: "context-menu-with-sides",
      filePath: "examples/base/context-menu-with-sides.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-with-sides")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-with-sides"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "context-menu-with-submenu": {
      name: "context-menu-with-submenu",
      filePath: "examples/base/context-menu-with-submenu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/context-menu-with-submenu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "context-menu-with-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] }
      }),
    },
    "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-simple": {
      name: "date-picker-simple",
      filePath: "examples/base/date-picker-simple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/date-picker-simple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-simple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-with-presets": {
      name: "date-picker-with-presets",
      filePath: "examples/base/date-picker-with-presets.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/date-picker-with-presets")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-with-presets"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "date-picker-with-range": {
      name: "date-picker-with-range",
      filePath: "examples/base/date-picker-with-range.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/date-picker-with-range")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "date-picker-with-range"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "default-item-group": {
      name: "default-item-group",
      filePath: "examples/base/default-item-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/default-item-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "default-item-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dialog-chat-settings": {
      name: "dialog-chat-settings",
      filePath: "examples/base/dialog-chat-settings.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dialog-chat-settings")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dialog-chat-settings"
        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-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-with-form": {
      name: "dialog-with-form",
      filePath: "examples/base/dialog-with-form.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dialog-with-form")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dialog-with-form"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dialog-with-sticky-footer": {
      name: "dialog-with-sticky-footer",
      filePath: "examples/base/dialog-with-sticky-footer.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dialog-with-sticky-footer")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dialog-with-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-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-with-sides": {
      name: "drawer-with-sides",
      filePath: "examples/base/drawer-with-sides.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/drawer-with-sides")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "drawer-with-sides"
        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": {
      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-dialog": {
      name: "dropdown-menu-dialog",
      filePath: "examples/base/dropdown-menu-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-dialog"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-in-dialog": {
      name: "dropdown-menu-in-dialog",
      filePath: "examples/base/dropdown-menu-in-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-in-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-in-dialog"
        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-with-avatar": {
      name: "dropdown-menu-with-avatar",
      filePath: "examples/base/dropdown-menu-with-avatar.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-with-avatar")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-with-avatar"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-with-checkboxes-icons": {
      name: "dropdown-menu-with-checkboxes-icons",
      filePath: "examples/base/dropdown-menu-with-checkboxes-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-with-checkboxes-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-with-checkboxes-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-with-checkboxes": {
      name: "dropdown-menu-with-checkboxes",
      filePath: "examples/base/dropdown-menu-with-checkboxes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-with-checkboxes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-with-checkboxes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-with-destructive": {
      name: "dropdown-menu-with-destructive",
      filePath: "examples/base/dropdown-menu-with-destructive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-with-destructive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-with-destructive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-with-icons": {
      name: "dropdown-menu-with-icons",
      filePath: "examples/base/dropdown-menu-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-with-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-with-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-with-radio-icons": {
      name: "dropdown-menu-with-radio-icons",
      filePath: "examples/base/dropdown-menu-with-radio-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-with-radio-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-with-radio-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-with-radio": {
      name: "dropdown-menu-with-radio",
      filePath: "examples/base/dropdown-menu-with-radio.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-with-radio")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-with-radio"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-with-shortcuts": {
      name: "dropdown-menu-with-shortcuts",
      filePath: "examples/base/dropdown-menu-with-shortcuts.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-with-shortcuts")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-with-shortcuts"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "dropdown-menu-with-submenu": {
      name: "dropdown-menu-with-submenu",
      filePath: "examples/base/dropdown-menu-with-submenu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/dropdown-menu-with-submenu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "dropdown-menu-with-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-basic": {
      name: "empty-basic",
      filePath: "examples/base/empty-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/empty-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-basic"
        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-icon": {
      name: "empty-icon",
      filePath: "examples/base/empty-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/empty-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-in-card": {
      name: "empty-in-card",
      filePath: "examples/base/empty-in-card.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/empty-in-card")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-in-card"
        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-with-border": {
      name: "empty-with-border",
      filePath: "examples/base/empty-with-border.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/empty-with-border")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-with-border"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-with-icon": {
      name: "empty-with-icon",
      filePath: "examples/base/empty-with-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/empty-with-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-with-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-with-muted-background-alt": {
      name: "empty-with-muted-background-alt",
      filePath: "examples/base/empty-with-muted-background-alt.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/empty-with-muted-background-alt")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-with-muted-background-alt"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "empty-with-muted-background": {
      name: "empty-with-muted-background",
      filePath: "examples/base/empty-with-muted-background.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/empty-with-muted-background")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "empty-with-muted-background"
        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-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-in-dialog": {
      name: "hover-card-in-dialog",
      filePath: "examples/base/hover-card-in-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/hover-card-in-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "hover-card-in-dialog"
        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-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-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-fields": {
      name: "input-fields",
      filePath: "examples/base/input-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-fields"
        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-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-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-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-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-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-fields": {
      name: "input-otp-fields",
      filePath: "examples/base/input-otp-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-otp-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-fields"
        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-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-otp-simple": {
      name: "input-otp-simple",
      filePath: "examples/base/input-otp-simple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-otp-simple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-simple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-otp-with-separator": {
      name: "input-otp-with-separator",
      filePath: "examples/base/input-otp-with-separator.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-otp-with-separator")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-otp-with-separator"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-types": {
      name: "input-types",
      filePath: "examples/base/input-types.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-types")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-types"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-with-button": {
      name: "input-with-button",
      filePath: "examples/base/input-with-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-with-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-with-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-with-description": {
      name: "input-with-description",
      filePath: "examples/base/input-with-description.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-with-description")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-with-description"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-with-label": {
      name: "input-with-label",
      filePath: "examples/base/input-with-label.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-with-label")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-with-label"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-with-native-select": {
      name: "input-with-native-select",
      filePath: "examples/base/input-with-native-select.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-with-native-select")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-with-native-select"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-with-select": {
      name: "input-with-select",
      filePath: "examples/base/input-with-select.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-with-select")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-with-select"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "input-with-text": {
      name: "input-with-text",
      filePath: "examples/base/input-with-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/input-with-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "input-with-text"
        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-default-extra-small": {
      name: "item-default-extra-small",
      filePath: "examples/base/item-default-extra-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-default-extra-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-default-extra-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-default-small": {
      name: "item-default-small",
      filePath: "examples/base/item-default-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-default-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-default-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-default-with-image": {
      name: "item-default-with-image",
      filePath: "examples/base/item-default-with-image.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-default-with-image")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-default-with-image"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-default": {
      name: "item-default",
      filePath: "examples/base/item-default.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-default")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-default"
        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-footer-examples": {
      name: "item-footer-examples",
      filePath: "examples/base/item-footer-examples.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-footer-examples")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-footer-examples"
        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-and-footer-examples": {
      name: "item-header-and-footer-examples",
      filePath: "examples/base/item-header-and-footer-examples.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-header-and-footer-examples")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-header-and-footer-examples"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-header-examples": {
      name: "item-header-examples",
      filePath: "examples/base/item-header-examples.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-header-examples")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-header-examples"
        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-default": {
      name: "item-link-default",
      filePath: "examples/base/item-link-default.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-link-default")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-link-default"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-link-muted": {
      name: "item-link-muted",
      filePath: "examples/base/item-link-muted.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-link-muted")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-link-muted"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-link-outline": {
      name: "item-link-outline",
      filePath: "examples/base/item-link-outline.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-link-outline")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-link-outline"
        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-muted-extra-small": {
      name: "item-muted-extra-small",
      filePath: "examples/base/item-muted-extra-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-muted-extra-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-muted-extra-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-muted-small": {
      name: "item-muted-small",
      filePath: "examples/base/item-muted-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-muted-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-muted-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-muted-with-image": {
      name: "item-muted-with-image",
      filePath: "examples/base/item-muted-with-image.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-muted-with-image")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-muted-with-image"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-muted": {
      name: "item-muted",
      filePath: "examples/base/item-muted.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-muted")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-muted"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-outline-extra-small": {
      name: "item-outline-extra-small",
      filePath: "examples/base/item-outline-extra-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-outline-extra-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-outline-extra-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-outline-small": {
      name: "item-outline-small",
      filePath: "examples/base/item-outline-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-outline-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-outline-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-outline-with-image-extra-small": {
      name: "item-outline-with-image-extra-small",
      filePath: "examples/base/item-outline-with-image-extra-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-outline-with-image-extra-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-outline-with-image-extra-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-outline-with-image-small": {
      name: "item-outline-with-image-small",
      filePath: "examples/base/item-outline-with-image-small.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-outline-with-image-small")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-outline-with-image-small"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-outline-with-image": {
      name: "item-outline-with-image",
      filePath: "examples/base/item-outline-with-image.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-outline-with-image")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-outline-with-image"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-outline": {
      name: "item-outline",
      filePath: "examples/base/item-outline.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-outline")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-outline"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "item-separator-example": {
      name: "item-separator-example",
      filePath: "examples/base/item-separator-example.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/item-separator-example")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "item-separator-example"
        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-arrow-keys": {
      name: "kbd-arrow-keys",
      filePath: "examples/base/kbd-arrow-keys.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/kbd-arrow-keys")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-arrow-keys"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-basic": {
      name: "kbd-basic",
      filePath: "examples/base/kbd-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/kbd-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-basic"
        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-example": {
      name: "kbd-group-example",
      filePath: "examples/base/kbd-group-example.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/kbd-group-example")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-group-example"
        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-in-input-group": {
      name: "kbd-in-input-group",
      filePath: "examples/base/kbd-in-input-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/kbd-in-input-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-in-input-group"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-in-tooltip": {
      name: "kbd-in-tooltip",
      filePath: "examples/base/kbd-in-tooltip.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/kbd-in-tooltip")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-in-tooltip"
        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-modifier-keys": {
      name: "kbd-modifier-keys",
      filePath: "examples/base/kbd-modifier-keys.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/kbd-modifier-keys")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-modifier-keys"
        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] }
      }),
    },
    "kbd-with-icons-and-text": {
      name: "kbd-with-icons-and-text",
      filePath: "examples/base/kbd-with-icons-and-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/kbd-with-icons-and-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-with-icons-and-text"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-with-icons": {
      name: "kbd-with-icons",
      filePath: "examples/base/kbd-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/kbd-with-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-with-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "kbd-with-samp": {
      name: "kbd-with-samp",
      filePath: "examples/base/kbd-with-samp.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/kbd-with-samp")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "kbd-with-samp"
        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-disabled": {
      name: "label-disabled",
      filePath: "examples/base/label-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/label-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "label-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "label-with-checkbox": {
      name: "label-with-checkbox",
      filePath: "examples/base/label-with-checkbox.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/label-with-checkbox")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "label-with-checkbox"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "label-with-input": {
      name: "label-with-input",
      filePath: "examples/base/label-with-input.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/label-with-input")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "label-with-input"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "label-with-textarea": {
      name: "label-with-textarea",
      filePath: "examples/base/label-with-textarea.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/label-with-textarea")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "label-with-textarea"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-basic": {
      name: "menubar-basic",
      filePath: "examples/base/menubar-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/menubar-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-basic"
        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-destructive": {
      name: "menubar-destructive",
      filePath: "examples/base/menubar-destructive.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/menubar-destructive")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-destructive"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-format": {
      name: "menubar-format",
      filePath: "examples/base/menubar-format.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/menubar-format")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-format"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-in-dialog": {
      name: "menubar-in-dialog",
      filePath: "examples/base/menubar-in-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/menubar-in-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-in-dialog"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-insert": {
      name: "menubar-insert",
      filePath: "examples/base/menubar-insert.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/menubar-insert")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-insert"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-with-checkboxes": {
      name: "menubar-with-checkboxes",
      filePath: "examples/base/menubar-with-checkboxes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/menubar-with-checkboxes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-with-checkboxes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-with-icons": {
      name: "menubar-with-icons",
      filePath: "examples/base/menubar-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/menubar-with-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-with-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-with-radio": {
      name: "menubar-with-radio",
      filePath: "examples/base/menubar-with-radio.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/menubar-with-radio")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-with-radio"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-with-shortcuts": {
      name: "menubar-with-shortcuts",
      filePath: "examples/base/menubar-with-shortcuts.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/menubar-with-shortcuts")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-with-shortcuts"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "menubar-with-submenu": {
      name: "menubar-with-submenu",
      filePath: "examples/base/menubar-with-submenu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/menubar-with-submenu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "menubar-with-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-basic": {
      name: "native-select-basic",
      filePath: "examples/base/native-select-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/native-select-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-basic"
        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-fields": {
      name: "native-select-fields",
      filePath: "examples/base/native-select-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/native-select-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-fields"
        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-sizes": {
      name: "native-select-sizes",
      filePath: "examples/base/native-select-sizes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/native-select-sizes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-sizes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "native-select-with-field": {
      name: "native-select-with-field",
      filePath: "examples/base/native-select-with-field.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/native-select-with-field")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-with-field"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "native-select-with-groups": {
      name: "native-select-with-groups",
      filePath: "examples/base/native-select-with-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/native-select-with-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "native-select-with-groups"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "navigation-menu-basic": {
      name: "navigation-menu-basic",
      filePath: "examples/base/navigation-menu-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/navigation-menu-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "navigation-menu-basic"
        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] }
      }),
    },
    "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-basic": {
      name: "pagination-basic",
      filePath: "examples/base/pagination-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/pagination-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "pagination-basic"
        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-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-in-dialog": {
      name: "popover-in-dialog",
      filePath: "examples/base/popover-in-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/popover-in-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "popover-in-dialog"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "popover-with-form": {
      name: "popover-with-form",
      filePath: "examples/base/popover-with-form.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/popover-with-form")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "popover-with-form"
        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-values": {
      name: "progress-values",
      filePath: "examples/base/progress-values.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/progress-values")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "progress-values"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "progress-with-label": {
      name: "progress-with-label",
      filePath: "examples/base/progress-with-label.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/progress-with-label")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "progress-with-label"
        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-basic": {
      name: "radio-group-basic",
      filePath: "examples/base/radio-group-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/radio-group-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-basic"
        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-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-grid": {
      name: "radio-group-grid",
      filePath: "examples/base/radio-group-grid.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/radio-group-grid")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-grid"
        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-with-descriptions": {
      name: "radio-group-with-descriptions",
      filePath: "examples/base/radio-group-with-descriptions.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/radio-group-with-descriptions")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-with-descriptions"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "radio-group-with-field-set": {
      name: "radio-group-with-field-set",
      filePath: "examples/base/radio-group-with-field-set.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/radio-group-with-field-set")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "radio-group-with-field-set"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "resizable-controlled": {
      name: "resizable-controlled",
      filePath: "examples/base/resizable-controlled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/resizable-controlled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "resizable-controlled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "resizable-demo-with-handle": {
      name: "resizable-demo-with-handle",
      filePath: "examples/base/resizable-demo-with-handle.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/resizable-demo-with-handle")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "resizable-demo-with-handle"
        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-horizontal": {
      name: "resizable-horizontal",
      filePath: "examples/base/resizable-horizontal.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/resizable-horizontal")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "resizable-horizontal"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "resizable-nested": {
      name: "resizable-nested",
      filePath: "examples/base/resizable-nested.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/resizable-nested")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "resizable-nested"
        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] }
      }),
    },
    "resizable-with-handle": {
      name: "resizable-with-handle",
      filePath: "examples/base/resizable-with-handle.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/resizable-with-handle")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "resizable-with-handle"
        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-horizontal": {
      name: "scroll-area-horizontal",
      filePath: "examples/base/scroll-area-horizontal.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/scroll-area-horizontal")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "scroll-area-horizontal"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "scroll-area-vertical": {
      name: "scroll-area-vertical",
      filePath: "examples/base/scroll-area-vertical.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/scroll-area-vertical")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "scroll-area-vertical"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-basic": {
      name: "select-basic",
      filePath: "examples/base/select-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-basic"
        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-fields": {
      name: "select-fields",
      filePath: "examples/base/select-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-fields"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-in-dialog": {
      name: "select-in-dialog",
      filePath: "examples/base/select-in-dialog.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-in-dialog")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-in-dialog"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-inline": {
      name: "select-inline",
      filePath: "examples/base/select-inline.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-inline")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-inline"
        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-item-aligned": {
      name: "select-item-aligned",
      filePath: "examples/base/select-item-aligned.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-item-aligned")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-item-aligned"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-large-list": {
      name: "select-large-list",
      filePath: "examples/base/select-large-list.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-large-list")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-large-list"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-multiple": {
      name: "select-multiple",
      filePath: "examples/base/select-multiple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-multiple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-multiple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-plan": {
      name: "select-plan",
      filePath: "examples/base/select-plan.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-plan")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-plan"
        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] }
      }),
    },
    "select-sizes": {
      name: "select-sizes",
      filePath: "examples/base/select-sizes.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-sizes")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-sizes"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-with-button": {
      name: "select-with-button",
      filePath: "examples/base/select-with-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-with-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-with-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-with-field": {
      name: "select-with-field",
      filePath: "examples/base/select-with-field.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-with-field")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-with-field"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-with-groups": {
      name: "select-with-groups",
      filePath: "examples/base/select-with-groups.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-with-groups")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-with-groups"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "select-with-icons": {
      name: "select-with-icons",
      filePath: "examples/base/select-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/select-with-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "select-with-icons"
        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-horizontal": {
      name: "separator-horizontal",
      filePath: "examples/base/separator-horizontal.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/separator-horizontal")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "separator-horizontal"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "separator-in-list": {
      name: "separator-in-list",
      filePath: "examples/base/separator-in-list.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/separator-in-list")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "separator-in-list"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "separator-vertical-menu": {
      name: "separator-vertical-menu",
      filePath: "examples/base/separator-vertical-menu.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/separator-vertical-menu")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "separator-vertical-menu"
        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-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] }
      }),
    },
    "sheet-with-form": {
      name: "sheet-with-form",
      filePath: "examples/base/sheet-with-form.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sheet-with-form")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sheet-with-form"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "sheet-with-sides": {
      name: "sheet-with-sides",
      filePath: "examples/base/sheet-with-sides.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sheet-with-sides")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sheet-with-sides"
        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-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-basic": {
      name: "slider-basic",
      filePath: "examples/base/slider-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/slider-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "slider-basic"
        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-fields": {
      name: "slider-fields",
      filePath: "examples/base/slider-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/slider-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "slider-fields"
        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-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-basic": {
      name: "sonner-basic",
      filePath: "examples/base/sonner-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sonner-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sonner-basic"
        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-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] }
      }),
    },
    "sonner-with-description": {
      name: "sonner-with-description",
      filePath: "examples/base/sonner-with-description.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/sonner-with-description")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "sonner-with-description"
        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-basic": {
      name: "spinner-basic",
      filePath: "examples/base/spinner-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/spinner-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-basic"
        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-color": {
      name: "spinner-color",
      filePath: "examples/base/spinner-color.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/spinner-color")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-color"
        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-in-badges": {
      name: "spinner-in-badges",
      filePath: "examples/base/spinner-in-badges.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/spinner-in-badges")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-in-badges"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-in-buttons": {
      name: "spinner-in-buttons",
      filePath: "examples/base/spinner-in-buttons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/spinner-in-buttons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-in-buttons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-in-empty": {
      name: "spinner-in-empty",
      filePath: "examples/base/spinner-in-empty.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/spinner-in-empty")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-in-empty"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "spinner-in-input-group": {
      name: "spinner-in-input-group",
      filePath: "examples/base/spinner-in-input-group.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/spinner-in-input-group")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-in-input-group"
        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-item": {
      name: "spinner-item",
      filePath: "examples/base/spinner-item.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/spinner-item")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "spinner-item"
        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-basic": {
      name: "switch-basic",
      filePath: "examples/base/switch-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/switch-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-basic"
        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-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-fields": {
      name: "switch-fields",
      filePath: "examples/base/switch-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/switch-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-fields"
        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] }
      }),
    },
    "switch-with-description": {
      name: "switch-with-description",
      filePath: "examples/base/switch-with-description.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/switch-with-description")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-with-description"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "switch-with-label": {
      name: "switch-with-label",
      filePath: "examples/base/switch-with-label.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/switch-with-label")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "switch-with-label"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-basic": {
      name: "table-basic",
      filePath: "examples/base/table-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/table-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-basic"
        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-simple": {
      name: "table-simple",
      filePath: "examples/base/table-simple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/table-simple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-simple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-with-actions": {
      name: "table-with-actions",
      filePath: "examples/base/table-with-actions.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/table-with-actions")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-with-actions"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-with-badges": {
      name: "table-with-badges",
      filePath: "examples/base/table-with-badges.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/table-with-badges")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-with-badges"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-with-footer": {
      name: "table-with-footer",
      filePath: "examples/base/table-with-footer.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/table-with-footer")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-with-footer"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-with-input": {
      name: "table-with-input",
      filePath: "examples/base/table-with-input.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/table-with-input")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-with-input"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "table-with-select": {
      name: "table-with-select",
      filePath: "examples/base/table-with-select.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/table-with-select")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "table-with-select"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-basic": {
      name: "tabs-basic",
      filePath: "examples/base/tabs-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tabs-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-basic"
        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-icon-only": {
      name: "tabs-icon-only",
      filePath: "examples/base/tabs-icon-only.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tabs-icon-only")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-icon-only"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-line-disabled": {
      name: "tabs-line-disabled",
      filePath: "examples/base/tabs-line-disabled.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tabs-line-disabled")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-line-disabled"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-line-with-content": {
      name: "tabs-line-with-content",
      filePath: "examples/base/tabs-line-with-content.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tabs-line-with-content")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-line-with-content"
        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-multiple": {
      name: "tabs-multiple",
      filePath: "examples/base/tabs-multiple.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tabs-multiple")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-multiple"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-variants-comparison": {
      name: "tabs-variants-comparison",
      filePath: "examples/base/tabs-variants-comparison.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tabs-variants-comparison")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-variants-comparison"
        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] }
      }),
    },
    "tabs-with-content": {
      name: "tabs-with-content",
      filePath: "examples/base/tabs-with-content.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tabs-with-content")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-with-content"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-with-dropdown": {
      name: "tabs-with-dropdown",
      filePath: "examples/base/tabs-with-dropdown.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tabs-with-dropdown")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-with-dropdown"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-with-icons": {
      name: "tabs-with-icons",
      filePath: "examples/base/tabs-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tabs-with-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-with-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tabs-with-input-and-button": {
      name: "tabs-with-input-and-button",
      filePath: "examples/base/tabs-with-input-and-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tabs-with-input-and-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tabs-with-input-and-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-basic": {
      name: "textarea-basic",
      filePath: "examples/base/textarea-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/textarea-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-basic"
        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-fields": {
      name: "textarea-fields",
      filePath: "examples/base/textarea-fields.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/textarea-fields")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-fields"
        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-with-button": {
      name: "textarea-with-button",
      filePath: "examples/base/textarea-with-button.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/textarea-with-button")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-with-button"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-with-description": {
      name: "textarea-with-description",
      filePath: "examples/base/textarea-with-description.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/textarea-with-description")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-with-description"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-with-label": {
      name: "textarea-with-label",
      filePath: "examples/base/textarea-with-label.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/textarea-with-label")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-with-label"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "textarea-with-text": {
      name: "textarea-with-text",
      filePath: "examples/base/textarea-with-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/textarea-with-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "textarea-with-text"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-basic": {
      name: "toggle-basic",
      filePath: "examples/base/toggle-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-basic"
        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-basic": {
      name: "toggle-group-basic",
      filePath: "examples/base/toggle-group-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-basic"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-date-range": {
      name: "toggle-group-date-range",
      filePath: "examples/base/toggle-group-date-range.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-date-range")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-date-range"
        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-filter": {
      name: "toggle-group-filter",
      filePath: "examples/base/toggle-group-filter.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-filter")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-filter"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-lg": {
      name: "toggle-group-lg",
      filePath: "examples/base/toggle-group-lg.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-lg")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-lg"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-outline-with-icons": {
      name: "toggle-group-outline-with-icons",
      filePath: "examples/base/toggle-group-outline-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-outline-with-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-outline-with-icons"
        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-single": {
      name: "toggle-group-single",
      filePath: "examples/base/toggle-group-single.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-single")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-single"
        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-sm": {
      name: "toggle-group-sm",
      filePath: "examples/base/toggle-group-sm.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-sm")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-sm"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-sort": {
      name: "toggle-group-sort",
      filePath: "examples/base/toggle-group-sort.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-sort")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-sort"
        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-outline-with-icons": {
      name: "toggle-group-vertical-outline-with-icons",
      filePath: "examples/base/toggle-group-vertical-outline-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import(
          "./base/toggle-group-vertical-outline-with-icons"
        )
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-vertical-outline-with-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-vertical-outline": {
      name: "toggle-group-vertical-outline",
      filePath: "examples/base/toggle-group-vertical-outline.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-vertical-outline")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-vertical-outline"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-vertical-with-spacing": {
      name: "toggle-group-vertical-with-spacing",
      filePath: "examples/base/toggle-group-vertical-with-spacing.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-vertical-with-spacing")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-vertical-with-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-group-with-icons": {
      name: "toggle-group-with-icons",
      filePath: "examples/base/toggle-group-with-icons.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-with-icons")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-with-icons"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-group-with-input-and-select": {
      name: "toggle-group-with-input-and-select",
      filePath: "examples/base/toggle-group-with-input-and-select.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-group-with-input-and-select")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-group-with-input-and-select"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-lg": {
      name: "toggle-lg",
      filePath: "examples/base/toggle-lg.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-lg")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-lg"
        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-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-sm": {
      name: "toggle-sm",
      filePath: "examples/base/toggle-sm.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-sm")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-sm"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-with-button-icon-text": {
      name: "toggle-with-button-icon-text",
      filePath: "examples/base/toggle-with-button-icon-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-with-button-icon-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-with-button-icon-text"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-with-button-icon": {
      name: "toggle-with-button-icon",
      filePath: "examples/base/toggle-with-button-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-with-button-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-with-button-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-with-button-text": {
      name: "toggle-with-button-text",
      filePath: "examples/base/toggle-with-button-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-with-button-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-with-button-text"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-with-icon": {
      name: "toggle-with-icon",
      filePath: "examples/base/toggle-with-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-with-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-with-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "toggle-with-text": {
      name: "toggle-with-text",
      filePath: "examples/base/toggle-with-text.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/toggle-with-text")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "toggle-with-text"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tooltip-basic": {
      name: "tooltip-basic",
      filePath: "examples/base/tooltip-basic.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tooltip-basic")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-basic"
        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-formatted": {
      name: "tooltip-formatted",
      filePath: "examples/base/tooltip-formatted.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tooltip-formatted")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-formatted"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tooltip-long-content": {
      name: "tooltip-long-content",
      filePath: "examples/base/tooltip-long-content.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tooltip-long-content")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-long-content"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tooltip-on-link": {
      name: "tooltip-on-link",
      filePath: "examples/base/tooltip-on-link.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tooltip-on-link")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-on-link"
        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] }
      }),
    },
    "tooltip-with-icon": {
      name: "tooltip-with-icon",
      filePath: "examples/base/tooltip-with-icon.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tooltip-with-icon")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-with-icon"
        return { default: mod.default || mod[exportName] }
      }),
    },
    "tooltip-with-keyboard": {
      name: "tooltip-with-keyboard",
      filePath: "examples/base/tooltip-with-keyboard.tsx",
      component: React.lazy(async () => {
        const mod = await import("./base/tooltip-with-keyboard")
        const exportName =
          Object.keys(mod).find(
            (key) =>
              typeof mod[key] === "function" || typeof mod[key] === "object"
          ) || "tooltip-with-keyboard"
        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-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] }
      }),
    },
  },
}