{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "angle-slider",
  "title": "Angle Slider",
  "description": "A dial for rotation and other circular values: drags one to one under pointer capture, steps by keyboard, wraps past 360, with a ring, a marked compass, a small knob and a 270 degree gauge.",
  "dependencies": [
    "motion"
  ],
  "registryDependencies": [
    "utils",
    "https://miseui.junsu4621.workers.dev/r/motion.json"
  ],
  "files": [
    {
      "path": "registry/miseui/ui/angle-slider.tsx",
      "content": "import type * as React from \"react\"\nimport { useMemo } from \"react\"\nimport type { MotionValue } from \"motion/react\"\nimport { useDial } from \"@/registry/miseui/ui/angle-slider-state\"\nimport type { DialRange } from \"@/registry/miseui/ui/angle-slider-math\"\nimport { DialRing, DialTicks, GaugeArc, Needle, RimThumb, type AngleSliderMark } from \"@/registry/miseui/ui/angle-slider-parts\"\nimport { cn } from \"@/registry/miseui/lib/utils\"\n\ntype AngleSliderVariant = \"plain\" | \"ticks\" | \"compact\" | \"gauge\"\ntype AngleSliderEffect = \"spring\"\n\nconst GAUGE_SWEEP = 270\nconst GAUGE_START = 225\nconst GAUGE_MAX = 100\nconst FULL_TURN = 360\n/** One notch of a page key: a quarter of a quarter turn is what people reach for on a dial. */\nconst DEFAULT_PAGE_STEP = 15\nconst COMPASS_MARKS: readonly AngleSliderMark[] = [\n  { value: 0, label: \"0°\" },\n  { value: 90, label: \"90°\" },\n  { value: 180, label: \"180°\" },\n  { value: 270, label: \"270°\" },\n]\n\nconst DIAL_CLASS: Record<AngleSliderVariant, string> = {\n  plain: \"size-32\",\n  ticks: \"size-40\",\n  compact: \"size-8 border bg-card shadow-xs pointer-coarse:size-10\",\n  gauge: \"size-36\",\n}\n\ntype AngleSliderProps = Omit<React.ComponentProps<\"div\">, \"onChange\" | \"defaultValue\"> & {\n  value?: number\n  defaultValue?: number\n  /** Fires on every change, drag included. */\n  onValueChange?: (value: number) => void\n  /** Fires once when the drag ends, or per key press. Save here. */\n  onValueCommit?: (value: number) => void\n  /** Defaults to 0. */\n  min?: number\n  /** Defaults to 360, or 100 on `gauge`. */\n  max?: number\n  step?: number\n  /** PageUp and PageDown distance. */\n  pageStep?: number\n  /** Going past the end comes round to the start. Full circles only; on by default there. */\n  wrap?: boolean\n  /** `plain` ring and thumb, `ticks` a marked compass, `compact` a small knob beside its value, `gauge` a 270 degree meter. */\n  variant?: AngleSliderVariant\n  /** `spring` eases the thumb to a clicked spot. Dragging always follows the pointer one to one. */\n  effect?: AngleSliderEffect\n  /** Labelled positions. `ticks` defaults to the four compass points. */\n  marks?: readonly AngleSliderMark[]\n  /** What the value reads as on screen. */\n  format?: (value: number) => string\n  /** What it reads as for assistive tech. Defaults to `format`, or \"45 degrees\" on a full circle. */\n  getValueText?: (value: number) => string\n  disabled?: boolean\n  /** Posts the value with the surrounding form. */\n  name?: string\n}\n\nfunction rangeFor(variant: AngleSliderVariant, min: number, max: number): DialRange {\n  const gauge = variant === \"gauge\"\n  return { min, max, sweep: gauge ? GAUGE_SWEEP : FULL_TURN, start: gauge ? GAUGE_START : 0 }\n}\n\ninterface DialFaceProps {\n  variant: AngleSliderVariant\n  range: DialRange\n  rotation: MotionValue<number>\n  marks?: readonly AngleSliderMark[]\n  display: string\n}\n\nfunction DialFace({ variant, range, rotation, marks, display }: DialFaceProps) {\n  const gauge = variant === \"gauge\"\n  if (variant === \"compact\") return <Needle rotation={rotation} inset=\"top-[12%] h-[38%]\" />\n  return (\n    <>\n      {variant === \"plain\" ? <DialRing /> : null}\n      {variant === \"ticks\" ? <DialTicks range={range} marks={marks ?? COMPASS_MARKS} /> : null}\n      {gauge ? <GaugeArc range={range} rotation={rotation} /> : null}\n      {variant === \"ticks\" ? <Needle rotation={rotation} inset=\"top-[2%] h-[16%]\" /> : <RimThumb rotation={rotation} />}\n      <output\n        data-slot=\"angle-slider-value\"\n        className={cn(\n          \"pointer-events-none absolute inset-0 grid place-items-center tabular-nums\",\n          gauge ? \"text-xl font-semibold tracking-tight\" : \"text-[15px] font-medium\",\n        )}\n      >\n        {display}\n      </output>\n    </>\n  )\n}\n\nfunction AngleSlider({\n  value: valueProp, defaultValue, onValueChange, onValueCommit, min = 0, max, step = 1, pageStep = DEFAULT_PAGE_STEP, wrap,\n  variant = \"plain\", effect, marks, format, getValueText, disabled = false, name, className,\n  \"aria-label\": ariaLabel, \"aria-labelledby\": ariaLabelledBy, ...props\n}: AngleSliderProps) {\n  const gauge = variant === \"gauge\"\n  const resolvedMax = max ?? (gauge ? GAUGE_MAX : FULL_TURN)\n  const range = useMemo(() => rangeFor(variant, min, resolvedMax), [variant, min, resolvedMax])\n  const dial = { value: valueProp, defaultValue, onValueChange, onValueCommit, range, step, pageStep, disabled }\n  const { value, rotation, handlers } = useDial({ ...dial, wrap: wrap ?? !gauge, spring: effect === \"spring\" })\n  const display = format ? format(value) : gauge ? String(value) : `${value}°`\n  const spoken = getValueText?.(value) ?? (format || gauge ? display : `${value} degrees`)\n  return (\n    <div data-slot=\"angle-slider\" data-variant={variant} data-effect={effect} className={cn(\"inline-flex max-w-full items-center gap-2\", disabled && \"opacity-50\", className)} {...props}>\n      {name ? <input type=\"hidden\" name={name} value={value} disabled={disabled} /> : null}\n      <div\n        role=\"slider\"\n        tabIndex={disabled ? -1 : 0}\n        aria-label={ariaLabel}\n        aria-labelledby={ariaLabelledBy}\n        aria-valuemin={range.min}\n        aria-valuemax={range.max}\n        aria-valuenow={value}\n        aria-valuetext={spoken}\n        aria-disabled={disabled || undefined}\n        data-slot=\"angle-slider-dial\"\n        className={cn(\n          \"relative shrink-0 touch-none rounded-full outline-none select-none focus-visible:ring-[3px] focus-visible:ring-ring/50\",\n          disabled ? \"cursor-not-allowed\" : \"cursor-grab active:cursor-grabbing\",\n          DIAL_CLASS[variant],\n        )}\n        {...handlers}\n      >\n        <DialFace variant={variant} range={range} rotation={rotation} marks={marks} display={display} />\n      </div>\n      {variant === \"compact\" ? (\n        <output data-slot=\"angle-slider-value\" className=\"text-[13px] tabular-nums\">\n          {display}\n        </output>\n      ) : null}\n    </div>\n  )\n}\n\nexport { AngleSlider, type AngleSliderProps, type AngleSliderVariant, type AngleSliderEffect, type AngleSliderMark }\n",
      "type": "registry:ui"
    },
    {
      "path": "registry/miseui/ui/angle-slider-math.ts",
      "content": "const FULL_TURN = 360\n\ninterface DialRange {\n  min: number\n  max: number\n  /** Degrees of the dial the range covers: 360 for a full circle, 270 for a gauge. */\n  sweep: number\n  /** Dial position of `min`, in degrees clockwise from the top. */\n  start: number\n}\n\nfunction normalizeAngle(angle: number) {\n  const turned = angle % FULL_TURN\n  // The extra `+ 0` turns -0 into 0, which otherwise leaks into aria-valuenow.\n  return (turned < 0 ? turned + FULL_TURN : turned) + 0\n}\n\n/** Degrees clockwise from the top, the way a dial is read. */\nfunction pointerToAngle(x: number, y: number, centreX: number, centreY: number) {\n  if (x === centreX && y === centreY) return 0\n  return normalizeAngle((Math.atan2(x - centreX, centreY - y) * 180) / Math.PI)\n}\n\n/** Signed distance the short way round, in -180..180. */\nfunction shortestDelta(from: number, to: number) {\n  const delta = normalizeAngle(to - from)\n  return delta > FULL_TURN / 2 ? delta - FULL_TURN : delta\n}\n\n/** Rounds on a grid anchored at `base`, then cuts binary noise so 0.1 + 0.2 reads as 0.3. */\nfunction snapToStep(value: number, step: number, base = 0) {\n  if (step <= 0) return value\n  return Number((Math.round((value - base) / step) * step + base).toFixed(10))\n}\n\nfunction clamp(value: number, min: number, max: number) {\n  return Math.min(max, Math.max(min, value))\n}\n\nfunction isFullCircle(range: DialRange) {\n  return range.sweep >= FULL_TURN\n}\n\nfunction valueToAngle(value: number, range: DialRange) {\n  const span = range.max - range.min\n  if (span === 0) return normalizeAngle(range.start)\n  return normalizeAngle(range.start + ((value - range.min) / span) * range.sweep)\n}\n\nfunction fractionOfRange(value: number, range: DialRange) {\n  const span = range.max - range.min\n  return span === 0 ? 0 : clamp((value - range.min) / span, 0, 1)\n}\n\n/** On a full circle the top is both ends of the range, so max folds onto min. */\nfunction wrapValue(value: number, range: DialRange) {\n  const span = range.max - range.min\n  if (span <= 0) return range.min\n  const turned = (value - range.min) % span\n  return (turned < 0 ? turned + span : turned) + range.min + 0\n}\n\n/** Keyboard and step changes: wrap past the ends on a wrapping dial, otherwise stop at them. */\nfunction stepValue(value: number, delta: number, range: DialRange, step: number, wrap: boolean) {\n  const next = snapToStep(value + delta, step, range.min)\n  return wrap && isFullCircle(range) ? wrapValue(next, range) : clamp(next, range.min, range.max)\n}\n\n/** Where on the range a pointer lands, or the nearer end when it is in the dead zone of a partial dial. */\nfunction angleToValue(angle: number, range: DialRange) {\n  const offset = normalizeAngle(angle - range.start)\n  const span = range.max - range.min\n  if (offset <= range.sweep) return range.min + (offset / range.sweep) * span\n  const pastEnd = offset - range.sweep\n  const beforeStart = FULL_TURN - offset\n  return pastEnd <= beforeStart ? range.max : range.min\n}\n\ninterface DragStep {\n  angle: number\n  previous: number\n  range: DialRange\n  step: number\n  wrap: boolean\n}\n\n/**\n * The value for one pointer position during a drag. A bounded dial must not leap across its seam: moving\n * past the top from 350 lands on 0 for a wrapping dial, but stays at the end for one that does not wrap.\n */\nfunction dragValue({ angle, previous, range, step, wrap }: DragStep) {\n  const span = range.max - range.min\n  const raw = angleToValue(angle, range)\n  const snapped = clamp(snapToStep(raw, step, range.min), range.min, range.max)\n  if (wrap && isFullCircle(range)) return wrapValue(snapped, range)\n  const leaping = Math.abs(raw - previous) > span / 2\n  if (!leaping) return snapped\n  return previous - range.min > span / 2 ? range.max : range.min\n}\n\n/** Dial position in degrees. Not normalised: a gauge must animate along its arc, never across the gap. */\nfunction dialRotation(value: number, range: DialRange) {\n  return range.start + fractionOfRange(value, range) * range.sweep\n}\n\nfunction polarPoint(angle: number, radius: number, centre: number) {\n  const radians = (angle * Math.PI) / 180\n  return { x: centre + radius * Math.sin(radians), y: centre - radius * Math.cos(radians) }\n}\n\n/** SVG path along the dial, clockwise from `start`. */\nfunction arcPath(start: number, sweep: number, radius: number, centre: number) {\n  const from = polarPoint(start, radius, centre)\n  const to = polarPoint(start + sweep, radius, centre)\n  const large = sweep > 180 ? 1 : 0\n  return `M${from.x.toFixed(3)} ${from.y.toFixed(3)}A${radius} ${radius} 0 ${large} 1 ${to.x.toFixed(3)} ${to.y.toFixed(3)}`\n}\n\n/** Value for a press. There is no drag to be continuous with, so a press may go anywhere on the range. */\nfunction pressValue(angle: number, range: DialRange, step: number, wrap: boolean) {\n  const snapped = clamp(snapToStep(angleToValue(angle, range), step, range.min), range.min, range.max)\n  return wrap && isFullCircle(range) ? wrapValue(snapped, range) : snapped\n}\n\nexport {\n  angleToValue,\n  arcPath,\n  clamp,\n  dialRotation,\n  dragValue,\n  fractionOfRange,\n  isFullCircle,\n  normalizeAngle,\n  pointerToAngle,\n  polarPoint,\n  pressValue,\n  shortestDelta,\n  snapToStep,\n  stepValue,\n  valueToAngle,\n  wrapValue,\n  type DialRange,\n}\n",
      "type": "registry:ui"
    },
    {
      "path": "registry/miseui/ui/angle-slider-parts.tsx",
      "content": "import { motion, useTransform, type MotionValue } from \"motion/react\"\nimport { arcPath, polarPoint, valueToAngle, type DialRange } from \"@/registry/miseui/ui/angle-slider-math\"\nimport { cn } from \"@/registry/miseui/lib/utils\"\n\ninterface AngleSliderMark {\n  value: number\n  label?: string\n}\n\n/** Everything is drawn on this box, so a dial of any size stays crisp and keeps its proportions. */\nconst VIEW_BOX = 100\nconst CENTRE = VIEW_BOX / 2\nconst RIM_RADIUS = 46\nconst TRACK_RADIUS = 44\nconst TICK_LENGTH = 3\nconst MAJOR_TICK_LENGTH = 6\nconst LABEL_RADIUS = 31\nconst TICK_STEP_DEGREES = 15\nconst GAUGE_STROKE = 6\n\nfunction rotate(rotation: MotionValue<number>) {\n  return { rotate: rotation }\n}\n\nfunction DialRing() {\n  return (\n    <svg aria-hidden=\"true\" viewBox={`0 0 ${VIEW_BOX} ${VIEW_BOX}`} className=\"absolute inset-0 size-full\">\n      <circle cx={CENTRE} cy={CENTRE} r={TRACK_RADIUS} fill=\"none\" strokeWidth={GAUGE_STROKE} className=\"stroke-muted\" />\n    </svg>\n  )\n}\n\nfunction RimThumb({ rotation }: { rotation: MotionValue<number> }) {\n  return (\n    <motion.div aria-hidden=\"true\" data-slot=\"angle-slider-thumb\" style={rotate(rotation)} className=\"absolute inset-0\">\n      {/* The track runs at radius 44 of 100, so a 12% thumb flush with the top sits exactly on it. The outline keeps a near-black accent visible on a dark panel. */}\n      <span className=\"absolute top-0 left-1/2 aspect-square w-[12%] -translate-x-1/2 rounded-full bg-mise shadow-sm ring-2 ring-background outline-1 outline-offset-2 outline-foreground/20\" />\n    </motion.div>\n  )\n}\n\nfunction Needle({ rotation, inset }: { rotation: MotionValue<number>; inset: string }) {\n  return (\n    <motion.div aria-hidden=\"true\" data-slot=\"angle-slider-thumb\" style={rotate(rotation)} className=\"absolute inset-0\">\n      <span className={cn(\"absolute left-1/2 w-0.5 -translate-x-1/2 rounded-full bg-foreground\", inset)} />\n    </motion.div>\n  )\n}\n\nfunction DialTicks({ range, marks }: { range: DialRange; marks: readonly AngleSliderMark[] }) {\n  const markAngles = marks.map((mark) => valueToAngle(mark.value, range))\n  const count = Math.round(360 / TICK_STEP_DEGREES)\n  const ticks = Array.from({ length: count }, (_, index) => index * TICK_STEP_DEGREES)\n  return (\n    <svg aria-hidden=\"true\" data-slot=\"angle-slider-ticks\" viewBox={`0 0 ${VIEW_BOX} ${VIEW_BOX}`} className=\"absolute inset-0 size-full\">\n      {ticks.map((angle) => {\n        const major = markAngles.includes(angle)\n        const outer = polarPoint(angle, RIM_RADIUS + 3, CENTRE)\n        const inner = polarPoint(angle, RIM_RADIUS + 3 - (major ? MAJOR_TICK_LENGTH : TICK_LENGTH), CENTRE)\n        return (\n          <line\n            key={angle}\n            x1={outer.x}\n            y1={outer.y}\n            x2={inner.x}\n            y2={inner.y}\n            strokeWidth={major ? 1 : 0.5}\n            className={major ? \"stroke-foreground\" : \"stroke-muted-foreground/60\"}\n          />\n        )\n      })}\n      {marks.map((mark) => {\n        if (!mark.label) return null\n        const point = polarPoint(valueToAngle(mark.value, range), LABEL_RADIUS, CENTRE)\n        return (\n          <text key={mark.value} x={point.x} y={point.y} textAnchor=\"middle\" dominantBaseline=\"central\" fontSize={7.5} className=\"fill-muted-foreground\">\n            {mark.label}\n          </text>\n        )\n      })}\n    </svg>\n  )\n}\n\nfunction GaugeArc({ range, rotation }: { range: DialRange; rotation: MotionValue<number> }) {\n  const path = arcPath(range.start, range.sweep, TRACK_RADIUS, CENTRE)\n  const filled = useTransform(rotation, (turned) => (turned - range.start) / range.sweep)\n  return (\n    <svg aria-hidden=\"true\" data-slot=\"angle-slider-gauge\" viewBox={`0 0 ${VIEW_BOX} ${VIEW_BOX}`} className=\"absolute inset-0 size-full\">\n      <path d={path} fill=\"none\" strokeWidth={GAUGE_STROKE} strokeLinecap=\"round\" className=\"stroke-muted\" />\n      <motion.path\n        d={path}\n        fill=\"none\"\n        strokeWidth={GAUGE_STROKE}\n        strokeLinecap=\"round\"\n        className=\"stroke-mise\"\n        style={{ pathLength: filled }}\n      />\n    </svg>\n  )\n}\n\nexport { DialRing, DialTicks, GaugeArc, Needle, RimThumb, type AngleSliderMark }\n",
      "type": "registry:ui"
    },
    {
      "path": "registry/miseui/ui/angle-slider-state.ts",
      "content": "import type * as React from \"react\"\nimport { useLayoutEffect, useRef, useState } from \"react\"\nimport { animate, useMotionValue, useReducedMotion, type AnimationPlaybackControls, type MotionValue } from \"motion/react\"\nimport { SPRING_DEFAULT } from \"@/registry/miseui/lib/motion\"\nimport {\n  dialRotation,\n  dragValue,\n  isFullCircle,\n  pointerToAngle,\n  pressValue,\n  shortestDelta,\n  snapToStep,\n  stepValue,\n  type DialRange,\n} from \"@/registry/miseui/ui/angle-slider-math\"\n\ninterface UseDialOptions {\n  value?: number\n  defaultValue?: number\n  onValueChange?: (value: number) => void\n  onValueCommit?: (value: number) => void\n  range: DialRange\n  step: number\n  pageStep: number\n  wrap: boolean\n  disabled: boolean\n  spring: boolean\n}\n\nfunction pointerAngle(event: React.PointerEvent<HTMLElement>) {\n  const rect = event.currentTarget.getBoundingClientRect()\n  return pointerToAngle(event.clientX, event.clientY, rect.left + rect.width / 2, rect.top + rect.height / 2)\n}\n\nfunction keyTargets(value: number, { range, step, pageStep, wrap }: Pick<UseDialOptions, \"range\" | \"step\" | \"pageStep\" | \"wrap\">) {\n  const by = (delta: number) => () => stepValue(value, delta, range, step, wrap)\n  // On a full circle the top of the range is the same spot as the bottom, so End stops one step short of it.\n  const end = wrap && isFullCircle(range) ? range.max - step : range.max\n  return {\n    ArrowRight: by(step),\n    ArrowUp: by(step),\n    ArrowLeft: by(-step),\n    ArrowDown: by(-step),\n    PageUp: by(pageStep),\n    PageDown: by(-pageStep),\n    Home: () => range.min,\n    End: () => snapToStep(end, step, range.min),\n  } as Record<string, (() => number) | undefined>\n}\n\n/** The one spring on a dial: from a press to where the press landed. Anything else cancels it. */\nfunction useDialJump(rotation: MotionValue<number>, range: DialRange) {\n  const running = useRef<AnimationPlaybackControls | null>(null)\n  useLayoutEffect(() => () => running.current?.stop(), [])\n\n  const stop = () => {\n    running.current?.stop()\n    running.current = null\n  }\n\n  const start = (next: number) => {\n    stop()\n    const from = rotation.get()\n    const target = dialRotation(next, range)\n    // A full circle takes the short way round; a gauge has a gap it must never cross.\n    const to = isFullCircle(range) ? from + shortestDelta(from, target) : target\n    running.current = animate(rotation, to, {\n      ...SPRING_DEFAULT,\n      onComplete: () => {\n        running.current = null\n      },\n    })\n  }\n\n  return { running, start, stop }\n}\n\ninterface DialDragOptions extends Pick<UseDialOptions, \"range\" | \"step\" | \"wrap\" | \"disabled\" | \"spring\" | \"onValueCommit\"> {\n  rotation: MotionValue<number>\n  latest: React.RefObject<number>\n  jump: ReturnType<typeof useDialJump>\n  report: (next: number) => void\n}\n\n/** Pointer capture carries the drag outside the dial. Only the press may spring; every move lands exactly. */\nfunction useDialDrag({ range, step, wrap, disabled, spring, onValueCommit, rotation, latest, jump, report }: DialDragOptions) {\n  const reduceMotion = useReducedMotion() ?? false\n  const dragging = useRef(false)\n\n  const onPointerDown = (event: React.PointerEvent<HTMLElement>) => {\n    if (disabled || event.button !== 0) return\n    event.currentTarget.setPointerCapture(event.pointerId)\n    event.currentTarget.focus({ preventScroll: true })\n    // Focus would otherwise be taken away again by the browser's default for a press on a non-input.\n    event.preventDefault()\n    dragging.current = true\n    const next = pressValue(pointerAngle(event), range, step, wrap)\n    if (spring && !reduceMotion) jump.start(next)\n    report(next)\n  }\n\n  const onPointerMove = (event: React.PointerEvent<HTMLElement>) => {\n    if (!dragging.current) return\n    jump.stop()\n    const next = dragValue({ angle: pointerAngle(event), previous: latest.current, range, step, wrap })\n    rotation.set(dialRotation(next, range))\n    report(next)\n  }\n\n  const endDrag = (event: React.PointerEvent<HTMLElement>) => {\n    if (!dragging.current) return\n    dragging.current = false\n    if (event.currentTarget.hasPointerCapture?.(event.pointerId)) event.currentTarget.releasePointerCapture(event.pointerId)\n    onValueCommit?.(latest.current)\n  }\n\n  return { onPointerDown, onPointerMove, onPointerUp: endDrag, onPointerCancel: endDrag }\n}\n\nfunction useDial(options: UseDialOptions) {\n  const { value: controlled, defaultValue, onValueChange, onValueCommit, range, disabled } = options\n  const [uncontrolled, setUncontrolled] = useState(defaultValue ?? range.min)\n  const value = controlled ?? uncontrolled\n  const rotation = useMotionValue(dialRotation(value, range))\n  const latest = useRef(value)\n  const jump = useDialJump(rotation, range)\n  const { running } = jump\n\n  const report = (next: number) => {\n    latest.current = next\n    setUncontrolled(next)\n    if (next !== value) onValueChange?.(next)\n  }\n\n  // Follows every change unless a press spring is on its way to that same value: then this would cut it short.\n  useLayoutEffect(() => {\n    latest.current = value\n    if (!running.current) rotation.set(dialRotation(value, range))\n  }, [value, range, rotation, running])\n\n  const drag = useDialDrag({ ...options, rotation, latest, jump, report })\n\n  const onKeyDown = (event: React.KeyboardEvent<HTMLElement>) => {\n    const target = disabled ? undefined : keyTargets(value, options)[event.key]\n    if (!target) return\n    event.preventDefault()\n    jump.stop()\n    const next = target()\n    report(next)\n    onValueCommit?.(next)\n  }\n\n  return { value, rotation, handlers: { ...drag, onKeyDown } }\n}\n\nexport { useDial }\n",
      "type": "registry:ui"
    }
  ],
  "categories": [
    "forms"
  ],
  "type": "registry:ui"
}