@nastechai-research/ui 0.13.2

package/dist/ui/components/icons/heart.js

@@ -0,0 +1,11 @@
+import { jsx } from "react/jsx-runtime";
+export function HeartIcon(props) {
+  return /* @__PURE__ */ jsx("svg", { fill: "none", viewBox: "0 0 14 12", ...props, children: /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M13.2 0v5.65714h-1.8857v1.88572H9.42857v1.88571H7.54286v1.88573H5.65714V9.42857H3.77143V7.54286H1.88571V5.65714H0V0h5.65714v1.88571h1.88572V0z",
+      fill: "currentColor"
+    }
+  ) });
+}
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiaW1wb3J0IHR5cGUgeyBTVkdQcm9wcyB9IGZyb20gJ3JlYWN0J1xuXG5leHBvcnQgZnVuY3Rpb24gSGVhcnRJY29uKHByb3BzOiBTVkdQcm9wczxTVkdTVkdFbGVtZW50Pikge1xuICByZXR1cm4gKFxuICAgIDxzdmcgZmlsbD1cIm5vbmVcIiB2aWV3Qm94PVwiMCAwIDE0IDEyXCIgey4uLnByb3BzfT5cbiAgICAgIDxwYXRoXG4gICAgICAgIGQ9XCJNMTMuMiAwdjUuNjU3MTRoLTEuODg1N3YxLjg4NTcySDkuNDI4NTd2MS44ODU3MUg3LjU0Mjg2djEuODg1NzNINS42NTcxNFY5LjQyODU3SDMuNzcxNDNWNy41NDI4NkgxLjg4NTcxVjUuNjU3MTRIMFYwaDUuNjU3MTR2MS44ODU3MWgxLjg4NTcyVjB6XCJcbiAgICAgICAgZmlsbD1cImN1cnJlbnRDb2xvclwiXG4gICAgICAvPlxuICAgIDwvc3ZnPlxuICApXG59XG4iXSwKICAibWFwcGluZ3MiOiAiQUFLTTtBQUhDLGdCQUFTLFVBQVUsT0FBZ0M7QUFDeEQsU0FDRSxvQkFBQyxTQUFJLE1BQUssUUFBTyxTQUFRLGFBQWEsR0FBRyxPQUN2QztBQUFBLElBQUM7QUFBQTtBQUFBLE1BQ0MsR0FBRTtBQUFBLE1BQ0YsTUFBSztBQUFBO0FBQUEsRUFDUCxHQUNGO0FBRUo7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/ui/components/icons/index.d.ts

@@ -0,0 +1,12 @@
+export * from './arrow';
+export * from './check';
+export * from './chevron';
+export * from './discord';
+export * from './eye';
+export * from './gear';
+export * from './github';
+export * from './hamburger';
+export * from './heart';
+export * from './link';
+export * from './minus';
+export * from './search';

package/dist/ui/components/icons/index.js

@@ -0,0 +1,13 @@
+export * from "./arrow.js";
+export * from "./check.js";
+export * from "./chevron.js";
+export * from "./discord.js";
+export * from "./eye.js";
+export * from "./gear.js";
+export * from "./github.js";
+export * from "./hamburger.js";
+export * from "./heart.js";
+export * from "./link.js";
+export * from "./minus.js";
+export * from "./search.js";
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiZXhwb3J0ICogZnJvbSAnLi9hcnJvdydcbmV4cG9ydCAqIGZyb20gJy4vY2hlY2snXG5leHBvcnQgKiBmcm9tICcuL2NoZXZyb24nXG5leHBvcnQgKiBmcm9tICcuL2Rpc2NvcmQnXG5leHBvcnQgKiBmcm9tICcuL2V5ZSdcbmV4cG9ydCAqIGZyb20gJy4vZ2VhcidcbmV4cG9ydCAqIGZyb20gJy4vZ2l0aHViJ1xuZXhwb3J0ICogZnJvbSAnLi9oYW1idXJnZXInXG5leHBvcnQgKiBmcm9tICcuL2hlYXJ0J1xuZXhwb3J0ICogZnJvbSAnLi9saW5rJ1xuZXhwb3J0ICogZnJvbSAnLi9taW51cydcbmV4cG9ydCAqIGZyb20gJy4vc2VhcmNoJ1xuIl0sCiAgIm1hcHBpbmdzIjogIkFBQUEsY0FBYztBQUNkLGNBQWM7QUFDZCxjQUFjO0FBQ2QsY0FBYztBQUNkLGNBQWM7QUFDZCxjQUFjO0FBQ2QsY0FBYztBQUNkLGNBQWM7QUFDZCxjQUFjO0FBQ2QsY0FBYztBQUNkLGNBQWM7QUFDZCxjQUFjOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/ui/components/icons/link.d.ts

@@ -0,0 +1,2 @@
+import type { SVGProps } from 'react';
+export declare function LinkIcon(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;

package/dist/ui/components/icons/link.js

@@ -0,0 +1,13 @@
+import { jsx } from "react/jsx-runtime";
+export function LinkIcon(props) {
+  return /* @__PURE__ */ jsx("svg", { fill: "none", viewBox: "0 0 17 7", ...props, children: /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M.264191.25061 6.27068.265071V2.26334h3.96512v1.99578l4.0238.00091.043-2.06986-4.0381.07302-.0142-2.01254L16.271.250649l-.0144 6.006381h-5.992l-.0287-1.9981-3.96528-.0002v1.99826l-6.02085-.0001zM6.24063 2.26197l-3.97944-.01436v1.99827l3.97954.01446z",
+      fill: "currentColor",
+      stroke: "currentColor",
+      strokeWidth: ".5"
+    }
+  ) });
+}
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiaW1wb3J0IHR5cGUgeyBTVkdQcm9wcyB9IGZyb20gJ3JlYWN0J1xuXG5leHBvcnQgZnVuY3Rpb24gTGlua0ljb24ocHJvcHM6IFNWR1Byb3BzPFNWR1NWR0VsZW1lbnQ+KSB7XG4gIHJldHVybiAoXG4gICAgPHN2ZyBmaWxsPVwibm9uZVwiIHZpZXdCb3g9XCIwIDAgMTcgN1wiIHsuLi5wcm9wc30+XG4gICAgICA8cGF0aFxuICAgICAgICBkPVwiTS4yNjQxOTEuMjUwNjEgNi4yNzA2OC4yNjUwNzFWMi4yNjMzNGgzLjk2NTEydjEuOTk1NzhsNC4wMjM4LjAwMDkxLjA0My0yLjA2OTg2LTQuMDM4MS4wNzMwMi0uMDE0Mi0yLjAxMjU0TDE2LjI3MS4yNTA2NDlsLS4wMTQ0IDYuMDA2MzgxaC01Ljk5MmwtLjAyODctMS45OTgxLTMuOTY1MjgtLjAwMDJ2MS45OTgyNmwtNi4wMjA4NS0uMDAwMXpNNi4yNDA2MyAyLjI2MTk3bC0zLjk3OTQ0LS4wMTQzNnYxLjk5ODI3bDMuOTc5NTQuMDE0NDZ6XCJcbiAgICAgICAgZmlsbD1cImN1cnJlbnRDb2xvclwiXG4gICAgICAgIHN0cm9rZT1cImN1cnJlbnRDb2xvclwiXG4gICAgICAgIHN0cm9rZVdpZHRoPVwiLjVcIlxuICAgICAgLz5cbiAgICA8L3N2Zz5cbiAgKVxufVxuIl0sCiAgIm1hcHBpbmdzIjogIkFBS007QUFIQyxnQkFBUyxTQUFTLE9BQWdDO0FBQ3ZELFNBQ0Usb0JBQUMsU0FBSSxNQUFLLFFBQU8sU0FBUSxZQUFZLEdBQUcsT0FDdEM7QUFBQSxJQUFDO0FBQUE7QUFBQSxNQUNDLEdBQUU7QUFBQSxNQUNGLE1BQUs7QUFBQSxNQUNMLFFBQU87QUFBQSxNQUNQLGFBQVk7QUFBQTtBQUFBLEVBQ2QsR0FDRjtBQUVKOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/ui/components/icons/minus.d.ts

@@ -0,0 +1,2 @@
+import type { SVGProps } from 'react';
+export declare function MinusIcon(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;

package/dist/ui/components/icons/minus.js

@@ -0,0 +1,13 @@
+import { jsx } from "react/jsx-runtime";
+export function MinusIcon(props) {
+  return /* @__PURE__ */ jsx("svg", { fill: "none", viewBox: "0 0 12 3", ...props, children: /* @__PURE__ */ jsx(
+    "path",
+    {
+      clipRule: "evenodd",
+      d: "M12 0 0-5.2e-7-1e-7 2.50075H12z",
+      fill: "currentColor",
+      fillRule: "evenodd"
+    }
+  ) });
+}
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiaW1wb3J0IHR5cGUgeyBTVkdQcm9wcyB9IGZyb20gJ3JlYWN0J1xuXG5leHBvcnQgZnVuY3Rpb24gTWludXNJY29uKHByb3BzOiBTVkdQcm9wczxTVkdTVkdFbGVtZW50Pikge1xuICByZXR1cm4gKFxuICAgIDxzdmcgZmlsbD1cIm5vbmVcIiB2aWV3Qm94PVwiMCAwIDEyIDNcIiB7Li4ucHJvcHN9PlxuICAgICAgPHBhdGhcbiAgICAgICAgY2xpcFJ1bGU9XCJldmVub2RkXCJcbiAgICAgICAgZD1cIk0xMiAwIDAtNS4yZS03LTFlLTcgMi41MDA3NUgxMnpcIlxuICAgICAgICBmaWxsPVwiY3VycmVudENvbG9yXCJcbiAgICAgICAgZmlsbFJ1bGU9XCJldmVub2RkXCJcbiAgICAgIC8+XG4gICAgPC9zdmc+XG4gIClcbn1cbiJdLAogICJtYXBwaW5ncyI6ICJBQUtNO0FBSEMsZ0JBQVMsVUFBVSxPQUFnQztBQUN4RCxTQUNFLG9CQUFDLFNBQUksTUFBSyxRQUFPLFNBQVEsWUFBWSxHQUFHLE9BQ3RDO0FBQUEsSUFBQztBQUFBO0FBQUEsTUFDQyxVQUFTO0FBQUEsTUFDVCxHQUFFO0FBQUEsTUFDRixNQUFLO0FBQUEsTUFDTCxVQUFTO0FBQUE7QUFBQSxFQUNYLEdBQ0Y7QUFFSjsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/ui/components/icons/search.d.ts

@@ -0,0 +1,2 @@
+import type { SVGProps } from 'react';
+export declare function SearchIcon(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;

package/dist/ui/components/icons/search.js

@@ -0,0 +1,33 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+export function SearchIcon(props) {
+  return /* @__PURE__ */ jsxs("svg", { fill: "none", viewBox: "0 0 20 21", ...props, children: [
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        clipRule: "evenodd",
+        d: "M7.49773 1.6664h6.66637V0H7.49773zM14.1641 15.0001H7.49773v1.6664h6.66637z",
+        fill: "currentColor",
+        fillRule: "evenodd"
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        clipRule: "evenodd",
+        d: "M5.8336 3.33278H7.5v-1.6664H5.8336zM15.8359 13.3329h-1.6671v1.6672h1.6671zM4.16877 5.00017h1.66717V3.33301H4.16877zM17.5 11.6665h-1.6664v1.6664H17.5zM4.16406 11.6665V5.00012h-1.6664v6.66638zM17.4977 5.00012v6.66638h1.6664V5.00012z",
+        fill: "currentColor",
+        fillRule: "evenodd"
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        clipRule: "evenodd",
+        d: "M17.5 5.00017V3.33301h-1.6664v1.66716zM15.8359 3.33278v-1.6664h-1.6671v1.6664zM15.8359 10.0002V6.6665h-1.6671v3.3337zM14.1641 6.6664V5h-1.6664v1.6664zM5.8335 13.3328v-1.6664H4.16633V15H7.5v-1.6671zM4.16406 16.6664V15h-1.6664v1.6664zM2.5 18.3331v-1.6664H.8336v1.6664z",
+        fill: "currentColor",
+        fillRule: "evenodd"
+      }
+    )
+  ] });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ui/components/image-distortion.d.ts

@@ -0,0 +1,21 @@
+export declare function ImageDistortion({ active, autoPlay, className, fallbackClassName, src, style, tint, tintStrength }: ImageDistortionProps): import("react").JSX.Element;
+export type AutoPlayPattern = 'aggressive' | 'gentle' | 'slash';
+interface ImageDistortionProps {
+    active?: boolean;
+    /**
+     * Drive the distortion with a choreographed motion pattern instead of
+     * waiting for a real pointer. Useful for posters, social clips, and any
+     * context where the image needs to feel alive on its own.
+     */
+    autoPlay?: AutoPlayPattern;
+    className?: string;
+    fallbackClassName?: string;
+    src: string;
+    style?: React.CSSProperties;
+    tint?: string;
+    tintStrength?: {
+        active: number;
+        inactive: number;
+    };
+}
+export {};

package/dist/ui/components/image-distortion.js

@@ -0,0 +1,398 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { useGpuTier } from "../../hooks/use-gpu-tier.js";
+import { cn, hexToRgb } from "../../utils/index.js";
+const NUM_BANDS = 12;
+const VERT = `attribute vec2 a;varying vec2 vUv;void main(){vUv=vec2(a.x*.5+.5,.5-a.y*.5);gl_Position=vec4(a,0,1);}`;
+const FRAG = `precision highp float;
+uniform float t;
+uniform vec2 r,imgSize,vel;
+uniform sampler2D tex;
+uniform float bands[${NUM_BANDS}];
+uniform vec3 tint;
+uniform float tintStrength;
+varying vec2 vUv;
+
+float h(vec2 p){return fract(sin(dot(p,vec2(127.1,311.7)))*43758.5453);}
+
+// cover-style UV: crops the image to fill the canvas, centered
+vec2 coverUV(vec2 uv){
+  float canvasAspect=r.x/r.y;
+  float imgAspect=imgSize.x/imgSize.y;
+  vec2 scale=canvasAspect>imgAspect
+    ?vec2(1.0,imgAspect/canvasAspect)
+    :vec2(canvasAspect/imgAspect,1.0);
+  return(uv-0.5)*scale+0.5;
+}
+
+void main(){
+  vec2 uv=coverUV(vUv);
+  float scanY=floor(vUv.y*r.y);
+
+  float bandF=vUv.y*${NUM_BANDS}.0;
+  int bandIdx=int(floor(bandF));
+  float bandFrac=fract(bandF);
+
+  float strength=0.0;
+  for(int i=0;i<${NUM_BANDS};i++){
+    if(i==bandIdx) strength=bands[i];
+  }
+
+  float neighborStr=0.0;
+  int neighborIdx=bandFrac>.5?bandIdx+1:bandIdx-1;
+  for(int i=0;i<${NUM_BANDS};i++){
+    if(i==neighborIdx) neighborStr=bands[i];
+  }
+  float edgeBlend=abs(bandFrac-.5)*2.0;
+  edgeBlend*=edgeBlend;
+  strength=mix(strength,neighborStr,edgeBlend*.3);
+
+  float speed=length(vel);
+  float dirBlend=smoothstep(0.0,0.02,speed);
+  vec2 dir=speed>.0001?vel/speed:vec2(0);
+  dir*=dirBlend;
+
+  float rowSeed=h(vec2(scanY,floor(t*3.)+float(bandIdx)*7.));
+  float rowVar=mix(.4,1.0,rowSeed);
+
+  float ySmooth=vUv.y*6.0+t*0.7;
+  float yNoise=mix(h(vec2(floor(ySmooth),13.)),h(vec2(floor(ySmooth)+1.0,13.)),smoothstep(0.0,1.0,fract(ySmooth)));
+  float colVar=mix(.4,1.0,yNoise);
+
+  float tearShiftX=dir.x*strength*rowVar*0.15;
+  float tearShiftY=dir.y*strength*colVar*0.10;
+
+  float bandSeed=h(vec2(float(bandIdx),42.));
+  tearShiftX+=strength*(.5-bandSeed)*0.05;
+
+  float yJitter=mix(h(vec2(floor(ySmooth),73.)),h(vec2(floor(ySmooth)+1.0,73.)),smoothstep(0.0,1.0,fract(ySmooth)));
+  tearShiftY+=strength*(.5-yJitter)*0.035;
+
+  uv.x+=tearShiftX;
+  uv.y+=tearShiftY;
+
+  float sortGate=step(.5,strength)*step(.4,rowSeed);
+  uv.x+=dir.x*sortGate*strength*0.03;
+  uv.y+=dir.y*sortGate*strength*0.02;
+
+  float caX=abs(tearShiftX)*2.5+sortGate*strength*0.01;
+  float caY=abs(tearShiftY)*2.5+sortGate*strength*0.01;
+  float cr=texture2D(tex,vec2(uv.x+caX,uv.y+caY)).r;
+  float cg=texture2D(tex,uv).g;
+  float cb=texture2D(tex,vec2(uv.x-caX,uv.y-caY)).b;
+
+  vec3 col=vec3(cr,cg,cb);
+
+  col*=.97+.03*sin(vUv.y*r.y*3.14159);
+
+  float bandEdge=smoothstep(.02,.0,min(bandFrac,1.0-bandFrac));
+  col+=vec3(bandEdge*strength*.1);
+
+  col=mix(col,col*tint,tintStrength);
+
+  gl_FragColor=vec4(col,1.0);
+}`;
+const AUTOPLAY_PATTERNS = {
+  aggressive: (t) => {
+    const cycle = 1.4;
+    const phase = t % cycle / cycle;
+    const stab = Math.exp(-((phase - 0.15) ** 2) * 260);
+    const angle = Math.floor(t / cycle) * 1.37;
+    const mx = 0.5 + Math.cos(angle) * 0.42 * (stab + 0.15);
+    const my = 0.5 + Math.sin(angle) * 0.38 * (stab + 0.15);
+    return { hover: 0.55 + stab * 0.45, mx, my };
+  },
+  gentle: (t) => ({
+    hover: 0.45 + Math.sin(t * 0.9) * 0.1,
+    mx: 0.5 + Math.sin(t * 0.5) * 0.28,
+    my: 0.5 + Math.cos(t * 0.37) * 0.22
+  }),
+  slash: (t) => {
+    const cycle = 3.6;
+    const phase = t % cycle / cycle;
+    const slash = Math.exp(-((phase - 0.28) ** 2) * 180);
+    const micro = Math.exp(-((phase - 0.7) ** 2) * 340);
+    const driftX = 0.5 + Math.sin(t * 0.7) * 0.16;
+    const driftY = 0.55 + Math.cos(t * 0.5) * 0.14;
+    const slashX = -0.15 + phase * 1.55;
+    const slashY = 0.95 - phase * 1.35;
+    const mx = driftX * (1 - slash) + slashX * slash;
+    const my = driftY * (1 - slash) + slashY * slash;
+    return { hover: 0.5 + slash * 0.5 + micro * 0.35, mx, my };
+  }
+};
+export function ImageDistortion({
+  active = true,
+  autoPlay,
+  className,
+  fallbackClassName,
+  src,
+  style,
+  tint,
+  tintStrength
+}) {
+  const canvasRef = useRef(null);
+  const tier = useGpuTier();
+  const [loaded, setLoaded] = useState(false);
+  const activeRef = useRef(active);
+  activeRef.current = active;
+  const tintStrengthRef = useRef(tintStrength);
+  tintStrengthRef.current = tintStrength;
+  const autoPlayRef = useRef(autoPlay);
+  autoPlayRef.current = autoPlay;
+  const state = useRef({
+    bandTargets: new Float32Array(NUM_BANDS),
+    bands: new Float32Array(NUM_BANDS),
+    hoverTarget: 0,
+    imgH: 1,
+    imgW: 1,
+    mx: 0.5,
+    my: 0.5,
+    prevMx: 0.5,
+    prevMy: 0.5,
+    vx: 0,
+    vy: 0
+  });
+  useEffect(() => {
+    if (tier === 0) {
+      return;
+    }
+    const c = canvasRef.current;
+    if (!c) {
+      return;
+    }
+    const gl = c.getContext("webgl");
+    if (!gl) {
+      return;
+    }
+    const compile = (type, source) => {
+      const s = gl.createShader(type);
+      gl.shaderSource(s, source);
+      gl.compileShader(s);
+      return s;
+    };
+    const prog = gl.createProgram();
+    gl.attachShader(prog, compile(gl.VERTEX_SHADER, VERT));
+    gl.attachShader(prog, compile(gl.FRAGMENT_SHADER, FRAG));
+    gl.linkProgram(prog);
+    gl.useProgram(prog);
+    gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer());
+    gl.bufferData(
+      gl.ARRAY_BUFFER,
+      new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]),
+      gl.STATIC_DRAW
+    );
+    const a = gl.getAttribLocation(prog, "a");
+    gl.enableVertexAttribArray(a);
+    gl.vertexAttribPointer(a, 2, gl.FLOAT, false, 0, 0);
+    const uT = gl.getUniformLocation(prog, "t");
+    const uR = gl.getUniformLocation(prog, "r");
+    const uImgSize = gl.getUniformLocation(prog, "imgSize");
+    const uVel = gl.getUniformLocation(prog, "vel");
+    const uTex = gl.getUniformLocation(prog, "tex");
+    const uTint = gl.getUniformLocation(prog, "tint");
+    const uTintStrength = gl.getUniformLocation(prog, "tintStrength");
+    const uBands = [];
+    for (let i = 0; i < NUM_BANDS; i++) {
+      uBands.push(gl.getUniformLocation(prog, `bands[${i}]`));
+    }
+    const texture = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    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);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texImage2D(
+      gl.TEXTURE_2D,
+      0,
+      gl.RGBA,
+      1,
+      1,
+      0,
+      gl.RGBA,
+      gl.UNSIGNED_BYTE,
+      new Uint8Array([0, 0, 0, 255])
+    );
+    const img = new Image();
+    img.crossOrigin = "anonymous";
+    img.onload = () => {
+      state.current.imgW = img.naturalWidth;
+      state.current.imgH = img.naturalHeight;
+      gl.bindTexture(gl.TEXTURE_2D, texture);
+      gl.texImage2D(
+        gl.TEXTURE_2D,
+        0,
+        gl.RGBA,
+        gl.RGBA,
+        gl.UNSIGNED_BYTE,
+        img
+      );
+      setLoaded(true);
+    };
+    img.src = src;
+    gl.activeTexture(gl.TEXTURE0);
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    gl.uniform1i(uTex, 0);
+    const resize = () => {
+      const rect = c.getBoundingClientRect();
+      const dpr = Math.min(devicePixelRatio, 2);
+      c.width = rect.width * dpr;
+      c.height = rect.height * dpr;
+      gl.viewport(0, 0, c.width, c.height);
+    };
+    resize();
+    const ro = new ResizeObserver(resize);
+    ro.observe(c);
+    const onMove = (e) => {
+      const rect = c.getBoundingClientRect();
+      state.current.mx = (e.clientX - rect.left) / rect.width;
+      state.current.my = (e.clientY - rect.top) / rect.height;
+    };
+    const onEnter = () => {
+      state.current.hoverTarget = 1;
+    };
+    const onLeave = () => {
+      state.current.hoverTarget = 0;
+    };
+    if (!autoPlayRef.current) {
+      c.addEventListener("pointermove", onMove);
+      c.addEventListener("pointerenter", onEnter);
+      c.addEventListener("pointerleave", onLeave);
+    }
+    const bandEaseRates = new Float32Array(NUM_BANDS);
+    for (let i = 0; i < NUM_BANDS; i++) {
+      bandEaseRates[i] = 0.02 + Math.random() * 0.06;
+    }
+    const tintVec = tint ? (() => {
+      const [tr, tg, tb] = hexToRgb(tint);
+      return [tr / 255, tg / 255, tb / 255];
+    })() : [1, 1, 1];
+    const t0 = performance.now();
+    let raf = 0;
+    let visible = !document.hidden;
+    let inView = true;
+    const loop = () => {
+      raf = requestAnimationFrame(loop);
+      const s = state.current;
+      const pattern = autoPlayRef.current ? AUTOPLAY_PATTERNS[autoPlayRef.current] : null;
+      if (pattern) {
+        const driven = pattern((performance.now() - t0) / 1e3);
+        s.mx = driven.mx;
+        s.my = driven.my;
+        s.hoverTarget = driven.hover;
+      }
+      const dvx = s.mx - s.prevMx;
+      const dvy = s.my - s.prevMy;
+      s.vx += (dvx * 8 - s.vx) * 0.1;
+      s.vy += (dvy * 8 - s.vy) * 0.1;
+      s.prevMx = s.mx;
+      s.prevMy = s.my;
+      const speed = Math.sqrt(s.vx * s.vx + s.vy * s.vy);
+      for (let i = 0; i < NUM_BANDS; i++) {
+        const bandCenter = (i + 0.5) / NUM_BANDS;
+        const dist = Math.abs(s.my - bandCenter);
+        const proximity = Math.max(0, 1 - dist / 0.3);
+        const activation = s.hoverTarget * proximity * (0.4 + Math.min(speed, 1) * 0.6);
+        s.bandTargets[i] = activation;
+      }
+      for (let i = 0; i < NUM_BANDS; i++) {
+        const rate = bandEaseRates[i];
+        const current = s.bands[i] ?? 0;
+        const target = s.bandTargets[i] ?? 0;
+        s.bands[i] = current + (target - current) * rate;
+        if (s.bands[i] < 1e-3) {
+          s.bands[i] = 0;
+        }
+      }
+      gl.uniform1f(uT, (performance.now() - t0) / 1e3);
+      gl.uniform2f(uR, c.width, c.height);
+      gl.uniform2f(uImgSize, s.imgW, s.imgH);
+      gl.uniform2f(uVel, s.vx, s.vy);
+      gl.uniform3f(uTint, tintVec[0], tintVec[1], tintVec[2]);
+      const ts = tintStrengthRef.current;
+      const defaultStrength = tint ? 0.35 : 0;
+      const defaultInactive = tint ? 0.15 : 0;
+      gl.uniform1f(
+        uTintStrength,
+        activeRef.current ? ts?.active ?? defaultStrength : ts?.inactive ?? defaultInactive
+      );
+      for (let i = 0; i < NUM_BANDS; i++) {
+        gl.uniform1f(uBands[i], s.bands[i]);
+      }
+      gl.bindTexture(gl.TEXTURE_2D, texture);
+      gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+    };
+    const start = () => {
+      if (visible && inView && !raf) {
+        raf = requestAnimationFrame(loop);
+      }
+    };
+    const stop = () => {
+      if (raf) {
+        cancelAnimationFrame(raf);
+        raf = 0;
+      }
+    };
+    const onVisibility = () => {
+      visible = !document.hidden;
+      visible ? start() : stop();
+    };
+    const io = new IntersectionObserver(
+      (entries) => {
+        inView = entries.some((e) => e.isIntersecting);
+        inView ? start() : stop();
+      },
+      { threshold: 0 }
+    );
+    io.observe(c);
+    document.addEventListener("visibilitychange", onVisibility);
+    start();
+    return () => {
+      stop();
+      io.disconnect();
+      document.removeEventListener("visibilitychange", onVisibility);
+      ro.disconnect();
+      c.removeEventListener("pointermove", onMove);
+      c.removeEventListener("pointerenter", onEnter);
+      c.removeEventListener("pointerleave", onLeave);
+      gl.deleteTexture(texture);
+      gl.deleteProgram(prog);
+      setLoaded(false);
+    };
+  }, [src, tier, tint]);
+  if (tier === 0) {
+    return (
+      // eslint-disable-next-line @next/next/no-img-element
+      /* @__PURE__ */ jsx(
+        "img",
+        {
+          alt: "",
+          className: cn(
+            "absolute inset-0 h-full w-full object-cover",
+            fallbackClassName ?? className
+          ),
+          fetchPriority: "high",
+          src,
+          style: { mixBlendMode: "overlay", ...style }
+        }
+      )
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    "canvas",
+    {
+      className: cn(
+        "absolute inset-0 h-full w-full transition-opacity duration-500",
+        className
+      ),
+      ref: canvasRef,
+      style: {
+        mixBlendMode: "overlay",
+        opacity: loaded ? 1 : 0,
+        ...style
+      }
+    }
+  );
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["<stdin>"],
  "sourcesContent": ["'use client'\n\nimport { useEffect, useRef, useState } from 'react'\n\nimport { useGpuTier } from '../../hooks/use-gpu-tier'\nimport { cn, hexToRgb } from '../../utils'\n\nconst NUM_BANDS = 12\n\nconst VERT = `attribute vec2 a;varying vec2 vUv;void main(){vUv=vec2(a.x*.5+.5,.5-a.y*.5);gl_Position=vec4(a,0,1);}`\n\nconst FRAG = `precision highp float;\nuniform float t;\nuniform vec2 r,imgSize,vel;\nuniform sampler2D tex;\nuniform float bands[${NUM_BANDS}];\nuniform vec3 tint;\nuniform float tintStrength;\nvarying vec2 vUv;\n\nfloat h(vec2 p){return fract(sin(dot(p,vec2(127.1,311.7)))*43758.5453);}\n\n// cover-style UV: crops the image to fill the canvas, centered\nvec2 coverUV(vec2 uv){\n  float canvasAspect=r.x/r.y;\n  float imgAspect=imgSize.x/imgSize.y;\n  vec2 scale=canvasAspect>imgAspect\n    ?vec2(1.0,imgAspect/canvasAspect)\n    :vec2(canvasAspect/imgAspect,1.0);\n  return(uv-0.5)*scale+0.5;\n}\n\nvoid main(){\n  vec2 uv=coverUV(vUv);\n  float scanY=floor(vUv.y*r.y);\n\n  float bandF=vUv.y*${NUM_BANDS}.0;\n  int bandIdx=int(floor(bandF));\n  float bandFrac=fract(bandF);\n\n  float strength=0.0;\n  for(int i=0;i<${NUM_BANDS};i++){\n    if(i==bandIdx) strength=bands[i];\n  }\n\n  float neighborStr=0.0;\n  int neighborIdx=bandFrac>.5?bandIdx+1:bandIdx-1;\n  for(int i=0;i<${NUM_BANDS};i++){\n    if(i==neighborIdx) neighborStr=bands[i];\n  }\n  float edgeBlend=abs(bandFrac-.5)*2.0;\n  edgeBlend*=edgeBlend;\n  strength=mix(strength,neighborStr,edgeBlend*.3);\n\n  float speed=length(vel);\n  float dirBlend=smoothstep(0.0,0.02,speed);\n  vec2 dir=speed>.0001?vel/speed:vec2(0);\n  dir*=dirBlend;\n\n  float rowSeed=h(vec2(scanY,floor(t*3.)+float(bandIdx)*7.));\n  float rowVar=mix(.4,1.0,rowSeed);\n\n  float ySmooth=vUv.y*6.0+t*0.7;\n  float yNoise=mix(h(vec2(floor(ySmooth),13.)),h(vec2(floor(ySmooth)+1.0,13.)),smoothstep(0.0,1.0,fract(ySmooth)));\n  float colVar=mix(.4,1.0,yNoise);\n\n  float tearShiftX=dir.x*strength*rowVar*0.15;\n  float tearShiftY=dir.y*strength*colVar*0.10;\n\n  float bandSeed=h(vec2(float(bandIdx),42.));\n  tearShiftX+=strength*(.5-bandSeed)*0.05;\n\n  float yJitter=mix(h(vec2(floor(ySmooth),73.)),h(vec2(floor(ySmooth)+1.0,73.)),smoothstep(0.0,1.0,fract(ySmooth)));\n  tearShiftY+=strength*(.5-yJitter)*0.035;\n\n  uv.x+=tearShiftX;\n  uv.y+=tearShiftY;\n\n  float sortGate=step(.5,strength)*step(.4,rowSeed);\n  uv.x+=dir.x*sortGate*strength*0.03;\n  uv.y+=dir.y*sortGate*strength*0.02;\n\n  float caX=abs(tearShiftX)*2.5+sortGate*strength*0.01;\n  float caY=abs(tearShiftY)*2.5+sortGate*strength*0.01;\n  float cr=texture2D(tex,vec2(uv.x+caX,uv.y+caY)).r;\n  float cg=texture2D(tex,uv).g;\n  float cb=texture2D(tex,vec2(uv.x-caX,uv.y-caY)).b;\n\n  vec3 col=vec3(cr,cg,cb);\n\n  col*=.97+.03*sin(vUv.y*r.y*3.14159);\n\n  float bandEdge=smoothstep(.02,.0,min(bandFrac,1.0-bandFrac));\n  col+=vec3(bandEdge*strength*.1);\n\n  col=mix(col,col*tint,tintStrength);\n\n  gl_FragColor=vec4(col,1.0);\n}`\n\n/**\n * Choreographed motion patterns used when `autoPlay` is set. Each pattern\n * returns a synthetic pointer position in [0,1] and a hover intensity in\n * [0,1] for the current time (seconds). They drive the shader without\n * requiring a real pointer, which is what lets us record the distortion\n * as a GIF / screenshot / poster.\n */\nconst AUTOPLAY_PATTERNS: Record<\n  AutoPlayPattern,\n  (t: number) => { hover: number; mx: number; my: number }\n> = {\n  aggressive: t => {\n    const cycle = 1.4\n    const phase = (t % cycle) / cycle\n    const stab = Math.exp(-((phase - 0.15) ** 2) * 260)\n    const angle = Math.floor(t / cycle) * 1.37\n    const mx = 0.5 + Math.cos(angle) * 0.42 * (stab + 0.15)\n    const my = 0.5 + Math.sin(angle) * 0.38 * (stab + 0.15)\n\n    return { hover: 0.55 + stab * 0.45, mx, my }\n  },\n  gentle: t => ({\n    hover: 0.45 + Math.sin(t * 0.9) * 0.1,\n    mx: 0.5 + Math.sin(t * 0.5) * 0.28,\n    my: 0.5 + Math.cos(t * 0.37) * 0.22\n  }),\n  slash: t => {\n    // Long breath -> sword slash -> recoil twitch, repeating.\n    const cycle = 3.6\n    const phase = (t % cycle) / cycle\n    const slash = Math.exp(-((phase - 0.28) ** 2) * 180)\n    const micro = Math.exp(-((phase - 0.7) ** 2) * 340)\n\n    const driftX = 0.5 + Math.sin(t * 0.7) * 0.16\n    const driftY = 0.55 + Math.cos(t * 0.5) * 0.14\n\n    // Slash trajectory: bottom-left up into the giant's chest (top-right).\n    const slashX = -0.15 + phase * 1.55\n    const slashY = 0.95 - phase * 1.35\n\n    const mx = driftX * (1 - slash) + slashX * slash\n    const my = driftY * (1 - slash) + slashY * slash\n\n    return { hover: 0.5 + slash * 0.5 + micro * 0.35, mx, my }\n  }\n}\n\nexport function ImageDistortion({\n  active = true,\n  autoPlay,\n  className,\n  fallbackClassName,\n  src,\n  style,\n  tint,\n  tintStrength\n}: ImageDistortionProps) {\n  const canvasRef = useRef<HTMLCanvasElement>(null)\n  const tier = useGpuTier()\n  const [loaded, setLoaded] = useState(false)\n\n  const activeRef = useRef(active)\n  activeRef.current = active\n  const tintStrengthRef = useRef(tintStrength)\n  tintStrengthRef.current = tintStrength\n  const autoPlayRef = useRef(autoPlay)\n  autoPlayRef.current = autoPlay\n\n  const state = useRef({\n    bandTargets: new Float32Array(NUM_BANDS),\n    bands: new Float32Array(NUM_BANDS),\n    hoverTarget: 0,\n    imgH: 1,\n    imgW: 1,\n    mx: 0.5,\n    my: 0.5,\n    prevMx: 0.5,\n    prevMy: 0.5,\n    vx: 0,\n    vy: 0\n  })\n\n  useEffect(() => {\n    if (tier === 0) {\n      return\n    }\n\n    const c = canvasRef.current\n\n    if (!c) {\n      return\n    }\n\n    const gl = c.getContext('webgl')\n\n    if (!gl) {\n      return\n    }\n\n    const compile = (type: number, source: string) => {\n      const s = gl.createShader(type)!\n      gl.shaderSource(s, source)\n      gl.compileShader(s)\n\n      return s\n    }\n\n    const prog = gl.createProgram()!\n    gl.attachShader(prog, compile(gl.VERTEX_SHADER, VERT))\n    gl.attachShader(prog, compile(gl.FRAGMENT_SHADER, FRAG))\n    gl.linkProgram(prog)\n    gl.useProgram(prog)\n\n    gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer())\n    gl.bufferData(\n      gl.ARRAY_BUFFER,\n      new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]),\n      gl.STATIC_DRAW\n    )\n\n    const a = gl.getAttribLocation(prog, 'a')\n    gl.enableVertexAttribArray(a)\n    gl.vertexAttribPointer(a, 2, gl.FLOAT, false, 0, 0)\n\n    const uT = gl.getUniformLocation(prog, 't')\n    const uR = gl.getUniformLocation(prog, 'r')\n    const uImgSize = gl.getUniformLocation(prog, 'imgSize')\n    const uVel = gl.getUniformLocation(prog, 'vel')\n    const uTex = gl.getUniformLocation(prog, 'tex')\n    const uTint = gl.getUniformLocation(prog, 'tint')\n    const uTintStrength = gl.getUniformLocation(prog, 'tintStrength')\n    const uBands: (null | WebGLUniformLocation)[] = []\n\n    for (let i = 0; i < NUM_BANDS; i++) {\n      uBands.push(gl.getUniformLocation(prog, `bands[${i}]`))\n    }\n\n    const texture = gl.createTexture()!\n    gl.bindTexture(gl.TEXTURE_2D, texture)\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)\n    gl.texImage2D(\n      gl.TEXTURE_2D,\n      0,\n      gl.RGBA,\n      1,\n      1,\n      0,\n      gl.RGBA,\n      gl.UNSIGNED_BYTE,\n      new Uint8Array([0, 0, 0, 255])\n    )\n\n    const img = new Image()\n    img.crossOrigin = 'anonymous'\n\n    img.onload = () => {\n      state.current.imgW = img.naturalWidth\n      state.current.imgH = img.naturalHeight\n      gl.bindTexture(gl.TEXTURE_2D, texture)\n      gl.texImage2D(\n        gl.TEXTURE_2D,\n        0,\n        gl.RGBA,\n        gl.RGBA,\n        gl.UNSIGNED_BYTE,\n        img\n      )\n      setLoaded(true)\n    }\n\n    img.src = src\n\n    gl.activeTexture(gl.TEXTURE0)\n    gl.bindTexture(gl.TEXTURE_2D, texture)\n    gl.uniform1i(uTex, 0)\n\n    const resize = () => {\n      const rect = c.getBoundingClientRect()\n      const dpr = Math.min(devicePixelRatio, 2)\n      c.width = rect.width * dpr\n      c.height = rect.height * dpr\n      gl.viewport(0, 0, c.width, c.height)\n    }\n\n    resize()\n    const ro = new ResizeObserver(resize)\n    ro.observe(c)\n\n    const onMove = (e: PointerEvent) => {\n      const rect = c.getBoundingClientRect()\n      state.current.mx = (e.clientX - rect.left) / rect.width\n      state.current.my = (e.clientY - rect.top) / rect.height\n    }\n\n    const onEnter = () => {\n      state.current.hoverTarget = 1\n    }\n\n    const onLeave = () => {\n      state.current.hoverTarget = 0\n    }\n\n    // When autoPlay drives the distortion we want the poster to look\n    // alive regardless of whether a pointer is near the canvas, so we\n    // skip the real pointer listeners entirely.\n    if (!autoPlayRef.current) {\n      c.addEventListener('pointermove', onMove)\n      c.addEventListener('pointerenter', onEnter)\n      c.addEventListener('pointerleave', onLeave)\n    }\n\n    const bandEaseRates = new Float32Array(NUM_BANDS)\n\n    for (let i = 0; i < NUM_BANDS; i++) {\n      bandEaseRates[i] = 0.02 + Math.random() * 0.06\n    }\n\n    const tintVec: readonly [number, number, number] = tint\n      ? (() => {\n          const [tr, tg, tb] = hexToRgb(tint)\n\n          return [tr / 255, tg / 255, tb / 255] as const\n        })()\n      : ([1, 1, 1] as const)\n\n    const t0 = performance.now()\n    let raf = 0\n    let visible = !document.hidden\n    let inView = true\n\n    const loop = () => {\n      raf = requestAnimationFrame(loop)\n      const s = state.current\n\n      const pattern = autoPlayRef.current\n        ? AUTOPLAY_PATTERNS[autoPlayRef.current]\n        : null\n\n      if (pattern) {\n        const driven = pattern((performance.now() - t0) / 1e3)\n        s.mx = driven.mx\n        s.my = driven.my\n        s.hoverTarget = driven.hover\n      }\n\n      const dvx = s.mx - s.prevMx\n      const dvy = s.my - s.prevMy\n      s.vx += (dvx * 8 - s.vx) * 0.1\n      s.vy += (dvy * 8 - s.vy) * 0.1\n      s.prevMx = s.mx\n      s.prevMy = s.my\n\n      const speed = Math.sqrt(s.vx * s.vx + s.vy * s.vy)\n\n      for (let i = 0; i < NUM_BANDS; i++) {\n        const bandCenter = (i + 0.5) / NUM_BANDS\n        const dist = Math.abs(s.my - bandCenter)\n        const proximity = Math.max(0, 1 - dist / 0.3)\n        const activation =\n          s.hoverTarget * proximity * (0.4 + Math.min(speed, 1) * 0.6)\n        s.bandTargets[i] = activation\n      }\n\n      for (let i = 0; i < NUM_BANDS; i++) {\n        const rate = bandEaseRates[i]!\n        const current = s.bands[i] ?? 0\n        const target = s.bandTargets[i] ?? 0\n        s.bands[i] = current + (target - current) * rate\n\n        if (s.bands[i]! < 0.001) {\n          s.bands[i] = 0\n        }\n      }\n\n      gl.uniform1f(uT, (performance.now() - t0) / 1e3)\n      gl.uniform2f(uR, c.width, c.height)\n      gl.uniform2f(uImgSize, s.imgW, s.imgH)\n      gl.uniform2f(uVel, s.vx, s.vy)\n      gl.uniform3f(uTint, tintVec[0], tintVec[1], tintVec[2])\n\n      const ts = tintStrengthRef.current\n      const defaultStrength = tint ? 0.35 : 0\n      const defaultInactive = tint ? 0.15 : 0\n      gl.uniform1f(\n        uTintStrength,\n        activeRef.current\n          ? (ts?.active ?? defaultStrength)\n          : (ts?.inactive ?? defaultInactive)\n      )\n\n      for (let i = 0; i < NUM_BANDS; i++) {\n        gl.uniform1f(uBands[i]!, s.bands[i]!)\n      }\n\n      gl.bindTexture(gl.TEXTURE_2D, texture)\n      gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4)\n    }\n\n    const start = () => {\n      if (visible && inView && !raf) {\n        raf = requestAnimationFrame(loop)\n      }\n    }\n\n    const stop = () => {\n      if (raf) {\n        cancelAnimationFrame(raf)\n        raf = 0\n      }\n    }\n\n    const onVisibility = () => {\n      visible = !document.hidden\n      visible ? start() : stop()\n    }\n\n    const io = new IntersectionObserver(\n      entries => {\n        inView = entries.some(e => e.isIntersecting)\n        inView ? start() : stop()\n      },\n      { threshold: 0 }\n    )\n\n    io.observe(c)\n    document.addEventListener('visibilitychange', onVisibility)\n\n    start()\n\n    return () => {\n      stop()\n      io.disconnect()\n      document.removeEventListener('visibilitychange', onVisibility)\n      ro.disconnect()\n      c.removeEventListener('pointermove', onMove)\n      c.removeEventListener('pointerenter', onEnter)\n      c.removeEventListener('pointerleave', onLeave)\n      gl.deleteTexture(texture)\n      gl.deleteProgram(prog)\n      setLoaded(false)\n    }\n    // autoPlay is intentionally omitted so toggling it at runtime doesn't\n    // tear down the shader pipeline. The ref-driven loop reads the live\n    // value each frame, so listener attach/detach is handled once on mount.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [src, tier, tint])\n\n  if (tier === 0) {\n    return (\n      // eslint-disable-next-line @next/next/no-img-element\n      <img\n        alt=\"\"\n        className={cn(\n          'absolute inset-0 h-full w-full object-cover',\n          fallbackClassName ?? className\n        )}\n        fetchPriority=\"high\"\n        src={src}\n        style={{ mixBlendMode: 'overlay', ...style }}\n      />\n    )\n  }\n\n  return (\n    <canvas\n      className={cn(\n        'absolute inset-0 h-full w-full transition-opacity duration-500',\n        className\n      )}\n      ref={canvasRef}\n      style={{\n        mixBlendMode: 'overlay',\n        opacity: loaded ? 1 : 0,\n        ...style\n      }}\n    />\n  )\n}\n\nexport type AutoPlayPattern = 'aggressive' | 'gentle' | 'slash'\n\ninterface ImageDistortionProps {\n  active?: boolean\n  /**\n   * Drive the distortion with a choreographed motion pattern instead of\n   * waiting for a real pointer. Useful for posters, social clips, and any\n   * context where the image needs to feel alive on its own.\n   */\n  autoPlay?: AutoPlayPattern\n  className?: string\n  fallbackClassName?: string\n  src: string\n  style?: React.CSSProperties\n  tint?: string\n  tintStrength?: { active: number; inactive: number }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/ui/components/input.d.ts

@@ -0,0 +1 @@
+export declare function Input({ className, ...props }: React.InputHTMLAttributes<HTMLInputElement>): import("react").JSX.Element;

package/dist/ui/components/input.js

@@ -0,0 +1,21 @@
+import { jsx } from "react/jsx-runtime";
+import { cn } from "../../utils/index.js";
+export function Input({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    "input",
+    {
+      className: cn(
+        "flex h-9 w-full border border-midground/15 bg-background/40 px-3 py-1 font-courier text-sm transition-colors",
+        "placeholder:text-midground/50",
+        "focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-midground/30 focus-visible:border-midground/25",
+        "disabled:cursor-not-allowed disabled:opacity-50",
+        className
+      ),
+      ...props
+    }
+  );
+}
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiaW1wb3J0IHsgY24gfSBmcm9tICcuLi8uLi91dGlscydcblxuZXhwb3J0IGZ1bmN0aW9uIElucHV0KHtcbiAgY2xhc3NOYW1lLFxuICAuLi5wcm9wc1xufTogUmVhY3QuSW5wdXRIVE1MQXR0cmlidXRlczxIVE1MSW5wdXRFbGVtZW50Pikge1xuICByZXR1cm4gKFxuICAgIDxpbnB1dFxuICAgICAgY2xhc3NOYW1lPXtjbihcbiAgICAgICAgJ2ZsZXggaC05IHctZnVsbCBib3JkZXIgYm9yZGVyLW1pZGdyb3VuZC8xNSBiZy1iYWNrZ3JvdW5kLzQwIHB4LTMgcHktMSBmb250LWNvdXJpZXIgdGV4dC1zbSB0cmFuc2l0aW9uLWNvbG9ycycsXG4gICAgICAgICdwbGFjZWhvbGRlcjp0ZXh0LW1pZGdyb3VuZC81MCcsXG4gICAgICAgICdmb2N1cy12aXNpYmxlOm91dGxpbmUtbm9uZSBmb2N1cy12aXNpYmxlOnJpbmctMSBmb2N1cy12aXNpYmxlOnJpbmctbWlkZ3JvdW5kLzMwIGZvY3VzLXZpc2libGU6Ym9yZGVyLW1pZGdyb3VuZC8yNScsXG4gICAgICAgICdkaXNhYmxlZDpjdXJzb3Itbm90LWFsbG93ZWQgZGlzYWJsZWQ6b3BhY2l0eS01MCcsXG4gICAgICAgIGNsYXNzTmFtZVxuICAgICAgKX1cbiAgICAgIHsuLi5wcm9wc31cbiAgICAvPlxuICApXG59XG5cbiJdLAogICJtYXBwaW5ncyI6ICJBQU9JO0FBUEosU0FBUyxVQUFVO0FBRVosZ0JBQVMsTUFBTTtBQUFBLEVBQ3BCO0FBQUEsRUFDQSxHQUFHO0FBQ0wsR0FBZ0Q7QUFDOUMsU0FDRTtBQUFBLElBQUM7QUFBQTtBQUFBLE1BQ0MsV0FBVztBQUFBLFFBQ1Q7QUFBQSxRQUNBO0FBQUEsUUFDQTtBQUFBLFFBQ0E7QUFBQSxRQUNBO0FBQUEsTUFDRjtBQUFBLE1BQ0MsR0FBRztBQUFBO0FBQUEsRUFDTjtBQUVKOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/ui/components/label.d.ts

@@ -0,0 +1 @@
+export declare function Label({ className, ...props }: React.LabelHTMLAttributes<HTMLLabelElement>): import("react").JSX.Element;

package/dist/ui/components/label.js

@@ -0,0 +1,18 @@
+import { jsx } from "react/jsx-runtime";
+import { cn } from "../../utils/index.js";
+export function Label({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    "label",
+    {
+      className: cn(
+        "font-mondwest text-xs tracking-[0.1em] uppercase leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70",
+        className
+      ),
+      ...props
+    }
+  );
+}
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiaW1wb3J0IHsgY24gfSBmcm9tICcuLi8uLi91dGlscydcblxuZXhwb3J0IGZ1bmN0aW9uIExhYmVsKHtcbiAgY2xhc3NOYW1lLFxuICAuLi5wcm9wc1xufTogUmVhY3QuTGFiZWxIVE1MQXR0cmlidXRlczxIVE1MTGFiZWxFbGVtZW50Pikge1xuICByZXR1cm4gKFxuICAgIDxsYWJlbFxuICAgICAgY2xhc3NOYW1lPXtjbihcbiAgICAgICAgJ2ZvbnQtbW9uZHdlc3QgdGV4dC14cyB0cmFja2luZy1bMC4xZW1dIHVwcGVyY2FzZSBsZWFkaW5nLW5vbmUgcGVlci1kaXNhYmxlZDpjdXJzb3Itbm90LWFsbG93ZWQgcGVlci1kaXNhYmxlZDpvcGFjaXR5LTcwJyxcbiAgICAgICAgY2xhc3NOYW1lXG4gICAgICApfVxuICAgICAgey4uLnByb3BzfVxuICAgIC8+XG4gIClcbn1cbiJdLAogICJtYXBwaW5ncyI6ICJBQU9JO0FBUEosU0FBUyxVQUFVO0FBRVosZ0JBQVMsTUFBTTtBQUFBLEVBQ3BCO0FBQUEsRUFDQSxHQUFHO0FBQ0wsR0FBZ0Q7QUFDOUMsU0FDRTtBQUFBLElBQUM7QUFBQTtBQUFBLE1BQ0MsV0FBVztBQUFBLFFBQ1Q7QUFBQSxRQUNBO0FBQUEsTUFDRjtBQUFBLE1BQ0MsR0FBRztBQUFBO0FBQUEsRUFDTjtBQUVKOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/ui/components/leva-client.d.ts

@@ -0,0 +1 @@
+export declare function LevaClient(): import("react").JSX.Element;