{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "liquid-glass",
  "type": "registry:ui",
  "title": "Liquid Glass",
  "description": "WebGL refractive glass close to Apple's Liquid Glass: provider, engine and components (button, bar, card, search, switch, slider, tabs, dialog).",
  "dependencies": [
    "@radix-ui/react-dialog",
    "@radix-ui/react-slider",
    "@radix-ui/react-switch",
    "@radix-ui/react-tabs",
    "clsx",
    "next-themes",
    "tailwind-merge"
  ],
  "files": [
    {
      "path": "lib/utils.ts",
      "content": "import { clsx, type ClassValue } from \"clsx\"\nimport { twMerge } from \"tailwind-merge\"\n\nexport function cn(...inputs: ClassValue[]) {\n  return twMerge(clsx(inputs))\n}\n",
      "type": "registry:lib",
      "target": "lib/utils.ts"
    },
    {
      "path": "lib/liquid-glass/engine.ts",
      "content": "import { selectShapes, type ShapeCandidate } from \"./budget\"\nimport { effectiveOpacity, paintsOverBackdrop } from \"./occlusion\"\n\n/* WebGL liquid-glass renderer. A canvas sits behind the UI; every [data-glass] element gets\n   refracting glass drawn beneath it (live position/size/radius/opacity). [data-glass-solid]\n   elements are painted into the scene so glass can refract them. */\n\nexport type GlassPreset = \"button\" | \"bar\" | \"card\" | \"sheet\" | \"knob\" | \"blob\"\n\nexport interface LiquidGlassOptions {\n  /** Max refraction offset at the rim, in px. */\n  refraction?: number\n  /** Chromatic dispersion, 0–1. */\n  dispersion?: number\n  /** Blur radius of the frosted layer, in px. */\n  frost?: number\n  /** Width of the curved rim, in px. */\n  bezel?: number\n  /** Smooth-union radius for merging shapes, in px. */\n  mergeK?: number\n  mode?: \"light\" | \"dark\"\n  /** Squash, stretch and press-to-grow. */\n  liquid?: boolean\n}\n\nexport interface GlassShape {\n  grow: number\n  squash: number\n  frost: number\n  tint: number\n  tintPressed?: number\n  tintColor?: [number, number, number]\n  merge: number\n  layer: number\n}\n\ninterface GlassItem extends GlassShape {\n  el: HTMLElement\n  sx: number; sy: number; vx: number; vy: number\n  v: { x: number; y: number }\n  last: { x: number; y: number } | null\n  pressed: boolean; held: boolean\n  scs: string; t: number\n  down: () => void\n  id: number\n  parent: GlassItem | null\n  /** A non-glass ancestor paints over the canvas, so shader glass would be hidden. */\n  blocked: boolean\n  live: boolean\n}\n\ninterface Solid {\n  el: HTMLElement; layer: number; opacity: string; live: boolean\n  parent: GlassItem | null; blocked: boolean\n}\n\ntype Source = HTMLImageElement | HTMLVideoElement | HTMLCanvasElement\n\nconst MAXG = 32, MAXS = 8\nconst PRESETS: Record<GlassPreset, GlassShape> = {\n  button: { grow: 0.14, squash: 1, frost: 0.15, tint: 0, merge: 0, layer: 0 },\n  bar:    { grow: 0.03, squash: 0.4, frost: 0.45, tint: 0, merge: 0, layer: 0 },\n  card:   { grow: 0, squash: 0, frost: 1, tint: 0.2, merge: 0, layer: 0 },\n  sheet:  { grow: 0, squash: 0, frost: 1, tint: 0.28, merge: 1, layer: 0 },\n  knob:   { grow: 0.5, squash: 1, frost: 0, tint: 1, tintPressed: 0, tintColor: [1, 1, 1], merge: 0, layer: 1 },\n  blob:   { grow: 0.1, squash: 1.6, frost: 0.1, tint: 0, merge: 1, layer: 0 },\n}\nconst VS = 'attribute vec2 p;varying vec2 vUv;void main(){vUv=p*.5+.5;vUv.y=1.-vUv.y;gl_Position=vec4(p,0.,1.);}';\nconst FS = `precision highp float;\n#define MAXG ${MAXG}\n#define MAXS ${MAXS}\nvarying vec2 vUv;\nuniform sampler2D uTex;uniform sampler2D uBlur;uniform vec2 uRes;uniform vec4 uFit;\nuniform vec4 uG[MAXG];uniform vec4 uGP[MAXG];uniform vec4 uGT[MAXG];uniform int uGN;\nuniform vec4 uS[MAXS];uniform vec4 uSC[MAXS];uniform vec4 uSP[MAXS];uniform int uSN;\nuniform float uBezel;uniform float uStrength;uniform float uDisp;uniform float uMergeK;uniform float uDark;uniform vec2 uPtr;\nfloat sdRR(vec2 p,vec2 b,float r){r=min(r,min(b.x,b.y));vec2 q=abs(p)-b+r;return length(max(q,0.))+min(max(q.x,q.y),0.)-r;}\nfloat smin(float a,float b,float k){float h=max(k-abs(a-b),0.)/k;return min(a,b)-h*h*k*.25;}\nfloat lay(vec4 q){return q.y>1.5?1.:0.;}\nfloat field(vec2 p,float L){\n float dm=1e4;float dh=1e4;\n for(int i=0;i<MAXG;i++){if(i>=uGN)break;\nif(uGT[i].w<.002||abs(lay(uGP[i])-L)>.5)continue;\nfloat d=sdRR(p-uG[i].xy,uG[i].zw,uGP[i].x);\nif(uGP[i].y>.5&&uGP[i].y<1.5)dm=smin(dm,d,uMergeK);else dh=min(dh,d);}\n return min(dm,dh);}\nvoid nearest(vec2 p,float L,out vec4 P,out vec4 T,out float hm){\n float best=1e4;P=vec4(0.);T=vec4(0.);hm=1.;\n for(int i=0;i<MAXG;i++){if(i>=uGN)break;\nif(uGT[i].w<.002||abs(lay(uGP[i])-L)>.5)continue;\nfloat d=sdRR(p-uG[i].xy,uG[i].zw,uGP[i].x);\nif(d<best){best=d;P=uGP[i];T=uGT[i];hm=min(uG[i].z,uG[i].w);}}}\nvec3 bg(vec2 px,float fr){vec2 u=clamp(px/uRes,0.,1.);vec3 c=texture2D(uTex,u*uFit.xy+uFit.zw).rgb;\n if(fr>.001)c=mix(c,texture2D(uBlur,u).rgb,fr);return c;}\nvec3 solids(vec2 px,vec3 c,float L){\n for(int i=0;i<MAXS;i++){if(i>=uSN)break;if(abs(uSP[i].y-L)>.5)continue;\nfloat d=sdRR(px-uS[i].xy,uS[i].zw,uSP[i].x);c=mix(c,uSC[i].rgb,clamp(.5-d,0.,1.)*uSC[i].a);}\n return c;}\nvec3 scene(vec2 px,float fr){return solids(px,bg(px,fr),0.);}\nvec3 finish(vec3 col,vec2 px,vec2 g,float x,float inside,vec4 P,vec4 T){\n float l=dot(col,vec3(.299,.587,.114));col=mix(vec3(l),col,1.2);\n col=uDark>.5?col*.78+.015:col*1.02+.03;\n col=mix(col,T.rgb,P.z);\n vec2 Ld=normalize(uPtr-px+vec2(.001));float fc=dot(g,Ld);float rim=pow(1.-x,6.);\n float hi=rim*(max(fc,0.)*.85+max(-fc,0.)*.3)+(1.-smoothstep(0.,1.5,inside))*.22;\n return col+vec3(hi*(uDark>.5?.6:1.));}\nfloat shadow(vec2 px,float L){return 1.-smoothstep(-16.,34.,field(px-vec2(0.,10.),L));}\nvec3 shade0(vec2 px){\n float d=field(px,0.);vec3 base=scene(px,0.);\n if(d<60.)base*=1.-shadow(px,0.)*(uDark>.5?.32:.16)*smoothstep(0.,2.,d);\n if(d>=.5)return base;\n vec4 P;vec4 T;float hm;nearest(px,0.,P,T,hm);\n float bez=min(uBezel,hm*.85);float inside=max(-d,0.);float x=clamp(inside/bez,0.,1.);\n vec2 e=vec2(.75,0.);\n vec2 g=vec2(field(px+e.xy,0.)-field(px-e.xy,0.),field(px+e.yx,0.)-field(px-e.yx,0.));g/=max(length(g),1e-4);\n vec2 off=-g*uStrength*min(1.,hm/40.)*pow(1.-x,2.2);\n float fr=P.w;vec3 col;\n col.r=scene(px+off*(1.+uDisp),fr).r;col.g=scene(px+off,fr).g;col.b=scene(px+off*(1.-uDisp),fr).b;\n col=finish(col,px,g,x,inside,P,T);\n return mix(base,col,clamp(.5-d,0.,1.)*T.w);}\nvec3 top0(vec2 px){return solids(px,shade0(px),1.);}\nvoid main(){\n vec2 px=vUv*uRes;float d=field(px,1.);vec3 base=top0(px);\n if(d<60.)base*=1.-shadow(px,1.)*(uDark>.5?.3:.14)*smoothstep(0.,2.,d);\n if(d>=.5){gl_FragColor=vec4(base,1.);return;}\n vec4 P;vec4 T;float hm;nearest(px,1.,P,T,hm);\n float bez=min(uBezel,hm*.85);float inside=max(-d,0.);float x=clamp(inside/bez,0.,1.);\n vec2 e=vec2(.75,0.);\n vec2 g=vec2(field(px+e.xy,1.)-field(px-e.xy,1.),field(px+e.yx,1.)-field(px-e.yx,1.));g/=max(length(g),1e-4);\n vec2 off=-g*uStrength*min(1.,hm/40.)*pow(1.-x,2.2);\n vec3 col;col.r=top0(px+off*(1.+uDisp)).r;col.g=top0(px+off).g;col.b=top0(px+off*(1.-uDisp)).b;\n col=finish(col,px,g,x,inside,P,T);\n gl_FragColor=vec4(mix(base,col,clamp(.5-d,0.,1.)*T.w),1.);}`;\n\n\n/* Computed colours come back in whatever space the stylesheet used (Tailwind v4 emits\n   oklab/oklch/lab), so let a 2D canvas resolve them to sRGB rather than parsing by hand. */\nconst colorCache = new Map<string, [number, number, number, number]>()\nlet colorCtx: CanvasRenderingContext2D | null = null\nfunction parseColor(s: string): [number, number, number, number] {\n  const hit = colorCache.get(s)\n  if (hit) return hit\n  let out: [number, number, number, number] = [0, 0, 0, 0]\n  if (s && s !== \"transparent\") {\n    colorCtx ??= Object.assign(document.createElement(\"canvas\"), { width: 1, height: 1 }).getContext(\"2d\", { willReadFrequently: true })\n    if (colorCtx) {\n      colorCtx.clearRect(0, 0, 1, 1)\n      colorCtx.fillStyle = s\n      colorCtx.fillRect(0, 0, 1, 1)\n      const [r, g, b, a] = colorCtx.getImageData(0, 0, 1, 1).data\n      out = a ? [r / 255, g / 255, b / 255, a / 255] : [0, 0, 0, 0]\n    }\n  }\n  if (colorCache.size > 256) colorCache.clear()\n  colorCache.set(s, out)\n  return out\n}\nconst len = (v: string, ref: number) => !v ? 0 : v.trim().endsWith(\"%\") ? parseFloat(v) / 100 * ref : parseFloat(v) || 0\n\ntype Uniforms = Record<string, WebGLUniformLocation | null>\n\nexport class LiquidGlass {\n  static PRESETS = PRESETS\n\n  readonly canvas: HTMLCanvasElement\n  readonly failed: boolean = false\n  o: Required<LiquidGlassOptions>\n  private gl!: WebGLRenderingContext\n  private program!: WebGLProgram\n  private buffer!: WebGLBuffer\n  private u: Uniforms = {}\n  private tex!: WebGLTexture\n  private blurTex!: WebGLTexture\n  private blurC!: HTMLCanvasElement\n  private items: GlassItem[] = []\n  private solids: Solid[] = []\n  private ptr: { x: number; y: number } | null = null\n  private tilt: { g: number; b: number } | null = null\n  private lastPtr = 0\n  private light = { x: -400, y: -600 }\n  private fit = [1, 1, 0, 0]\n  private size = { w: 0, h: 0 }\n  private src: Source | null = null\n  private live = false\n  private dirty = false\n  private ready = false\n  private raf = 0\n  private frames = 0\n  private nextId = 1\n  private bG = new Float32Array(MAXG * 4); private bGP = new Float32Array(MAXG * 4); private bGT = new Float32Array(MAXG * 4)\n  private bS = new Float32Array(MAXS * 4); private bSC = new Float32Array(MAXS * 4); private bSP = new Float32Array(MAXS * 4)\n\n  constructor(canvas: HTMLCanvasElement, opts: LiquidGlassOptions = {}) {\n    this.canvas = canvas\n    this.o = { refraction: 28, dispersion: 0.1, frost: 14, bezel: 26, mergeK: 40, mode: \"light\", liquid: true, ...opts }\n    const gl = canvas.getContext(\"webgl\", { antialias: false })\n    if (!gl || gl.isContextLost()) { this.failed = true; console.warn(\"LiquidGlass: WebGL unavailable\"); return }\n    this.gl = gl\n    const sh = (t: number, s: string) => {\n      const o = gl.createShader(t)!\n      gl.shaderSource(o, s); gl.compileShader(o)\n      if (!gl.getShaderParameter(o, gl.COMPILE_STATUS)) console.error(gl.getShaderInfoLog(o))\n      return o\n    }\n    const pr = gl.createProgram()!\n    const vs = sh(gl.VERTEX_SHADER, VS), fs = sh(gl.FRAGMENT_SHADER, FS)\n    gl.attachShader(pr, vs); gl.attachShader(pr, fs)\n    gl.linkProgram(pr)\n    gl.deleteShader(vs); gl.deleteShader(fs)\n    if (!gl.getProgramParameter(pr, gl.LINK_STATUS)) {\n      console.error(\"LiquidGlass:\", gl.getProgramInfoLog(pr))\n      gl.deleteProgram(pr); this.failed = true; return\n    }\n    gl.useProgram(pr); this.program = pr\n    const b = gl.createBuffer()!; gl.bindBuffer(gl.ARRAY_BUFFER, b); this.buffer = b\n    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]), gl.STATIC_DRAW)\n    const loc = gl.getAttribLocation(pr, \"p\"); gl.enableVertexAttribArray(loc); gl.vertexAttribPointer(loc, 2, gl.FLOAT, false, 0, 0)\n    ;[\"uTex\", \"uBlur\", \"uRes\", \"uFit\", \"uGN\", \"uSN\", \"uBezel\", \"uStrength\", \"uDisp\", \"uMergeK\", \"uDark\", \"uPtr\"].forEach(n => this.u[n] = gl.getUniformLocation(pr, n))\n    ;[\"uG\", \"uGP\", \"uGT\", \"uS\", \"uSC\", \"uSP\"].forEach(n => this.u[n] = gl.getUniformLocation(pr, n + \"[0]\"))\n    this.tex = this._tex(0); this.blurTex = this._tex(1)\n    gl.uniform1i(this.u.uTex, 0); gl.uniform1i(this.u.uBlur, 1)\n    this.blurC = document.createElement(\"canvas\")\n    window.addEventListener(\"pointermove\", this._onPtr)\n    window.addEventListener(\"pointerup\", this._onUp)\n    window.addEventListener(\"pointercancel\", this._onUp)\n    window.addEventListener(\"deviceorientation\", this._onTilt)\n    this.raf = requestAnimationFrame(this._loop)\n  }\n\n  private _onPtr = (e: PointerEvent) => { this.ptr = { x: e.clientX, y: e.clientY }; this.lastPtr = performance.now() }\n  private _onUp = () => this.items.forEach(i => { if (!i.held) i.pressed = false })\n  private _onTilt = (e: DeviceOrientationEvent) => {\n    if (e.gamma != null && e.beta != null && performance.now() - this.lastPtr > 3000) { this.tilt = { g: e.gamma, b: e.beta }; this.ptr = null }\n  }\n  private _loop = () => { this._frame(); this.raf = requestAnimationFrame(this._loop) }\n\n  private _tex(unit: number) {\n    const gl = this.gl, t = gl.createTexture()!\n    gl.activeTexture(gl.TEXTURE0 + unit); gl.bindTexture(gl.TEXTURE_2D, t)\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)\n    return t\n  }\n\n  set(o: LiquidGlassOptions) {\n    const f = this.o.frost\n    Object.assign(this.o, o)\n    if (o.frost !== undefined && o.frost !== f) this.dirty = true\n  }\n\n  setSource(src: Source, { live }: { live?: boolean } = {}) {\n    this.src = src\n    this.live = live ?? (typeof HTMLVideoElement !== \"undefined\" && src instanceof HTMLVideoElement)\n    this.dirty = true\n  }\n\n  invalidate() { this.dirty = true }\n\n  scan(rootEl: ParentNode) {\n    // Drop elements that left the page or no longer ask for glass (a variant or webgl change).\n    const keep = (el: HTMLElement, attr: string) => el.isConnected && el.hasAttribute(attr)\n    this.items.filter(i => !keep(i.el, \"data-glass\")).forEach(i => this._detach(i))\n    this.items = this.items.filter(i => keep(i.el, \"data-glass\"))\n    this.solids.filter(s => s.live && !keep(s.el, \"data-glass-solid\")).forEach(s => { s.el.style.opacity = s.opacity })\n    this.solids = this.solids.filter(s => keep(s.el, \"data-glass-solid\"))\n    rootEl.querySelectorAll<HTMLElement>(\"[data-glass]\").forEach(el => this.add(el))\n    rootEl.querySelectorAll<HTMLElement>(\"[data-glass-solid]\").forEach(el => this.addSolid(el))\n    this.refreshOcclusion()\n  }\n\n  /** Links each item to its closest glass ancestor (nested glass is drawn on the top layer) and\n      blocks items under any other ancestor that paints: the canvas is behind it. Backgrounds\n      change with state and theme, so the frame loop calls this periodically too. */\n  refreshOcclusion() {\n    const byEl = new Map(this.items.map(i => [i.el as Element, i]))\n    const link = (x: { el: HTMLElement; parent: GlassItem | null; blocked: boolean }) => {\n      x.parent = null\n      x.blocked = false\n      for (let p = x.el.parentElement; p && p !== document.body; p = p.parentElement) {\n        const g = byEl.get(p)\n        if (g) { x.parent ??= g; continue }\n        if (paintsOverBackdrop(getComputedStyle(p))) { x.blocked = true; break }\n      }\n    }\n    this.items.forEach(link)\n    this.solids.forEach(link)\n  }\n\n  add(el: HTMLElement, opts: Partial<GlassShape> & { preset?: GlassPreset } = {}) {\n    const existing = this.items.find(i => i.el === el)\n    if (existing) return existing\n    const d = el.dataset, pre = PRESETS[(opts.preset || d.glass) as GlassPreset] || PRESETS.bar\n    const ov: Partial<GlassShape> = {}\n    ;([\"tint\", \"frost\", \"layer\", \"merge\", \"grow\", \"squash\"] as const).forEach(k => { if (d[k] !== undefined) ov[k] = parseFloat(d[k]!) })\n    const it = {\n      ...pre, ...ov, ...opts,\n      el, sx: 1, sy: 1, vx: 0, vy: 0, v: { x: 0, y: 0 }, last: null, pressed: false, held: false, scs: \"\", t: 0,\n      id: this.nextId++, parent: null, blocked: false, live: false,\n      down: () => { it.pressed = true },\n    } as GlassItem\n    it.t = it.tint\n    el.addEventListener(\"pointerdown\", it.down)\n    this.items.push(it)\n    return it\n  }\n\n  addSolid(el: HTMLElement) {\n    if (this.solids.some(s => s.el === el)) return\n    this.solids.push({ el, layer: parseFloat(el.dataset.layer || \"0\"), opacity: el.style.opacity, live: false, parent: null, blocked: false })\n  }\n\n  press(el: HTMLElement, on: boolean) {\n    const it = this.items.find(i => i.el === el)\n    if (it) { it.pressed = on; it.held = on }\n  }\n\n  remove(el: HTMLElement) {\n    const it = this.items.find(i => i.el === el)\n    if (it) this._detach(it)\n    const s = this.solids.find(s => s.el === el)\n    if (s?.live) el.style.opacity = s.opacity\n    this.items = this.items.filter(i => i.el !== el)\n    this.solids = this.solids.filter(s => s.el !== el)\n  }\n\n  /** Stops rendering and releases GL resources. The canvas stays usable, so a remount\n      (React strict mode, HMR) can create a new engine on the same element. */\n  destroy() {\n    cancelAnimationFrame(this.raf)\n    document.documentElement.classList.remove(\"lg-ready\")\n    window.removeEventListener(\"pointermove\", this._onPtr); window.removeEventListener(\"pointerup\", this._onUp)\n    window.removeEventListener(\"pointercancel\", this._onUp); window.removeEventListener(\"deviceorientation\", this._onTilt)\n    this.items.forEach(i => this._detach(i))\n    this.solids.forEach(s => { if (s.live) s.el.style.opacity = s.opacity })\n    this.items = []; this.solids = []\n    const gl = this.gl\n    if (gl && !this.failed) {\n      gl.deleteTexture(this.tex); gl.deleteTexture(this.blurTex)\n      gl.deleteBuffer(this.buffer); gl.deleteProgram(this.program)\n      gl.clearColor(0, 0, 0, 0); gl.clear(gl.COLOR_BUFFER_BIT)\n    }\n  }\n\n  private _detach(it: GlassItem) {\n    it.el.removeEventListener(\"pointerdown\", it.down)\n    this._setLive(it, false)\n  }\n\n  /* data-glass-live marks elements the shader draws this frame; only those drop their CSS glass. */\n  private _setLive(it: GlassItem, live: boolean) {\n    if (it.live === live) return\n    it.live = live\n    if (live) it.el.setAttribute(\"data-glass-live\", \"\")\n    else { it.el.removeAttribute(\"data-glass-live\"); it.el.style.scale = \"\"; it.scs = \"\"; it.sx = it.sy = 1; it.vx = it.vy = 0 }\n  }\n\n  private _upload(W: number, H: number) {\n    const gl = this.gl, s = this.src!\n    if (s instanceof HTMLVideoElement && s.readyState < 2) return\n    const sw = (s as HTMLVideoElement).videoWidth || (s as HTMLImageElement).naturalWidth || s.width\n    const sh = (s as HTMLVideoElement).videoHeight || (s as HTMLImageElement).naturalHeight || s.height\n    if (!sw || !sh) return\n    const A = W / H, B = sw / sh\n    let fx = 1, fy = 1, ox = 0, oy = 0\n    if (B > A) { fx = A / B; ox = (1 - fx) / 2 } else { fy = B / A; oy = (1 - fy) / 2 }\n    this.fit = [fx, fy, ox, oy]\n    try {\n      gl.activeTexture(gl.TEXTURE0); gl.bindTexture(gl.TEXTURE_2D, this.tex)\n      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, s)\n      const bc = this.blurC, bw = Math.max(2, Math.round(W / 4)), bh = Math.max(2, Math.round(H / 4))\n      if (bc.width !== bw) bc.width = bw\n      if (bc.height !== bh) bc.height = bh\n      const x = bc.getContext(\"2d\")!, br = Math.max(this.o.frost / 4, 0.01), pad = br * 3\n      x.filter = `blur(${br}px)`\n      x.drawImage(s, ox * sw, oy * sh, fx * sw, fy * sh, -pad, -pad, bw + 2 * pad, bh + 2 * pad)\n      gl.activeTexture(gl.TEXTURE1); gl.bindTexture(gl.TEXTURE_2D, this.blurTex)\n      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, bc)\n      this.ready = true\n      // The canvas now shows the backdrop (drawn later this same frame), so DOM copies of it marked\n      // data-glass-backdrop can step aside: they sit above the canvas and would hide the glass.\n      document.documentElement.classList.add(\"lg-ready\")\n    } catch (e) { console.warn(\"LiquidGlass: source not usable (CORS?)\", e) }\n    this.dirty = false\n  }\n\n  private _frame() {\n    const gl = this.gl, cv = this.canvas\n    const W = cv.clientWidth, H = cv.clientHeight\n    if (!W || !H) return\n    const cr = cv.getBoundingClientRect(), k = W / cr.width\n    const dpr = Math.min(window.devicePixelRatio || 1, 1.5), bw = Math.round(W * dpr), bh = Math.round(H * dpr)\n    if (cv.width !== bw || cv.height !== bh) { cv.width = bw; cv.height = bh }\n    gl.viewport(0, 0, bw, bh)\n    // The cover-fit and the downscaled blur both depend on the viewport size.\n    if (W !== this.size.w || H !== this.size.h) { this.size = { w: W, h: H }; this.dirty = true }\n    if (this.src && (this.dirty || this.live)) this._upload(W, H)\n    if (!this.ready) return\n    if (++this.frames % 30 === 0) this.refreshOcclusion()\n    let tx = -W * 0.2, ty = -H * 0.6\n    if (this.ptr) { tx = (this.ptr.x - cr.left) * k; ty = (this.ptr.y - cr.top) * k }\n    else if (this.tilt) { tx = W / 2 + this.tilt.g / 30 * W; ty = H / 2 + (this.tilt.b - 45) / 30 * H }\n    this.light.x += (tx - this.light.x) * 0.12; this.light.y += (ty - this.light.y) * 0.12\n    const dark = this.o.mode === \"dark\", liquid = this.o.liquid\n    type Vis = { it: GlassItem; r: DOMRect; cs: CSSStyleDeclaration }\n    const vis = new Map<number, Vis>()\n    const cands: ShapeCandidate[] = []\n    for (const it of this.items) {\n      const el = it.el\n      if (!el.isConnected || it.blocked) continue\n      const r = el.getBoundingClientRect()\n      if (r.width < 1 || r.height < 1) continue\n      if (r.bottom < cr.top - 40 || r.top > cr.bottom + 40 || r.right < cr.left - 40 || r.left > cr.right + 40) continue\n      const cs = getComputedStyle(el)\n      if (cs.visibility === \"hidden\") continue\n      vis.set(it.id, { it, r, cs })\n      cands.push({ id: it.id, parent: it.parent?.id ?? null, area: r.width * r.height })\n    }\n    const chosen = selectShapes(cands, MAXG)\n    for (const it of this.items) this._setLive(it, chosen.has(it.id))\n    let n = 0\n    for (const [id, depth] of chosen) {\n      const { it, r, cs } = vis.get(id)!\n      const el = it.el\n      const op = effectiveOpacity(el)\n      const cx = (r.left + r.width / 2 - cr.left) * k, cy = (r.top + r.height / 2 - cr.top) * k\n      const hx = r.width / 2 * k / it.sx, hy = r.height / 2 * k / it.sy\n      if (it.last) { it.v.x = it.v.x * 0.6 + (cx - it.last.x) * 0.4; it.v.y = it.v.y * 0.6 + (cy - it.last.y) * 0.4 }\n      it.last = { x: cx, y: cy }\n      const g = it.pressed && liquid ? 1 + it.grow : 1, sq = liquid ? it.squash : 0\n      const ax = Math.abs(it.v.x), ay = Math.abs(it.v.y)\n      const tX = g * (1 + Math.min(ax * 0.018 * sq, 0.35) - Math.min(ay * 0.009 * sq, 0.18))\n      const tY = g * (1 + Math.min(ay * 0.018 * sq, 0.35) - Math.min(ax * 0.009 * sq, 0.18))\n      if (liquid) { it.vx = (it.vx + (tX - it.sx) * 0.22) * 0.7; it.sx += it.vx; it.vy = (it.vy + (tY - it.sy) * 0.22) * 0.7; it.sy += it.vy }\n      else { it.sx = tX; it.sy = tY; it.vx = it.vy = 0 }\n      const scs = Math.abs(it.sx - 1) < 0.002 && Math.abs(it.sy - 1) < 0.002 ? \"\" : `${it.sx.toFixed(4)} ${it.sy.toFixed(4)}`\n      if (scs !== it.scs) { el.style.scale = scs; it.scs = scs }\n      const Hx = hx * it.sx, Hy = hy * it.sy, ow = el.offsetWidth || r.width\n      const rad = Math.min(len(cs.borderTopLeftRadius, ow) * (hx * 2 / ow) * Math.min(it.sx, it.sy), Hx, Hy)\n      const tt = it.pressed && it.tintPressed !== undefined ? it.tintPressed : it.tint\n      it.t += (tt - it.t) * 0.2\n      const tv = cs.getPropertyValue(\"--lg-tint\").trim()\n      const custom = tv && tv !== \"transparent\" ? parseColor(tv) : null\n      const tc: [number, number, number] = it.tintColor || (custom ? [custom[0], custom[1], custom[2]] : dark ? [0.07, 0.07, 0.09] : [1, 1, 1])\n      const layer = Math.max(depth, it.layer >= 1 ? 1 : 0)\n      this.bG.set([cx, cy, Hx, Hy], n * 4)\n      this.bGP.set([rad, layer >= 1 ? 2 : (it.merge ? 1 : 0), it.t, it.frost], n * 4)\n      this.bGT.set([tc[0], tc[1], tc[2], op], n * 4)\n      n++\n    }\n    let m = 0\n    for (const s of this.solids) {\n      const el = s.el\n      const r = el.isConnected ? el.getBoundingClientRect() : null\n      // Only paint a solid into the scene where the canvas is visible, as for glass.\n      const draw = m < MAXS && !s.blocked && (!s.parent || s.parent.live) && !!r && r.width >= 1 && r.height >= 1\n      if (draw !== s.live) { s.live = draw; el.style.opacity = draw ? \"0\" : s.opacity }\n      if (!draw) continue\n      const cs = getComputedStyle(el), hx = r!.width / 2 * k, hy = r!.height / 2 * k, ow = el.offsetWidth || r!.width\n      this.bS.set([(r!.left + r!.width / 2 - cr.left) * k, (r!.top + r!.height / 2 - cr.top) * k, hx, hy], m * 4)\n      this.bSC.set(parseColor(cs.backgroundColor), m * 4)\n      this.bSP.set([Math.min(len(cs.borderTopLeftRadius, ow) * (hx * 2 / ow), hx, hy), s.layer, 0, 0], m * 4)\n      m++\n    }\n    const u = this.u, o = this.o\n    gl.uniform2f(u.uRes, W, H); gl.uniform4fv(u.uFit, this.fit)\n    gl.uniform4fv(u.uG, this.bG); gl.uniform4fv(u.uGP, this.bGP); gl.uniform4fv(u.uGT, this.bGT); gl.uniform1i(u.uGN, n)\n    gl.uniform4fv(u.uS, this.bS); gl.uniform4fv(u.uSC, this.bSC); gl.uniform4fv(u.uSP, this.bSP); gl.uniform1i(u.uSN, m)\n    gl.uniform1f(u.uBezel, o.bezel); gl.uniform1f(u.uStrength, o.refraction); gl.uniform1f(u.uDisp, o.dispersion)\n    gl.uniform1f(u.uMergeK, Math.max(o.mergeK, 0.001)); gl.uniform1f(u.uDark, dark ? 1 : 0)\n    gl.uniform2f(u.uPtr, this.light.x, this.light.y)\n    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4)\n  }\n}\n\nexport default LiquidGlass\n",
      "type": "registry:lib",
      "target": "lib/liquid-glass/engine.ts"
    },
    {
      "path": "lib/liquid-glass/budget.ts",
      "content": "/* Chooses which glass shapes the shader draws this frame. The shader has a fixed number of\n   slots and two layers, so: layer 0 first, larger shapes first, a child only if its parent is\n   drawn, and nothing deeper than one level of nesting. Undrawn shapes keep their CSS glass. */\n\nexport interface ShapeCandidate { id: number; parent: number | null; area: number }\n\nexport function selectShapes(cands: ShapeCandidate[], max: number): Map<number, 0 | 1> {\n  const byId = new Map(cands.map(c => [c.id, c]))\n  const depth = (c: ShapeCandidate) => {\n    let d = 0\n    for (let p = c.parent; p !== null && byId.has(p); p = byId.get(p)!.parent) d++\n    return d\n  }\n  const ordered = cands\n    .map(c => ({ c, d: depth(c) }))\n    .filter(x => x.d <= 1)\n    .sort((a, b) => a.d - b.d || b.c.area - a.c.area)\n  const out = new Map<number, 0 | 1>()\n  for (const { c, d } of ordered) {\n    if (out.size >= max) break\n    if (d === 1 && !out.has(c.parent!)) continue\n    out.set(c.id, d as 0 | 1)\n  }\n  return out\n}\n",
      "type": "registry:lib",
      "target": "lib/liquid-glass/budget.ts"
    },
    {
      "path": "lib/liquid-glass/occlusion.ts",
      "content": "/* WebGL glass is drawn on a canvas behind the whole page, so it is only visible where nothing in\n   the DOM paints over it. An element whose ancestor has a background or a backdrop filter must\n   keep its CSS glass instead. */\n\nexport interface PaintStyle { backgroundColor: string; backgroundImage: string; backdropFilter: string }\n\nconst MIN_ALPHA = 0.05\n\nfunction alpha(color: string) {\n  if (!color || color === \"transparent\") return 0\n  const slash = color.match(/\\/\\s*([\\d.]+)(%?)\\s*\\)$/)\n  if (slash) return parseFloat(slash[1]) / (slash[2] ? 100 : 1)\n  const rgba = color.match(/^rgba\\([^,]+,[^,]+,[^,]+,\\s*([\\d.]+)\\s*\\)$/)\n  if (rgba) return parseFloat(rgba[1])\n  return 1\n}\n\nexport function paintsOverBackdrop(s: PaintStyle) {\n  return (s.backdropFilter !== \"\" && s.backdropFilter !== \"none\")\n    || (s.backgroundImage !== \"\" && s.backgroundImage !== \"none\")\n    || alpha(s.backgroundColor) > MIN_ALPHA\n}\n\n/** Opacity as rendered: the element's own times every ancestor's (fades on a parent fade the glass too). */\nexport function effectiveOpacity(el: Element) {\n  let o = 1\n  for (let p: Element | null = el; p && p !== document.body && o > 0; p = p.parentElement) {\n    const v = parseFloat(getComputedStyle(p).opacity)\n    if (!Number.isNaN(v)) o *= v\n  }\n  return o\n}\n",
      "type": "registry:lib",
      "target": "lib/liquid-glass/occlusion.ts"
    },
    {
      "path": "lib/liquid-glass/backdrop-stack.ts",
      "content": "/* The provider refracts the most recently pushed backdrop; pages push their own on mount and pop\n   it on unmount. A base entry (the site wallpaper) always sits below page entries, whichever\n   mounted first. */\nexport interface BackdropEntry<T> { id: number; src: T; live?: boolean; base?: boolean }\n\nexport function pushBackdrop<T>(stack: BackdropEntry<T>[], e: BackdropEntry<T>) {\n  const rest = stack.filter(x => x.id !== e.id)\n  return e.base ? [e, ...rest] : [...rest, e]\n}\n\nexport function popBackdrop<T>(stack: BackdropEntry<T>[], id: number) {\n  return stack.filter(x => x.id !== id)\n}\n",
      "type": "registry:lib",
      "target": "lib/liquid-glass/backdrop-stack.ts"
    },
    {
      "path": "lib/liquid-glass/material.ts",
      "content": "import type * as React from \"react\"\nimport { cn } from \"@/lib/utils\"\n\n/* Liquid glass material: turns a role + material into the CSS classes (see the .lg layer in\n   app/globals.css) and the data-glass attributes the WebGL engine picks up. */\n\nexport type Material = \"regular\" | \"clear\" | \"tinted\"\nexport type GlassRole = \"surface\" | \"sheet\" | \"bar\" | \"control\" | \"knob\" | \"inline\" | \"overlay\"\nexport interface GlassOverride { tint?: string; frost?: number }\nexport interface LiquidProps {\n  /** Glass material. Default `regular`. */\n  material?: Material\n  /** Tint colour (any CSS colour). Defaults to the primary colour for `tinted`. */\n  tint?: string\n  /** Per-instance override. */\n  glass?: GlassOverride\n  /** Draw with the WebGL engine when a LiquidGlassProvider is present. WebGL glass sits behind\n      the page, so only elements resting directly on the backdrop should use it. Defaults to\n      true for in-flow roles and false for sheets; overlays and inline items never use it. */\n  webgl?: boolean\n}\n\n/** `data-*` attributes for the WebGL engine. */\nexport type DataAttrs = { [K in `data-${string}`]?: string }\n\nconst PRESET: Record<GlassRole, string | null> = {\n  surface: \"card\", sheet: \"sheet\", bar: \"bar\", control: \"button\", knob: \"knob\", inline: null, overlay: null,\n}\n// Roles whose elements usually float over page content default to CSS-only.\nconst WEBGL_DEFAULT: Record<GlassRole, boolean> = {\n  surface: true, sheet: false, bar: true, control: true, knob: true, inline: false, overlay: false,\n}\nconst PARAMS: Record<Material, { frost: number; tint: number }> = {\n  regular: { frost: 1, tint: 0.2 },\n  clear: { frost: 0.1, tint: 0 },\n  tinted: { frost: 0.6, tint: 0.35 },\n}\nexport function liquidGlass({ role, material = \"regular\", tint, glass, webgl = WEBGL_DEFAULT[role] }: LiquidProps & { role: GlassRole }): {\n  className: string; style: React.CSSProperties; attrs: DataAttrs\n} {\n  const p = PARAMS[material]\n  const color = glass?.tint ?? tint\n  const frost = glass?.frost ?? p.frost\n  const style: Record<string, string> = {}\n  if (color) {\n    style[\"--lg-tint\"] = color\n    if (material !== \"tinted\") style[\"--lg-tint-amt\"] = \"18%\"\n  }\n  const preset = webgl ? PRESET[role] : null\n  const attrs: DataAttrs = preset\n    ? { \"data-glass\": preset, \"data-frost\": String(frost), \"data-tint\": String(p.tint) }\n    : {}\n  return { className: `lg lg-${material} lg-${role}`, style: style as React.CSSProperties, attrs }\n}\n\n/** Spread onto an element: material classes/attrs merged with the element's own className and style. */\nexport function liquidProps(\n  opts: LiquidProps & { role: GlassRole },\n  own: { className?: string; style?: React.CSSProperties } = {}\n): { className: string; style: React.CSSProperties } & DataAttrs {\n  const r = liquidGlass(opts)\n  return { ...r.attrs, className: cn(r.className, own.className), style: { ...r.style, ...own.style } }\n}\n\n/** A component's `variant` (default `liquid`) together with its material (default `regular`). */\nexport function resolveVariant<V extends string>(variant: V | undefined, material: Material | undefined) {\n  return { variant: (variant ?? \"liquid\") as V | \"liquid\", material: material ?? \"regular\" }\n}\n",
      "type": "registry:lib",
      "target": "lib/liquid-glass/material.ts"
    },
    {
      "path": "components/ui/liquid/liquid-glass-provider.tsx",
      "content": "\"use client\"\n\nimport * as React from \"react\"\nimport { useTheme } from \"next-themes\"\nimport { LiquidGlass, type LiquidGlassOptions } from \"@/lib/liquid-glass/engine\"\nimport { popBackdrop, pushBackdrop, type BackdropEntry } from \"@/lib/liquid-glass/backdrop-stack\"\nimport { LiquidFilters } from \"./liquid-filters\"\n\nexport type Backdrop = string | HTMLImageElement | HTMLVideoElement | HTMLCanvasElement\n\n/* While the engine runs, <html> has .lg-on. Elements the engine actually draws carry\n   data-glass-live and lose their CSS glass so only the shader glass shows; everything else\n   (overlays, shapes over the cap, deep nesting) keeps the CSS look. The app shell goes\n   transparent so the canvas shows through, and once the canvas shows the backdrop (.lg-ready) any\n   DOM copy of it marked data-glass-backdrop is hidden. Shipped with the provider so installing it needs\n   no stylesheet edits. */\nconst LIQUID_GLASS_CSS = `\nhtml.lg-on [data-glass-live] {\n  background: transparent !important;\n  backdrop-filter: none !important;\n  -webkit-backdrop-filter: none !important;\n  border-color: transparent !important;\n  box-shadow: none !important;\n}\nhtml.lg-on .lg-control[data-glass-live]:active { scale: none; }\nhtml.lg-ready [data-glass-backdrop] { visibility: hidden; }\nhtml.lg-on body { background: transparent; }\n`\n\nconst LiquidGlassContext = React.createContext<LiquidGlass | null>(null)\nconst BackdropContext = React.createContext<{\n  push: (e: BackdropEntry<Backdrop>) => void\n  pop: (id: number) => void\n} | null>(null)\n\nexport const useLiquidGlass = () => React.useContext(LiquidGlassContext)\n\nlet nextBackdropId = 1\n/** Makes `src` the refracted backdrop while the calling component is mounted. A `base` backdrop\n    (the site wallpaper) stays below any page backdrop. */\nexport function useLiquidBackdrop(src: Backdrop | null, { live, base }: { live?: boolean; base?: boolean } = {}) {\n  const ctx = React.useContext(BackdropContext)\n  const id = React.useRef(0)\n  if (!id.current) id.current = nextBackdropId++\n  React.useEffect(() => {\n    if (!ctx || !src) return\n    ctx.push({ id: id.current, src, live, base })\n    return () => ctx.pop(id.current)\n  }, [ctx, src, live, base])\n}\n\nexport interface LiquidGlassProviderProps {\n  /** Default backdrop: image URL, or an <img>/<video>/<canvas>. Pages can override it with useLiquidBackdrop. */\n  backdrop?: Backdrop\n  /** Re-upload the source every frame (auto for video; set for animated canvases). */\n  live?: boolean\n  options?: Omit<LiquidGlassOptions, \"mode\">\n  children: React.ReactNode\n}\n\n/**\n * Renders the backdrop + all liquid glass on one fixed, full-viewport WebGL canvas behind the\n * app. Elements with `data-glass` anywhere in the document (including Radix portals) get glass\n * drawn beneath them. Without WebGL, or with reduced transparency, the CSS glass stays.\n */\nexport function LiquidGlassProvider({ backdrop, live, options, children }: LiquidGlassProviderProps) {\n  const canvasRef = React.useRef<HTMLCanvasElement>(null)\n  const [engine, setEngine] = React.useState<LiquidGlass | null>(null)\n  const [stack, setStack] = React.useState<BackdropEntry<Backdrop>[]>([])\n  const { resolvedTheme } = useTheme()\n  const mode = resolvedTheme === \"dark\" ? \"dark\" : \"light\"\n\n  const backdropApi = React.useMemo(() => ({\n    push: (e: BackdropEntry<Backdrop>) => setStack(s => pushBackdrop(s, e)),\n    pop: (id: number) => setStack(s => popBackdrop(s, id)),\n  }), [])\n\n  React.useEffect(() => {\n    const canvas = canvasRef.current\n    if (!canvas) return\n    if (window.matchMedia(\"(prefers-reduced-transparency: reduce)\").matches) return\n    const reduceMotion = window.matchMedia(\"(prefers-reduced-motion: reduce)\").matches\n    const lg = new LiquidGlass(canvas, { ...options, mode, liquid: reduceMotion ? false : options?.liquid ?? true })\n    if (lg.failed) return\n    document.documentElement.classList.add(\"lg-on\")\n    lg.scan(document.body)\n    let queued = false\n    const mo = new MutationObserver(() => {\n      if (queued) return\n      queued = true\n      requestAnimationFrame(() => { queued = false; lg.scan(document.body) })\n    })\n    mo.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: [\"data-glass\", \"data-glass-solid\"] })\n    setEngine(lg)\n    return () => {\n      mo.disconnect()\n      lg.destroy()\n      document.documentElement.classList.remove(\"lg-on\")\n      setEngine(null)\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [])\n\n  React.useEffect(() => {\n    if (!engine) return\n    engine.set({ mode })\n    // Backgrounds change with the theme; re-check which glass the canvas can show.\n    const raf = requestAnimationFrame(() => engine.scan(document.body))\n    return () => cancelAnimationFrame(raf)\n  }, [engine, mode])\n  React.useEffect(() => { if (engine && options) engine.set(options) }, [engine, options])\n\n  const top = stack.at(-1) ?? (backdrop ? { id: 0, src: backdrop, live } : null)\n  const src = top?.src, srcLive = top?.live\n  React.useEffect(() => {\n    if (!engine || !src) return\n    if (typeof src !== \"string\") { engine.setSource(src, { live: srcLive }); return }\n    let cancelled = false\n    const img = new Image()\n    img.crossOrigin = \"anonymous\"\n    img.onload = () => { if (!cancelled) engine.setSource(img) }\n    img.src = src\n    return () => { cancelled = true }\n  }, [engine, src, srcLive])\n\n  return (\n    <LiquidGlassContext.Provider value={engine}>\n      <BackdropContext.Provider value={backdropApi}>\n        <style href=\"liquid-glass\" precedence=\"default\">{LIQUID_GLASS_CSS}</style>\n        <LiquidFilters />\n        <canvas\n          ref={canvasRef}\n          aria-hidden\n          style={{ position: \"fixed\", inset: 0, width: \"100vw\", height: \"100vh\", zIndex: 0, pointerEvents: \"none\" }}\n        />\n        <div style={{ position: \"relative\", zIndex: 1 }}>{children}</div>\n      </BackdropContext.Provider>\n    </LiquidGlassContext.Provider>\n  )\n}\n",
      "type": "registry:ui",
      "target": "components/ui/liquid/liquid-glass-provider.tsx"
    },
    {
      "path": "components/ui/liquid/liquid-filters.tsx",
      "content": "\"use client\"\n\nimport * as React from \"react\"\n\n/* SVG filter used by the .lg CSS layer for edge lensing. Displacement is neutral (0.5) in the\n   middle and ramps to the edges: red drives x, green drives y. Only Chromium applies url()\n   filters inside backdrop-filter, so html.lg-lens is set there and nowhere else. */\nconst ramp = (dir: \"x\" | \"y\", channel: string) =>\n  `data:image/svg+xml,${encodeURIComponent(\n    `<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"100\" height=\"100\" preserveAspectRatio=\"none\"><defs><linearGradient id=\"g\" x2=\"${dir === \"x\" ? 1 : 0}\" y2=\"${dir === \"y\" ? 1 : 0}\"><stop offset=\"0\" stop-color=\"${channel}\" stop-opacity=\"1\"/><stop offset=\".14\" stop-color=\"${channel}\" stop-opacity=\".5\"/><stop offset=\".86\" stop-color=\"${channel}\" stop-opacity=\".5\"/><stop offset=\"1\" stop-color=\"${channel}\" stop-opacity=\"0\"/></linearGradient></defs><rect width=\"100\" height=\"100\" fill=\"url(#g)\"/></svg>`\n  )}`\n\nexport function LiquidFilters() {\n  React.useEffect(() => {\n    if (!/Chrome\\//.test(navigator.userAgent)) return\n    document.documentElement.classList.add(\"lg-lens\")\n    return () => document.documentElement.classList.remove(\"lg-lens\")\n  }, [])\n  return (\n    <svg aria-hidden width=\"0\" height=\"0\" style={{ position: \"absolute\" }}>\n      <filter id=\"lg-lens\" x=\"0\" y=\"0\" width=\"100%\" height=\"100%\" colorInterpolationFilters=\"sRGB\">\n        <feImage href={ramp(\"x\", \"#f00\")} x=\"0\" y=\"0\" width=\"100%\" height=\"100%\" preserveAspectRatio=\"none\" result=\"rx\" />\n        <feImage href={ramp(\"y\", \"#0f0\")} x=\"0\" y=\"0\" width=\"100%\" height=\"100%\" preserveAspectRatio=\"none\" result=\"gy\" />\n        <feComposite in=\"rx\" in2=\"gy\" operator=\"arithmetic\" k2=\"1\" k3=\"1\" result=\"map\" />\n        <feDisplacementMap in=\"SourceGraphic\" in2=\"map\" scale=\"24\" xChannelSelector=\"R\" yChannelSelector=\"G\" />\n      </filter>\n    </svg>\n  )\n}\n",
      "type": "registry:ui",
      "target": "components/ui/liquid/liquid-filters.tsx"
    }
  ]
}