{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "louver",
  "type": "registry:ui",
  "title": "Louver",
  "description": "Gradient blinds: angled slats tilt open around the cursor to reveal a brighter rosewood-to-indigo field behind, each open slat catching a 1px lit edge, with a slow diagonal shimmer when idle. Original OGL fragment shader, offscreen-paused and reduced-motion-safe. Idles on its own when untouched — a ghost cursor tilts the blinds.",
  "dependencies": [
    "ogl"
  ],
  "registryDependencies": [
    "https://crucibleui.com/r/use-visibility-pause.json",
    "https://crucibleui.com/r/use-reduced-motion.json",
    "https://crucibleui.com/r/use-dpr-cap.json"
  ],
  "files": [
    {
      "path": "registry/default/backgrounds/louver/louver.tsx",
      "type": "registry:ui",
      "target": "components/crucible/louver.tsx",
      "content": "\"use client\";\n\nimport * as React from \"react\";\nimport { Mesh, Program, Renderer, Triangle } from \"ogl\";\n\nimport { cn } from \"@/lib/utils\";\nimport { useReducedMotion } from \"@/hooks/use-reduced-motion\";\nimport { useVisibilityPause } from \"@/hooks/use-visibility-pause\";\nimport { clampDpr, useDprCap } from \"@/hooks/use-dpr-cap\";\n\nexport interface LouverProps {\n  /**\n   * Two gradient stops `[from, to]` for the field behind the blinds.\n   * Any hex strings. Defaults to rosewood → indigo duotone.\n   */\n  colors?: [string, string];\n  /**\n   * Number of slats. Clamped so no slat renders narrower than ~10 CSS px\n   * (the effective count drops automatically on short stages). Default 24.\n   */\n  slatCount?: number;\n  /** Slat tilt from horizontal, in degrees. Default 18. */\n  angle?: number;\n  /** Baseline openness of every slat, 0–0.8. Default 0.07. */\n  openBias?: number;\n  /**\n   * Pointer influence radius as a fraction of the stage height (the blinds\n   * tilt open within this distance of the cursor). Default 0.32.\n   */\n  radius?: number;\n  /** Respond to the pointer. When false only the idle shimmer runs. Default true. */\n  interactive?: boolean;\n  /** Animation speed multiplier. 1 = default. */\n  speed?: number;\n  /** Strength of the pointer reveal and lit-edge highlight. 1 = default. */\n  intensity?: number;\n  /** Freeze the animation, holding the current frame. */\n  paused?: boolean;\n  /**\n   * Idle autoplay: after ~1.5s with no real pointer, a seeded ghost cursor\n   * drifts over the blinds on a slow Lissajous path, tilting them open at a\n   * slightly softer strength, so the field never looks dead in thumbnails and\n   * heroes. The real pointer takes over instantly. Only when `interactive`;\n   * never under reduced motion. Default true.\n   */\n  idle?: boolean;\n  /** Extra classes for the wrapper. Positioned `absolute inset-0 -z-10`. */\n  className?: string;\n}\n\nconst DEFAULT_COLORS: [string, string] = [\n  \"#9f5b66\", // rosewood\n  \"#312e81\", // indigo\n];\n\n/** No slat may render narrower than this many CSS px — below it, moiré. */\nconst MIN_SLAT_CSS_PX = 10;\n\n/** Ghost takes over this long (ms) after the last real pointer activity. */\nconst GHOST_DELAY_MS = 1500;\n/** Ghost reveal strength relative to a real pointer. */\nconst GHOST_PRESENCE = 0.75;\n\n/** `uTime` used for the designed reduced-motion still. */\nconst STATIC_TIME = 0.35;\n\n/** Hex → [r,g,b] in 0–1. Accepts #rgb / #rrggbb. */\nfunction hexToRgb(hex: string): [number, number, number] {\n  let h = hex.replace(\"#\", \"\").trim();\n  if (h.length === 3) {\n    h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];\n  }\n  const int = parseInt(h, 16);\n  if (Number.isNaN(int) || h.length !== 6) return [0.62, 0.36, 0.4];\n  return [((int >> 16) & 255) / 255, ((int >> 8) & 255) / 255, (int & 255) / 255];\n}\n\nconst VERTEX = /* glsl */ `\nprecision highp float;\nattribute vec2 position;\nattribute vec2 uv;\nvarying vec2 vUv;\nvoid main() {\n  vUv = uv;\n  gl_Position = vec4(position, 0.0, 1.0);\n}\n`;\n\n/**\n * Original gradient-blinds fragment shader. The frame is sliced into angled\n * slats; each slat's OPENNESS is the duty cycle of a smooth pulse wave across\n * the slat axis — the fraction of the cell where the slat has tilted away and\n * the brighter gradient field behind shows through. Openness is sampled at\n * the slat's centerline (constant across a slat's width, free to vary along\n * its length), so slats read as rigid vanes that twist open locally around\n * the cursor and close softly after it passes. A slow diagonal shimmer sweeps\n * openness across the field when uninteracted, and every open slat carries a\n * ~1px lit edge at its free lip. Premultiplied-alpha output: closed slat\n * faces stay faintly translucent so the page tone grounds them — no CSS\n * blend-mode crutch. GLSL ES 1.00.\n */\nconst FRAGMENT = /* glsl */ `\nprecision highp float;\n\nvarying vec2 vUv;\n\nuniform float uTime;\nuniform vec2 uResolution;\nuniform vec2 uMouse;       // damped pointer, centered aspect-corrected space\nuniform float uInfluence;  // eased 0..1 pointer presence\nuniform vec3 uColorA;\nuniform vec3 uColorB;\nuniform float uCount;      // effective slat count (min-width clamped)\nuniform float uAngle;      // radians from horizontal\nuniform float uOpenBias;\nuniform float uRadius;     // fraction of stage height\nuniform float uSpeed;\nuniform float uIntensity;\nuniform float uSeed;       // 0..1 per-instance\nuniform float uStaticFrame; // 1 = designed reduced-motion still\n\nfloat hash11(float n) {\n  return fract(sin(n * 127.1 + 311.7) * 43758.5453);\n}\n\nfloat hash21(vec2 p) {\n  p = fract(p * vec2(219.18, 371.43));\n  p += dot(p, p + 37.51);\n  return fract(p.x * p.y);\n}\n\n// Soft plateau pulse over x in [0,1): eases up, holds, eases down.\nfloat pulse(float x) {\n  return smoothstep(0.04, 0.42, x) * (1.0 - smoothstep(0.58, 0.96, x));\n}\n\nvoid main() {\n  float aspect = uResolution.x / max(uResolution.y, 1.0);\n  // Static frames drop the speed multiplier and seed offset so the designed\n  // arrangement is identical for every instance and every speed setting.\n  float t = mix(uTime * uSpeed + uSeed * 43.0, uTime, uStaticFrame);\n\n  // Centered, aspect-corrected: one unit = stage height, isotropic.\n  vec2 p = (vUv - 0.5) * vec2(aspect, 1.0);\n\n  float ca = cos(uAngle);\n  float sa = sin(uAngle);\n  vec2 nrm = vec2(-sa, ca); // across the slats (slat normal)\n  vec2 tng = vec2(ca, sa);  // along the slats\n\n  float s = dot(p, nrm);\n  float q = dot(p, tng);\n\n  float x = s * uCount + 64.0; // offset keeps floor() in positive territory\n  float i = floor(x);\n  float f = fract(x); // 0 = hinge edge, 1 = free edge of this slat\n\n  // Slat centerline point — openness is constant across a slat's width.\n  float sc = (i + 0.5 - 64.0) / uCount;\n  vec2 cp = nrm * sc + tng * q;\n\n  // ---- openness: pointer tilt + idle diagonal shimmer over a base bias ----\n  vec2 md = cp - uMouse;\n  float rr = max(uRadius * uRadius, 1e-4);\n  float g = exp(-dot(md, md) / rr * 2.4);\n  float open01 = g * uInfluence; // local, eased pointer reveal\n\n  float jitter = hash11(i + uSeed * 289.0);\n  float diag = cp.x + cp.y;\n  float ph = fract(diag * 1.1 - t * 0.10 + jitter * 0.12);\n  // The shimmer yields locally where the cursor is working, not globally.\n  float shimmer = pulse(ph) * 0.16 * (1.0 - 0.75 * open01);\n\n  float o = clamp(uOpenBias + shimmer + open01 * 0.95 * uIntensity, 0.0, 0.94);\n\n  // ---- the gradient field, and its brighter self behind the blinds ----\n  float wob = 0.07 * sin(t * 0.07 + uSeed * 6.2832);\n  float gt = clamp(vUv.x * 0.62 + (1.0 - vUv.y) * 0.38 + wob, 0.0, 1.0);\n  vec3 grad = mix(uColorA, uColorB, gt);\n  vec3 bright = pow(grad, vec3(0.78)) * (0.85 + 0.35 * open01 * uIntensity);\n\n  // ---- closed slat face: a dim tilted vane catching light at its free lip ----\n  float faceLight = mix(0.14, 0.30, f);\n  faceLight *= 0.9 + 0.2 * jitter;                       // per-slat variation\n  faceLight *= 0.65 + 0.35 * smoothstep(0.0, 0.06, f);   // hinge crease shadow\n  vec3 face = grad * faceLight;\n\n  // ---- open-gap mask: duty cycle o of the pulse wave across the slat ----\n  float aa = uCount / max(uResolution.y, 1.0); // ~1 device px in cell units\n  float edgePos = 1.0 - o;\n  float m = smoothstep(edgePos - aa, edgePos + aa, f);\n\n  vec3 col = mix(face, bright, m);\n\n  // ---- ~1px lit edge on the free lip of every open slat ----\n  float band = (f - edgePos) / (1.6 * aa + 1e-5);\n  float edgeAmt = exp(-band * band)\n                * smoothstep(0.03, 0.14, o)\n                * (0.35 + 0.65 * o);\n  vec3 edgeCol = mix(bright, vec3(1.0), 0.55);\n  col += edgeCol * edgeAmt * 0.9 * uIntensity;\n\n  // Soft exponential tone curve — highlights roll off instead of clipping.\n  col = 1.0 - exp(-col * 1.45);\n\n  // Gentle vignette sinks the frame edges.\n  col *= 1.0 - 0.25 * dot(p, p);\n\n  // Time-varying grain kills 8-bit banding in the smooth gradients.\n  float grain = hash21(gl_FragCoord.xy + fract(t) * 113.0) - 0.5;\n  col += grain * (1.6 / 255.0);\n\n  // Premultiplied alpha: gaps opaque, closed faces faintly translucent.\n  float alpha = mix(0.92, 1.0, m);\n  gl_FragColor = vec4(max(col, 0.0) * alpha, alpha);\n}\n`;\n\n/**\n * OGL's Program.setShaders early-returns on a failed link WITHOUT creating\n * `uniformLocations` — rendering such a program throws deep inside OGL.\n * Treat \"unlinked\" as \"skip the frame\".\n */\nfunction programLinked(program: Program): boolean {\n  return (program as unknown as { uniformLocations?: unknown }).uniformLocations !== undefined;\n}\n\ninterface Uniform<T> {\n  value: T;\n}\n\ninterface Internals {\n  renderer: Renderer;\n  mesh: Mesh;\n  program: Program;\n  uTime: Uniform<number>;\n  uResolution: Uniform<[number, number]>;\n  uMouse: Uniform<[number, number]>;\n  uInfluence: Uniform<number>;\n  uCount: Uniform<number>;\n  uStaticFrame: Uniform<number>;\n  mouseTarget: [number, number];\n  influenceTarget: number;\n  lastElapsed: number;\n  applyCount: () => void;\n  renderNow: () => void;\n  loseContext: (() => void) | null;\n}\n\n/**\n * Louver — gradient blinds. A rosewood → indigo gradient field seen through\n * angled slats: each slat's openness is the duty cycle of a smooth pulse wave\n * across the slat axis, so the vanes tilt open around the cursor to reveal\n * the brighter field behind and close softly after it passes (exponential\n * time-constant damping plus an eased 0→1 influence scalar). A slow diagonal\n * shimmer sweeps slat openness when uninteracted, and every open slat carries\n * a ~1px lit edge at its free lip. Premultiplied transparent output, DPR ≤2,\n * offscreen/hidden-tab pause, reduced-motion designed still, full GL\n * teardown. Drop it inside any `relative` container; it fills and sits behind\n * content.\n */\nexport function Louver({\n  colors = DEFAULT_COLORS,\n  slatCount = 24,\n  angle = 18,\n  openBias = 0.07,\n  radius = 0.32,\n  interactive = true,\n  speed = 1,\n  intensity = 1,\n  paused = false,\n  idle = true,\n  className,\n}: LouverProps) {\n  const internalsRef = React.useRef<Internals | null>(null);\n  const [failed, setFailed] = React.useState(false);\n\n  const reducedMotion = useReducedMotion();\n  const staticFrame = paused || reducedMotion;\n\n  // Per-instance deterministic seed — SSR/hydration-safe, desynchronizes\n  // multiple instances on one page without Math.random().\n  const reactId = React.useId();\n  const seed = React.useMemo(() => {\n    let h = 0;\n    for (let i = 0; i < reactId.length; i++) {\n      h = (h * 31 + reactId.charCodeAt(i)) >>> 0;\n    }\n    return (h % 1024) / 1024;\n  }, [reactId]);\n\n  // Latest props, read from resize/pointer handlers without re-running setup.\n  const propsRef = React.useRef({ slatCount, interactive, idle });\n  propsRef.current = { slatCount, interactive, idle };\n  // performance.now() of the last real pointer activity; -Infinity = never.\n  const lastRealPointerRef = React.useRef(-Infinity);\n  const insideRef = React.useRef(false);\n\n  const tick = React.useCallback((elapsed: number) => {\n    const it = internalsRef.current;\n    if (!it || !programLinked(it.program)) return;\n    if (elapsed < it.lastElapsed) it.lastElapsed = elapsed;\n    const dt = Math.max(elapsed - it.lastElapsed, 0);\n    it.lastElapsed = elapsed;\n\n    // Idle ghost: a slow seeded Lissajous cursor in the shader's centered,\n    // aspect-corrected frame, at reduced presence.\n    const { interactive: live, idle: ghostOn } = propsRef.current;\n    if (live && ghostOn && !insideRef.current && performance.now() - lastRealPointerRef.current > GHOST_DELAY_MS) {\n      const res = it.uResolution.value;\n      const aspect = res[0] / Math.max(res[1], 1);\n      it.mouseTarget[0] = 0.36 * aspect * Math.sin(elapsed * 0.31) * Math.cos(elapsed * 0.097);\n      it.mouseTarget[1] = 0.3 * Math.sin(elapsed * 0.23 + 1.3);\n      it.influenceTarget = GHOST_PRESENCE;\n    }\n\n    // Frame-rate-independent exponential damping (1 - e^(-dt/tau)).\n    const km = 1 - Math.exp(-dt / 0.12);\n    const m = it.uMouse.value;\n    m[0] += (it.mouseTarget[0] - m[0]) * km;\n    m[1] += (it.mouseTarget[1] - m[1]) * km;\n\n    // Influence rises quickly, falls slowly — blinds close softly after the\n    // cursor passes instead of snapping shut.\n    const tau = it.influenceTarget > it.uInfluence.value ? 0.18 : 0.55;\n    const ki = 1 - Math.exp(-dt / tau);\n    it.uInfluence.value += (it.influenceTarget - it.uInfluence.value) * ki;\n\n    it.uTime.value = elapsed;\n    it.renderer.render({ scene: it.mesh });\n  }, []);\n\n  const containerRef = useVisibilityPause<HTMLDivElement>(tick, {\n    paused: staticFrame,\n  });\n\n  // Host-imposed DPR ceiling (galleries of thumbnails cap fill rate).\n  const dprCap = useDprCap();\n\n  // GL setup / teardown. Mounts exactly once — every knob change afterwards\n  // mutates uniforms in place (second effect below), never rebuilds context.\n  React.useEffect(() => {\n    const container = containerRef.current;\n    if (!container) return;\n\n    // Created per mount, never reused: once WEBGL_lose_context has killed a\n    // canvas's context (our teardown), that canvas can only ever return the\n    // same dead context — StrictMode's double-mount would come back black.\n    const canvas = document.createElement(\"canvas\");\n    canvas.setAttribute(\"aria-hidden\", \"true\");\n    canvas.className = \"absolute inset-0 block h-full w-full\";\n    container.appendChild(canvas);\n\n    const effectiveDpr = clampDpr(dprCap, 2);\n\n    let renderer: Renderer;\n    let gl: Renderer[\"gl\"];\n    try {\n      renderer = new Renderer({\n        canvas,\n        dpr: effectiveDpr,\n        alpha: true,\n        premultipliedAlpha: true,\n        antialias: false,\n      });\n      gl = renderer.gl;\n      gl.clearColor(0, 0, 0, 0);\n    } catch (err) {\n      console.warn(\"[crucible] WebGL unavailable — rendering static fallback.\", err);\n      canvas.remove();\n      setFailed(true);\n      return;\n    }\n\n    const onContextLost = (e: Event) => {\n      e.preventDefault();\n      setFailed(true);\n    };\n    canvas.addEventListener(\"webglcontextlost\", onContextLost);\n\n    const uTime: Uniform<number> = { value: 0 };\n    const uResolution: Uniform<[number, number]> = {\n      value: [gl.drawingBufferWidth || 1, gl.drawingBufferHeight || 1],\n    };\n    const uMouse: Uniform<[number, number]> = { value: [0, 0] };\n    const uInfluence: Uniform<number> = { value: 0 };\n    const uCount: Uniform<number> = { value: 24 };\n    const uStaticFrame: Uniform<number> = { value: 0 };\n\n    const program = new Program(gl, {\n      vertex: VERTEX,\n      fragment: FRAGMENT,\n      uniforms: {\n        uTime,\n        uResolution,\n        uMouse,\n        uInfluence,\n        uCount,\n        uStaticFrame,\n        uColorA: { value: [0, 0, 0] },\n        uColorB: { value: [0, 0, 0] },\n        uAngle: { value: 0 },\n        uOpenBias: { value: 0 },\n        uRadius: { value: 0.32 },\n        uSpeed: { value: 1 },\n        uIntensity: { value: 1 },\n        uSeed: { value: 0 },\n      },\n    });\n\n    const geometry = new Triangle(gl);\n    const mesh = new Mesh(gl, { geometry, program });\n    const loseExt = gl.getExtension(\"WEBGL_lose_context\");\n\n    const renderNow = () => {\n      if (programLinked(program)) renderer.render({ scene: mesh });\n    };\n\n    // Minimum-slat-pixel-width clamp: on short stages the effective slat\n    // count drops so no slat renders narrower than MIN_SLAT_CSS_PX. (Cell\n    // units are isotropic with 1 unit = stage height, so slat width in CSS px\n    // is height / count regardless of angle.)\n    const applyCount = () => {\n      const h = Math.max(container.clientHeight, 1);\n      const maxCount = Math.max(2, Math.floor(h / MIN_SLAT_CSS_PX));\n      const want = Math.max(2, Math.round(propsRef.current.slatCount));\n      uCount.value = Math.min(want, maxCount);\n    };\n\n    const internals: Internals = {\n      renderer,\n      mesh,\n      program,\n      uTime,\n      uResolution,\n      uMouse,\n      uInfluence,\n      uCount,\n      uStaticFrame,\n      mouseTarget: [0, 0],\n      influenceTarget: 0,\n      lastElapsed: 0,\n      applyCount,\n      renderNow,\n      loseContext: loseExt ? () => loseExt.loseContext() : null,\n    };\n    internalsRef.current = internals;\n\n    const resize = () => {\n      const { clientWidth: w, clientHeight: h } = container;\n      renderer.setSize(Math.max(w, 1), Math.max(h, 1));\n      uResolution.value[0] = gl.drawingBufferWidth;\n      uResolution.value[1] = gl.drawingBufferHeight;\n      applyCount();\n      // Keep the frame correct even while the loop is idle (paused/reduced).\n      renderNow();\n    };\n\n    const ro = new ResizeObserver(resize);\n    ro.observe(container);\n    resize();\n\n    // Pointer → centered, aspect-corrected space (1 unit = stage height),\n    // matching the shader's coordinate frame.\n    const toLocal = (e: PointerEvent): [number, number] | null => {\n      const r = container.getBoundingClientRect();\n      if (r.width === 0 || r.height === 0) return null;\n      const aspect = r.width / r.height;\n      return [\n        ((e.clientX - r.left) / r.width - 0.5) * aspect,\n        0.5 - (e.clientY - r.top) / r.height,\n      ];\n    };\n\n    const onPointerEnter = (e: PointerEvent) => {\n      if (!propsRef.current.interactive) return;\n      const pos = toLocal(e);\n      if (!pos) return;\n      // Snap position on entry (influence eases in from 0, so no fly-in\n      // streak) — the reveal blooms in place under the cursor.\n      internals.mouseTarget[0] = pos[0];\n      internals.mouseTarget[1] = pos[1];\n      internals.uMouse.value[0] = pos[0];\n      internals.uMouse.value[1] = pos[1];\n      internals.influenceTarget = 1;\n      insideRef.current = true;\n      lastRealPointerRef.current = performance.now();\n    };\n    const onPointerMove = (e: PointerEvent) => {\n      if (!propsRef.current.interactive) return;\n      const pos = toLocal(e);\n      if (!pos) return;\n      internals.mouseTarget[0] = pos[0];\n      internals.mouseTarget[1] = pos[1];\n      internals.influenceTarget = 1;\n      insideRef.current = true;\n      lastRealPointerRef.current = performance.now();\n    };\n    const onPointerLeave = () => {\n      // Leave the position where it was — the blinds close softly in place.\n      internals.influenceTarget = 0;\n      insideRef.current = false;\n      // The ghost resumes after the usual delay rather than snapping in.\n      lastRealPointerRef.current = performance.now();\n    };\n    container.addEventListener(\"pointerenter\", onPointerEnter);\n    container.addEventListener(\"pointermove\", onPointerMove);\n    container.addEventListener(\"pointerleave\", onPointerLeave);\n\n    return () => {\n      internalsRef.current = null;\n      ro.disconnect();\n      canvas.removeEventListener(\"webglcontextlost\", onContextLost);\n      container.removeEventListener(\"pointerenter\", onPointerEnter);\n      container.removeEventListener(\"pointermove\", onPointerMove);\n      container.removeEventListener(\"pointerleave\", onPointerLeave);\n      internals.loseContext?.();\n      canvas.remove();\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [dprCap]);\n\n  // Live-sync knobs into the running program — uniforms mutate in place,\n  // the GL context is never rebuilt. Re-renders if the loop is idle so\n  // static frames reflect prop changes.\n  React.useEffect(() => {\n    const it = internalsRef.current;\n    if (!it || !programLinked(it.program)) return;\n    const u = it.program.uniforms;\n    u.uColorA.value = hexToRgb(colors[0]);\n    u.uColorB.value = hexToRgb(colors[1]);\n    u.uAngle.value = (angle * Math.PI) / 180;\n    u.uOpenBias.value = Math.min(Math.max(openBias, 0), 0.8);\n    u.uRadius.value = Math.max(radius, 0.02);\n    u.uSpeed.value = speed;\n    u.uIntensity.value = intensity;\n    u.uSeed.value = seed;\n    it.applyCount();\n    if (!interactive || !idle) it.influenceTarget = 0;\n    if (staticFrame) it.renderNow();\n    // dprCap: the setup effect rebuilds the program with placeholder uniforms\n    // when the cap changes — re-apply the real values after it.\n  }, [colors, slatCount, angle, openBias, radius, speed, intensity, seed, staticFrame, interactive, idle, dprCap]);\n\n  // Reduced motion: a designed still — the diagonal shimmer frozen as a\n  // graceful open/closed arrangement, pointer quiet. Paused merely holds the\n  // current frame.\n  React.useEffect(() => {\n    const it = internalsRef.current;\n    if (!it) return;\n    if (reducedMotion) {\n      it.uStaticFrame.value = 1;\n      it.uTime.value = STATIC_TIME;\n      it.uInfluence.value = 0;\n      it.influenceTarget = 0;\n    } else {\n      it.uStaticFrame.value = 0;\n    }\n    if (staticFrame) it.renderNow();\n  }, [reducedMotion, staticFrame, dprCap]);\n\n  return (\n    <div\n      ref={containerRef}\n      aria-hidden\n      data-crucible=\"louver\"\n      className={cn(\"absolute inset-0 -z-10 overflow-hidden\", className)}\n    >\n      {failed && (\n        <div\n          aria-hidden\n          className=\"absolute inset-0\"\n          style={{\n            background: `linear-gradient(125deg, ${colors[0]}33, ${colors[1]}40)`,\n          }}\n        />\n      )}\n    </div>\n  );\n}\n"
    }
  ]
}