@mkbabb/glass-ui 0.3.0 → 2.1.0

package/dist/aurora.js

@@ -0,0 +1,541 @@
+import { t as e } from "./_plugin-vue_export-helper-n-_DRHWS.js";
+import { n as t, r as n, t as r } from "./presets-BMzCDrmR.js";
+import { t as i } from "./useIntersectionPause-CXYfYg_C.js";
+import { computed as a, createElementBlock as o, createElementVNode as s, defineComponent as c, normalizeClass as l, normalizeStyle as u, onBeforeUnmount as d, onMounted as f, openBlock as p, readonly as m, ref as h, unref as g, watch as _ } from "vue";
+//#region src/components/custom/aurora/shaders/aurora.vert.ts
+var v = "#version 300 es\nin vec2 aPos;\nout vec2 vUv;\nvoid main() {\n  vUv = aPos * 0.5 + 0.5;\n  gl_Position = vec4(aPos, 0.0, 1.0);\n}", y = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\nout vec4 fragColor;\n\n#define MAX_NUCLEI 6\n#define MAX_STOPS  8\n\n// ── Uniforms ───────────────────────────────────────────────────────────────\nuniform float uTime;\n\n// Palette baked CPU-side to linear-sRGB\nuniform vec3  uPalette[MAX_STOPS];\nuniform int   uStopCount;\n\n// Nuclei (parallel arrays)\nuniform int   uNucleiCount;\nuniform vec2  uNucleiPos[MAX_NUCLEI];\nuniform float uNucleiRadius[MAX_NUCLEI];\nuniform float uNucleiPaletteBias[MAX_NUCLEI];\nuniform float uNucleiValueBias[MAX_NUCLEI];\nuniform float uNucleiDriftRadius[MAX_NUCLEI];\nuniform float uNucleiDriftPhase[MAX_NUCLEI];\n// Anisotropy: per-nucleus elongation (1.0 = isotropic) and major-axis angle (radians).\n// Defaults (1.0 / 0.0) reduce to the original circular Gaussian.\nuniform float uNucleiElong[MAX_NUCLEI];\nuniform float uNucleiAngle[MAX_NUCLEI];\nuniform float uSoftmaxBeta;\nuniform float uValueVariance;\n\n// Warp\nuniform float uWarpAmount;\nuniform float uWarpScale;\nuniform float uWarpDrift;\nuniform int   uWarpMode;      // 0=fbm 1=cellular 2=hybrid\nuniform int   uNoiseOctaves;\n\n// Medium\n// 0 smooth, 1 pastel, 2 watercolor, 3 oil\nuniform int   uMedium;\nuniform int   uFlowPattern;   // 0 none, 1 radial, 2 swirl, 3 diagonal, 4 multi\nuniform vec2  uFlowFocal;\nuniform float uFlowAngle;\nuniform float uFlowCurl;\nuniform vec2  uCursor;          // in 0..1 screen space (matches pN)\nuniform float uCursorStrength;  // 0..1 attraction amount\nuniform float uCursorRadius;    // radius of influence (0.05..0.5)\nuniform float uStrokeAmount;\nuniform float uStrokeScale;\nuniform float uStrokeAnisotropy;\nuniform int   uStrokeLayers;  // 1 or 2 (crosshatch)\nuniform int   uStrokeMode;    // 0 oil (modern gestural), 1 palette-knife, 2 crayon/oil-pastel, 3 modern-chunky\nuniform float uWetEdge;\nuniform float uGranulation;\nuniform float uImpasto;\nuniform float uBrokenColor;\nuniform float uCanvasGrain;\n\n// Motion\nuniform float uNucleiDrift;\nuniform float uPaletteDrift;\nuniform float uBreathDepth;\nuniform float uBreathPeriod;\n\n// Output\nuniform float uSaturation;\nuniform float uPaperGrain;\nuniform float uAlpha;\n\n// ── Noise ──────────────────────────────────────────────────────────────────\nfloat hash21(vec2 p) {\n  p = fract(p * vec2(123.34, 456.21));\n  p += dot(p, p + 45.32);\n  return fract(p.x * p.y);\n}\n\nvec2 hash22(vec2 p) {\n  p = vec2(dot(p, vec2(127.1, 311.7)),\n           dot(p, vec2(269.5, 183.3)));\n  return fract(sin(p) * 43758.5453);\n}\n\nfloat vnoise(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  vec2 u = f * f * (3.0 - 2.0 * f);\n  float a = hash21(i);\n  float b = hash21(i + vec2(1.0, 0.0));\n  float c = hash21(i + vec2(0.0, 1.0));\n  float d = hash21(i + vec2(1.0, 1.0));\n  return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);\n}\n\nfloat fbm(vec2 p) {\n  float v = 0.0;\n  float a = 0.5;\n  mat2 r = mat2(0.8, 0.6, -0.6, 0.8);\n  for (int i = 0; i < 5; i++) {\n    if (i >= uNoiseOctaves) break;\n    v += a * vnoise(p);\n    p = r * p * 2.02;\n    a *= 0.5;\n  }\n  return v;\n}\n\n// Cellular / Worley f1\nfloat cellular(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  float m = 1e9;\n  for (int y = -1; y <= 1; y++) {\n    for (int x = -1; x <= 1; x++) {\n      vec2 g = vec2(float(x), float(y));\n      vec2 o = hash22(i + g);\n      vec2 r = g + o - f;\n      m = min(m, dot(r, r));\n    }\n  }\n  return sqrt(m);\n}\n\n// ── Warp ──────────────────────────────────────────────────────────────────\nvec2 domainWarp(vec2 p, float t) {\n  // Quilez canonical double warp\n  vec2 q = vec2(fbm(p * uWarpScale + vec2(0.0, 0.0) + t * uWarpDrift),\n                fbm(p * uWarpScale + vec2(5.2, 1.3) + t * uWarpDrift));\n  vec2 r = vec2(fbm(p * uWarpScale + 4.0 * q + vec2(1.7, 9.2)),\n                fbm(p * uWarpScale + 4.0 * q + vec2(8.3, 2.8)));\n\n  vec2 warp = r;\n  if (uWarpMode == 1) {\n    // cellular — chunky territories (MEADOW block-like)\n    float c1 = cellular(p * uWarpScale * 1.5 + vec2(t * uWarpDrift * 2.0, 0.0));\n    float c2 = cellular(p * uWarpScale * 1.5 + vec2(11.0, 7.0 + t * uWarpDrift * 2.0));\n    warp = vec2(c1, c2);\n  } else if (uWarpMode == 2) {\n    // hybrid — fbm + cellular averaged\n    float c1 = cellular(p * uWarpScale * 1.2);\n    float c2 = cellular(p * uWarpScale * 1.2 + vec2(11.0, 7.0));\n    warp = mix(r, vec2(c1, c2), 0.5);\n  }\n  vec2 warped = p + uWarpAmount * warp;\n\n  // Cursor swirl — rotate p around uCursor with radial falloff.\n  // This warps the underlying color field so the bands sweep around the pointer.\n  if (uCursorStrength > 0.001) {\n    vec2 toP = p - uCursor;\n    float d = length(toP);\n    float r = max(uCursorRadius, 0.01);\n    // Smooth falloff; strong near cursor, zero beyond ~1.5× radius.\n    float w = exp(-(d * d) / (r * r * 0.45));\n    // Max rotation ~120° at cursor center, scaled by strength\n    float ang = w * uCursorStrength * 2.1;\n    float ca = cos(ang), sa = sin(ang);\n    vec2 rotated = vec2(ca * toP.x - sa * toP.y, sa * toP.x + ca * toP.y) + uCursor;\n    // Also pinch slightly toward the cursor (gravity) — adds depth to swirl\n    float pinch = w * uCursorStrength * 0.08;\n    rotated = mix(rotated, uCursor, pinch);\n    // Blend original warped position with cursor-rotated version\n    warped = mix(warped, rotated + uWarpAmount * warp * 0.7, w * uCursorStrength);\n  }\n\n  return warped;\n}\n\n// ── Palette LUT ───────────────────────────────────────────────────────────\nvec3 samplePalette(float id) {\n  id = clamp(id, 0.0, 1.0);\n  float scaled = id * float(uStopCount - 1);\n  int i0 = int(floor(scaled));\n  int i1 = min(i0 + 1, uStopCount - 1);\n  float t = fract(scaled);\n  t = smoothstep(0.0, 1.0, t);\n  return mix(uPalette[i0], uPalette[i1], t);\n}\n\n// ── Nuclei field ──────────────────────────────────────────────────────────\nvoid nucleiField(vec2 p, float t, out float paletteId, out float valueMod) {\n  float accumBias  = 0.0;\n  float accumValue = 0.0;\n  float accumW     = 0.0;\n  for (int i = 0; i < MAX_NUCLEI; i++) {\n    if (i >= uNucleiCount) break;\n    vec2 posI = uNucleiPos[i]\n              + uNucleiDriftRadius[i] * vec2(\n                  cos(t * uNucleiDrift + uNucleiDriftPhase[i]),\n                  sin(t * uNucleiDrift + uNucleiDriftPhase[i] * 1.13)\n                );\n    vec2 diff = p - posI;\n    // Anisotropic Gaussian: rotate diff into the nucleus's local frame\n    // (major axis along uNucleiAngle), then scale the major-axis component by\n    // 1/elongation so the squared distance describes an ellipse. Defaults\n    // 1.0/0.0 reduce to the isotropic dot(diff, diff).\n    float ca = cos(uNucleiAngle[i]);\n    float sa = sin(uNucleiAngle[i]);\n    vec2  local = vec2( ca * diff.x + sa * diff.y,\n                       -sa * diff.x + ca * diff.y);\n    float along  = local.x / max(uNucleiElong[i], 0.01);\n    float across = local.y;\n    float d2 = along * along + across * across;\n    float r = max(uNucleiRadius[i], 0.01);\n    float w = exp(-uSoftmaxBeta * d2 / (r * r));\n    accumBias  += w * uNucleiPaletteBias[i];\n    accumValue += w * uNucleiValueBias[i];\n    accumW     += w;\n  }\n  paletteId = accumBias  / max(accumW, 1e-4);\n  valueMod  = accumValue / max(accumW, 1e-4);\n\n  // Palette drift — subtle global paletteId shift\n  paletteId += 0.04 * sin(t * uPaletteDrift * 6.2831) * uPaletteDrift * 20.0;\n  paletteId = clamp(paletteId, 0.0, 1.0);\n}\n\n// ── Flow field ────────────────────────────────────────────────────────────\nvec2 flowField(vec2 p, float t) {\n  vec2 dir = vec2(1.0, 0.0);\n  if (uFlowPattern == 1) {\n    // radial\n    dir = normalize(p - uFlowFocal + 1e-4);\n  } else if (uFlowPattern == 2) {\n    // swirl — tangent to radial\n    vec2 rad = normalize(p - uFlowFocal + 1e-4);\n    dir = vec2(-rad.y, rad.x);\n  } else if (uFlowPattern == 3) {\n    // diagonal\n    float a = radians(uFlowAngle);\n    dir = vec2(cos(a), sin(a));\n  } else if (uFlowPattern == 4) {\n    // multi — curl-noise driven\n    float n = fbm(p * 2.0 + t * 0.02);\n    float a = n * 6.2831;\n    dir = vec2(cos(a), sin(a));\n  }\n  // curl — perturb by noise. Radial gets much less curl so rays stay clean.\n  if (uFlowCurl > 0.0) {\n    float n = fbm(p * 3.0) - 0.5;\n    float curlAmt = uFlowCurl;\n    if (uFlowPattern == 1) curlAmt *= 0.25;  // radial: preserve ray clarity\n    if (uFlowPattern == 2) curlAmt *= 0.55;  // swirl: allow moderate curl\n    float a = atan(dir.y, dir.x) + n * 3.14159 * curlAmt;\n    dir = vec2(cos(a), sin(a));\n  }\n  // cursor influence — swirl around the cursor position\n  if (uCursorStrength > 0.001) {\n    vec2 toCur = uCursor - p;\n    float d = length(toCur);\n    float r = max(uCursorRadius, 0.01);\n    float w = exp(-(d * d) / (r * r * 0.5));\n    // swirl tangent\n    vec2 tangent = vec2(-toCur.y, toCur.x) / max(d, 1e-4);\n    float a0 = atan(dir.y, dir.x);\n    float a1 = atan(tangent.y, tangent.x);\n    // blend angle\n    float da = a1 - a0;\n    da = atan(sin(da), cos(da)); // wrap to [-pi, pi]\n    float a = a0 + da * w * uCursorStrength;\n    dir = vec2(cos(a), sin(a));\n  }\n  return dir;\n}\n\n// ── Color utils ───────────────────────────────────────────────────────────\nconst vec3 W_LUMA = vec3(0.2126, 0.7152, 0.0722);\n\nvec3 hueShift(vec3 c, float degrees) {\n  float a = radians(degrees);\n  float co = cos(a), si = sin(a);\n  mat3 m = mat3(\n    0.299 + 0.701 * co + 0.168 * si,\n    0.587 - 0.587 * co + 0.330 * si,\n    0.114 - 0.114 * co - 0.497 * si,\n\n    0.299 - 0.299 * co - 0.328 * si,\n    0.587 + 0.413 * co + 0.035 * si,\n    0.114 - 0.114 * co + 0.292 * si,\n\n    0.299 - 0.300 * co + 1.250 * si,\n    0.587 - 0.588 * co - 1.050 * si,\n    0.114 + 0.886 * co - 0.203 * si\n  );\n  return m * c;\n}\n\nvec3 brokenColorJitter(vec3 c, float hueSeed, float valueSeed, float strength) {\n  float amt = clamp(uBrokenColor * strength, 0.0, 1.0);\n  if (amt <= 0.001) return c;\n  float hueDeg = (hueSeed - 0.5) * 32.0 * amt;\n  float valueMul = 1.0 + (valueSeed - 0.5) * 0.28 * amt;\n  return max(hueShift(c, hueDeg) * valueMul, vec3(0.0));\n}\n\nvec3 saturate3(vec3 c, float amt) {\n  float l = dot(c, W_LUMA);\n  return mix(vec3(l), c, amt);\n}\n\n// ACES approximation\nvec3 aces(vec3 x) {\n  float a = 2.51;\n  float b = 0.03;\n  float c = 2.43;\n  float d = 0.59;\n  float e = 0.14;\n  return clamp((x * (a * x + b)) / (x * (c * x + d) + e), 0.0, 1.0);\n}\n\n// ── Medium overlays ───────────────────────────────────────────────────────\n\n// A quick re-computation of base color for edge-mask sampling\nvec3 sampleBase(vec2 p, float t) {\n  vec2 pw = domainWarp(p, t);\n  float id; float vm;\n  nucleiField(pw, t, id, vm);\n  vec3 c = samplePalette(id);\n  c *= 1.0 + uValueVariance * vm;\n  return c;\n}\n\nvec3 mediumWatercolor(vec3 col, vec2 p, float t) {\n  // Wet-edge cauliflowers via luma-gradient magnitude\n  float eps = 0.004;\n  vec3 cx1 = sampleBase(p + vec2(eps, 0.0), t);\n  vec3 cx2 = sampleBase(p - vec2(eps, 0.0), t);\n  vec3 cy1 = sampleBase(p + vec2(0.0, eps), t);\n  vec3 cy2 = sampleBase(p - vec2(0.0, eps), t);\n  float gx = dot(cx1 - cx2, W_LUMA);\n  float gy = dot(cy1 - cy2, W_LUMA);\n  float edge = sqrt(gx * gx + gy * gy) / (2.0 * eps);\n  float mask = smoothstep(0.0, 2.5, edge);\n  col *= mix(1.0, 0.78, mask * uWetEdge);\n\n  // Granulation — pigment settles in paper tooth\n  float paper = 0.5 * vnoise(p * 160.0) + 0.5 * vnoise(p * 360.0);\n  float pigLoad = 1.0 - dot(col, W_LUMA);\n  col *= 1.0 - uGranulation * pigLoad * (paper - 0.5);\n\n  // Wash banding — faint horizontal wet gradient\n  float band = fbm(vec2(p.x * 1.5, p.y * 0.4));\n  col *= 1.0 + 0.04 * (band - 0.5);\n  return col;\n}\n\nvec3 mediumPastel(vec3 col, vec2 p, float t) {\n  vec2 flow = flowField(p, t);\n  vec2 perp = vec2(-flow.y, flow.x);\n  float along  = dot(p, flow) * uStrokeScale;\n  float across = dot(p, perp) * uStrokeScale;\n  across += 0.03 * (vnoise(p * 260.0) - 0.5);\n\n  float aniso = mix(1.0, 0.18, uStrokeAnisotropy);\n  float stroke = fbm(vec2(along * aniso, across));\n  col *= mix(1.0, 0.82 + 0.32 * stroke, uStrokeAmount);\n\n  // Pastel tooth — tiny high-frequency grain\n  float tooth = vnoise(p * 800.0);\n  col *= 1.0 - 0.08 * uStrokeAmount * (tooth - 0.5);\n  return col;\n}\n\n// ── Curved swept brushstroke primitive ────────────────────────────────────\n// A stroke is a curved spine from A to B with quadratic bulge K (sideways offset\n// at midpoint). Width varies along length via a shape profile. Edge is ragged\n// (bristle-modulated), ends are rounded blobs, inside has streak modulation.\n//\n// For pixel p, we invert an approximate projection onto the curved spine:\n//   1) project p onto straight AB axis -> along0, cross0\n//   2) at parameter along0, spine offset = 4·K·along0·(1-along0) perpendicular\n//   3) cross = cross0 - spineOffset, refine along one iteration\n// Coverage blends paint atop col based on per-stroke color sampled from the\n// underlying base at spine midpoint — so overlapping strokes from different\n// palette regions meet at hard, ragged demarcations.\n\nstruct StrokeHit {\n  float coverage;  // 0..1\n  vec3  color;\n  float alongT;    // 0..1 along spine, for internal modulation\n  float crossN;    // cross distance / current half-width, signed\n  float edgeN;     // distance to edge in half-widths (0 = at edge, 1 = at spine)\n};\n\nStrokeHit noHit() { return StrokeHit(0.0, vec3(0.0), 0.0, 0.0, 0.0); }\n\nvec2 rotateDir(vec2 dir, float angle) {\n  float ca = cos(angle), sa = sin(angle);\n  return vec2(dir.x * ca - dir.y * sa, dir.x * sa + dir.y * ca);\n}\n\nvec2 safeDir(vec2 dir) {\n  float len = length(dir);\n  return len > 1e-4 ? dir / len : vec2(1.0, 0.0);\n}\n\n// Shape profile along the stroke. type:\n//   0 tapered    — thin-fat-thin (classic brush)\n//   1 load-drag  — fat start, tapers to a point\n//   2 dab        — ellipse-like, round center\n//   3 even       — near-constant, slight end taper\nfloat strokeShape(float t, int type) {\n  t = clamp(t, 0.0, 1.0);\n  if (type == 1) {\n    // loaded at t=0, tapering\n    return pow(1.0 - t, 0.55) * smoothstep(0.0, 0.08, t);\n  } else if (type == 2) {\n    // dab / blob\n    float d = t - 0.5;\n    return exp(-d * d * 12.0);\n  } else if (type == 3) {\n    // mostly even, slight end softening\n    return smoothstep(0.0, 0.08, t) * smoothstep(1.0, 0.92, t) * 0.95 + 0.05;\n  }\n  // 0 tapered\n  return smoothstep(0.0, 0.22, t) * smoothstep(1.0, 0.78, t);\n}\n\n// A single curved stroke.\n//   a, b           — endpoints\n//   halfW          — base half-width (world units)\n//   bulge          — signed perpendicular midpoint offset, in world units\n//   shapeType      — 0..3\n//   bristleFreq    — spatial frequency of edge raggedness\n//   bristleAmp     — 0..0.5 fraction of halfW chewed away at edge extrema\n//   streakSeed     — uniqueness seed for internal streaks\n//   colAtMid       — pre-sampled color at midpoint\nStrokeHit curvedStroke(vec2 p, vec2 a, vec2 b, float halfW,\n                       float bulge, int shapeType,\n                       float bristleFreq, float bristleAmp,\n                       float streakSeed, vec3 colAtMid) {\n  vec2 ab = b - a;\n  float L = length(ab);\n  if (L < 1e-5) return noHit();\n  vec2 tang = ab / L;\n  vec2 norm = vec2(-tang.y, tang.x);\n\n  vec2 rel = p - a;\n  float along0 = dot(rel, tang) / L;      // straight projection 0..1 along AB\n  float cross0 = dot(rel, norm);          // signed cross\n\n  // Spine sideways offset due to bulge (parabolic)\n  float bend = 4.0 * bulge * along0 * (1.0 - along0);\n  float cross1 = cross0 - bend;\n\n  // One refinement step: as the spine bends, the closest-point along shifts.\n  // Spine tangent differs from straight tangent; first-order correction:\n  float dBend = 4.0 * bulge * (1.0 - 2.0 * along0);  // d(bend)/d(along)\n  float along1 = along0 + (cross1 * dBend) / (L * (1.0 + dBend * dBend / (L * L)));\n\n  // Bristle-ragged edge: half-width gets chewed by 1D noise along the spine\n  float edgeNoise = fbm(vec2(along1 * bristleFreq, streakSeed * 7.3)) - 0.5;\n  float edgeNoise2 = fbm(vec2(along1 * bristleFreq * 2.3, streakSeed * 3.1 + 17.0)) - 0.5;\n  float edgeMod = 1.0 - bristleAmp * (0.6 + 0.4 * edgeNoise) * (0.5 + edgeNoise2);\n\n  // Width profile along the stroke\n  float shape = strokeShape(along1, shapeType);\n  float halfWNow = halfW * shape * edgeMod;\n\n  // Inside-segment coverage\n  float cov = 0.0;\n  if (along1 >= 0.0 && along1 <= 1.0 && halfWNow > 1e-6) {\n    float cn = abs(cross1) / halfWNow;\n    // razor-hard edge with tiny aa\n    cov = 1.0 - smoothstep(0.88, 1.02, cn);\n  }\n\n  // End-cap blobs (rounded tips, not perpendicular cuts)\n  float capA = 0.0, capB = 0.0;\n  {\n    vec2 capCenterA = a + norm * (bulge * 0.0); // at a\n    vec2 capCenterB = a + tang * L + norm * bend * 0.0 + norm * 0.0; // at b; bend is 0 at endpoints\n    capCenterB = b;\n    float endShapeA = strokeShape(0.02, shapeType);\n    float endShapeB = strokeShape(0.98, shapeType);\n    float rA = halfW * endShapeA * (0.9 + 0.2 * fbm(vec2(streakSeed * 13.0)));\n    float rB = halfW * endShapeB * (0.9 + 0.2 * fbm(vec2(streakSeed * 19.0 + 5.0)));\n    float dA = length(p - capCenterA);\n    float dB = length(p - capCenterB);\n    capA = 1.0 - smoothstep(rA * 0.85, rA * 1.05, dA);\n    capB = 1.0 - smoothstep(rB * 0.85, rB * 1.05, dB);\n    // Only apply caps if we're BEYOND the segment; otherwise the segment wins.\n    capA *= (along1 < 0.05) ? 1.0 : 0.0;\n    capB *= (along1 > 0.95) ? 1.0 : 0.0;\n  }\n\n  float coverage = max(cov, max(capA, capB));\n  if (coverage < 0.002) return noHit();\n\n  // Edge distance (for impasto later): 0 at edge, 1 at spine\n  float edgeDist = halfWNow > 1e-6 ? clamp(1.0 - abs(cross1) / halfWNow, 0.0, 1.0) : 0.0;\n\n  return StrokeHit(\n    coverage,\n    colAtMid,\n    clamp(along1, 0.0, 1.0),\n    halfWNow > 1e-6 ? cross1 / halfWNow : 0.0,\n    edgeDist\n  );\n}\n\n// Composite stroke over col with internal streaking + impasto edge highlight.\n//   streakAmp    — 0..0.2 how much internal streaks darken/lighten\n//   impastoAmp   — 0..1 edge catch-light strength\n//   hardness     — 0..1 how crisp the compositing transition is (1 = razor, 0 = creamy)\nvoid paintOver(inout vec3 col, StrokeHit s, float streakFreq, float streakAmp,\n               float impastoAmp, float hardness, float streakSeed) {\n  if (s.coverage < 0.002) return;\n  float strokeOpacity = clamp(uStrokeAmount, 0.0, 1.0);\n  if (strokeOpacity <= 0.001) return;\n  vec3 c = s.color;\n\n  // Internal streaks — fbm along spine, modulated by cross position. Gives\n  // the loaded-brush look: some bristles carry more pigment than others.\n  float streakA = fbm(vec2(s.alongT * streakFreq, s.crossN * 2.7 + streakSeed));\n  float streakB = fbm(vec2(s.alongT * streakFreq * 0.6 + streakSeed * 3.7, s.crossN * 4.1));\n  float streak = 0.6 * (streakA - 0.5) + 0.4 * (streakB - 0.5);\n  c *= 1.0 + streak * streakAmp * 2.0;\n\n  // Subtle value variance across width (hollow-center catch-light)\n  float crossShade = smoothstep(0.0, 0.4, s.edgeN) * (1.0 - smoothstep(0.65, 1.0, s.edgeN));\n  c *= 1.0 + crossShade * 0.05;\n\n  // Impasto edge highlight — bright rim on one side of the stroke\n  float rim = smoothstep(0.85, 1.0, 1.0 - s.edgeN) * step(0.0, s.crossN);\n  c += impastoAmp * rim * vec3(0.18, 0.15, 0.11);\n  // Shadow on the other side (darker, cooler)\n  float shadow = smoothstep(0.85, 1.0, 1.0 - s.edgeN) * step(0.0, -s.crossN);\n  c -= impastoAmp * shadow * 0.25 * vec3(0.10, 0.09, 0.07);\n\n  float softLimit = mix(0.35, 0.98, hardness);\n  float alpha = smoothstep(0.0, 1.0 - softLimit, s.coverage) * strokeOpacity;\n  col = mix(col, c, alpha);\n}\n\n// Best-of-9-neighbor placement: sample 3x3 surrounding cells and take the\n// stroke that covers this pixel most. Breaks the grid by per-cell jitter and\n// sparse density via noise thresholding.\nStrokeHit bestOil(vec2 p, float cellSize, float lenMul, float halfWMul,\n                  float jitterAmt, float density, int shapeType,\n                  float bristleAmp, vec2 flow, float t, float seed) {\n  vec2 cell = floor(p / cellSize);\n\n  StrokeHit best = noHit();\n  // 3x3 neighborhood\n  for (int dy = -1; dy <= 1; dy++) {\n    for (int dx = -1; dx <= 1; dx++) {\n      vec2 cc = cell + vec2(float(dx), float(dy));\n      vec2 hh = hash22(cc + seed) - 0.5;\n      // Density gate — noise threshold; sparse placement.\n      float gate = hash21(cc * 1.7 + seed * 0.3);\n      if (gate > density) continue;\n\n      vec2 center = (cc + 0.5 + hh * jitterAmt) * cellSize;\n\n      // Per-stroke direction: consume the layer-provided flow, then add only\n      // deterministic local perturbation so alternate stroke layers stay live.\n      vec2 f = safeDir(flow);\n      float angJ = (hash21(cc + seed + 11.0) - 0.5) * 0.9;  // +/- 0.45 rad\n      float localCurl = (fbm(center * (2.6 + seed * 0.11) + seed * 1.9) - 0.5) * 0.55 * uFlowCurl;\n      vec2 dir = rotateDir(f, angJ + localCurl);\n\n      float lenV = cellSize * lenMul * (0.65 + 0.55 * hash21(cc + seed + 23.0));\n      float halfW = cellSize * halfWMul * (0.70 + 0.55 * hash21(cc + seed + 41.0));\n      float bulge = (hash21(cc + seed + 53.0) - 0.5) * lenV * 0.35;\n\n      vec2 a = center - dir * (lenV * 0.5);\n      vec2 b = center + dir * (lenV * 0.5);\n\n      vec3 colMid = brokenColorJitter(\n        sampleBase(center, t),\n        hash21(cc + seed + 89.0),\n        hash21(cc * 2.3 + seed + 97.0),\n        1.0\n      );\n\n      StrokeHit h = curvedStroke(p, a, b, halfW, bulge, shapeType,\n                                 7.0, bristleAmp,\n                                 hash21(cc + seed + 67.0), colMid);\n      if (h.coverage > best.coverage) best = h;\n    }\n  }\n  return best;\n}\n\n// ── Crayon / oil-pastel — paper tooth × wax pigment ───────────────────────\n// Crayon is not strokes. It's pigment crumbs dragged across paper tooth.\n// Model: heavy 2D tooth noise at multiple scales, anisotropically stretched\n// along flow direction, multiplied into the base color. Add a slow \"waxy\n// film\" that slightly unifies hues, and occasional darker \"pressed\" spots\n// where the crayon dug in. NO straight segments.\nvec3 mediumOil_crayon(vec3 col, vec2 p, float t) {\n  vec2 flow = flowField(p, t);\n  float ang = atan(flow.y, flow.x);\n  float ca = cos(-ang), sa = sin(-ang);\n  vec2 pr = vec2(p.x * ca - p.y * sa, p.x * sa + p.y * ca);\n\n  // Anisotropic tooth — squished along flow, coarse cross flow.\n  float aniso = mix(0.45, 0.95, uStrokeAnisotropy);\n  float scale = max(uStrokeScale * 1.6, 180.0);\n\n  float t1 = vnoise(vec2(pr.x * scale * aniso, pr.y * scale));\n  float t2 = vnoise(vec2(pr.x * scale * aniso * 0.4, pr.y * scale * 0.4) + 11.0);\n  float t3 = vnoise(vec2(pr.x * scale * aniso * 2.1, pr.y * scale * 2.1) + 23.0);\n  float tooth = 0.55 * t1 + 0.30 * t2 + 0.15 * t3;\n  // Center at 0, amplify\n  tooth = (tooth - 0.5) * 1.4;\n\n  // Multiplicative darkening where tooth is low (pigment skipped paper valleys)\n  float lay = 1.0 + tooth * 0.32 * uStrokeAmount;\n  vec3 result = col * lay;\n\n  // Occasional pressed-in crumbs — rare darker crumbs\n  float crumbs = smoothstep(0.78, 0.95, vnoise(pr * scale * 3.0));\n  result *= 1.0 - crumbs * 0.18 * uStrokeAmount;\n\n  // Waxy highlight film — slight lightening on tooth peaks\n  float waxy = smoothstep(0.55, 0.85, t1);\n  result += waxy * 0.04 * vec3(1.0);\n\n  // Paper tooth overlay (subtler than oil's canvas)\n  float paperTooth = vnoise(p * 340.0) - 0.5;\n  result *= 1.0 + paperTooth * 0.14 * uCanvasGrain;\n\n  // Broken-color pigment: stable wax/pigment patches, not temporal flicker.\n  vec2 pigmentCell = floor(pr * max(scale * 0.18, 32.0));\n  float pigmentMask = smoothstep(0.28, 0.82, vnoise(pr * scale * 0.21 + 19.0));\n  result = brokenColorJitter(\n    result,\n    hash21(pigmentCell + 17.0),\n    hash21(pigmentCell * 2.1 + 31.0),\n    0.45 + 0.55 * pigmentMask\n  );\n\n  // Crayon is saturation-amplified\n  result = saturate3(result, 1.12);\n\n  return result;\n}\n\nvec3 mediumOil(vec3 col, vec2 p, float t) {\n  // Mode knobs (uStrokeMode):\n  //   0 oil         — balanced modern-abstract/palette-knife hybrid\n  //   1 knife       — palette-knife impasto: razor edges, heavy bristle/shadow\n  //   2 crayon      — soft-edged wax smudges on tooth (no straight segments)\n  //   3 brushwork   — thick bristle brush\n  int mode = uStrokeMode;\n\n  // Per-mode parameters\n  int  shapeType   = 0;     // tapered\n  float bristleAmp = 0.25;  // 0..0.5\n  float streakFreq = 9.0;\n  float streakAmp  = 0.09;\n  float impastoAmp = 0.9;\n  float hardness   = 0.80;  // edge compositing\n  float toothScale = 240.0;\n  float toothAmp   = 0.09;\n  float pigmentSat = 1.03;\n  float densityBig = 0.65;\n  float densityMed = 0.78;\n  float densitySml = 0.90;\n\n  if (mode == 1) {        // palette knife\n    shapeType = 3;        // flat, even\n    bristleAmp = 0.12;\n    streakFreq = 4.0;  streakAmp = 0.05;\n    impastoAmp = 1.6;\n    hardness   = 0.95;\n    toothAmp   = 0.04;\n    densityBig = 0.80; densityMed = 0.88; densitySml = 0.70;\n  } else if (mode == 2) { // crayon — handled specially below\n    return mediumOil_crayon(col, p, t);\n  } else if (mode == 3) { // thick brushwork\n    shapeType = 0;        // tapered\n    bristleAmp = 0.32;\n    streakFreq = 14.0; streakAmp = 0.14;\n    impastoAmp = 1.2;\n    hardness   = 0.85;\n    toothAmp   = 0.07;\n  }\n\n  // Scales & multipliers from uniforms\n  float baseScale = max(uStrokeScale * 0.006, 0.008);\n  // Three layers: big gestural, medium body, small dabs\n  float sBig = baseScale * 2.4;\n  float sMed = baseScale * 1.1;\n  float sSml = baseScale * 0.45;\n\n  float lenMulBig = mix(2.2, 3.8, uStrokeAnisotropy);\n  float widMulBig = mix(0.55, 0.32, uStrokeAnisotropy);\n  float lenMulMed = mix(2.0, 3.4, uStrokeAnisotropy);\n  float widMulMed = mix(0.50, 0.30, uStrokeAnisotropy);\n  float lenMulSml = mix(1.6, 2.6, uStrokeAnisotropy);\n  float widMulSml = mix(0.45, 0.32, uStrokeAnisotropy);\n\n  float jitterAmt = 0.75;   // large jitter — no grid\n  vec2 flow = flowField(p, t);\n\n  vec3 result = col;\n\n  // Layer 1 — big gestural strokes (sparse, shaping)\n  StrokeHit hBig = bestOil(p, sBig, lenMulBig, widMulBig, jitterAmt * 0.55,\n                           densityBig, shapeType, bristleAmp, flow, t, 1.3);\n  paintOver(result, hBig, streakFreq * 0.7, streakAmp,\n            uImpasto * impastoAmp * uStrokeAmount, hardness, 1.3);\n\n  // Layer 2 — medium body strokes\n  StrokeHit hMed = bestOil(p + vec2(11.3, 3.7), sMed, lenMulMed, widMulMed,\n                           jitterAmt, densityMed, shapeType, bristleAmp, flow, t, 2.7);\n  paintOver(result, hMed, streakFreq, streakAmp,\n            uImpasto * impastoAmp * uStrokeAmount, hardness, 2.7);\n\n  // Layer 3 — small dabs (more frequent, smaller)\n  int smlShape = (mode == 1) ? 2 : shapeType; // knife uses dabs for sparkle\n  StrokeHit hSml = bestOil(p + vec2(-5.1, 8.4), sSml, lenMulSml, widMulSml,\n                           jitterAmt * 1.3, densitySml, smlShape,\n                           bristleAmp * 0.85, flow, t, 4.1);\n  paintOver(result, hSml, streakFreq * 1.4, streakAmp * 0.8,\n            uImpasto * impastoAmp * 0.65 * uStrokeAmount, hardness, 4.1);\n\n  // Layer 4 — fill dabs (very dense, very small) — covers bald spots\n  float sFill = baseScale * 0.22;\n  float lenMulFill = mix(1.4, 2.0, uStrokeAnisotropy);\n  float widMulFill = mix(0.50, 0.38, uStrokeAnisotropy);\n  int fillShape = (mode == 1) ? 3 : 2; // knife=even, others=dab (round fills)\n  StrokeHit hFill = bestOil(p + vec2(3.9, -6.2), sFill, lenMulFill, widMulFill,\n                            jitterAmt * 1.5, 0.95, fillShape,\n                            bristleAmp * 0.6, flow, t, 8.9);\n  paintOver(result, hFill, streakFreq * 1.8, streakAmp * 0.6,\n            uImpasto * impastoAmp * 0.4 * uStrokeAmount, hardness * 0.9, 8.9);\n\n  // Optional crosshatch layer\n  if (uStrokeLayers == 2) {\n    vec2 flow2 = vec2(-flow.y, flow.x);\n    StrokeHit hX = bestOil(p + vec2(7.3, -2.1), sMed, lenMulMed * 0.9, widMulMed,\n                           jitterAmt, densityMed * 0.7, shapeType, bristleAmp, flow2, t, 6.5);\n    paintOver(result, hX, streakFreq, streakAmp * 0.85,\n              uImpasto * impastoAmp * 0.55 * uStrokeAmount, hardness, 6.5);\n  }\n\n  // Canvas tooth — linen weave\n  float tooth1 = vnoise(p * toothScale);\n  float tooth2 = vnoise(p * toothScale * vec2(0.6, 2.4) + 37.0);\n  float tooth  = (0.6 * tooth1 + 0.4 * tooth2) - 0.5;\n  result *= 1.0 + tooth * toothAmp * uCanvasGrain;\n\n  // Pigment saturation boost\n  result = saturate3(result, pigmentSat);\n\n  return result;\n}\n\n// ── Main ──────────────────────────────────────────────────────────────────\nvoid main() {\n  // Normalized 0..1 coordinates for nuclei, domain warp, and medium sampling.\n  vec2 uv = vUv;\n  vec2 pN = uv;\n\n  float t = uTime;\n\n  // Warp in pN space\n  vec2 p_warp = domainWarp(pN, t);\n\n  // Composition\n  float paletteId; float valueMod;\n  nucleiField(p_warp, t, paletteId, valueMod);\n  vec3 col = samplePalette(paletteId);\n  col *= 1.0 + uValueVariance * valueMod;\n\n  // Breath — slow global luminance wobble\n  float breath = sin(t * 6.2831 / max(uBreathPeriod, 1.0));\n  col *= 1.0 + uBreathDepth * breath * 0.5;\n\n  // Medium\n  if (uMedium == 1) col = mediumPastel(col, pN, t);\n  else if (uMedium == 2) col = mediumWatercolor(col, pN, t);\n  else if (uMedium == 3) col = mediumOil(col, pN, t);\n\n  // Saturation trim\n  col = saturate3(col, uSaturation);\n\n  // Tonemap + film grain\n  col = aces(col);\n  float grain = hash21(gl_FragCoord.xy + t * 17.0);\n  col += (grain - 0.5) * uPaperGrain;\n\n  col = clamp(col * 0.985 + 0.008, 0.0, 1.0);\n  fragColor = vec4(col * uAlpha, uAlpha);\n}\n";
+//#endregion
+//#region src/components/custom/aurora/composables/color.ts
+function b(e, t, n) {
+	return e < t ? t : e > n ? n : e;
+}
+function x(e) {
+	return e <= .04045 ? e / 12.92 : ((e + .055) / 1.055) ** 2.4;
+}
+function S(e) {
+	return e <= .0031308 ? 12.92 * e : 1.055 * e ** (1 / 2.4) - .055;
+}
+function C(e, t, n) {
+	let r = x(e), i = x(t), a = x(n), o = Math.cbrt(.4122214708 * r + .5363325363 * i + .0514459929 * a), s = Math.cbrt(.2119034982 * r + .6806995451 * i + .1073969566 * a), c = Math.cbrt(.0883024619 * r + .2817188376 * i + .6299787005 * a);
+	return [
+		.2104542553 * o + .793617785 * s - .0040720468 * c,
+		1.9779984951 * o - 2.428592205 * s + .4505937099 * c,
+		.0259040371 * o + .7827717662 * s - .808675766 * c
+	];
+}
+function w(e, t, n) {
+	return [
+		e,
+		Math.sqrt(t * t + n * n),
+		(Math.atan2(n, t) * 180 / Math.PI + 360) % 360
+	];
+}
+function T(e, t, n) {
+	let r = n * Math.PI / 180;
+	return [
+		e,
+		t * Math.cos(r),
+		t * Math.sin(r)
+	];
+}
+function E(e, t, n) {
+	let r = e + .3963377774 * t + .2158037573 * n, i = e - .1055613458 * t - .0638541728 * n, a = e - .0894841775 * t - 1.291485548 * n, o = r * r * r, s = i * i * i, c = a * a * a;
+	return [
+		4.0767416621 * o - 3.3077115913 * s + .2309699292 * c,
+		-1.2684380046 * o + 2.6097574011 * s - .3413193965 * c,
+		-.0041960863 * o - .7034186147 * s + 1.707614701 * c
+	];
+}
+function D(e, t, n) {
+	let [r, i, a] = E(e, t, n);
+	return [
+		b(Math.round(S(r) * 255), 0, 255),
+		b(Math.round(S(i) * 255), 0, 255),
+		b(Math.round(S(a) * 255), 0, 255)
+	];
+}
+function O(e, t, n) {
+	let [r, i, a] = C(e / 255, t / 255, n / 255);
+	return w(r, i, a);
+}
+function k(e, t, n) {
+	let [r, i, a] = T(e, t, n);
+	return D(r, i, a);
+}
+function A(e) {
+	let [t, n, r] = T(e.L, e.C, e.h), [i, a, o] = E(t, n, r);
+	return [
+		Math.max(0, i),
+		Math.max(0, a),
+		Math.max(0, o)
+	];
+}
+function j(e, t = 8, n) {
+	let r = n ?? new Float32Array(t * 3), i = Math.min(e.length, t);
+	for (let t = 0; t < i; t++) {
+		let [n, i, a] = A(e[t]);
+		r[t * 3 + 0] = n, r[t * 3 + 1] = i, r[t * 3 + 2] = a;
+	}
+	for (let e = i; e < t; e++) r[e * 3 + 0] = 0, r[e * 3 + 1] = 0, r[e * 3 + 2] = 0;
+	return r;
+}
+function M(e) {
+	if (e.length === 0) return "transparent";
+	if (e.length === 1) return N(e[0]);
+	let t = e.length;
+	return `linear-gradient(135deg, ${e.map((e, n) => {
+		let r = Math.round(n / (t - 1) * 100);
+		return `${N(e)} ${r}%`;
+	}).join(", ")})`;
+}
+function N(e) {
+	let [t, n, r] = k(e.L, e.C, e.h), i = (e) => e.toString(16).padStart(2, "0");
+	return `#${i(t)}${i(n)}${i(r)}`;
+}
+function P(e) {
+	let t = e.replace("#", ""), [n, r, i] = O(parseInt(t.slice(0, 2), 16), parseInt(t.slice(2, 4), 16), parseInt(t.slice(4, 6), 16));
+	return {
+		L: n,
+		C: r,
+		h: i
+	};
+}
+var F = null;
+function I(e) {
+	if (!F) {
+		let e = document.createElement("canvas");
+		e.width = e.height = 1, F = e.getContext("2d", { willReadFrequently: !0 });
+	}
+	F.clearRect(0, 0, 1, 1), F.fillStyle = "#808080", F.fillStyle = e, F.fillRect(0, 0, 1, 1);
+	let t = F.getImageData(0, 0, 1, 1).data;
+	return [
+		t[0],
+		t[1],
+		t[2]
+	];
+}
+function L(e) {
+	let [t, n, r] = I(e), [i, a, o] = O(t, n, r);
+	return {
+		L: i,
+		C: a,
+		h: o
+	};
+}
+//#endregion
+//#region src/components/custom/aurora/composables/runtime.ts
+var R = {
+	smooth: 0,
+	pastel: 1,
+	watercolor: 2,
+	oil: 3
+}, z = {
+	none: 0,
+	radial: 1,
+	swirl: 2,
+	diagonal: 3,
+	multi: 4
+}, B = {
+	fbm: 0,
+	cellular: 1,
+	hybrid: 2
+}, V = {
+	oil: 0,
+	knife: 1,
+	crayon: 2,
+	chunky: 3
+}, H = .22, U = .18, W = .992;
+function G(e) {
+	return e.mode === "capture" ? !0 : e.initStrategy === "eager";
+}
+function K(e) {
+	return typeof e.preserveDrawingBuffer == "boolean" ? e.preserveDrawingBuffer : e.mode === "capture";
+}
+function q(e, t, n) {
+	let r = e.createShader(t);
+	if (e.shaderSource(r, n), e.compileShader(r), !e.getShaderParameter(r, e.COMPILE_STATUS)) {
+		let t = e.getShaderInfoLog(r) ?? "unknown";
+		throw e.deleteShader(r), Error(`[Aurora] shader compile failed:\n${t}`);
+	}
+	return r;
+}
+function J(e, t, n) {
+	let r = e.createProgram();
+	if (e.attachShader(r, t), e.attachShader(r, n), e.linkProgram(r), !e.getProgramParameter(r, e.LINK_STATUS)) {
+		let t = e.getProgramInfoLog(r) ?? "unknown";
+		throw e.deleteProgram(r), Error(`[Aurora] program link failed:\n${t}`);
+	}
+	return r;
+}
+var Y = /* @__PURE__ */ "uTime.uPalette.uStopCount.uNucleiCount.uNucleiPos.uNucleiRadius.uNucleiPaletteBias.uNucleiValueBias.uNucleiDriftRadius.uNucleiDriftPhase.uNucleiElong.uNucleiAngle.uSoftmaxBeta.uValueVariance.uWarpAmount.uWarpScale.uWarpDrift.uWarpMode.uNoiseOctaves.uMedium.uFlowPattern.uFlowFocal.uFlowAngle.uFlowCurl.uCursor.uCursorStrength.uCursorRadius.uStrokeAmount.uStrokeScale.uStrokeAnisotropy.uStrokeLayers.uStrokeMode.uWetEdge.uGranulation.uImpasto.uBrokenColor.uCanvasGrain.uNucleiDrift.uPaletteDrift.uBreathDepth.uBreathPeriod.uSaturation.uPaperGrain.uAlpha".split(".");
+function X(e, t, n = {}) {
+	let r = K(n), i = t, a = n.mode !== "capture", o = typeof window < "u" && window.matchMedia ? window.matchMedia("(prefers-reduced-motion: reduce)").matches : !1, s = performance.now(), c = {
+		x: .5,
+		y: .5,
+		targetX: .5,
+		targetY: .5,
+		strength: 0,
+		targetStrength: 0,
+		radius: .25
+	}, l = null, u = !1;
+	function d(e, t, n = .8) {
+		c.targetX = e, c.targetY = t, c.targetStrength = n;
+	}
+	function f() {
+		c.targetStrength = 0;
+	}
+	function p(e) {
+		c.radius = e;
+	}
+	function m(e) {
+		o = e;
+	}
+	function h() {
+		if (l || u) return;
+		let t = e.getContext("webgl2", {
+			antialias: !1,
+			alpha: !0,
+			premultipliedAlpha: !0,
+			preserveDrawingBuffer: r
+		});
+		if (!t) throw Error("[Aurora] WebGL2 unavailable");
+		let n = q(t, t.VERTEX_SHADER, v), d = q(t, t.FRAGMENT_SHADER, y), f = J(t, n, d);
+		t.useProgram(f);
+		let p = t.createVertexArray();
+		t.bindVertexArray(p);
+		let m = t.createBuffer();
+		t.bindBuffer(t.ARRAY_BUFFER, m), t.bufferData(t.ARRAY_BUFFER, new Float32Array([
+			-1,
+			-1,
+			3,
+			-1,
+			-1,
+			3
+		]), t.STATIC_DRAW);
+		let h = t.getAttribLocation(f, "aPos");
+		t.enableVertexAttribArray(h), t.vertexAttribPointer(h, 2, t.FLOAT, !1, 0, 0);
+		let g = {};
+		for (let e of Y) g[e] = t.getUniformLocation(f, e);
+		function _() {
+			let n = Math.min(window.devicePixelRatio || 1, 2), r = e.clientWidth || e.parentElement?.clientWidth || 1, i = e.clientHeight || e.parentElement?.clientHeight || 1, a = Math.max(1, Math.floor(r * n)), o = Math.max(1, Math.floor(i * n));
+			e.width = a, e.height = o, t.viewport(0, 0, a, o), t.useProgram(f);
+		}
+		let b = new ResizeObserver(() => _());
+		b.observe(e), requestAnimationFrame(() => {
+			_(), requestAnimationFrame(_);
+		});
+		let x = {
+			palette: new Float32Array(24),
+			pos: new Float32Array(12),
+			rad: new Float32Array(6),
+			pb: new Float32Array(6),
+			vb: new Float32Array(6),
+			dr: new Float32Array(6),
+			dp: new Float32Array(6),
+			elong: new Float32Array(6),
+			angle: new Float32Array(6)
+		};
+		function S(e) {
+			i = e, t.useProgram(f), j(e.palette, 8, x.palette), t.uniform3fv(g.uPalette, x.palette), t.uniform1i(g.uStopCount, Math.min(e.palette.length, 8));
+			let n = Math.min(e.nuclei.length, 6);
+			t.uniform1i(g.uNucleiCount, n);
+			for (let t = 0; t < n; t++) {
+				let n = e.nuclei[t];
+				x.pos[t * 2 + 0] = n.x, x.pos[t * 2 + 1] = 1 - n.y, x.rad[t] = n.radius, x.pb[t] = n.paletteBias, x.vb[t] = n.valueBias, x.dr[t] = n.driftRadius, x.dp[t] = n.driftPhase, x.elong[t] = n.elongation ?? 1, x.angle[t] = -(n.angle ?? 0) * Math.PI / 180;
+			}
+			for (let e = n; e < 6; e++) x.pos[e * 2 + 0] = 0, x.pos[e * 2 + 1] = 0, x.rad[e] = 0, x.pb[e] = 0, x.vb[e] = 0, x.dr[e] = 0, x.dp[e] = 0, x.elong[e] = 1, x.angle[e] = 0;
+			t.uniform2fv(g.uNucleiPos, x.pos), t.uniform1fv(g.uNucleiRadius, x.rad), t.uniform1fv(g.uNucleiPaletteBias, x.pb), t.uniform1fv(g.uNucleiValueBias, x.vb), t.uniform1fv(g.uNucleiDriftRadius, x.dr), t.uniform1fv(g.uNucleiDriftPhase, x.dp), t.uniform1fv(g.uNucleiElong, x.elong), t.uniform1fv(g.uNucleiAngle, x.angle), t.uniform1f(g.uSoftmaxBeta, e.softmaxBeta), t.uniform1f(g.uValueVariance, e.valueVariance), t.uniform1f(g.uWarpAmount, e.warpAmount), t.uniform1f(g.uWarpScale, e.warpScale), t.uniform1f(g.uWarpDrift, e.warpDrift), t.uniform1i(g.uWarpMode, B[e.warpMode]), t.uniform1i(g.uNoiseOctaves, e.noiseOctaves), t.uniform1i(g.uMedium, R[e.medium]), t.uniform1i(g.uFlowPattern, z[e.flow.pattern]), t.uniform2f(g.uFlowFocal, e.flow.focalX, 1 - e.flow.focalY), t.uniform1f(g.uFlowAngle, e.flow.angle), t.uniform1f(g.uFlowCurl, e.flow.curl), t.uniform2f(g.uCursor, c.x, 1 - c.y), t.uniform1f(g.uCursorStrength, c.strength), t.uniform1f(g.uCursorRadius, c.radius), t.uniform1f(g.uStrokeAmount, e.strokeAmount), t.uniform1f(g.uStrokeScale, e.strokeScale), t.uniform1f(g.uStrokeAnisotropy, e.strokeAnisotropy), t.uniform1i(g.uStrokeLayers, e.strokeLayers), t.uniform1i(g.uStrokeMode, V[e.strokeMode]), t.uniform1f(g.uWetEdge, e.wetEdge), t.uniform1f(g.uGranulation, e.granulation), t.uniform1f(g.uImpasto, e.impasto), t.uniform1f(g.uBrokenColor, e.brokenColor), t.uniform1f(g.uCanvasGrain, e.canvasGrain), t.uniform1f(g.uNucleiDrift, e.nucleiDrift), t.uniform1f(g.uPaletteDrift, e.paletteDrift), t.uniform1f(g.uBreathDepth, e.breathDepth), t.uniform1f(g.uBreathPeriod, e.breathPeriod), t.uniform1f(g.uSaturation, e.saturation), t.uniform1f(g.uPaperGrain, e.paperGrain), t.uniform1f(g.uAlpha, e.alpha);
+		}
+		S(i), _(), t.clearColor(0, 0, 0, 0), t.disable(t.DEPTH_TEST), t.enable(t.BLEND), t.blendFunc(t.ONE, t.ONE_MINUS_SRC_ALPHA);
+		let C = 0;
+		function w() {
+			c.x += (c.targetX - c.x) * H, c.y += (c.targetY - c.y) * H, c.strength += (c.targetStrength - c.strength) * U, c.targetStrength *= W;
+		}
+		function T(e) {
+			t.useProgram(f), t.uniform2f(g.uCursor, c.x, 1 - c.y), t.uniform1f(g.uCursorStrength, c.strength), t.uniform1f(g.uCursorRadius, c.radius), t.uniform1f(g.uTime, e), t.clear(t.COLOR_BUFFER_BIT), t.drawArrays(t.TRIANGLES, 0, 3);
+		}
+		function E() {
+			if (!a) return;
+			let e = o ? 3.7 : (performance.now() - s) / 1e3;
+			w(), T(e), C = requestAnimationFrame(E);
+		}
+		a && (C = requestAnimationFrame(E));
+		function D(e) {
+			T(e);
+		}
+		function O() {
+			a = !1, cancelAnimationFrame(C);
+		}
+		function k() {
+			a || (a = !0, s = performance.now() - 1e3, E());
+		}
+		function A() {
+			a = !1, cancelAnimationFrame(C), b.disconnect(), t.deleteProgram(f), t.deleteShader(n), t.deleteShader(d), t.deleteBuffer(m), t.deleteVertexArray(p);
+			let e = t.getExtension("WEBGL_lose_context");
+			e && e.loseContext();
+		}
+		l = {
+			setConfig: S,
+			renderAt: D,
+			pause: O,
+			resume: k,
+			dispose: A
+		};
+	}
+	return G(n) && h(), {
+		arm: h,
+		update: (e) => {
+			i = e, l?.setConfig(e);
+		},
+		setCursor: d,
+		clearCursor: f,
+		setCursorRadius: p,
+		setReducedMotion: m,
+		pause: () => {
+			a = !1, l?.pause();
+		},
+		resume: () => {
+			a = !0, l?.resume();
+		},
+		renderAt: (e) => l?.renderAt(e),
+		dispose: () => {
+			l ? l.dispose() : u = !0;
+		}
+	};
+}
+//#endregion
+//#region src/components/custom/aurora/composables/configSource.ts
+function Z(e) {
+	return typeof e == "function" ? e : e && typeof e == "object" && "value" in e ? () => e.value : () => e;
+}
+//#endregion
+//#region src/components/custom/aurora/composables/useAurora.ts
+function ee(e) {
+	if (typeof window > "u") return () => {};
+	if (typeof window.requestIdleCallback == "function") {
+		let t = window.requestIdleCallback(() => e(), { timeout: 2e3 });
+		return () => window.cancelIdleCallback?.(t);
+	}
+	let t = 0, n, r = !1;
+	return t = requestAnimationFrame(() => {
+		r || (t = requestAnimationFrame(() => {
+			r || (n = setTimeout(() => {
+				r || e();
+			}, 0));
+		}));
+	}), () => {
+		r = !0, cancelAnimationFrame(t), n !== void 0 && clearTimeout(n);
+	};
+}
+function Q(e, t, n = {}, r = {}) {
+	let a = Z(t), o = r.renderMode === "css", s = null, c = null, l = null, u = null, p = null, g = null, v = !1, y = h(!1), b = n.mode === "capture" || n.initStrategy === "eager";
+	function x() {
+		g && s && s.setReducedMotion(g.matches);
+	}
+	function S(e) {
+		let t = e instanceof Error ? e : Error(String(e));
+		if (n.onInitError) {
+			n.onInitError(t);
+			return;
+		}
+		Promise.reject(t);
+	}
+	function C() {
+		if (!(v || !s)) {
+			v = !0;
+			try {
+				s.arm();
+			} catch (e) {
+				S(e);
+				return;
+			}
+			y.value = !0, g = window.matchMedia("(prefers-reduced-motion: reduce)"), g.addEventListener("change", x), c = _(a, (e) => s?.update(e), { deep: !0 });
+		}
+	}
+	return f(() => {
+		let t = e.value;
+		if (!t || o) return;
+		try {
+			s = X(t, a(), {
+				initStrategy: "deferred",
+				...n
+			});
+		} catch (e) {
+			S(e);
+			return;
+		}
+		if (b) {
+			C();
+			return;
+		}
+		p = i(e, {
+			pause: () => s?.pause(),
+			resume: () => s?.resume()
+		});
+		let r = p.isIntersecting;
+		l = _(r, (e) => {
+			!e || v || u || (u = ee(() => {
+				u = null, r.value && C();
+			}));
+		}, { immediate: !0 });
+	}), d(() => {
+		u?.(), l?.(), c?.(), p?.dispose(), g?.removeEventListener("change", x), s?.dispose(), s = null;
+	}), {
+		setCursor: (e, t, n) => s?.setCursor(e, t, n),
+		clearCursor: () => s?.clearCursor(),
+		setCursorRadius: (e) => s?.setCursorRadius(e),
+		renderAt: (e) => s?.renderAt(e),
+		pause: () => s?.pause(),
+		resume: () => s?.resume(),
+		isArmed: m(y)
+	};
+}
+//#endregion
+//#region src/components/custom/aurora/renderMode.ts
+function $(e) {
+	if (e !== "auto") return e;
+	if (typeof navigator > "u" || typeof window > "u") return "webgl";
+	let t = typeof navigator.hardwareConcurrency == "number" && navigator.hardwareConcurrency <= 4, n = typeof window.matchMedia == "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches, r = navigator.connection?.saveData === !0;
+	return t || n || r ? "css" : "webgl";
+}
+//#endregion
+//#region src/components/custom/aurora/Aurora.vue
+var te = /* @__PURE__ */ e(/* @__PURE__ */ c({
+	__name: "Aurora",
+	props: {
+		config: { default: () => r },
+		runtimeOptions: {},
+		onInitError: {},
+		renderMode: { default: "auto" },
+		opacityCeiling: { default: 1 }
+	},
+	setup(e, { expose: t }) {
+		let n = e, r = $(n.renderMode), i = a(() => Math.max(0, Math.min(1, n.opacityCeiling))), c = h(null), d = Q(c, () => n.config, a(() => ({
+			...n.runtimeOptions ?? {},
+			...n.onInitError ? { onInitError: n.onInitError } : {}
+		})).value, { renderMode: r }), f = a(() => M(n.config.palette));
+		return t({
+			config: n.config,
+			canvasRef: c,
+			setCursor: d.setCursor,
+			clearCursor: d.clearCursor,
+			setCursorRadius: d.setCursorRadius,
+			renderAt: d.renderAt,
+			pause: d.pause,
+			resume: d.resume,
+			isArmed: d.isArmed
+		}), (e, t) => (p(), o("div", {
+			class: "aurora-root block h-full w-full overflow-hidden",
+			style: u({ "--aurora-opacity-ceiling": i.value })
+		}, [s("div", {
+			class: "aurora-placeholder h-full w-full",
+			"aria-hidden": "true",
+			style: u({ backgroundImage: f.value })
+		}, null, 4), s("canvas", {
+			ref_key: "canvasRef",
+			ref: c,
+			"aria-hidden": "true",
+			class: l(["aurora-canvas block h-full w-full", { "aurora-canvas--armed": g(d).isArmed.value }])
+		}, null, 2)], 4));
+	}
+}), [["__scopeId", "data-v-80ea8f7d"]]);
+//#endregion
+//#region src/components/custom/aurora/composables/useCursorInteraction.ts
+function ne(e, t, n) {
+	let r = Z(t), i = n.hitFraction ?? .35, a = null, o = null;
+	function s(e, t) {
+		let n = t.getBoundingClientRect();
+		return {
+			x: (e.clientX - n.left) / Math.max(n.width, 1),
+			y: (e.clientY - n.top) / Math.max(n.height, 1)
+		};
+	}
+	function c(e, t, n) {
+		let r = t - e.x, i = n - e.y, a = (e.angle ?? 0) * Math.PI / 180, o = Math.cos(a), s = Math.sin(a), c = o * r + s * i, l = -s * r + o * i, u = c / Math.max(e.elongation ?? 1, .01), d = l;
+		return u * u + d * d;
+	}
+	function l(e, t) {
+		let n = null, a = Infinity;
+		for (let o = 0; o < r().nuclei.length; o++) {
+			let s = r().nuclei[o], l = c(s, e, t), u = s.radius * i;
+			l < u * u && l < a && (a = l, n = o);
+		}
+		return n;
+	}
+	function u(e, t) {
+		let n = 0, i = 0;
+		for (let a of r().nuclei) {
+			let o = c(a, e, t), s = Math.max(a.radius, .01), l = Math.exp(-r().softmaxBeta * o / (s * s));
+			n += l * a.paletteBias, i += l;
+		}
+		return i > 1e-4 ? n / i : .5;
+	}
+	function p() {
+		if (r().nuclei.length === 0) return .5;
+		let e = r().nuclei.map((e) => e.radius).sort((e, t) => e - t);
+		return e[Math.floor(e.length / 2)];
+	}
+	function m(e, t) {
+		return {
+			x: e,
+			y: t,
+			radius: p(),
+			paletteBias: u(e, t),
+			valueBias: 0,
+			driftRadius: .012,
+			driftPhase: Math.random() * Math.PI * 2
+		};
+	}
+	function h(t) {
+		let i = e.value;
+		if (!i) return;
+		let { x: o, y: c } = s(t, i);
+		a !== null && (r().nuclei[a].x = Math.max(0, Math.min(1, o)), r().nuclei[a].y = Math.max(0, Math.min(1, c))), n.setCursor(o, c, 1);
+	}
+	function g() {
+		a === null && n.clearCursor();
+	}
+	function _(t) {
+		let n = e.value;
+		if (!n) return;
+		let { x: i, y: c } = s(t, n), u = l(i, c);
+		if (t.altKey && u === null) {
+			if (r().nuclei.length >= 6) return;
+			r().nuclei.push(m(i, c)), t.preventDefault();
+			return;
+		}
+		if ((t.shiftKey || t.button === 2) && u !== null) {
+			if (r().nuclei.length <= 1) return;
+			r().nuclei.splice(u, 1), t.preventDefault();
+			return;
+		}
+		u !== null && t.button === 0 && (a = u, o = t.pointerId, n.setPointerCapture(t.pointerId), t.preventDefault());
+	}
+	function v(t) {
+		let n = e.value;
+		if (n && o !== null && t.pointerId === o) {
+			try {
+				n.releasePointerCapture(t.pointerId);
+			} catch {}
+			o = null, a = null;
+		}
+	}
+	function y(t) {
+		let n = e.value;
+		if (!n) return;
+		let i = {
+			clientX: t.clientX,
+			clientY: t.clientY
+		}, a = n.getBoundingClientRect(), o = l((i.clientX - a.left) / Math.max(a.width, 1), (i.clientY - a.top) / Math.max(a.height, 1));
+		o !== null && r().nuclei.length > 1 && (r().nuclei.splice(o, 1), t.preventDefault());
+	}
+	return f(() => {
+		let t = e.value;
+		t && (t.addEventListener("pointermove", h), t.addEventListener("pointerleave", g), t.addEventListener("pointerdown", _), t.addEventListener("pointerup", v), t.addEventListener("pointercancel", v), t.addEventListener("contextmenu", y));
+	}), d(() => {
+		let t = e.value;
+		t && (t.removeEventListener("pointermove", h), t.removeEventListener("pointerleave", g), t.removeEventListener("pointerdown", _), t.removeEventListener("pointerup", v), t.removeEventListener("pointercancel", v), t.removeEventListener("contextmenu", y));
+	}), { isDragging: () => a };
+}
+//#endregion
+export { te as Aurora, r as DEFAULT_AURORA_CONFIG, t as MAX_NUCLEI, n as MAX_STOPS, X as createAurora, L as cssToOklch, j as flattenPalette, P as hexToOklchStop, N as oklchStopToHex, A as oklchToLinear, M as paletteToCssGradient, $ as resolveRenderMode, Q as useAurora, ne as useCursorInteraction };

package/dist/badge-BbxVKZfw.js

@@ -0,0 +1,49 @@
+import { t as e } from "./cn-DJXf4yaB.js";
+import { createElementBlock as t, defineComponent as n, normalizeClass as r, openBlock as i, renderSlot as a, unref as o } from "vue";
+import { cva as s } from "class-variance-authority";
+//#endregion
+//#region src/components/ui/badge/Badge.vue
+var c = /* @__PURE__ */ n({
+	__name: "Badge",
+	props: {
+		variant: {},
+		size: {},
+		class: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] }
+	},
+	setup(n) {
+		let s = n;
+		return (c, u) => (i(), t("div", { class: r(o(e)(o(l)({
+			variant: n.variant,
+			size: n.size
+		}), s.class)) }, [a(c.$slots, "default")], 2));
+	}
+}), l = s("focus-ring inline-flex items-center rounded-badge border font-semibold transition-colors", {
+	variants: {
+		variant: {
+			default: "border-transparent bg-primary text-primary-foreground hover:bg-primary/80",
+			secondary: "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
+			destructive: "border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80",
+			outline: "text-foreground",
+			success: "border-transparent bg-success text-success-foreground hover:bg-success/80",
+			warning: "border-transparent bg-warning text-warning-foreground hover:bg-warning/80",
+			info: "border-transparent bg-info text-info-foreground hover:bg-info/80"
+		},
+		size: {
+			sm: "text-xs leading-4 px-2 py-0.5",
+			md: "text-sm leading-5 px-2.5 py-1",
+			lg: "text-base leading-6 px-3 py-1.5"
+		}
+	},
+	defaultVariants: {
+		variant: "default",
+		size: "md"
+	}
+});
+//#endregion
+export { c as n, l as t };

package/dist/badge.d.ts

@@ -0,0 +1 @@
+export * from "./components/ui/badge";

package/dist/badge.js

@@ -0,0 +1,2 @@
+import { n as e, t } from "./badge-BbxVKZfw.js";
+export { e as Badge, t as badgeVariants };