voice-ring 0.0.0-stage → 0.1.0

package/dist/index.es.js

@@ -0,0 +1,1186 @@
+import { jsx as In } from "react/jsx-runtime";
+import { useState as _t, useEffect as kt, useRef as Rt, useCallback as En } from "react";
+let qt = null;
+function Nn() {
+  if (typeof window > "u") return null;
+  const t = window;
+  return t.AudioContext ?? t.webkitAudioContext ?? null;
+}
+function ce() {
+  return Nn() != null;
+}
+function Bn() {
+  const t = Nn();
+  return t ? (qt || (qt = new t()), qt.state === "suspended" && qt.resume().catch(() => {
+  }), qt) : null;
+}
+const en = /* @__PURE__ */ new WeakMap();
+function ts(t) {
+  const n = Bn();
+  if (!n || t.getAudioTracks().length === 0) return null;
+  let e = en.get(t);
+  e || (e = { node: n.createMediaStreamSource(t), refs: 0 }, en.set(t, e)), e.refs += 1;
+  const s = n.createAnalyser();
+  s.fftSize = 1024, s.smoothingTimeConstant = 0.5, e.node.connect(s);
+  let o = !1;
+  return {
+    analyser: s,
+    release: () => {
+      if (!o) {
+        o = !0;
+        try {
+          e.node.disconnect(s);
+        } catch {
+        }
+        if (e.refs -= 1, e.refs <= 0) {
+          try {
+            e.node.disconnect();
+          } catch {
+          }
+          en.delete(t);
+        }
+      }
+    }
+  };
+}
+const Ht = {
+  positive: { r: 92, g: 224, b: 150 },
+  negative: { r: 255, g: 104, b: 104 },
+  calm: { r: 104, g: 162, b: 255 }
+}, ns = {
+  green: Ht.positive,
+  red: Ht.negative,
+  blue: Ht.calm
+}, ss = 0.7, es = 1.1, os = 0.6;
+class as {
+  constructor() {
+    this.glow = { r: 0, g: 0, b: 0, amount: 0, t: 0, size: 0 };
+  }
+  /** Advance toward `target` (null: fade out). `still` jumps straight there. */
+  step(n, e, s, o, r) {
+    const c = this.glow, l = (a) => r ? 1 : 1 - Math.exp(-n / a), i = e ? 1 : 0;
+    if (c.amount += (i - c.amount) * l(i > c.amount ? ss : es), e) {
+      const a = c.amount < 0.03 ? 1 : l(os);
+      c.r += (e.r - c.r) * a, c.g += (e.g - c.g) * a, c.b += (e.b - c.b) * a;
+    }
+    return c.t = s, c.size = o, c;
+  }
+}
+const dt = {
+  move: 2,
+  pull: 0.7,
+  deform: 0.1,
+  squash: 0.5,
+  lens: 0.67,
+  stretch: 1,
+  split: 1,
+  blur: 1,
+  bounce: 1
+};
+function cs(t, n) {
+  const e = Math.abs(t.move) + Math.abs(t.pull) + 2 * Math.abs(t.deform);
+  return e === 0 ? 0 : Math.ceil(n * 0.36 * e) + 2;
+}
+class rs {
+  constructor() {
+    this.x = 0, this.v = 0, this.landed = !1;
+  }
+  /**
+   * How far the spring runs ahead of the press (+) or behind it (−). It
+   * lags as the orb arrives, but only a rebound counts as behind: the orb
+   * never backs off the edge before it has pressed into it.
+   */
+  step(n, e) {
+    const r = Math.max(1, Math.ceil(e * 240)), c = e / r;
+    for (let i = 0; i < r; i++)
+      this.v += (15 * 15 * (n - this.x) - 2 * 0.3 * 15 * this.v) * c, this.x += this.v * c;
+    const l = this.x - n;
+    return n <= 0 ? this.landed = !1 : l >= 0 && (this.landed = !0), l < 0 && !this.landed ? 0 : l;
+  }
+}
+function is(t, n, e, s, o = [1 / 0, 1 / 0], r = 0) {
+  if (Math.abs(n) < 2e-3 || s.move === 0 && s.pull === 0 && s.deform === 0) return t;
+  const c = e / 2, l = e * 0.36, i = n < 0 ? -1 : 1, a = Math.abs(n), M = (b, S) => {
+    const x = (b - c) / l, F = (S - c) / l, A = Math.max(0, Math.min(1, (x * i + 1) / 2)), B = Math.max(0, x * i);
+    return n * l * (s.move + s.pull * A * A + s.deform * B * B * Math.exp(-F * F * 1.5));
+  }, h = Math.max(0, Math.min(2, s.lens ?? 1)), f = l * 0.9, p = i > 0 ? o[1] : o[0], d = Number.isFinite(p) ? Math.min(f * 0.45, l * 0.3 * h * Math.max(0, s.stretch ?? 1)) : 0;
+  let m = 1, v = 1 / 0, _ = 1;
+  if (Number.isFinite(p)) {
+    v = i > 0 ? e + p : -p;
+    const b = (S, x, F) => {
+      _ = Math.max(_, F);
+      const A = M(S, x) * i;
+      A > 1e-9 && (m = Math.min(m, Math.max(0, ((v - S) * i - F - d) / A)));
+    };
+    for (const S of t.dots) b(S.x, S.y, S.r);
+    for (const S of t.strokes) for (let x = 0; x < S.pts.length; x += 2) b(S.pts[x], S.pts[x + 1], 1);
+  }
+  const u = m < 1 ? Math.min(1, (1 - m) / 0.35) : 0, g = u > 0 ? r * (s.bounce ?? 1) : 0, y = Math.min(1.4, u + Math.max(0, g)), N = l * 0.12 * Math.max(0, -g), T = v - i * _, z = T - i * d, w = l * 0.55 * y * (s.squash ?? 0);
+  let k = 1 / 0, P = -1 / 0, D = !0;
+  const O = (b, S) => {
+    const x = Math.max(0, Math.min(1, ((b - c) / l * i + 1) / 2)), F = 1 - 0.15 * s.deform * a * m * x;
+    let A = b + M(b, S) * m + i * (w * 0.5 - N), B = c + (S - c) * F;
+    if (w > 0) {
+      const C = (A - (z - i * w)) * i;
+      if (C > 0) {
+        const I = C / w, E = w * (I / Math.sqrt(1 + I * I));
+        A = z - i * w + i * E, B = c + (B - c) * (1 + 0.18 * y * (s.squash ?? 0) * (E / w));
+      }
+    }
+    return D && (z - A) * i < Math.max(w, f * 0.3) && (k = Math.min(k, B), P = Math.max(P, B)), [A, B];
+  };
+  for (const b of t.dots)
+    [b.x, b.y] = O(b.x, b.y);
+  for (const b of t.strokes)
+    for (let S = 0; S < b.pts.length; S += 2) {
+      const [x, F] = O(b.pts[S], b.pts[S + 1]);
+      b.pts[S] = x, b.pts[S + 1] = F;
+    }
+  if (u > 0 && P > k) {
+    const b = h * y;
+    t.contact = {
+      side: i,
+      x: T,
+      y0: k,
+      y1: P,
+      depth: w,
+      press: u,
+      lens: b > 0.02 ? {
+        zone: f,
+        // drawn across the gap as it presses, all the way at full press
+        gap: d * Math.min(1, y),
+        flare: 0.22 * b * Math.max(0, s.stretch ?? 1),
+        split: f * 0.1 * b * Math.max(0, s.split ?? 1),
+        blur: f * 0.075 * b * Math.max(0, s.blur ?? 1),
+        cy: c
+      } : void 0
+    };
+  }
+  if (D = !1, t.light) {
+    const b = t.light;
+    [b.cx, b.cy] = O(b.cx, b.cy);
+    for (const S of b.spec) [S.x, S.y] = O(S.x, S.y);
+  }
+  return t;
+}
+const ht = Math.PI * 2;
+function Et(t, n, e) {
+  return t + (n - t) * e;
+}
+function K(t) {
+  return t < 0 ? 0 : t > 1 ? 1 : t;
+}
+function pn(t, n, e) {
+  const s = K((e - t) / (n - t));
+  return s * s * (3 - 2 * s);
+}
+const Wt = (t) => t < 1e-6 ? 1 : Math.sin(t) / t, ls = Math.hypot(2.1, 1.3), hs = Math.hypot(1.9, 1.7), us = Math.hypot(4.3 - 2.9, -3.7, -3.1), fs = Math.hypot(4.3 + 2.9, 3.7, -3.1);
+function Mn(t, n, e, s = 1) {
+  const o = 1 / Math.max(0.05, s), r = 0.9 * e, c = -0.7 * e + 1.3, l = 2.1 * e, i = -1.6 * e, a = t * (0.55 * Math.sin(r) * Wt(ls * o) + 0.45 * Math.sin(c) * Wt(hs * o)) + n * 0.5 * (Math.cos(l - i) * Wt(us * o) - Math.cos(l + i) * Wt(fs * o));
+  return (M, h, f) => (M *= o, h *= o, f *= o, t * (0.55 * Math.sin(2.1 * M + 1.3 * h + r) + 0.45 * Math.sin(1.7 * f - 1.9 * h + c)) + n * Math.sin(4.3 * M - 3.1 * f + l) * Math.sin(3.7 * h + 2.9 * M + i) - a);
+}
+function xt(t, n) {
+  const e = Math.sin(t * 12.9898 + n * 78.233) * 43758.5453;
+  return e - Math.floor(e);
+}
+function yt(t, n, e) {
+  const s = Math.sin(t * 127.1 + n * 311.7 + e * 74.7) * 43758.5453;
+  return s - Math.floor(s);
+}
+function Gt(t, n, e) {
+  const s = Math.floor(t), o = Math.floor(n), r = Math.floor(e);
+  let c = t - s, l = n - o, i = e - r;
+  c = c * c * (3 - 2 * c), l = l * l * (3 - 2 * l), i = i * i * (3 - 2 * i);
+  const a = Et(yt(s, o, r), yt(s + 1, o, r), c), M = Et(yt(s, o + 1, r), yt(s + 1, o + 1, r), c), h = Et(yt(s, o, r + 1), yt(s + 1, o, r + 1), c), f = Et(yt(s, o + 1, r + 1), yt(s + 1, o + 1, r + 1), c);
+  return Et(Et(a, M, l), Et(h, f, l), i);
+}
+function mn(t, n) {
+  const e = Math.PI * (3 - Math.sqrt(5)), s = 1 - 2 * (t + 0.5) / n, o = Math.sqrt(1 - s * s), r = t * e;
+  return [o * Math.cos(r), s, o * Math.sin(r)];
+}
+function Yt(t, n, e, s, o) {
+  const r = Math.sin(n), c = Math.cos(n), l = Math.sin(t), i = Math.cos(t);
+  return (a, M, h) => {
+    const f = a * i + h * l, p = -a * l + h * i, d = M * c - p * r, m = M * r + p * c;
+    return [e + f * o, s - d * o, m];
+  };
+}
+function Lt(t, n = 0.6) {
+  return (t / 200) ** n;
+}
+function Ct(t, n, e = 0.3) {
+  const s = [];
+  for (const o of t)
+    (o.a ?? 1) < 0.02 || (o.r = Math.max(e, o.r), s.push(o));
+  return s.sort((o, r) => o.z - r.z), { dots: s, strokes: n };
+}
+const Xt = 32;
+function ds(t, n = 0, e = 0, s = 1) {
+  const o = t.r / 255, r = t.g / 255, c = t.b / 255, l = Math.max(o, r, c), i = Math.min(o, r, c);
+  let a = (l + i) / 2, M = l === i ? 0 : (l - i) / (1 - Math.abs(2 * a - 1)), h = 0;
+  if (l !== i) {
+    const m = l - i;
+    h = l === o ? (r - c) / m % 6 : l === r ? (c - o) / m + 2 : (o - r) / m + 4, h *= 60;
+  }
+  h = ((h + n) % 360 + 360) % 360, M = Math.min(1, M * (1 + e)), a = 0.5 + (a - 0.5) * (1 - 0.6 * e), a = Math.max(0, Math.min(1, a * s));
+  const f = (m) => (m + h / 30) % 12, p = M * Math.min(a, 1 - a), d = (m) => a - p * Math.max(-1, Math.min(f(m) - 3, 9 - f(m), 1));
+  return [Math.round(d(0) * 255), Math.round(d(8) * 255), Math.round(d(4) * 255)];
+}
+function ps(t) {
+  const n = Math.max(0, Math.min(1, t.saturation)), e = Math.max(0, Math.min(1, t.neutral)), s = t.start ?? 0.1, o = Math.max(0.05, t.width ?? 0.6), r = [];
+  for (let h = 0; h < Xt; h++) {
+    const f = h / (Xt - 1), p = Math.max(0, Math.min(1, (f - s) / o)), d = p * p * (3 - 2 * p);
+    r.push(n * (1 - e * (1 - d)));
+  }
+  const c = t.angle * Math.PI / 180, l = Math.cos(c), i = Math.sin(c), a = t.size / 2, M = t.size * 0.8;
+  return {
+    rgb: ds(t.accent, t.hue, Math.max(0, Math.min(1, t.vivid ?? 0)), t.brightness),
+    mix: r,
+    saturation: n,
+    at: (h, f) => {
+      const p = ((h - a) * l + (f - a) * i) / M + 0.5;
+      return Math.max(0, Math.min(Xt - 1, Math.round(p * (Xt - 1))));
+    }
+  };
+}
+const Ms = [120, 232, 214], ms = [64, 72, 255];
+function An(t, n, e) {
+  t /= 255, n /= 255, e /= 255;
+  const s = Math.max(t, n, e), o = Math.min(t, n, e), r = (s + o) / 2;
+  if (s === o) return [0, 0, r];
+  const c = s - o, l = r > 0.5 ? c / (2 - s - o) : c / (s + o);
+  return [(s === t ? (n - e) / c + (n < e ? 6 : 0) : s === n ? (e - t) / c + 2 : (t - n) / c + 4) / 6, l, r];
+}
+function gs(t, n, e) {
+  const s = (c) => (c + t * 12) % 12, o = n * Math.min(e, 1 - e), r = (c) => e - o * Math.max(-1, Math.min(s(c) - 3, 9 - s(c), 1));
+  return [r(0) * 255, r(8) * 255, r(4) * 255];
+}
+const on = (t) => (t /= 255) <= 0.04045 ? t / 12.92 : ((t + 0.055) / 1.055) ** 2.4, bs = (t) => 255 * (t <= 31308e-7 ? 12.92 * t : 1.055 * Math.max(0, t) ** (1 / 2.4) - 0.055);
+function dn(t, n, e) {
+  const [s, o, r] = [on(t), on(n), on(e)], c = Math.cbrt(0.4122214708 * s + 0.5363325363 * o + 0.0514459929 * r), l = Math.cbrt(0.2119034982 * s + 0.6806995451 * o + 0.1073969566 * r), i = Math.cbrt(0.0883024619 * s + 0.2817188376 * o + 0.6299787005 * r);
+  return [
+    0.2104542553 * c + 0.793617785 * l - 0.0040720468 * i,
+    1.9779984951 * c - 2.428592205 * l + 0.4505937099 * i,
+    0.0259040371 * c + 0.7827717662 * l - 0.808675766 * i
+  ];
+}
+function zn(t, n, e) {
+  const s = (t + 0.3963377774 * n + 0.2158037573 * e) ** 3, o = (t - 0.1055613458 * n - 0.0638541728 * e) ** 3, r = (t - 0.0894841775 * n - 1.291485548 * e) ** 3, c = (l) => Math.max(0, Math.min(255, bs(l)));
+  return [
+    c(4.0767416621 * s - 3.3077115913 * o + 0.2309699292 * r),
+    c(-1.2684380046 * s + 2.6097574011 * o - 0.3413193965 * r),
+    c(-0.0041960863 * s - 0.7034186147 * o + 1.707614701 * r)
+  ];
+}
+function vs(t, n, e, s) {
+  const o = s && s.amount > 5e-3 ? s : void 0;
+  return t.map(([r, c, l, i]) => {
+    if (e && (c += (e.r - c) * 0.85, l += (e.g - l) * 0.85, i += (e.b - i) * 0.85), o) {
+      const [, M, h] = An(c, l, i), [f] = An(o.r, o.g, o.b), p = gs((f + 0.1 * Math.sin(2 * Math.PI * r) + 1) % 1, M, h), d = dn(c, l, i), m = dn(p[0], p[1], p[2]), v = o.amount;
+      [c, l, i] = zn(d[0] + (m[0] - d[0]) * v, d[1] + (m[1] - d[1]) * v, d[2] + (m[2] - d[2]) * v);
+    }
+    const a = n ? 1 : 0.82;
+    return [r, c * a, l * a, i * a];
+  });
+}
+const Dn = (t, n, e) => `rgb(${Math.round(t)},${Math.round(n)},${Math.round(e)})`;
+function ys(t, n = 36) {
+  const e = t.filter(([a]) => a < 1), s = e.length;
+  if (s < 3) return t;
+  const o = e.map(([, a, M, h]) => dn(a, M, h)), r = (a) => (a % s + s) % s, c = (a) => e[r(a)][0] + Math.floor(a / s), l = (a) => {
+    const M = c(a + 1) - c(a - 1);
+    return o[r(a + 1)].map((h, f) => (h - o[r(a - 1)][f]) / M);
+  }, i = [];
+  for (let a = 0; a <= n; a++) {
+    const M = a / n;
+    let h = -1;
+    for (; h < s - 1 && c(h + 1) <= M; ) h++;
+    const f = c(h + 1) - c(h), p = (M - c(h)) / f, d = p * p, m = d * p, v = o[r(h)], _ = o[r(h + 1)], u = l(h), g = l(h + 1), y = [0, 1, 2].map(
+      (w) => (2 * m - 3 * d + 1) * v[w] + (m - 2 * d + p) * f * u[w] + (-2 * m + 3 * d) * _[w] + (m - d) * f * g[w]
+    ), [N, T, z] = zn(y[0], y[1], y[2]);
+    i.push([M, N, T, z]);
+  }
+  return i;
+}
+const xs = 1.5, qn = typeof CanvasRenderingContext2D == "function" && "filter" in CanvasRenderingContext2D.prototype, Rn = /* @__PURE__ */ new WeakMap();
+function an(t, n) {
+  return (typeof OffscreenCanvas == "function" ? new OffscreenCanvas(t, n) : Object.assign(document.createElement("canvas"), { width: t, height: n })).getContext("2d");
+}
+function ws(t) {
+  const { width: n, height: e } = t.canvas;
+  let s = Rn.get(t);
+  return (!s || s.full.canvas.width !== n || s.full.canvas.height !== e) && (s = { full: an(n, e) }, qn || (s.half = an(Math.ceil(n / 2), Math.ceil(e / 2)), s.quarter = an(Math.ceil(n / 4), Math.ceil(e / 4))), Rn.set(t, s)), s.full.setTransform(1, 0, 0, 1, 0, 0), s.full.clearRect(0, 0, n, e), s.full.setTransform(t.getTransform()), s;
+}
+function cn(t, n) {
+  t.globalCompositeOperation = "copy", t.imageSmoothingEnabled = !0, t.imageSmoothingQuality = "high", t.drawImage(n.canvas, 0, 0, t.canvas.width, t.canvas.height);
+}
+function Ss(t, n, e) {
+  const s = t.getTransform();
+  t.save(), t.setTransform(1, 0, 0, 1, 0, 0), t.globalCompositeOperation = e, t.globalAlpha = 1, t.imageSmoothingEnabled = !0, t.imageSmoothingQuality = "high", qn ? (t.filter = `blur(${xs * Math.hypot(s.a, s.b)}px)`, t.drawImage(n.full.canvas, 0, 0)) : n.half && n.quarter && (cn(n.half, n.full), cn(n.quarter, n.half), cn(n.half, n.quarter), t.drawImage(n.half.canvas, 0, 0, n.half.canvas.width * 2, n.half.canvas.height * 2)), t.restore();
+}
+function Pn(t, n, e) {
+  const s = typeof t.createConicGradient == "function" ? t.createConicGradient(n.angle, n.cx, n.cy) : t.createLinearGradient(n.cx - n.r, n.cy - n.r, n.cx + n.r, n.cy + n.r);
+  for (const [o, r, c, l] of e) s.addColorStop(K(o), Dn(r, c, l));
+  return s;
+}
+function Ts(t, n, e, s, o, r) {
+  const c = ys(vs(e.stops, s, o, r)), l = Pn(t, e, c), i = n.strokes.map((u) => {
+    const g = new Path2D(), y = u.pts.length >> 1;
+    let N = 0;
+    for (let T = 0; T < y; T++)
+      T === 0 ? g.moveTo(u.pts[0], u.pts[1]) : g.lineTo(u.pts[2 * T], u.pts[2 * T + 1]), N += u.a[T];
+    return u.closed && g.closePath(), { p: g, a: y ? N / y : 1, w: u.w };
+  }), a = Math.max(1, i.length), M = e.intensity, h = s ? "lighter" : "source-over", f = (u, g, y = t) => {
+    for (const N of i)
+      y.lineWidth = u(N.w), y.globalAlpha = K(g(N.a)), y.stroke(N.p);
+  }, p = (u, g) => {
+    u.lineCap = "round", u.lineJoin = "round", u.globalCompositeOperation = h, u.strokeStyle = g;
+  }, d = ws(t), m = d.full;
+  p(m, Pn(m, e, c));
+  const v = e.halo * M * (s ? 1 : 0.2) / a;
+  for (const [u, g] of [
+    [0.7, 0.045],
+    [0.42, 0.075],
+    [0.24, 0.11],
+    [0.12, 0.16]
+  ])
+    f(
+      () => e.r * u,
+      () => g * v,
+      m
+    );
+  const _ = M * (s ? 1 : 0.6);
+  for (const [u, g] of [
+    [16, 0.05],
+    [8, 0.11],
+    [4, 0.2]
+  ])
+    f(
+      (y) => y * u,
+      (y) => g * _ * y,
+      m
+    );
+  if (Ss(t, d, h), t.save(), p(t, l), s && e.fringe > 0) {
+    for (const [u, g, y] of [
+      [1 + e.fringe, Ms, 0.16],
+      [1 - e.fringe, ms, 0.22]
+    ])
+      t.save(), t.translate(e.cx, e.cy), t.scale(u, u), t.translate(-e.cx, -e.cy), t.strokeStyle = Dn(g[0], g[1], g[2]), f(
+        (N) => N * 1.4 / u,
+        (N) => y * M * N
+      ), t.restore();
+    t.strokeStyle = l;
+  }
+  if (f(
+    (u) => u,
+    (u) => 0.7 * u * (0.75 + 0.25 * M)
+  ), s)
+    for (const u of e.spec) {
+      const g = t.createRadialGradient(u.x, u.y, 0, u.x, u.y, u.r);
+      g.addColorStop(0, "rgba(255,255,255,1)"), g.addColorStop(0.35, "rgba(255,255,255,0.45)"), g.addColorStop(1, "rgba(255,255,255,0)"), t.strokeStyle = g, f(
+        (y) => y * 2.2,
+        (y) => u.a * y
+      );
+    }
+  t.restore();
+}
+const Es = `
+attribute vec2 aPos;
+varying vec2 vUv;
+void main() {
+  vUv = vec2(aPos.x + 1.0, 1.0 - aPos.y) * 0.5;
+  gl_Position = vec4(aPos, 0.0, 1.0);
+}`, As = `
+precision highp float;
+uniform sampler2D uTex;
+uniform vec2 uSize;
+uniform float uWall, uSide, uZone, uGap, uFlare, uSplit, uBlur, uCy;
+varying vec2 vUv;
+const int TAPS = 16;
+vec4 tap(vec2 p) { return texture2D(uTex, p / uSize); }
+void main() {
+  vec2 p = vUv * uSize;
+  // 0 a zone back from the edge … 1 at it and past it
+  float t = clamp(1.0 - (uWall - p.x) * uSide / uZone, 0.0, 1.0);
+  if (t <= 0.0) { gl_FragColor = tap(p); return; }
+  float w = t * t;
+  // drawn out across the gap toward the edge, and opened a little taller
+  float d = (uWall - p.x) * uSide + uGap * w;
+  vec2 s = vec2(uWall - uSide * d, uCy + (p.y - uCy) / (1.0 + uFlare * w));
+  // dispersion: red bent further out than blue, along the stretch and the flare
+  vec2 split = vec2(uSide, 0.6 * (p.y - uCy) / uZone) * uSplit * w;
+  // the blur grows toward the edge, drawn out along the stretch
+  float b = uBlur * w;
+  vec3 rgb = vec3(0.0);
+  float a = 0.0;
+  for (int i = 0; i < TAPS; i++) {
+    float f = float(i);
+    float r = sqrt((f + 0.5) / float(TAPS)) * b;
+    vec2 o = vec2(cos(f * 2.39996) * 1.8, sin(f * 2.39996)) * r;
+    vec4 cr = tap(s + o + split);
+    vec4 cg = tap(s + o);
+    vec4 cb = tap(s + o - split);
+    rgb += vec3(cr.r, cg.g, cb.b);
+    a += max(cg.a, max(cr.a, cb.a));
+  }
+  gl_FragColor = vec4(rgb, a) / float(TAPS);
+}`;
+let Vt;
+function Rs() {
+  if (typeof document > "u") return null;
+  const t = document.createElement("canvas"), n = t.getContext("webgl", { premultipliedAlpha: !0, antialias: !1, depth: !1 });
+  if (!n) return null;
+  const e = (i, a) => {
+    const M = n.createShader(i);
+    return n.shaderSource(M, a), n.compileShader(M), M;
+  }, s = n.createProgram();
+  if (n.attachShader(s, e(n.VERTEX_SHADER, Es)), n.attachShader(s, e(n.FRAGMENT_SHADER, As)), n.linkProgram(s), !n.getProgramParameter(s, n.LINK_STATUS)) return null;
+  n.useProgram(s);
+  const o = n.createBuffer();
+  n.bindBuffer(n.ARRAY_BUFFER, o), n.bufferData(n.ARRAY_BUFFER, new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]), n.STATIC_DRAW);
+  const r = n.getAttribLocation(s, "aPos");
+  n.enableVertexAttribArray(r), n.vertexAttribPointer(r, 2, n.FLOAT, !1, 0, 0);
+  const c = n.createTexture();
+  n.bindTexture(n.TEXTURE_2D, c), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_WRAP_S, n.CLAMP_TO_EDGE), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_WRAP_T, n.CLAMP_TO_EDGE), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_MIN_FILTER, n.LINEAR), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_MAG_FILTER, n.LINEAR), n.pixelStorei(n.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !0);
+  const l = {};
+  for (const i of ["uSize", "uWall", "uSide", "uZone", "uGap", "uFlare", "uSplit", "uBlur", "uCy"])
+    l[i] = n.getUniformLocation(s, i);
+  return { gl: n, canvas: t, source: document.createElement("canvas"), tex: c, u: l };
+}
+function Ps(t, n, e, s) {
+  if (Vt === void 0 && (Vt = Rs()), !Vt) return !1;
+  const { gl: o, canvas: r, source: c, tex: l, u: i } = Vt, a = t.getTransform(), M = Math.hypot(a.a, a.b) || 1, h = t.canvas.width, f = t.canvas.height, p = a.a * e + a.e, d = s.zone * M, m = s.blur * M, v = Math.max(0, Math.floor(n > 0 ? p - d - 2 * m - 4 : 0)), u = Math.min(h, Math.ceil(n > 0 ? h : p + d + 2 * m + 4)) - v;
+  if (u < 2 || f < 2) return !1;
+  (c.width !== u || c.height !== f) && (c.width = u, c.height = f);
+  const g = c.getContext("2d");
+  return g.clearRect(0, 0, u, f), g.drawImage(t.canvas, v, 0, u, f, 0, 0, u, f), (r.width !== u || r.height !== f) && (r.width = u, r.height = f), o.viewport(0, 0, u, f), o.bindTexture(o.TEXTURE_2D, l), o.texImage2D(o.TEXTURE_2D, 0, o.RGBA, o.RGBA, o.UNSIGNED_BYTE, c), o.uniform2f(i.uSize, u, f), o.uniform1f(i.uWall, p - v), o.uniform1f(i.uSide, n), o.uniform1f(i.uZone, d), o.uniform1f(i.uGap, s.gap * M), o.uniform1f(i.uFlare, s.flare), o.uniform1f(i.uSplit, s.split * M), o.uniform1f(i.uBlur, m), o.uniform1f(i.uCy, a.d * s.cy + a.f), o.clearColor(0, 0, 0, 0), o.clear(o.COLOR_BUFFER_BIT), o.drawArrays(o.TRIANGLE_STRIP, 0, 4), t.save(), t.setTransform(1, 0, 0, 1, 0, 0), t.globalCompositeOperation = "copy", t.beginPath(), t.rect(v, 0, u, f), t.clip(), t.drawImage(r, v, 0), t.restore(), !0;
+}
+function Gn(t, n, e, s) {
+  const o = 2.2 / s.size, r = Gt(t * o + s.t * 0.11, n * o - s.t * 0.08, s.t * 0.07), c = pn(0.3, 0.75, r);
+  return s.amount * (0.2 + 0.75 * c) * K(1.3 - e);
+}
+function Ln(t, n, e, s, o, r = 0, c, l = 0) {
+  const i = Math.round(n * 1e3) / 1e3, a = (d) => e ? d * (1 - t) : d + (255 - d) * t, M = (e ? 1 - t : t) * 255;
+  let h = s ? a(s.r) : M, f = s ? a(s.g) : M, p = s ? a(s.b) : M;
+  return c && l > 0 && (h += (a(c[0]) - h) * l, f += (a(c[1]) - f) * l, p += (a(c[2]) - p) * l), o && r > 0 && (h += (a(o.r) - h) * r, f += (a(o.g) - f) * r, p += (a(o.b) - p) * r), `rgba(${Math.round(h)},${Math.round(f)},${Math.round(p)},${i})`;
+}
+const _n = 24, kn = 8;
+function _s(t, n, e, s, o, r) {
+  const c = o && o.amount > 5e-3 ? o : void 0, l = r && r.saturation > 0 ? r : void 0, i = /* @__PURE__ */ new Map();
+  for (const a of n) {
+    const M = a.pts.length >> 1, h = a.closed ? M : M - 1;
+    let f = "", p;
+    for (let d = 0; d < h; d++) {
+      const m = d + 1 === M ? 0 : d + 1, v = Math.round(K((a.a[d] + a.a[m]) / 2) * _n);
+      if (v === 0) {
+        f = "";
+        continue;
+      }
+      const _ = c ? Math.round(
+        Gn((a.pts[2 * d] + a.pts[2 * m]) / 2, (a.pts[2 * d + 1] + a.pts[2 * m + 1]) / 2, a.white, c) * kn
+      ) : 0, u = l ? l.at((a.pts[2 * d] + a.pts[2 * m]) / 2, (a.pts[2 * d + 1] + a.pts[2 * m + 1]) / 2) : 0, g = `${v}|${a.white}|${Math.round(a.w * 20)}|${_}|${u}`;
+      if (g !== f) {
+        let y = i.get(g);
+        y || (y = { path: new Path2D(), white: a.white, w: a.w, a: v / _n, gw: _ / kn, ci: u }, i.set(g, y)), p = y, f = g, y.path.moveTo(a.pts[2 * d], a.pts[2 * d + 1]);
+      }
+      p.path.lineTo(a.pts[2 * m], a.pts[2 * m + 1]);
+    }
+  }
+  t.lineCap = "round", t.lineJoin = "round";
+  for (const a of i.values())
+    t.strokeStyle = Ln(K(a.white), a.a, e, s, c, a.gw, l == null ? void 0 : l.rgb, l == null ? void 0 : l.mix[a.ci]), t.lineWidth = a.w, t.stroke(a.path);
+}
+function ks(t, n, e, s, o, r, c = !1) {
+  const l = o && o.amount > 5e-3 ? o : void 0, i = r && r.saturation > 0 ? r : void 0;
+  for (const a of n) {
+    const M = K(a.white), h = l ? Gn(a.x, a.y, M, l) : 0, f = i ? i.at(a.x, a.y) : 0;
+    if (t.fillStyle = Ln(M, K(a.a ?? 1), e, s, l, h, i == null ? void 0 : i.rgb, i == null ? void 0 : i.mix[f]), c) {
+      t.fillRect(a.x - a.r, a.y - a.r, 2 * a.r, 2 * a.r);
+      continue;
+    }
+    t.beginPath(), t.arc(a.x, a.y, a.r, 0, ht), t.fill();
+  }
+}
+function Cs(t, n, e, s, o, r) {
+  var l;
+  const c = r && r.saturation > 0 && !n.light ? ps(r) : void 0;
+  n.light ? Ts(t, n, n.light, e, s, o) : n.strokes.length && _s(t, n.strokes, e, s, o, c), ks(t, n.dots, e, s, o, c, n.square), (l = n.contact) != null && l.lens && Ps(t, n.contact.side, n.contact.x, n.contact.lens);
+}
+const Fs = [
+  [0, 255, 150, 90],
+  [0.12, 255, 110, 120],
+  [0.24, 255, 80, 170],
+  [0.4, 190, 80, 255],
+  [0.58, 90, 92, 255],
+  [0.74, 60, 132, 255],
+  // violet warms through magenta into the gold at the top, so the gold
+  // fades in rather than meeting the violet at an edge
+  [0.84, 170, 90, 255],
+  [0.93, 240, 104, 165],
+  [1, 255, 150, 90]
+], Is = (t, n, e, s) => {
+  const o = t / 2, r = e.level, [c, l] = e.softBands, i = e.bands[2], a = e.drive, M = e.processing, h = 0.5 * r + 0.5 * e.soft, f = o * (s.radius ?? 0.56) * (1 + (s.zoom ?? 0.17) * e.soft) * (1 - 0.06 * M), p = s.deform ?? 1.45, d = 0.02 + (0.14 * c + 0.06 * r) * p, m = 0.01 + (0.07 * l + 0.03 * i) * p, v = Mn(d, m, a, s.deformRadius ?? 1.75), _ = Math.max(0.6, (s.lineW ?? 1.85) * Lt(t, 0.5)), u = Math.max(1, Math.round(s.rings ?? 6)), g = Math.max(24, Math.round(s.segs ?? 140)), y = s.lean ?? 0.91, N = s.ringGap ?? 0.02, T = [];
+  let z = 0, w = 0;
+  for (let x = 0; x < u; x++) {
+    const F = 0.16 * (0.5 + xt(x, 2.1)) * (x % 2 ? 1 : -1), A = Math.max(
+      0.02,
+      y * (0.2 + 0.8 * xt(x, 3.1)) + 0.03 * Math.sin(n * 0.27 + x * 1.3) + 0.08 * Math.sin(a * 0.35 + x * 1.7)
+    ), B = xt(x, 7.7) * ht + n * 0.05 * (x % 2 ? 1 : -1) + a * F, C = Math.sin(A) * Math.cos(B), I = Math.sin(A) * Math.sin(B), E = Math.cos(A), R = Math.hypot(C, E), q = E / R, L = -C / R, U = I * L, $ = E * q - C * L, j = -I * q, tt = f * (1 + N * (x - (u - 1) / 2)), H = Math.sin(A), X = [], at = [], Z = [];
+    for (let J = 0; J < g; J++) {
+      const W = J / g * ht, ut = Math.cos(W), ct = Math.sin(W), rt = q * ut + U * ct, nt = $ * ct, Mt = L * ut + j * ct, lt = v(rt, nt, Mt);
+      X.push(rt, nt), at.push(lt), z += lt, w++, Z.push(0.62 + 0.38 * K((Mt / H + 1) / 2));
+    }
+    T.push({ dirs: X, f: at, a: Z, rk: tt });
+  }
+  const k = w ? z / w : 0;
+  let P = 0, D = 0;
+  for (const { dirs: x, f: F } of T)
+    for (let A = 0; A < F.length; A++) {
+      const B = x[2 * A], C = x[2 * A + 1], I = Math.hypot(B, C) || 1;
+      P += (F[A] - k) * (B / I), D += (F[A] - k) * (C / I);
+    }
+  P = w ? 2 * P / w : 0, D = w ? 2 * D / w : 0;
+  const O = T.map(({ dirs: x, f: F, a: A, rk: B }) => {
+    const C = [];
+    for (let I = 0; I < F.length; I++) {
+      const E = x[2 * I], R = x[2 * I + 1], q = Math.hypot(E, R) || 1, L = B * (1 + F[I] - k - P * (E / q) - D * (R / q));
+      C.push(o + E * L, o - R * L);
+    }
+    return { pts: C, a: A, white: 0, w: _, closed: !0 };
+  }), b = 2.3 + 0.25 * Math.sin(n * 0.21) + 2 * e.spin, S = {
+    cx: o,
+    cy: o,
+    r: f,
+    stops: Fs,
+    // warm at the top, cool below, swaying rather than turning — the
+    // spectrum flows with the voice but keeps its sense of up; processing
+    // spins it all the way round
+    angle: -Math.PI / 2 - 0.35 + 0.5 * Math.sin(n * 0.07) + 0.4 * Math.sin(a * 0.2) + e.spin,
+    // processing lights the ring up: brighter bloom and a bigger halo
+    intensity: 0.62 + 0.55 * h + 0.5 * M,
+    halo: (s.halo ?? 0.5) * (1 + 0.6 * M),
+    spec: [
+      {
+        x: o + Math.cos(b) * f,
+        y: o + Math.sin(b) * f,
+        r: f * (0.5 + 0.25 * M),
+        a: 0.5 + 0.35 * h + 0.4 * M
+      }
+    ],
+    fringe: 0.016 + 0.012 * h
+  };
+  return { ...Ct([], O), light: S };
+}, On = -0.45, Un = 0.55, $n = 0.7, Ns = Math.hypot(On, Un, $n), Bs = (t, n, e, s) => {
+  const o = t / 2, r = e.level, [c, l, i] = e.bands, a = e.drive, M = e.processing, h = o * (s.radius ?? 0.72), f = h * (1 + (s.zoom ?? 0.3) * r) * (1 - 0.06 * M), p = s.rMul ?? 1, d = Math.max(4, Math.round(s.cells ?? 17)), m = 2 * h / d, v = m / 2 - Math.max(0.5, m * (s.gap ?? 0.24) / 2), _ = Math.ceil(f * 1.25 / m), u = (s.turn ?? 0.12) * n + 0.1 * a + 0.5 * e.spin, g = Math.sin(u), y = Math.cos(u), N = Math.sin(0.35), T = Math.cos(0.35), z = s.shade ?? 0.7, w = s.texture ?? 0.35, k = s.fade ?? 1.3, P = s.strength ?? 1.38, D = s.deform ?? 1.7, O = 0.012 + (0.09 * c + 0.03 * r) * D, b = (0.035 * l + 0.025 * i) * D, S = (C) => O * (0.55 * Math.sin(2 * C + 0.9 * a) + 0.45 * Math.sin(3 * C - 0.7 * a + 1.3)) + b * Math.sin(7 * C + 2.3 * a) * Math.sin(5 * C - 1.7 * a), x = 0.95 * Math.sin(n * 1.3), F = e.spectrum, A = F.length, B = [];
+  for (let C = -_; C <= _; C++)
+    for (let I = -_; I <= _; I++) {
+      const E = o + I * m, R = o + C * m, q = (E - o) / f, L = -(R - o) / f, U = S(Math.atan2(L, q)), $ = Math.hypot(q, L) / (1 + U);
+      if ($ >= 1) continue;
+      const j = 1 / (1 + U), tt = q * j, H = L * j, X = Math.sqrt(Math.max(0, 1 - tt * tt - H * H)), at = K((tt * On + H * Un + X * $n) / Ns), Z = 1 - z + z * at, J = H * T + X * N, W = -H * N + X * T, ut = tt * y - W * g, ct = tt * g + W * y, rt = 0.65 * Gt(ut * 2.2 + a * 0.15, J * 2.2, ct * 2.2 - a * 0.1) + 0.35 * Gt(ut * 4.6 - a * 0.2, J * 4.6 + 7.3, ct * 4.6), nt = 1 - w + w * pn(0.32, 0.68, rt), Mt = A ? F[Math.min(A - 1, Math.floor($ * A))] : r, lt = 0.35 * r + 0.85 * Mt, mt = Math.exp(-((H - x) ** 2) / 0.01) * M, it = 1 - 0.4 * k * (1 - X), wt = (0.35 + 0.75 * Z * nt + 0.3 * lt + 0.2 * mt) * it * p, Ft = 0.22 + 0.62 * Z * nt + 0.22 * lt + 0.3 * mt;
+      B.push({
+        x: E,
+        y: R,
+        z: X * f,
+        r: v * Math.min(1, wt),
+        white: K(1 - Ft * P),
+        a: K((1 - 0.75 * k * (1 - Math.sqrt(X))) * P)
+      });
+    }
+  return { ...Ct(B, [], s.rMin ?? 0.4), square: !0 };
+}, zs = (t, n, e, s) => {
+  const o = t / 2, r = t / 2, c = 0.5 * e.level + 0.5 * e.soft, l = (1 + (s.swell ?? 0.49) * c) * (1 - 0.14 * e.processing), i = t / 2 * (s.radius ?? 0.56), a = s.persp ?? 0.25, M = Yt(n * 0.12 + e.drive * 0.03, 0.3, 0, 0, 1), h = Lt(t, s.rsPow ?? 0.9) * (s.rMul ?? 1), f = [], p = s.orbitN ?? 12, d = s.particles ?? 6;
+  for (let m = 0; m < p; m++) {
+    const v = xt(m, 1.7), _ = xt(m, 5.2), u = xt(m, 8.9), g = i * (0.45 + 0.52 * v), y = v * ht, N = Math.acos(2 * _ - 1), T = Math.sin(N) * Math.cos(y), z = Math.cos(N), w = Math.sin(N) * Math.sin(y);
+    let k = -z, P = T;
+    const D = Math.max(1e-6, Math.sqrt(k * k + P * P));
+    k /= D, P /= D;
+    const O = -w * P, b = w * k, S = T * P - z * k, x = (0.25 + 0.55 * u) * (u > 0.5 ? 1 : -1);
+    for (let F = 0; F < d; F++) {
+      const A = e.drive * x + F / d * ht + _ * 6, B = Math.cos(A), C = Math.sin(A), [I, E, R] = M((k * B + O * C) * g, (P * B + b * C) * g, S * C * g), q = K((R / i + 1) / 2), L = l / (1 - a * R / i);
+      f.push({
+        x: o + I * L,
+        y: r + E * L,
+        z: R,
+        r: ((s.partR ?? 0.47) + (s.partRDepth ?? 0.65) * q) * h * L,
+        white: 0.32 - 0.24 * q
+      });
+    }
+  }
+  return Ct(f, [], s.rMin);
+}, Ds = (t, n, e, s) => {
+  const o = t / 2, r = t / 2, c = e.soft, [l, i] = e.softBands, a = t / 2 * (s.radius ?? 0.66) * (1 + (s.zoom ?? 0.21) * e.level), M = e.drive, h = s.deform ?? 1, f = s.wave ?? 1, p = 0.015 + (0.1 * l + 0.05 * e.level) * h, d = 0.04 * i * h, m = Mn(p, d, M), v = 0.55 + 0.05 * Math.sin(n * 0.37), _ = Math.cos(v), u = Math.sin(v);
+  let g = 0;
+  for (let E = 0; E < 48; E++) {
+    const R = E / 48 * ht;
+    g += m(Math.cos(R), Math.sin(R) * _, Math.sin(R) * u);
+  }
+  g /= 48;
+  const y = (E, R, q) => 1 + m(E, R, q) - g, T = Yt(0, 0.3, o, r, 1), z = Lt(t, s.rsPow ?? 0.6) * (s.rMul ?? 1), w = e.drive, k = [], P = s.ghostN ?? 60;
+  for (let E = 0; E < P; E++) {
+    const R = mn(E, P), q = a * y(R[0], R[1], R[2]), [L, U, $] = T(R[0] * q, R[1] * q, R[2] * q), j = ($ / a + 1) / 2;
+    k.push({ x: L, y: U, z: $, r: 0.65 * z, white: 0.78, a: 0.1 + 0.22 * j });
+  }
+  const D = -u, O = _, b = Math.max(1, Math.round(s.lanes ?? 10)), S = Math.max(8, Math.round(s.segs ?? 56)), x = e.processing, F = (s.laneGap ?? 0.062) * (1 + 0.25 * c) * (1 - 0.4 * x), A = w * 1.6, B = 0.15 * (0.55 + 0.9 * l * f) * (1 - 0.6 * x), C = 0.06 * (0.5 + 1.2 * i * f), I = 0.05 + 0.05 * c;
+  for (let E = 0; E < b; E++) {
+    const R = (E - (b - 1) / 2) * F, q = Math.abs(E - (b - 1) / 2) / Math.max(1, (b - 1) / 2);
+    for (let L = 0; L < S; L++) {
+      const U = L / S * ht, $ = B * Math.sin(U * 3 - w * 0.95 + E * 0.18) + C * Math.sin(U * 5 + w * 0.6) + I * Math.sin(U * 2 + n * 0.31 + Math.sin(n * 0.17) * 1.5), j = R + $, tt = Math.cos(U), H = Math.sin(U), X = tt, at = H * _ + D * j, Z = H * u + O * j, J = Math.sqrt(X * X + at * at + Z * Z), W = a * y(X / J, at / J, Z / J) / J, [ut, ct, rt] = T(X * W, at * W, Z * W), nt = (rt / a + 1) / 2, Mt = Math.max(0, $) * c, lt = Math.atan2(Math.sin(U - A), Math.cos(U - A)), mt = Math.exp(-(lt * lt) / 0.18) * x;
+      k.push({
+        x: ut,
+        y: ct,
+        z: rt,
+        r: ((s.rBase ?? 0.49) + (s.rDepth ?? 0.78) * nt) * (1 - 0.25 * q) * (1 + 1.2 * Mt + 0.5 * mt) * z,
+        white: 0.52 - 0.44 * nt + 0.18 * q - 0.3 * mt,
+        a: 0.4 + 0.6 * nt
+      });
+    }
+  }
+  return Ct(k, [], s.rMin);
+}, qs = (t, n, e, s) => {
+  const o = t / 2, r = e.level, [c, l] = e.softBands, i = e.bands[2], a = e.drive, M = o * (s.radius ?? 0.6) * (1 + (s.zoom ?? 0.06) * e.soft) * (1 - 0.08 * e.processing), h = Yt((s.yaw ?? 0.42) + 0.08 * Math.sin(n * 0.23), s.tilt ?? 0.32, o, o, 1), f = Math.max(0.4, (s.lineW ?? 0.6) * Lt(t, 0.5)), p = (T) => 0.06 + 0.94 * K((T / M + 1) / 2) ** 2, d = s.deform ?? 1, m = 0.02 + (0.14 * c + 0.06 * r) * d, v = 0.01 + (0.07 * l + 0.03 * i) * d, _ = Mn(m, v, a), u = [], g = Math.max(24, Math.round(s.segs ?? 96)), y = Math.max(0, Math.round(s.limbs ?? 2));
+  for (let T = 0; T < y; T++) {
+    const z = 0.1 + 0.05 * Math.sin(n * 0.31 + T * 2.1), w = n * 0.17 * (T % 2 ? 1 : -1) + T * 2.4, k = Math.sin(z) * Math.cos(w), P = Math.sin(z) * Math.sin(w), D = Math.cos(z), O = Math.hypot(k, D), b = D / O, S = -k / O, x = P * S, F = D * b - k * S, A = -P * b, B = [], C = [];
+    for (let I = 0; I < g; I++) {
+      const E = I / g * ht, R = b * Math.cos(E) + x * Math.sin(E), q = F * Math.sin(E), L = S * Math.cos(E) + A * Math.sin(E), U = M * (1 + 6e-3 * T + _(R, q, L));
+      B.push(o + R * U, o - q * U), C.push(0.55 + 0.35 * K((L / Math.sin(z) + 1) / 2));
+    }
+    u.push({ pts: B, a: C, white: 0, w: f, closed: !0 });
+  }
+  const N = Math.max(2, Math.round(s.circles ?? 8));
+  for (let T = 0; T < N; T++) {
+    const [z, w, k] = mn(T, N), P = a * 0.16 * (0.5 + xt(T, 2.1)) * (T % 2 ? 1 : -1) + xt(T, 6.6) * ht, D = w * Math.cos(P) - k * Math.sin(P), O = w * Math.sin(P) + k * Math.cos(P), b = Math.max(1e-6, Math.hypot(O, z)), S = O / b, x = -z / b, F = D * x, A = O * S - z * x, B = -D * S, C = [], I = [];
+    for (let E = 0; E < g; E++) {
+      const R = E / g * ht, q = S * Math.cos(R) + F * Math.sin(R), L = A * Math.sin(R), U = x * Math.cos(R) + B * Math.sin(R), $ = M * (1 + _(q, L, U)), [j, tt, H] = h(q * $, L * $, U * $);
+      C.push(j, tt), I.push(p(H));
+    }
+    u.push({ pts: C, a: I, white: 0, w: f, closed: !0 });
+  }
+  return Ct([], u, s.rMin);
+}, Gs = (t, n, e, s) => {
+  const o = t / 2, r = e.level, [c, l, i] = e.bands, a = e.drive, M = e.processing, h = o * (s.radius ?? 0.6) * (1 + (s.zoom ?? 0.1) * r) * (1 - 0.08 * M), f = 0.95 * Math.sin(n * 1.3), p = Yt(n * 0.14, 0.32, o, o, 1), d = Lt(t, s.rsPow ?? 0.6) * (s.rMul ?? 1), m = Math.max(40, Math.round(s.dotN ?? 900)), v = s.cloudFreq ?? 2.3, _ = s.deform ?? 1, u = 0.018 + (0.12 * c + 0.04 * r) * _, g = (0.045 * l + 0.03 * i) * _, y = [], N = [];
+  let T = 0;
+  for (let w = 0; w < m; w++) {
+    const k = mn(w, m), [P, D, O] = k, b = 0.55 * Math.sin(2.1 * P + 1.3 * D + 0.9 * a) + 0.45 * Math.sin(1.7 * O - 1.9 * D - 0.7 * a + 1.3), S = Math.sin(5.3 * P - 4.1 * O + 2.3 * a) * Math.sin(4.7 * D + 3.1 * P - 1.7 * a), x = u * b + g * S;
+    y.push(k), N.push(x), T += x / m;
+  }
+  const z = [];
+  for (let w = 0; w < m; w++) {
+    const [k, P, D] = y[w], O = N[w] - T, b = h * (1 + O), [S, x, F] = p(k * b, P * b, D * b), A = K((F / h + 1) / 2), B = 0.65 * Gt(k * v + a * 0.21, P * v - a * 0.15, D * v + a * 0.1) + 0.35 * Gt(k * v * 2.1 - a * 0.29, P * v * 2.1 + 7.3, D * v * 2.1 + a * 0.24), C = pn(0.34, 0.68, B), I = Math.exp(-((P - f) ** 2) / 0.012) * M, E = Math.max(0, O) / 0.16;
+    z.push({
+      x: S,
+      y: x,
+      z: F,
+      r: ((s.rBase ?? 0.27) + (s.rDepth ?? 0.84) * A) * (0.22 + 0.95 * C + 0.6 * I) * (1 + 0.5 * E) * d,
+      white: 0.62 - 0.52 * A - 0.16 * C - 0.3 * I,
+      a: 0.3 + 0.7 * A
+    });
+  }
+  return Ct(z, [], s.rMin ?? 0.25);
+}, re = ["orbit", "sash", "signal", "swell", "pixel", "aura"], Ls = {
+  orbit: zs,
+  sash: Ds,
+  signal: qs,
+  swell: Gs,
+  pixel: Bs,
+  aura: Is
+}, ot = {
+  orbit: {
+    speed: 1.05,
+    driveGain: 0.12,
+    opts: { orbitN: 12, particles: 6 },
+    counts: {}
+  },
+  sash: {
+    speed: 1.5,
+    driveGain: 0.8,
+    gain: 1.1,
+    opts: { lanes: 10, segs: 56, ghostN: 60 },
+    counts: { segs: 0.45, ghostN: 0.8 }
+  },
+  signal: {
+    speed: 1.6,
+    driveGain: 2,
+    opts: { circles: 8, segs: 96 },
+    counts: { circles: 0.5, segs: 0.5 }
+  },
+  swell: {
+    speed: 1.4,
+    driveGain: 2.4,
+    opts: { dotN: 900 },
+    counts: { dotN: 1 }
+  },
+  pixel: {
+    speed: 1.2,
+    driveGain: 1.6,
+    attack: 0.16,
+    dotSize: 0.55,
+    opts: { cells: 17 },
+    counts: { cells: 0.5 }
+  },
+  aura: {
+    speed: 1.6,
+    driveGain: 2,
+    voiceSpeed: 0.9,
+    // barely drifts toward the voice: it leans, its near side drawn out and
+    // bulging a touch; light meets the edge through a soft lens rather than
+    // squashing on it
+    lean: { move: 0.21, pull: 0.36, deform: 0.28, squash: 0, bounce: 0.92, lens: 0.49, stretch: 1.04, split: 1.01, blur: 1.24 },
+    opts: { rings: 6, segs: 140 },
+    counts: { segs: 0.5 }
+  }
+};
+function Os(t, n, e = 1, s = 1) {
+  const o = t in ot ? t : "orbit", r = ot[o], c = Math.min(1.4, Math.max(0.2, n / 200)) * Math.max(0.1, e), l = { ...r.opts };
+  for (const [i, a] of Object.entries(r.counts)) {
+    const M = l[i];
+    M != null && (l[i] = Math.max(1, Math.round(M * c ** a)));
+  }
+  return s !== 1 && (l.rMul = Math.max(0.1, s)), { frame: Ls[o], speed: r.speed, driveGain: r.driveGain, gain: r.gain ?? 1, opts: l };
+}
+function Us(t) {
+  let n = t;
+  for (; n; ) {
+    const e = n.getAttribute("data-theme");
+    if (e === "dark") return !0;
+    if (e === "light") return !1;
+    if (n.classList.contains("dark")) return !0;
+    if (n.classList.contains("light")) return !1;
+    n = n.parentElement;
+  }
+  return null;
+}
+function $s() {
+  return typeof matchMedia > "u" || matchMedia("(prefers-color-scheme: dark)").matches;
+}
+function Ws(t, n) {
+  const [e, s] = _t(!0);
+  return kt(() => {
+    if (t === "dark") {
+      s(!0);
+      return;
+    }
+    if (t === "light") {
+      s(!1);
+      return;
+    }
+    const o = () => {
+      const i = Us(n.current);
+      s(i ?? $s());
+    };
+    o();
+    const r = typeof matchMedia < "u" ? matchMedia("(prefers-color-scheme: dark)") : null, c = () => o();
+    r == null || r.addEventListener("change", c);
+    let l = null;
+    return typeof MutationObserver < "u" && n.current && (l = new MutationObserver(o), l.observe(document.documentElement, {
+      attributes: !0,
+      attributeFilter: ["class", "data-theme"],
+      subtree: !0
+    })), () => {
+      r == null || r.removeEventListener("change", c), l == null || l.disconnect();
+    };
+  }, [t, n]), e;
+}
+function Xs() {
+  const [t, n] = _t(!1);
+  return kt(() => {
+    if (typeof matchMedia > "u") return;
+    const e = matchMedia("(prefers-reduced-motion: reduce)");
+    n(e.matches);
+    const s = (o) => n(o.matches);
+    return e.addEventListener("change", s), () => e.removeEventListener("change", s);
+  }, []), t;
+}
+const pt = 16, Vs = 2.1, Ks = 0.3, Hs = 2.5, Ys = 1.6, js = 5, Cn = 2.2, Fn = [
+  [80, 300],
+  [300, 2e3],
+  [2e3, 6e3]
+], rn = 90, Zs = 7e3, ln = Math.PI * 2, hn = 0.35, un = 0.9;
+function Wn(t) {
+  return t < 0 ? 0 : t > 1 ? 1 : t;
+}
+function fn(t, n) {
+  if (t <= n) return 0;
+  const e = (t - n) / Math.max(1e-3, 1 - n);
+  return Wn((1 - Math.exp(-3 * e)) / (1 - Math.exp(-3)));
+}
+function At(t, n, e, s, o) {
+  const r = n > t ? s : o;
+  return t + (n - t) * (1 - Math.exp(-e / Math.max(1e-3, r)));
+}
+class Js {
+  constructor() {
+    this.clock = 0, this.t = 0, this.drive = 0, this.level = 0, this.bands = [0, 0, 0], this.spectrum = new Float32Array(pt), this.floor = new Float32Array(pt + 3).fill(1), this.heard = 0, this.proc = 0, this.spin = 0, this.pan = 0, this.panVel = 0, this.raw = { level: 0, bands: [0, 0, 0], spectrum: new Float32Array(pt) }, this.timeBuf = null, this.freqBuf = null, this.out = {
+      level: 0,
+      bands: [0, 0, 0],
+      soft: 0,
+      softBands: [0, 0, 0],
+      spectrum: this.spectrum,
+      drive: 0,
+      processing: 0,
+      spin: 0,
+      pan: 0
+    };
+  }
+  /** Read an analyser: RMS loudness, three voice bands and the spectrum. */
+  readAnalyser(n, e, s) {
+    (!this.timeBuf || this.timeBuf.length !== n.fftSize) && (this.timeBuf = new Float32Array(n.fftSize)), (!this.freqBuf || this.freqBuf.length !== n.frequencyBinCount) && (this.freqBuf = new Uint8Array(n.frequencyBinCount));
+    const o = this.timeBuf, r = this.freqBuf;
+    n.getFloatTimeDomainData(o);
+    let c = 0;
+    for (let h = 0; h < o.length; h++) c += o[h] * o[h];
+    this.raw.level = Math.sqrt(c / o.length) * js * e, n.getByteFrequencyData(r);
+    const l = n.context.sampleRate / n.fftSize, i = (h, f) => {
+      const p = Math.max(0, Math.floor(h / l)), d = Math.max(p, Math.min(r.length - 1, Math.ceil(f / l)));
+      let m = 0;
+      for (let v = p; v <= d; v++) m += r[v];
+      return m / (d - p + 1) / 255;
+    }, a = (h, f) => {
+      const p = this.floor[h];
+      return this.floor[h] = f < p ? f : p + (f - p) * (1 - Math.exp(-s / 8)), Math.max(0, f - this.floor[h]) / Math.max(0.05, 1 - this.floor[h]);
+    };
+    for (let h = 0; h < 3; h++)
+      this.raw.bands[h] = a(h, i(Fn[h][0], Fn[h][1])) * Cn * e;
+    const M = Zs / rn;
+    for (let h = 0; h < pt; h++) {
+      const f = rn * M ** (h / pt), p = rn * M ** ((h + 1) / pt);
+      this.raw.spectrum[h] = a(3 + h, i(f, p)) * Cn * e;
+    }
+  }
+  /**
+   * Read a plain level. There is no spectrum behind it, so the bands and
+   * slots are given a little independent life — slow, out-of-phase drifts
+   * scaled by the level, with two formant-like humps wandering the
+   * spectrum — so a level-driven orb still moves like a voice.
+   */
+  readLevel(n, e) {
+    const s = Wn(n) * e, o = this.clock;
+    this.raw.level = s, this.raw.bands[0] = s, this.raw.bands[1] = s * (0.72 + 0.28 * Math.sin(o * 2.3)), this.raw.bands[2] = s * (0.6 + 0.4 * Math.sin(o * 3.7 + 2));
+    const r = 0.28 + 0.1 * Math.sin(o * 2.3) + 0.05 * Math.sin(o * 5.1), c = 0.64 + 0.1 * Math.sin(o * 1.7 + 1);
+    for (let l = 0; l < pt; l++) {
+      const i = l / (pt - 1), a = Math.exp(-((i - r) ** 2) / 0.012) + 0.6 * Math.exp(-((i - c) ** 2) / 8e-3);
+      this.raw.spectrum[l] = s * (0.25 + 0.75 * a) * (1 - 0.4 * i);
+    }
+  }
+  /** Nothing to read: let every envelope settle. */
+  readSilence() {
+    this.raw.level = 0, this.raw.bands.fill(0), this.raw.spectrum.fill(0);
+  }
+  /** Advance by `dt` real seconds. `still` (reduced motion) holds the clocks. */
+  step(n, e, s) {
+    const { threshold: o, attack: r, release: c, rate: l } = e, i = this.proc = At(this.proc, e.processing ? 1 : 0, n, 0.35, 0.5), a = e.calm + (1 - e.calm) * Math.min(1, Math.max(this.heard * 2.5, i));
+    s || (this.clock += n, this.t += n * l * a * (1 + 0.5 * i));
+    const M = fn(this.raw.level, o);
+    this.level = At(this.level, M, n, r, c), this.heard = At(this.heard, this.level, n, hn, un);
+    for (let u = 0; u < 3; u++)
+      this.bands[u] = At(this.bands[u], fn(this.raw.bands[u], o * 0.6), n, r, c * 1.15);
+    for (let u = 0; u < pt; u++)
+      this.spectrum[u] = At(this.spectrum[u], fn(this.raw.spectrum[u], o * 0.6), n, r, c);
+    const h = this.clock, f = s ? 0.5 : 0.5 + 0.5 * Math.sin(ln * h / 6), p = e.idle * f * (1 - i), d = this.out;
+    d.level = this.level + (1 - this.level) * p;
+    for (let u = 0; u < 3; u++) d.bands[u] = this.bands[u] + (1 - this.bands[u]) * p * 0.6;
+    d.soft = At(d.soft, d.level, n, hn, un);
+    for (let u = 0; u < 3; u++) d.softBands[u] = At(d.softBands[u], d.bands[u], n, hn, un);
+    if (s || (this.drive += n * l * (a + e.driveGain * this.level + 1.3 * i)), d.drive = this.drive, d.processing = i, !s) {
+      const u = Math.ceil(this.spin / ln - 1e-6) * ln, g = Math.min(Ks, (u - this.spin) * 0.6);
+      this.spin += n * (Vs * l * i + g * (1 - i));
+    }
+    d.spin = this.spin;
+    const m = Math.max(-1, Math.min(1, e.direction || 0)), v = this.heard > 0.06 && !e.processing ? m : 0, _ = Math.abs(v) > Math.abs(this.pan) ? Hs : Ys;
+    return this.panVel += (_ * _ * (v - this.pan) - 2 * _ * this.panVel) * n, this.pan += this.panVel * n, d.pan = this.pan, d;
+  }
+}
+function Qs(t) {
+  if (!t) return;
+  const n = t.trim().match(/^#([0-9a-f]{3}|[0-9a-f]{6})$/i);
+  if (n) {
+    let s = n[1];
+    s.length === 3 && (s = s.replace(/./g, (r) => r + r));
+    const o = parseInt(s, 16);
+    return { r: o >> 16 & 255, g: o >> 8 & 255, b: o & 255 };
+  }
+  const e = t.trim().match(/^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)/i);
+  if (e) return { r: Number(e[1]), g: Number(e[2]), b: Number(e[3]) };
+}
+const te = {
+  idle: "Waiting",
+  listening: "Listening",
+  speaking: "Speaking",
+  processing: "Thinking"
+}, ne = 1e3 / 62;
+function se({
+  type: t = "orbit",
+  state: n = "listening",
+  size: e = 160,
+  stream: s,
+  analyser: o,
+  level: r,
+  sensitivity: c = 0.85,
+  threshold: l = 0.04,
+  attack: i,
+  release: a = 0.32,
+  idle: M = 0.1,
+  calm: h = 0.4,
+  voiceSpeed: f,
+  emotion: p = null,
+  emotionColors: d,
+  saturation: m = 2,
+  accent: v = null,
+  gradientAngle: _ = 99,
+  gradientSpin: u = 12,
+  neutral: g = 1,
+  colorBrightness: y = 1.02,
+  colorHue: N = 0,
+  gradientStart: T = 0.1,
+  gradientWidth: z = 0.6,
+  direction: w,
+  directionMove: k,
+  directionPull: P,
+  directionDeform: D,
+  directionSquash: O,
+  directionLens: b,
+  directionStretch: S,
+  directionSplit: x,
+  directionBlur: F,
+  directionBounce: A,
+  directionMargin: B,
+  directionBounds: C,
+  theme: I = "auto",
+  speed: E = 1,
+  paused: R = !1,
+  color: q,
+  dots: L = 1,
+  dotSize: U,
+  opts: $,
+  frame: j,
+  onLevel: tt,
+  style: H,
+  "aria-label": X,
+  ...at
+}) {
+  const Z = Rt(null), J = Ws(I, Z), W = Xs(), ut = $ ? JSON.stringify($) : "", ct = !!(s || o || r != null || n === "processing"), rt = Rt(null);
+  rt.current || (rt.current = new Js());
+  const nt = Rt(null);
+  nt.current || (nt.current = new as());
+  const Mt = p ? (d == null ? void 0 : d[p]) ?? Ht[p] : null, lt = {
+    saturation: Math.min(1, m),
+    vivid: Math.max(0, Math.min(1, m - 1)),
+    brightness: y,
+    hue: N,
+    start: T,
+    width: z,
+    accent: v ? ns[v] : null,
+    angle: _,
+    spin: u,
+    neutral: g,
+    size: e
+  }, mt = U ?? ot[t in ot ? t : "orbit"].dotSize ?? 1, it = ot[t in ot ? t : "orbit"].lean ?? {}, wt = B ?? ot[t in ot ? t : "orbit"].margin ?? 32, Ft = {
+    state: n,
+    level: r,
+    analyser: o,
+    sensitivity: c,
+    threshold: l,
+    attack: i ?? ot[t in ot ? t : "orbit"].attack ?? 0.06,
+    release: a,
+    idle: M,
+    calm: h,
+    voiceSpeed: f ?? ot[t in ot ? t : "orbit"].voiceSpeed ?? 1,
+    onLevel: tt,
+    emotionTint: Mt,
+    colors: lt,
+    direction: w,
+    bounds: C,
+    // each amount: the prop, else the type's own, else the shared default
+    lean: {
+      move: k ?? it.move ?? dt.move,
+      pull: P ?? it.pull ?? dt.pull,
+      deform: D ?? it.deform ?? dt.deform,
+      squash: O ?? it.squash ?? dt.squash,
+      lens: b ?? it.lens ?? dt.lens,
+      stretch: S ?? it.stretch ?? dt.stretch,
+      split: x ?? it.split ?? dt.split,
+      blur: F ?? it.blur ?? dt.blur,
+      bounce: A ?? it.bounce ?? dt.bounce
+    }
+  }, It = Rt(Ft);
+  It.current = Ft;
+  const Pt = w == null ? 0 : cs(Ft.lean, e), [gn, Xn] = _t([1 / 0, 1 / 0]), jt = Math.min(Pt, gn[0]), Zt = Math.min(Pt, gn[1]), gt = Pt ? jt + wt : 0, Nt = Pt ? Zt + wt : 0, Jt = Rt(null);
+  return kt(() => {
+    if (!s) return;
+    const st = ts(s);
+    return Jt.current = (st == null ? void 0 : st.analyser) ?? null, () => {
+      Jt.current = null, st == null || st.release();
+    };
+  }, [s]), kt(() => {
+    const st = Z.current;
+    if (!st) return;
+    const Bt = Math.min(2, typeof devicePixelRatio < "u" && devicePixelRatio || 1);
+    st.width = Math.round((e + gt + Nt) * Bt), st.height = Math.round(e * Bt);
+    const Ot = st.getContext("2d");
+    if (!Ot) return;
+    const St = Os(t, e, L, mt), Vn = $ ? { ...St.opts, ...$ } : St.opts, Kn = j ?? St.frame, Hn = Qs(q), bt = rt.current, Yn = nt.current, jn = new rs();
+    let bn = 0;
+    const Zn = (Y, V, G) => {
+      var Tn;
+      Ot.setTransform(Bt, 0, 0, Bt, gt * Bt, 0), Ot.clearRect(-gt, 0, e + gt + Nt, e);
+      const zt = R || W ? 0 : jn.step(bn, G), vt = is(Kn(e, bt.t, Y, Vn), Y.pan, e, It.current.lean, [jt, Zt], zt);
+      bn = ((Tn = vt.contact) == null ? void 0 : Tn.press) ?? 0;
+      const et = It.current.colors, ft = V.amount, Q = et.accent, Dt = Q ? { r: Q.r + (V.r - Q.r) * ft, g: Q.g + (V.g - Q.g) * ft, b: Q.b + (V.b - Q.b) * ft } : { r: V.r, g: V.g, b: V.b }, Qn = {
+        ...et,
+        accent: Dt,
+        saturation: et.saturation * (Q ? 1 : ft),
+        angle: et.angle + et.spin * bt.clock
+      };
+      Cs(Ot, vt, J, Hn, vt.light ? V : void 0, Qn);
+    };
+    let vn = -1 / 0;
+    const Jn = (Y) => {
+      var ft, Q;
+      if (!Pt || Y - vn < 500) return;
+      vn = Y;
+      const V = st.getBoundingClientRect().left + gt, G = (Q = (ft = It.current.bounds) == null ? void 0 : ft.current) == null ? void 0 : Q.getBoundingClientRect(), zt = G ? G.left : 0, vt = G ? G.right : document.documentElement.clientWidth, et = [
+        Math.max(0, Math.floor(V - zt - wt)),
+        Math.max(0, Math.floor(vt - V - e - wt))
+      ];
+      Xn((Dt) => Math.abs(Dt[0] - et[0]) > 1 || Math.abs(Dt[1] - et[1]) > 1 ? et : Dt);
+    };
+    let Ut = 0;
+    const yn = (Y) => {
+      var Q;
+      Jn(Y);
+      const V = Ut ? Math.min(0.05, (Y - Ut) / 1e3) : 1 / 60;
+      Ut = Y;
+      const G = It.current, zt = G.state === "listening" || G.state === "speaking", vt = Jt.current ?? G.analyser ?? null;
+      zt ? vt ? bt.readAnalyser(vt, G.sensitivity * St.gain, V) : G.level != null ? bt.readLevel(typeof G.level == "function" ? G.level() : G.level, G.sensitivity * St.gain) : bt.readSilence() : bt.readSilence();
+      const et = bt.step(
+        V,
+        {
+          sensitivity: G.sensitivity,
+          threshold: G.threshold,
+          attack: G.attack,
+          release: G.release,
+          idle: G.idle,
+          driveGain: St.driveGain * G.voiceSpeed,
+          calm: G.calm,
+          rate: St.speed * E,
+          processing: G.state === "processing",
+          direction: typeof G.direction == "function" ? G.direction() : G.direction ?? 0
+        },
+        W
+      );
+      (Q = G.onLevel) == null || Q.call(G, et.level);
+      const ft = Yn.step(V, G.emotionTint, bt.clock, e, R || W);
+      Zn(et, ft, V);
+    };
+    if (yn(performance.now()), R || W && !ct) return;
+    let Qt = 0, $t = !1, xn = 0;
+    const wn = (Y) => {
+      $t && (Qt = requestAnimationFrame(wn), !(Y - xn < ne) && (xn = Y, yn(Y)));
+    }, tn = () => {
+      $t || ($t = !0, Ut = 0, Qt = requestAnimationFrame(wn));
+    }, nn = () => {
+      $t = !1, cancelAnimationFrame(Qt);
+    };
+    let sn = !0;
+    const Tt = typeof IntersectionObserver < "u" ? new IntersectionObserver(([Y]) => {
+      sn = Y.isIntersecting, sn && document.visibilityState !== "hidden" ? tn() : nn();
+    }) : null;
+    Tt == null || Tt.observe(st);
+    const Sn = () => {
+      document.visibilityState === "hidden" ? nn() : sn && tn();
+    };
+    return document.addEventListener("visibilitychange", Sn), Tt || tn(), () => {
+      nn(), Tt == null || Tt.disconnect(), document.removeEventListener("visibilitychange", Sn);
+    };
+  }, [
+    t,
+    e,
+    Pt,
+    jt,
+    Zt,
+    gt,
+    Nt,
+    wt,
+    J,
+    E,
+    R,
+    W,
+    ct,
+    q,
+    L,
+    mt,
+    ut,
+    j,
+    R || W ? p : null,
+    R || W ? `${m}|${v}|${_}|${u}|${g}|${y}|${N}|${T}|${z}` : null
+  ]), /* @__PURE__ */ In(
+    "canvas",
+    {
+      ref: Z,
+      role: "img",
+      "aria-label": X ?? te[n],
+      style: { width: e + gt + Nt, height: e, display: "block", marginLeft: -gt, marginRight: -Nt, ...H },
+      ...at
+    }
+  );
+}
+const ee = {
+  echoCancellation: !1,
+  noiseSuppression: !1,
+  autoGainControl: !1
+};
+function Kt() {
+  return typeof navigator < "u" && typeof navigator.mediaDevices < "u" && typeof navigator.mediaDevices.getUserMedia == "function";
+}
+function ie(t = {}) {
+  const { constraints: n, autoStart: e = !1 } = t, [s, o] = _t(null), [r, c] = _t(() => Kt() ? "idle" : "unsupported"), [l, i] = _t(null), a = Rt(null), M = Rt(n);
+  M.current = n;
+  const h = En(() => {
+    const p = a.current;
+    a.current = null, p && p.getTracks().forEach((d) => d.stop()), o(null), c(Kt() ? "idle" : "unsupported");
+  }, []), f = En(async () => {
+    if (!Kt())
+      return c("unsupported"), null;
+    if (a.current) return a.current;
+    Bn(), c("requesting"), i(null);
+    try {
+      const p = await navigator.mediaDevices.getUserMedia({
+        audio: { ...ee, ...M.current ?? {} }
+      });
+      a.current = p, o(p), c("live");
+      const d = () => {
+        a.current === p && (a.current = null, o(null), c("idle"));
+      };
+      return p.getAudioTracks().forEach((m) => m.addEventListener("ended", d)), p;
+    } catch (p) {
+      const d = p instanceof Error ? p : new Error(String(p));
+      return i(d), c(d.name === "NotAllowedError" || d.name === "SecurityError" ? "denied" : "error"), null;
+    }
+  }, []);
+  return kt(() => {
+    e && f();
+  }, [e]), kt(
+    () => () => {
+      const p = a.current;
+      a.current = null, p && p.getTracks().forEach((d) => d.stop());
+    },
+    []
+  ), { stream: s, state: r, error: l, supported: Kt(), start: f, stop: h };
+}
+function le(t) {
+  return /* @__PURE__ */ In(se, { ...t, type: "aura" });
+}
+export {
+  ns as ACCENT_COLORS,
+  Ht as EMOTION_COLORS,
+  ot as PRESETS,
+  pt as SPECTRUM_N,
+  re as VOICE_ORB_TYPES,
+  Js as VoiceFollower,
+  se as VoiceOrb,
+  le as VoiceRing,
+  ts as acquireAnalyser,
+  Bn as getAudioContext,
+  ce as isAudioSupported,
+  Os as resolvePreset,
+  ie as useMicrophone
+};