@penner/responsive-easing 0.0.4 → 0.1.0

package/dist/index.es.js

@@ -0,0 +1,1721 @@
+import { clampNormalized as C } from "@penner/smart-primitive";
+import { amplitudeRatio as xt, dampingRate as Et, makeExpoEaseOut as mt, createVelocityFn as j, solveBackStrength as it, swim as kt, reverseEasingFn as Y, easingKit as D, backEaseIn as vt, backEaseInVelocity as lt } from "@penner/easing";
+const ct = 1.70158, Mt = ct + 1, at = (e) => Mt * e * e * e - ct * e * e, rt = (e) => 3 * Mt * e * e - 2 * ct * e, tt = {
+  // Public id uses the new 'bounce' name
+  id: "bounce",
+  label: "Bounce (hard-surface)",
+  build({
+    joinTime: e,
+    bounces: t,
+    decayPct: a,
+    L: n = at,
+    Ld: o = rt
+  }) {
+    if (e < ut)
+      return {
+        p: (x) => C(x),
+        v: (x) => 1,
+        meta: { r: 0, finalPct: 0 }
+      };
+    if (e > Pt)
+      return {
+        p: (x) => x >= 1 ? 1 : n(x),
+        v: (x) => x >= 1 ? 0 : o(x),
+        meta: { r: 0, finalPct: 0 }
+      };
+    const r = Math.ceil(t), s = t - Math.floor(t);
+    let i;
+    if (t <= 1)
+      i = C(1 - a / 100);
+    else {
+      const h = C(
+        1 - a / 100
+      );
+      h === 0 ? i = 0 : i = Math.pow(h, 1 / (2 * (t - 1)));
+    }
+    const l = (h) => n(h / e), d = (h) => o(h / e) / e, u = d(e), c = Math.abs(-i * u);
+    if (i === 0 || c === 0)
+      return {
+        p: (x) => x <= e ? l(x) : 1,
+        v: (x) => x <= e ? d(x) : 0,
+        meta: {
+          r: 0,
+          finalPct: 0,
+          g: 0,
+          edges: [e, 1]
+        }
+      };
+    const M = 1 - e, b = Math.floor(t), I = Math.abs(1 - i) < 1e-6 ? t : (1 - Math.pow(i, b)) / (1 - i) + s * Math.pow(i, b);
+    let g = 2 * c / M * I, p = 0;
+    const P = 50;
+    for (let h = 0; h <= P; h++) {
+      const w = h / P * e, x = l(w);
+      x < p && (p = x);
+    }
+    const O = 1 - p, f = c * c / (2 * g);
+    let E = c, V = !1, _ = 1;
+    if (f > O) {
+      E = Math.sqrt(2 * g * O), V = !0;
+      const h = Math.abs(1 - i) < 1e-6 ? t : (1 - Math.pow(i, b)) / (1 - i) + s * Math.pow(i, b), w = 2 * E * h / g;
+      _ = e + w, _ > 1 && (_ = 1);
+    }
+    const v = E, F = Array.from(
+      { length: r },
+      (h, w) => 2 * v * Math.pow(i, w) / g
+    ), k = [e];
+    F.forEach((h) => k.push(k[k.length - 1] + h)), V ? k[k.length - 1] = _ : k[k.length - 1] = 1;
+    const B = (h) => -v * Math.pow(i, h), N = (h) => {
+      if (h >= _)
+        return 1;
+      let w = k.findIndex(
+        (S, K) => K < k.length - 1 && h <= k[K + 1]
+      );
+      w < 0 && (w = r - 1);
+      const x = k[w], $ = h - x;
+      return 1 + (B(w) * $ + 0.5 * g * $ * $);
+    }, T = (h) => {
+      if (h >= _)
+        return 0;
+      let w = k.findIndex(
+        (A, S) => S < k.length - 1 && h <= k[S + 1]
+      );
+      w < 0 && (w = r - 1);
+      const x = k[w], $ = h - x;
+      return B(w) + g * $;
+    }, H = (h) => h <= e ? l(h) : N(h), m = (h) => h <= e ? d(h) : T(h), y = r <= 1 ? 100 : 100 * (1 - a / 100);
+    return {
+      p: H,
+      v: m,
+      meta: {
+        r: i,
+        finalPct: y,
+        g,
+        edges: k,
+        clamped: V,
+        settleTime: _
+      }
+    };
+  }
+}, St = 12;
+function Vt({
+  joinTime: e,
+  L: t = at,
+  Ld: a = rt,
+  bridge: n
+}) {
+  const o = St;
+  n && n.joinHeight;
+  const r = n ? e + n.duration : e, s = 1 - r;
+  let i;
+  if (n)
+    i = n.joinHeight;
+  else {
+    const E = a(1) * (1 - e) + o * e;
+    Math.abs(E) < 1e-9 ? i = 0.5 : i = o * e / E, i = Math.max(0.01, Math.min(0.999, i));
+  }
+  const l = n ? 1 : i, d = l - 1, u = n ? n.velocity * s : i * a(1) * (1 - e) / e, c = u + o * d, M = (f) => {
+    if (f <= 0) return l;
+    if (f >= 1) return 1;
+    const E = Math.exp(-o * f);
+    return 1 + (d + c * f) * E;
+  }, b = (f) => {
+    if (f <= 0) return u;
+    if (f >= 1) return 0;
+    const E = Math.exp(-o * f);
+    return (c - o * (d + c * f)) * E;
+  }, I = n ? n.joinHeight : i, g = (f) => I * t(f / e), p = (f) => I / e * a(f / e);
+  return {
+    p: (f) => {
+      if (f <= 0) return 0;
+      if (f >= 1) return 1;
+      if (f <= e) return g(f);
+      if (n && f <= r)
+        return n.joinHeight + n.velocity * (f - e);
+      const E = (f - r) / s;
+      return M(E);
+    },
+    v: (f) => {
+      if (f <= 0 || f >= 1) return 0;
+      if (f <= e) return p(f);
+      if (n && f <= r)
+        return n.velocity;
+      const E = (f - r) / s;
+      return b(E) / s;
+    },
+    meta: {
+      r: 0,
+      finalPct: 0,
+      k: o,
+      B: 0,
+      P: i,
+      guard: "critically-damped",
+      useBridge: !!n
+    }
+  };
+}
+function wt(e, t, a, n) {
+  const o = C(a / 100), r = t + 0.5, s = xt(o, r), i = r, l = Math.PI * i, d = Et(i, s), u = 1 - e, c = e <= ut * 10, M = u > 0 ? l / u : l, b = u > 0 ? d / u : d, I = n(1);
+  let g;
+  if (c)
+    g = 0;
+  else {
+    const O = I / e, f = l, E = O * (1 - e) + f * e;
+    g = Math.abs(E) < 1e-9 ? 0.5 : f * e / E, g = Math.max(0.01, Math.min(0.999, g));
+  }
+  const p = c ? 0 : g * I / e, P = t <= 1 ? 100 : 100 * (1 - a / 100);
+  return { P: g, v0: p, r: s, N: i, w: M, g: b, alpha: u, finalPct: P };
+}
+function Bt({
+  joinTime: e,
+  bounces: t,
+  decayPct: a,
+  L: n = at,
+  Ld: o = rt
+}) {
+  const r = wt(e, t, a, o), { r: s, g: i, alpha: l, finalPct: d } = r, u = o(1);
+  let c;
+  if (u > 1e-6) {
+    const y = Math.min(
+      l / (8 * Math.max(t, 1)),
+      l * 0.1
+    ), h = e / (e + u * y), x = t > 0 ? 0.5 * e * t * Math.PI / (u * l) : 0.5;
+    c = Math.min(h, x), c = Math.max(0.01, Math.min(0.999, c));
+  } else
+    c = r.P;
+  const M = c * u / e, b = t > 0 ? l / (2 * t + 1) : l, I = t > 0 ? l * 0.5 : l, g = 1e-6;
+  let p;
+  if (M > 1e-6) {
+    const y = (1 - c) / M;
+    p = Math.max(g, Math.min(I, y));
+  } else
+    p = Math.max(g, Math.min(I, b));
+  const P = p > 0 ? 2 * (1 - c - M * p) / (p * p) : 0, O = (y) => 0.5 * P * y * y + M * y + c, f = (y) => P * y + M, E = P * p + M, V = l - p, _ = V > 0 ? t * Math.PI / V : 0, v = _ > 0 ? E / _ : 0, F = (y) => 1 + v * Math.exp(-i * y) * Math.sin(_ * y), k = (y) => v * Math.exp(-i * y) * (_ * Math.cos(_ * y) - i * Math.sin(_ * y)), B = (y) => c * n(y / e), N = (y) => c / e * o(y / e), T = e + p;
+  return {
+    p: (y) => {
+      if (y <= 0) return 0;
+      if (y >= 1) return 1;
+      if (y <= e) return B(y);
+      if (y <= T) {
+        const w = y - e;
+        return O(w);
+      }
+      const h = y - T;
+      return F(h);
+    },
+    v: (y) => {
+      if (y <= 0 || y >= 1) return 0;
+      if (y <= e) return N(y);
+      if (y <= T) {
+        const w = y - e;
+        return f(w);
+      }
+      const h = y - T;
+      return k(h);
+    },
+    meta: { r: s, finalPct: d, k: i, B: _, P: c, guard: "quadratic-sine" }
+  };
+}
+const Nt = Bt, R = {
+  // Public id uses the new 'spring' name
+  id: "spring",
+  label: "Spring (phase-locked; bounce = half-cycle)",
+  /**
+   * Calculate the natural starting velocity for spring oscillations
+   *
+   * This is adaptive, blending the head's ending velocity with spring frequency
+   * to produce visually balanced bridges that respond to both the head's characteristics
+   * and the spring's oscillation rate.
+   *
+   * Strategy: Equal weight to head velocity and frequency (both at 1.0 by default)
+   * Formula: headVelocity * 1.0 + 1.0 * N^1.0 * 1.0 = headVelocity + N
+   */
+  getNaturalStartVelocity({ bounces: e, decayPct: t }, a, n) {
+    const o = e;
+    if (o <= 0)
+      return a(1);
+    let r;
+    if (o <= 1)
+      r = C(1 - t / 100);
+    else {
+      const M = C(
+        1 - t / 100
+      );
+      M === 0 ? r = 0 : r = Math.pow(M, 1 / (o - 1));
+    }
+    if (r === 0) return 0;
+    const s = a(1), i = n?.headWeight ?? 1, l = n?.freqWeight ?? 1, d = n?.freqExponent ?? 1, u = n?.baseMultiplier ?? 1, c = Math.pow(o, d);
+    return s * i + u * c * l;
+  },
+  build({
+    joinTime: e,
+    bounces: t,
+    decayPct: a,
+    L: n = at,
+    Ld: o = rt,
+    bridge: r
+  }) {
+    if (e < ut)
+      return {
+        p: (h) => C(h),
+        v: (h) => 1,
+        meta: {
+          r: 0,
+          finalPct: 0,
+          k: 0,
+          B: 0,
+          P: 0
+        }
+      };
+    if (e > Pt)
+      return {
+        p: (h) => h >= 1 ? 1 : n(h),
+        v: (h) => h >= 1 ? 0 : o(h),
+        meta: {
+          r: 0,
+          finalPct: 0,
+          k: 0,
+          B: 0,
+          P: 1
+        }
+      };
+    if (t <= 0)
+      return Vt({ joinTime: e, L: n, Ld: o, bridge: r });
+    if (!r)
+      return Nt({ joinTime: e, bounces: t, decayPct: a, L: n, Ld: o });
+    let s;
+    if (t <= 1)
+      s = C(1 - a / 100);
+    else {
+      const m = C(
+        1 - a / 100
+      );
+      m === 0 ? s = 0 : s = Math.pow(m, 1 / (t - 1));
+    }
+    const i = r ? r.joinHeight : 1, l = r ? e + r.duration : e;
+    if (s === 0) {
+      const m = (x) => i * n(x / e), y = (x) => i / e * o(x / e);
+      return {
+        p: (x) => x <= e ? m(x) : r && x <= l ? r.joinHeight + r.velocity * (x - e) : 1,
+        v: (x) => x <= e ? y(x) : r && x <= l ? r.velocity : 0,
+        meta: {
+          r: 0,
+          finalPct: 0,
+          k: 1 / 0,
+          B: 0,
+          P: i,
+          guard: "no-oscillation",
+          useBridge: !!r
+        }
+      };
+    }
+    const d = 1 - l, u = t <= 0 || d <= 0 ? 0 : t * Math.PI / d, c = s <= 0 ? 50 : u / Math.PI * -Math.log(s), M = (m) => Math.exp(-c * m) * Math.sin(u * m), b = (m) => Math.exp(-c * m) * (u * Math.cos(u * m) - c * Math.sin(u * m));
+    let I = "";
+    const g = Math.PI / (2 * u), p = Math.exp(-c * g), P = p > 1e-9 ? p : 1;
+    p <= 1e-9 && (I = "high-decay-fallback");
+    const O = (m) => M(d * m) / P, f = (m) => d * b(d * m) / P, E = () => !r || u === 0 ? 0 : r.joinHeight / e * o(1) * P / u, V = (m) => k + (1 - k) * m, _ = (m) => r ? 1 + E() * O(m) : V(m) + (1 - k) * O(m), v = (m) => r ? E() / (1 - l) * f(m) : (1 - k) * (1 + f(m)) / (1 - l), F = () => {
+      if (r) {
+        const m = f(0), y = 1 - l;
+        return Math.abs(m) < 1e-9 ? i : 1 - r.velocity * y / m;
+      } else {
+        const m = o(1), h = 1 + f(0);
+        return Math.abs(m * (1 - e) + h * e) < 1e-9 ? 0.5 : h * e / (m * (1 - e) + h * e);
+      }
+    }, k = F(), B = globalThis;
+    typeof B.__SPRING_TEST_HELPERS__ == "object" && (B.__SPRING_TEST_HELPERS__.calculateBridgeAmplitude = E, B.__SPRING_TEST_HELPERS__.calculateNonBridgeBaseline = V, B.__SPRING_TEST_HELPERS__.calculatePulsePosition = _, B.__SPRING_TEST_HELPERS__.calculatePulseVelocity = v, B.__SPRING_TEST_HELPERS__.calculateScalingFactor = F);
+    const N = (m) => {
+      if (m <= e)
+        return (r ? r.joinHeight : k) * n(m / e);
+      if (r && m <= l)
+        return r.joinHeight + r.velocity * (m - e);
+      const y = (m - l) / (1 - l);
+      return _(y);
+    }, T = (m) => {
+      if (m <= e)
+        return (r ? r.joinHeight : k) / e * o(m / e);
+      if (r && m <= l)
+        return r.velocity;
+      const y = (m - l) / (1 - l);
+      return v(y);
+    }, H = t <= 1 ? 100 : 100 * (1 - a / 100);
+    return {
+      p: N,
+      v: T,
+      meta: {
+        r: s,
+        finalPct: H,
+        k: c,
+        B: u,
+        P: k,
+        guard: I || "ok",
+        useBridge: !!r
+      }
+    };
+  }
+}, dt = R;
+function Ft(e, t, a, n) {
+  const o = Math.PI / 2, r = (A) => Math.abs(A) < 222e-17, s = (A) => {
+    const S = Math.sign(A), K = A * S;
+    return ((((-0.021641405 * K + 0.077981383) * K + -0.213301322) * K + o) * Math.sqrt(1 - K) - o) * S + o;
+  }, i = (A) => {
+    if (Math.abs(A) < 1) {
+      const S = A * A, K = S * A, Ot = K * S;
+      return A + K / 6 + Ot / 120;
+    }
+    return Math.sinh(A);
+  }, l = e - a, d = t - n, u = 3 * e, c = 3 * t, M = 3 * l + 1, b = -u - 3 * l, I = u, g = 3 * d + 1, p = -c - 3 * d, P = c, O = 1 / M, f = b * O, E = I * O, V = f / -3 * f + E, _ = f / 3, v = (2 * _ * _ - E) * _, F = Math.sign(V), k = Math.sign(b);
+  let B = 1, N = 1, T = 1, H, m, y;
+  if (r(M) && r(b))
+    H = 1, B = 1 / I, N = 0, m = 1, y = 0;
+  else if (r(M))
+    H = 2, B = k, N = -(I / (2 * b)), m = 1 / b, y = N * N;
+  else if (r(V))
+    H = 3, N = -_, m = O, y = -v;
+  else {
+    if (M < 0)
+      H = 4;
+    else if (V > 0)
+      H = 5;
+    else if (V < 0)
+      H = 6, T = k;
+    else
+      throw new Error("Invalid curve type");
+    B = -2 * F * T * Math.sqrt(Math.abs(V) / 3), N = -_, m = 3 * F * O / (V * B), y = 3 * F * (-v / V / B);
+  }
+  const h = g * B * B * B, w = (3 * g * N + p) * B * B, x = ((3 * g * N + 2 * p) * N + P) * B, $ = ((g * N + p) * N + P) * N;
+  return (A) => {
+    if (A <= 0) return 0;
+    if (A >= 1) return 1;
+    let S = m * A + y;
+    switch (H) {
+      case 1:
+        break;
+      case 2:
+        S = Math.sqrt(Math.max(0, S));
+        break;
+      case 3:
+        S = Math.cbrt(S);
+        break;
+      case 4:
+        S = Math.cos(
+          s(Math.max(-1, Math.min(1, S))) / 3 - 2.094395102393195
+        );
+        break;
+      case 5:
+        S = i(Math.log(S + Math.sqrt(S * S + 1)) / 3);
+        break;
+      case 6:
+        S = S >= 1 ? (
+          // Inlined fastAcosh: Math.acosh(phi) would be Math.log(phi + Math.sqrt(phi * phi - 1))
+          Math.cosh(Math.log(S + Math.sqrt(S * S - 1)) / 3)
+        ) : Math.cos(s(Math.max(-1, S)) / 3);
+        break;
+      default:
+        throw new Error("Invalid curve type");
+    }
+    return ((h * S + w) * S + x) * S + $;
+  };
+}
+function et(e, t, a, n) {
+  if (e < 0 || e > 1 || a < 0 || a > 1)
+    throw new Error("x1 & x2 must be in [0, 1]");
+  return e === t && a === n ? (o) => o : Ft(e, t, a, n);
+}
+function Ht(e, t) {
+  if (e <= 0) return 0;
+  if (e >= 1) return Number.POSITIVE_INFINITY;
+  if (t <= 1) return 0;
+  if (t - 1 < 1e-10) {
+    const n = e / (1 - e);
+    return Math.max(0, n * Math.pow(t - 1, 2));
+  }
+  const a = Math.pow((t - 1) / t, t - 1) / t;
+  return Math.pow(e, t) / (1 - e) * a;
+}
+function st(e, t) {
+  if (e <= 0 || t <= 1) return 0;
+  const a = e;
+  let n = 0, o = 1 - 1e-9;
+  for (let s = 0; s < 60; s++) {
+    const i = 0.5 * (n + o);
+    Ht(i, t) < a ? n = i : o = i;
+  }
+  const r = 0.5 * (n + o);
+  return r / (1 - r);
+}
+function At(e, t, a) {
+  const n = t;
+  if (a === 0 || n <= 1)
+    return Math.pow(e, Math.max(n, 0));
+  if (n - 1 < 1e-10)
+    return (a + 1) * e - a;
+  const r = Math.pow(e, n - 1) * ((a + 1) * e - a);
+  return r === 0 ? 0 : r;
+}
+function bt(e, t, a) {
+  const n = t;
+  return a === 0 || n <= 1 ? n * Math.pow(e, n - 1) : n - 1 < 1e-10 ? a + 1 : Math.abs(n - 2) < 1e-10 ? 2 * (a + 1) * e - a : e === 0 && n > 2 ? 0 : e === 0 && n <= 2 ? n * (a + 1) * Math.pow(1e-10, n - 1) : n * (a + 1) * Math.pow(e, n - 1) - a * (n - 1) * Math.pow(e, n - 2);
+}
+function Pe(e, t) {
+  if (t <= 0 || e <= 1) return 0;
+  const a = e, n = st(t, a);
+  return n <= 0 ? 0 : (a - 1) * n / (a * (n + 1));
+}
+function Oe(e) {
+  const t = e;
+  if (t <= 1)
+    return { u: 0.5, p: Math.pow(0.5, Math.max(t, 0)) };
+  const a = Math.pow(t, -1 / (t - 1));
+  return { u: a, p: Math.pow(a, t) };
+}
+function xe(e, t, a = 1.01, n = 10) {
+  if (e <= 0 || t <= 0 || t >= 1) return null;
+  const o = (d) => {
+    const u = st(e, d);
+    return u <= 0 ? 0 : (d - 1) * u / (d * (u + 1));
+  }, r = o(a), s = o(n);
+  if (t <= r && r > 0)
+    return a;
+  if (t >= s)
+    return n;
+  let i = a, l = n;
+  for (let d = 0; d < 50; d++) {
+    const u = 0.5 * (i + l), c = o(u);
+    if (Math.abs(c - t) < 1e-9)
+      return u;
+    c < t ? i = u : l = u;
+  }
+  return 0.5 * (i + l);
+}
+function Tt(e = 0.1) {
+  const t = it(e), a = (o) => {
+    const r = 1 - o;
+    return 1 - ((t + 1) * r * r * r - t * r * r);
+  }, n = (o) => {
+    const r = 1 - o;
+    return (t + 1) * 3 * r * r - t * 2 * r;
+  };
+  return {
+    id: "back-out",
+    label: `Back Out (${(e * 100).toFixed(0)}%)`,
+    easingFn: a,
+    velocityFn: n,
+    config: { overshoot: e }
+  };
+}
+function ot(e = 2) {
+  const t = Math.max(0.1, e);
+  return {
+    id: "power-out",
+    label: `Power Out (t^${t})`,
+    easingFn: (a) => {
+      const n = 1 - a;
+      return 1 - Math.pow(n, t);
+    },
+    velocityFn: (a) => {
+      const n = 1 - a;
+      return t * Math.pow(n, t - 1);
+    },
+    config: { exponent: t }
+  };
+}
+function Dt(e = 2, t = 0.1) {
+  const a = Math.max(0.1, e);
+  if (t <= 0 || a <= 1)
+    return ot(e);
+  const n = st(t, a), o = (s) => {
+    const i = 1 - s;
+    return n === 0 || a <= 1 ? 1 - Math.pow(i, a) : a - 1 < 1e-10 ? 1 - ((n + 1) * i - n) : 1 - Math.pow(i, a - 1) * ((n + 1) * i - n);
+  }, r = (s) => {
+    const i = 1 - s;
+    return bt(i, a, n);
+  };
+  return {
+    id: "power-back-out",
+    label: `Power Back Out (${(t * 100).toFixed(0)}%, n=${a.toFixed(2)})`,
+    easingFn: o,
+    velocityFn: r,
+    config: { exponent: a, overshoot: t, strength: n }
+  };
+}
+function Kt(e = 0.5, t = 0, a = 1, n = 0.5) {
+  const o = et(e, t, a, n), r = j(o, {
+    step: 1e-8,
+    boundarySample: 1e-3
+  });
+  return {
+    id: "bezier-out",
+    label: `Bezier (${e.toFixed(2)}, ${t.toFixed(2)}, ${a.toFixed(2)}, ${n.toFixed(2)})`,
+    easingFn: o,
+    velocityFn: r,
+    config: { x1: e, y1: t, x2: a, y2: n }
+  };
+}
+function Ct(e = 0.95) {
+  const t = Math.max(0, Math.min(1, e));
+  if (t === 0)
+    return {
+      id: "expo-out",
+      label: "Expo Out (linear)",
+      easingFn: (s) => s <= 0 ? 0 : s >= 1 ? 1 : s,
+      velocityFn: () => 1,
+      config: { decay: t }
+    };
+  if (t === 1)
+    return {
+      id: "expo-out",
+      label: "Expo Out (step)",
+      easingFn: (s) => s > 0 ? 1 : 0,
+      velocityFn: () => 0,
+      config: { decay: t }
+    };
+  const a = Math.log1p(-t), n = 1 / Math.expm1(a), o = mt(t), r = (s) => a * Math.exp(a * s) * n;
+  return {
+    id: "expo-out",
+    label: `Expo Out (${(t * 100).toFixed(0)}%)`,
+    easingFn: o,
+    velocityFn: r,
+    config: { decay: t }
+  };
+}
+const zt = {
+  back: Tt,
+  power: ot,
+  "power-back": Dt,
+  bezier: Kt,
+  expo: Ct
+};
+function Ee(e, t) {
+  const a = zt[e];
+  return e === "back" ? a(t?.overshoot ?? 0.1) : e === "power" ? a(t?.exponent ?? 2) : e === "power-back" ? a(t?.exponent ?? 2, t?.overshoot ?? 0.1) : e === "expo" ? a(t?.decay ?? 0.95) : a(
+    t?.x1 ?? 0.5,
+    t?.y1 ?? 0,
+    t?.x2 ?? 1,
+    t?.y2 ?? 0.5
+  );
+}
+function nt(e, t, a) {
+  let n;
+  Object.defineProperty(e, t, {
+    get: () => n ??= a(),
+    configurable: !0,
+    enumerable: !0
+  });
+}
+class J {
+  /** Immutable parameter object */
+  params;
+  constructor(t) {
+    this.params = Object.freeze({ ...t }), nt(this, "easeInVelocity", () => j(this.easeIn)), nt(this, "easeOutVelocity", () => j(this.easeOut));
+  }
+  /** Ease-out function — default: reverse of easeIn */
+  easeOut = (t) => 1 - this.easeIn(1 - t);
+  /** Velocity boundary for ease-out variant — default: reversed easeIn */
+  get easeOutBoundary() {
+    return {
+      start: this.easeInBoundary.end,
+      end: this.easeInBoundary.start
+    };
+  }
+}
+class G extends J {
+  static STROKES_KNOB = {
+    key: "strokes",
+    label: "Strokes",
+    type: "number",
+    default: 2,
+    min: 1,
+    max: 10,
+    step: 0.05,
+    isPrimary: !0
+  };
+  static EFFORT_KNOB = {
+    key: "effort",
+    label: "Effort",
+    type: "percent",
+    default: 0.4,
+    min: 0.05,
+    max: 0.95,
+    step: 0.01
+  };
+  static DRAG_KNOB = {
+    key: "drag",
+    label: "Drag",
+    type: "number",
+    default: 6,
+    min: 0.5,
+    max: 30,
+    step: 0.1
+  };
+  kind = "swim";
+  metadata = {
+    variants: { easeIn: !0, easeOut: !0 },
+    modes: { transition: !0, pulse: !1 }
+  };
+  knobSpecs = [
+    G.STROKES_KNOB,
+    G.EFFORT_KNOB,
+    G.DRAG_KNOB
+  ];
+  easeInBoundary = {
+    start: "zero",
+    end: "nonzero"
+  };
+  constructor(t) {
+    super(t);
+    const a = kt(t);
+    this.easeIn = (n) => a(n);
+  }
+  with(t) {
+    return new G({ ...this.params, ...t });
+  }
+  static create(t = {}) {
+    return new G({
+      strokes: t.strokes ?? 2,
+      effort: t.effort ?? 0.2,
+      drag: t.drag ?? 6
+    });
+  }
+}
+function Lt(e = 0.1) {
+  const t = it(e), a = t + 1;
+  return {
+    id: "back",
+    label: `Back (${(e * 100).toFixed(0)}% overshoot)`,
+    easingFn: (n) => n * n * (a * n - t),
+    velocityFn: (n) => n * (3 * a * n - 2 * t),
+    config: { overshoot: e, strength: t }
+  };
+}
+Lt(0.1);
+function Jt(e, t, a) {
+  const n = Math.max(1e-3, Math.min(0.999, a));
+  return (o) => {
+    if (o <= 0 || o >= 1) return 0;
+    if (o <= n) {
+      const r = o / n;
+      return e(r);
+    } else {
+      const r = (o - n) / (1 - n);
+      return 1 - t(r);
+    }
+  };
+}
+function $t(e = {}) {
+  const { bounces: t = 4, decay: a = 90 } = e, n = Math.max(0.5, t), o = Math.max(0, 1 - a / 100), r = n <= 1 ? o : o === 0 ? 0 : Math.pow(o, 1 / (n - 1)), s = n * Math.PI, i = r <= 0 ? 50 : s / Math.PI * -Math.log(r), l = i / s, d = Math.exp(-i) * (Math.cos(s) + l * Math.sin(s));
+  return (u) => u <= 0 ? 1 : u >= 1 ? 0 : Math.exp(-i * u) * (Math.cos(s * u) + l * Math.sin(s * u)) - d * u;
+}
+function Gt(e = {}) {
+  const { bounces: t = 4, decay: a = 90 } = e, n = Math.max(1, Math.round(t)), o = Math.max(0, 1 - a / 100), r = n <= 1 ? Math.sqrt(o) : o === 0 ? 0 : Math.pow(o, 1 / (2 * (n - 1)));
+  if (r === 0)
+    return (c) => c <= 0 ? 1 : c >= 1 ? 0 : 1 - c * c;
+  const s = Math.abs(1 - r) < 1e-6 ? 1 + 2 * n : 1 + 2 * r * (1 - Math.pow(r, n)) / (1 - r), i = 2 * s * s, l = 1 / s, d = i * l, u = [0, l];
+  for (let c = 1; c <= n; c++) {
+    const M = 2 * Math.pow(r, c) * d / i;
+    u.push(u[u.length - 1] + M);
+  }
+  return u[u.length - 1] = 1, (c) => {
+    if (c <= 0) return 1;
+    if (c >= 1) return 0;
+    if (c <= l)
+      return 1 - 0.5 * i * c * c;
+    let M = 0;
+    for (let p = 1; p < u.length - 1; p++)
+      if (c <= u[p + 1]) {
+        M = p;
+        break;
+      }
+    M === 0 && (M = u.length - 2);
+    const I = Math.pow(r, M) * d, g = c - u[M];
+    return I * g - 0.5 * i * g * g;
+  };
+}
+function ht(e, t, a) {
+  const n = Math.max(1e-3, Math.min(0.999, a));
+  return (o) => {
+    if (o <= 0 || o >= 1) return 0;
+    if (o <= n) {
+      const r = o / n;
+      return e(r);
+    } else {
+      const r = (o - n) / (1 - n);
+      return t(r);
+    }
+  };
+}
+function ke(e, t) {
+  return {
+    isValid: !0,
+    point: {
+      x: 1 - e.x,
+      y: 1 - e.y
+    }
+  };
+}
+function ve(e, t) {
+  return {
+    isValid: !0,
+    point: {
+      x: 1 - e.x,
+      y: 1 - e.y
+    }
+  };
+}
+class W extends J {
+  static EXPONENT_KNOB = {
+    key: "exponent",
+    label: "Exponent",
+    type: "number",
+    default: 2,
+    min: 0.1,
+    max: 10,
+    step: 0.01,
+    isPrimary: !0
+  };
+  kind = "power";
+  metadata = {
+    variants: { easeIn: !0, easeOut: !0 },
+    modes: { transition: !0, pulse: !0 }
+  };
+  knobSpecs = [W.EXPONENT_KNOB];
+  constructor(t) {
+    super(t);
+  }
+  get easeInBoundary() {
+    return {
+      start: this.params.exponent > 1 ? "zero" : "nonzero",
+      end: "nonzero"
+    };
+  }
+  easeIn = (t) => Math.pow(t, this.params.exponent);
+  easeInVelocity = (t) => {
+    const a = this.params.exponent;
+    return a * Math.pow(t, a - 1);
+  };
+  // Analytical: d/du[1 - easeIn(1-u)] = easeInVelocity(1-u)
+  easeOutVelocity = (t) => this.easeInVelocity(1 - t);
+  with(t) {
+    return new W({
+      ...this.params,
+      ...t,
+      exponent: Math.max(0.1, t.exponent ?? this.params.exponent)
+    });
+  }
+  static create(t = {}) {
+    const a = Math.max(0.1, t.exponent ?? 2);
+    return new W({ exponent: a });
+  }
+}
+const Yt = 1e-4, Xt = 0.9999, qt = 0, Ut = 1;
+function Wt(e) {
+  if (Number.isNaN(e))
+    return { atStart: !1, atEnd: !1 };
+  const t = Math.max(qt, Math.min(Ut, e));
+  return {
+    atStart: t <= Yt,
+    atEnd: t >= Xt
+  };
+}
+function ft(e) {
+  const { joinTime: t, headVelocityAtEnd: a, tailVelocityAtStart: n } = e;
+  if (t <= 0 || t >= 1)
+    return {
+      joinHeight: 0,
+      isValid: !1,
+      warning: `Invalid joinTime: ${t}. Must be in range (0, 1).`
+    };
+  if (a === 0)
+    return {
+      joinHeight: 0,
+      isValid: !1,
+      warning: `Invalid headVelocityAtEnd: ${a}. Must be non-zero.`
+    };
+  if (n <= 0)
+    return {
+      joinHeight: 0,
+      isValid: !1,
+      warning: `Invalid tailVelocityAtStart: ${n}. Must be positive.`
+    };
+  const o = a * (1 - t) + t * n;
+  if (Math.abs(o) < 1e-10)
+    return {
+      joinHeight: 0,
+      isValid: !1,
+      warning: "Denominator too close to zero. Cannot calculate join height."
+    };
+  const r = t * n / o;
+  let s;
+  return r < 0 ? s = `Join height is negative (${r.toFixed(4)}). This may indicate incompatible velocities.` : r > 1 ? a < 0 ? s = `Join height exceeds 1 (${r.toFixed(4)}) due to negative head slope. This creates a natural reflection/dip effect.` : s = `Join height exceeds 1 (${r.toFixed(4)}). This may cause overshoot beyond target.` : a < 0 && r <= 1 && (s = `Head ends with negative slope (${a.toFixed(4)}). Curve will dip below join height before tail recovers.`), {
+    joinHeight: r,
+    isValid: !0,
+    warning: s
+  };
+}
+function _t(e) {
+  const {
+    joinTime: t,
+    headVelocityAtEnd: a,
+    pulseNaturalStartVelocity: n,
+    isBounceStrategy: o
+  } = e;
+  if (o)
+    return {
+      isValid: !1,
+      failureReason: "bounce_tail_unsupported"
+    };
+  if (n <= 0)
+    return {
+      isValid: !1,
+      failureReason: "invalid_pulse_velocity"
+    };
+  const r = n;
+  let s = r * t / a;
+  s < 0 && (s = 1), s >= 1 && (s = 0.9999);
+  const l = (1 - s) / r;
+  return l <= 0 ? {
+    isValid: !1,
+    failureReason: "invalid_bridge_duration"
+  } : t + l >= 1 ? {
+    isValid: !1,
+    failureReason: "bridge_exceeds_timeline"
+  } : {
+    isValid: !0,
+    bridgeParams: {
+      joinHeight: s,
+      duration: l,
+      velocity: r
+    }
+  };
+}
+function Zt(e, t, a) {
+  return e !== void 0 && Number.isFinite(e) && e > 0 && t > 0 && a > 0;
+}
+function Qt(e, t, a, n) {
+  return t ? e * a / n : 0;
+}
+function Rt(e, t, a) {
+  const n = e;
+  return 1 / (1 / n + (a - a / n) + (1 - a) / t);
+}
+function jt(e) {
+  const {
+    joinTime: t,
+    headVelocityAtEnd: a,
+    tailVelocityAtStart: n,
+    maxSpeed: o,
+    naturalJoinHeight: r,
+    naturalJoinHeightIsValid: s
+  } = e;
+  if (Qt(
+    r,
+    s,
+    a,
+    t
+  ) <= o) return null;
+  const l = a, d = Rt(l, n, t), u = Math.max(o, Math.max(d, 1));
+  let c;
+  if (Math.abs(1 / l - 1) < 1e-9)
+    c = 0;
+  else {
+    const O = 1 / l - 1, f = 1 - 1 / n, E = 1 / u - 1 / n, V = t * O / (1 - t), _ = f - V;
+    let v;
+    Math.abs(_) < 1e-9 ? v = t : v = (E - V) / _, v = Math.max(t, Math.min(1 - 0.01, v)), c = t * (1 - v) / (1 - t), c = Math.max(0, Math.min(t, c));
+  }
+  const M = c > 0 ? u * c / l : 0, b = c > 0 ? t + (t - c) * (1 - t) / t : t + (1 - t) * (1 - 1 / (u * (1 / n))), I = Math.max(t, Math.min(1 - 0.01, b)), p = M + u * (t - c) + u * (I - t), P = 1 - I;
+  return p <= 0 || p >= 1 || P <= 0.01 ? null : {
+    cruiseSpeed: u,
+    tStar: c,
+    tC: I,
+    headHeight: M,
+    tailStartPos: p
+  };
+}
+function te(e, t, a) {
+  const { cruiseSpeed: n, tStar: o, tC: r, headHeight: s, tailStartPos: i } = e, l = 1 - r;
+  return (d) => {
+    if (d <= 0) return 0;
+    if (d >= 1) return 1;
+    if (o > 0 && d <= o) {
+      const u = d / o;
+      return s * t(u);
+    } else {
+      if (d <= r)
+        return (o > 0 ? s : 0) + n * (d - o);
+      {
+        const u = (d - r) / l;
+        return i + (1 - i) * a(u);
+      }
+    }
+  };
+}
+function ee(e) {
+  const {
+    joinTime: t,
+    headBounces: a,
+    headDecay: n,
+    tailBounces: o,
+    tailDecay: r,
+    springTailBuilder: s
+  } = e, i = s.build({
+    joinTime: 0.5,
+    bounces: a,
+    decayPct: n,
+    bridge: void 0
+  }), l = Y(i.p), d = (g) => l(g * 0.5), u = (g) => i.v(1 - g * 0.5) * 0.5, c = t, M = (g) => g <= 0 ? 0 : g >= t ? t : c * d(g / t), b = (g) => g <= 0 || g >= t ? 0 : c / t * u(g / t);
+  return s.build({
+    joinTime: t,
+    bounces: o,
+    decayPct: r,
+    L: M,
+    Ld: b,
+    bridge: void 0
+  }).p;
+}
+const ne = 10;
+function ae(e) {
+  const { joinTime: t, headBounces: a, headDecay: n, tailBounces: o, tailDecay: r } = e;
+  if (t <= 0 || t >= 1)
+    return { easingFn: null };
+  if (a < 1 || o < 1)
+    return { easingFn: null };
+  const s = dt.build({
+    joinTime: 0.5,
+    bounces: a,
+    decayPct: n,
+    bridge: void 0
+  }), i = dt.build({
+    joinTime: 0.5,
+    bounces: o,
+    decayPct: r,
+    bridge: void 0
+  }), l = Y(s.p), d = (_) => l(_ * 0.5), u = ne, c = t, M = c / u, b = (1 - c) / u, I = t - M, g = t + b, p = 1 - g;
+  if (I <= 0 || M <= 0 || b <= 0 || p <= 0)
+    return { easingFn: null };
+  const P = 2 * I, O = 2 * p, f = d(1), E = i.p(0.5);
+  return {
+    easingFn: (_) => {
+      if (_ <= 0) return 0;
+      if (_ >= 1) return 1;
+      if (_ <= I) {
+        const v = _ / I;
+        return P * d(v);
+      } else if (_ <= t) {
+        const v = P * f, F = (_ - I) / M;
+        return v + (c - v) * F;
+      } else if (_ <= g) {
+        const v = 1 - O * (1 - E), F = (_ - t) / b;
+        return c + (v - c) * F;
+      } else {
+        const v = (_ - g) / p, F = i.p(0.5 + v * 0.5);
+        return 1 - O * (1 - F);
+      }
+    },
+    diagnostics: {
+      joinPosition: c,
+      headBridgeDuration: M,
+      tailBridgeDuration: b,
+      headPulseDuration: I,
+      tailPulseDuration: p,
+      bridgeVelocity: u
+    }
+  };
+}
+function re() {
+  return {
+    easingFn: (e) => e,
+    velocityFn: () => 1
+  };
+}
+function se(e, t) {
+  const { joinTime: a, pulseTail: n, useBridge: o = !0, bridgeTuning: r } = e;
+  if (a <= 0 || a >= 1)
+    throw new Error(`Invalid joinTime: ${a}. Must be in range (0, 1).`);
+  if (n.bounces < 1)
+    throw new Error(
+      `Invalid pulse tail bounces: ${n.bounces}. Must be >= 1.`
+    );
+  const s = re(), i = 1 - a, l = t(n.strategy, {
+    head: s.easingFn,
+    headVelocityFn: s.velocityFn,
+    join: i,
+    bounces: n.bounces,
+    decay: n.decay,
+    useBridge: o,
+    bridgeTuning: r
+  });
+  return Y(l);
+}
+function z(e) {
+  return e.params;
+}
+function oe(e, t, a = {}) {
+  const {
+    joinTime: n = 0.5,
+    movement: o = "transition",
+    mirror: r = !1,
+    useBridge: s = !0,
+    bridgeTuning: i,
+    allowGeneralizedBackTail: l = !1,
+    maxSpeed: d
+  } = a, u = {
+    movement: o,
+    headKind: e.kind,
+    tailKind: t.kind,
+    joinTime: n,
+    mirror: r
+  };
+  return o === "pulse" ? ie(e, t, n, u) : ce(e, t, {
+    joinTime: n,
+    mirror: r,
+    useBridge: s,
+    bridgeTuning: i,
+    allowGeneralizedBackTail: l,
+    maxSpeed: d,
+    meta: u
+  });
+}
+function ie(e, t, a, n) {
+  const r = (e.kind === "spring" ? W.create({
+    exponent: z(e).bounces ?? 2
+  }) : e).easeOut;
+  let s;
+  if (t.kind === "spring") {
+    const { bounces: i, decay: l } = z(t);
+    s = ht(
+      r,
+      $t({ bounces: i, decay: l * 100 }),
+      a
+    );
+  } else if (t.kind === "bounce") {
+    const { bounces: i, decay: l } = z(t);
+    s = ht(
+      r,
+      Gt({ bounces: i, decay: l * 100 }),
+      a
+    );
+  } else
+    s = Jt(r, t.easeIn, a);
+  return D(s, n);
+}
+function ce(e, t, a) {
+  const { joinTime: n, mirror: o } = a, r = Wt(n);
+  return r.atStart && !(t.kind === "spring" || t.kind === "bounce") ? D((s) => Math.max(0, Math.min(1, s)), a.meta) : r.atEnd ? D(e.easeIn, a.meta) : e.kind === "spring" ? ue(e, t, a) : t.kind === "spring" || t.kind === "bounce" ? le(e, t, a) : e.kind === "bezier" && t.kind === "bezier" ? de(e, t, a) : he(e, t, a);
+}
+function ue(e, t, a) {
+  const { joinTime: n, useBridge: o, bridgeTuning: r } = a, s = z(e), i = s.bounces ?? 4, l = (s.decay ?? 0.95) * 100;
+  if (t.kind === "spring") {
+    const p = z(t), P = ae({
+      joinTime: n,
+      headBounces: i,
+      headDecay: l,
+      tailBounces: p.bounces,
+      tailDecay: p.decay * 100
+    });
+    if (P.easingFn)
+      return D(P.easingFn, a.meta);
+    const O = ee({
+      joinTime: n,
+      headBounces: i,
+      headDecay: l,
+      tailBounces: p.bounces,
+      tailDecay: p.decay * 100,
+      springTailBuilder: R
+    });
+    return D(O, a.meta);
+  }
+  if (t.kind === "bounce") {
+    const p = z(t), P = se(
+      {
+        joinTime: n,
+        // TODO: springHead.decay uses tailParams — should it use headParams instead?
+        // This path is currently disabled (spring head not exposed in Fuse app).
+        // When re-enabling, verify whether the spring head's own decay should drive
+        // the complementary curve, rather than mirroring the bounce tail's decay.
+        springHead: { decay: p.decay * 100 },
+        pulseTail: {
+          strategy: tt,
+          bounces: p.bounces,
+          decay: p.decay * 100
+        },
+        useBridge: o,
+        bridgeTuning: r
+      },
+      (O, f) => pt(O, f)
+    );
+    return D(P, a.meta);
+  }
+  const d = a.mirror ? Y(e.easeIn) : t.easeOut, u = a.mirror ? (p) => e.easeInVelocity(1 - p) : t.easeOutVelocity, c = Y(d), M = (p) => u(1 - p), b = 1 - n, I = pt(R, {
+    head: c,
+    headVelocityFn: M,
+    joinTime: b,
+    bounces: i,
+    decay: l,
+    useBridge: !0,
+    bridgeTuning: r
+  }), g = Y(I);
+  return D(g, a.meta);
+}
+function le(e, t, a) {
+  const { joinTime: n, useBridge: o, bridgeTuning: r } = a, s = z(t), i = s.bounces, l = s.decay * 100, d = (t.kind === "spring", t.constructor.tailStrategy), u = e.easeIn, c = e.easeInVelocity;
+  let M;
+  const b = t.kind === "spring";
+  if (o && !b && d.getNaturalStartVelocity) {
+    const g = d.getNaturalStartVelocity(
+      { bounces: i, decayPct: l },
+      c,
+      r
+    ), p = _t({
+      joinTime: n,
+      headVelocityAtEnd: c(1),
+      pulseNaturalStartVelocity: g,
+      isBounceStrategy: t.kind === "bounce"
+    });
+    p.isValid && (M = p.bridgeParams);
+  }
+  const I = d.build({
+    joinTime: n,
+    bounces: i,
+    decayPct: l,
+    L: u,
+    Ld: c,
+    bridge: M
+  });
+  return D(I.p, a.meta);
+}
+function de(e, t, a) {
+  const { joinTime: n } = a, o = z(e), r = z(t), s = n, i = o.x1 * n, l = o.y1 * s, d = o.x2 * n, u = o.y2 * s, c = n, M = s;
+  let b;
+  Math.abs(c - d) < 1e-8 ? b = 1e8 : b = (M - u) / (c - d);
+  const I = n + r.x1 * (1 - n), g = s + b * (I - n), p = n + r.x2 * (1 - n), P = s + r.y2 * (1 - s), O = i / n, f = l / s, E = d / n, V = u / s, _ = et(
+    O,
+    f,
+    E,
+    V
+  ), v = (I - n) / (1 - n), F = (g - s) / (1 - s), k = (p - n) / (1 - n), B = (P - s) / (1 - s), N = et(
+    v,
+    F,
+    k,
+    B
+  );
+  return D((H) => {
+    if (H <= 0) return 0;
+    if (H >= 1) return 1;
+    if (H <= n) {
+      const m = H / n;
+      return s * _(m);
+    } else {
+      const m = (H - n) / (1 - n);
+      return s + (1 - s) * N(m);
+    }
+  }, a.meta);
+}
+function he(e, t, a) {
+  const { joinTime: n, mirror: o, allowGeneralizedBackTail: r, maxSpeed: s } = a, i = e.easeIn, l = e.easeInVelocity;
+  let d, u;
+  o ? (d = Y(i), u = (P) => l(1 - P)) : (d = t.easeOut, u = t.easeOutVelocity);
+  const c = l(1), M = u(0);
+  if (Zt(s, c, M)) {
+    const P = ft({
+      joinTime: n,
+      headVelocityAtEnd: c,
+      tailVelocityAtStart: M
+    }), O = jt({
+      joinTime: n,
+      headVelocityAtEnd: c,
+      tailVelocityAtStart: M,
+      maxSpeed: s,
+      naturalJoinHeight: P.joinHeight,
+      naturalJoinHeightIsValid: P.isValid
+    });
+    if (O) {
+      const f = te(
+        O,
+        i,
+        d
+      );
+      return D(f, a.meta);
+    }
+  }
+  let b, I = !1, g = c;
+  if (c < 0 && (t.kind === "power" || t.kind === "back"))
+    b = 1, I = !0, g = c * (b / n);
+  else {
+    const P = ft({
+      joinTime: n,
+      headVelocityAtEnd: c,
+      tailVelocityAtStart: M
+    });
+    if (!P.isValid)
+      return D((f) => Math.max(0, Math.min(1, f)), a.meta);
+    const O = P.joinHeight;
+    b = Math.max(0, Math.min(1, O)), r && b >= 0.9999 && (t.kind === "power-back" || t.kind === "back" || t.kind === "power") && (I = !0, b = 1, g = c * (b / n));
+  }
+  return D((P) => {
+    if (P <= 0) return 0;
+    if (P >= 1) return 1;
+    if (P <= n) {
+      const O = P / n;
+      return b * i(O);
+    } else {
+      const O = (P - n) / (1 - n);
+      if (I) {
+        const f = g * (1 - n), E = b, V = f, _ = (3 * (1 - E) - 2 * V) / (V - (1 - E));
+        return (1 - V - E) * ((_ + 1) * O * O * O - _ * O * O) + V * O + E;
+      } else
+        return b + (1 - b) * d(O);
+    }
+  }, a.meta);
+}
+function pt(e, t) {
+  const {
+    head: a = (c) => c,
+    headVelocityFn: n = () => 1,
+    joinTime: o = 0.5,
+    bounces: r = 4,
+    decay: s = 95,
+    useBridge: i = !0,
+    bridgeTuning: l
+  } = t;
+  let d;
+  if (i && e.getNaturalStartVelocity) {
+    const c = e.getNaturalStartVelocity(
+      { bounces: r, decayPct: s },
+      n,
+      l
+    ), M = _t({
+      joinTime: o,
+      headVelocityAtEnd: n(1),
+      pulseNaturalStartVelocity: c,
+      isBounceStrategy: e === tt
+    });
+    M.isValid && (d = M.bridgeParams);
+  }
+  return e.build({
+    joinTime: o,
+    bounces: r,
+    decayPct: s,
+    L: a,
+    Ld: n,
+    bridge: d
+  }).p;
+}
+class Z extends J {
+  static OVERSHOOT_KNOB = {
+    key: "overshoot",
+    label: "Overshoot",
+    type: "percent",
+    default: 0.1,
+    min: 0,
+    max: 1,
+    step: 0.01,
+    isPrimary: !0
+  };
+  kind = "back";
+  metadata = {
+    variants: { easeIn: !0, easeOut: !0 },
+    modes: { transition: !0, pulse: !0 }
+  };
+  knobSpecs = [Z.OVERSHOOT_KNOB];
+  easeInBoundary = {
+    start: "zero",
+    end: "nonzero"
+  };
+  /** Cached strength parameter derived from overshoot */
+  strength;
+  constructor(t) {
+    super(t), this.strength = it(t.overshoot);
+  }
+  easeIn = (t) => vt(t, this.strength);
+  easeInVelocity = (t) => lt(t, this.strength);
+  // Analytical: d/du[1 - easeIn(1-u)] = easeInVelocity(1-u)
+  easeOutVelocity = (t) => lt(1 - t, this.strength);
+  with(t) {
+    return new Z({ ...this.params, ...t });
+  }
+  static create(t = {}) {
+    const a = t.overshoot ?? 0.1;
+    return new Z({ overshoot: a });
+  }
+}
+class X extends J {
+  static EXPONENT_KNOB = {
+    key: "exponent",
+    label: "Exponent",
+    type: "number",
+    default: 3,
+    min: 0.1,
+    max: 10,
+    step: 0.01,
+    isPrimary: !0
+  };
+  static OVERSHOOT_KNOB = {
+    key: "overshoot",
+    label: "Overshoot",
+    type: "percent",
+    default: 0,
+    min: 0,
+    max: 1,
+    step: 0.01
+  };
+  kind = "power-back";
+  metadata = {
+    variants: { easeIn: !0, easeOut: !0 },
+    modes: { transition: !0, pulse: !0 }
+  };
+  knobSpecs = [
+    X.EXPONENT_KNOB,
+    X.OVERSHOOT_KNOB
+  ];
+  /** Cached strength parameter derived from overshoot + exponent */
+  strength;
+  constructor(t) {
+    super(t), this.strength = st(t.overshoot, t.exponent);
+  }
+  get easeInBoundary() {
+    return {
+      start: this.params.exponent > 2 || this.params.overshoot <= 0 ? "zero" : "nonzero",
+      end: "nonzero"
+    };
+  }
+  easeIn = (t) => At(t, this.params.exponent, this.strength);
+  easeInVelocity = (t) => bt(t, this.params.exponent, this.strength);
+  // Analytical: d/du[1 - easeIn(1-u)] = easeInVelocity(1-u)
+  easeOutVelocity = (t) => this.easeInVelocity(1 - t);
+  with(t) {
+    return new X({
+      ...this.params,
+      ...t,
+      exponent: Math.max(0.1, t.exponent ?? this.params.exponent)
+    });
+  }
+  static create(t = {}) {
+    const a = Math.max(0.1, t.exponent ?? 3), n = t.overshoot ?? 0.3;
+    return new X({ exponent: a, overshoot: n });
+  }
+}
+class L extends J {
+  static X1_KNOB = {
+    key: "x1",
+    label: "X1",
+    type: "number",
+    default: 0.42,
+    min: 0,
+    max: 1,
+    step: 0.01
+  };
+  static Y1_KNOB = {
+    key: "y1",
+    label: "Y1",
+    type: "number",
+    default: 0,
+    min: -0.5,
+    max: 1.5,
+    step: 0.01
+  };
+  static X2_KNOB = {
+    key: "x2",
+    label: "X2",
+    type: "number",
+    default: 1,
+    min: 0,
+    max: 1,
+    step: 0.01
+  };
+  static Y2_KNOB = {
+    key: "y2",
+    label: "Y2",
+    type: "number",
+    default: 1,
+    min: -0.5,
+    max: 1.5,
+    step: 0.01
+  };
+  kind = "bezier";
+  metadata = {
+    variants: { easeIn: !0, easeOut: !0 },
+    modes: { transition: !0, pulse: !0 }
+  };
+  knobSpecs = [
+    L.X1_KNOB,
+    L.Y1_KNOB,
+    L.X2_KNOB,
+    L.Y2_KNOB
+  ];
+  /** Both ends depend on control points — always nonzero */
+  easeInBoundary = {
+    start: "nonzero",
+    end: "nonzero"
+  };
+  // Bezier is general-purpose — easeIn and easeOut are the same curve,
+  // directly defined by the stored control points (no reversal).
+  bezier = et(
+    this.params.x1,
+    this.params.y1,
+    this.params.x2,
+    this.params.y2
+  );
+  easeIn = (t) => this.bezier(t);
+  easeOut = (t) => this.bezier(t);
+  constructor(t) {
+    super(t);
+    const a = () => j(this.bezier, { boundarySample: 1e-3 });
+    nt(this, "easeInVelocity", a), nt(this, "easeOutVelocity", a);
+  }
+  with(t) {
+    return new L({ ...this.params, ...t });
+  }
+  static create(t = {}) {
+    return new L({
+      x1: t.x1 ?? 0.42,
+      y1: t.y1 ?? 0,
+      x2: t.x2 ?? 1,
+      y2: t.y2 ?? 1
+    });
+  }
+}
+class Q extends J {
+  static DECAY_KNOB = {
+    key: "decay",
+    label: "Decay",
+    type: "percent",
+    default: 0.95,
+    min: 0.8,
+    max: 0.999,
+    step: 1e-3,
+    isPrimary: !0
+  };
+  kind = "expo";
+  metadata = {
+    variants: { easeIn: !1, easeOut: !0 },
+    modes: { transition: !0, pulse: !1 }
+  };
+  knobSpecs = [Q.DECAY_KNOB];
+  easeInBoundary = {
+    start: "nonzero",
+    end: "nonzero"
+  };
+  /** Cached ease-out function and derivative constants */
+  easeOutFn;
+  negK;
+  scale;
+  d;
+  constructor(t) {
+    super(t), this.d = Math.max(0, Math.min(1, t.decay)), this.d === 0 ? (this.easeOutFn = (a) => Math.max(0, Math.min(1, a)), this.negK = 0, this.scale = 1) : this.d === 1 ? (this.easeOutFn = (a) => a > 0 ? 1 : 0, this.negK = -1 / 0, this.scale = 0) : (this.negK = Math.log1p(-this.d), this.scale = 1 / Math.expm1(this.negK), this.easeOutFn = mt(this.d));
+  }
+  /** easeIn is the reverse of easeOut (not natively supported, metadata.variants.easeIn = false) */
+  easeIn = (t) => 1 - this.easeOutFn(1 - t);
+  easeInVelocity = (t) => this.easeOutVelocityImpl(1 - t);
+  easeOut = (t) => this.easeOutFn(t);
+  easeOutVelocity = (t) => this.easeOutVelocityImpl(t);
+  easeOutVelocityImpl(t) {
+    return this.d === 0 ? 1 : this.d === 1 ? 0 : this.negK * Math.exp(this.negK * t) * this.scale;
+  }
+  with(t) {
+    return new Q({ ...this.params, ...t });
+  }
+  static create(t = {}) {
+    return new Q({ decay: t.decay ?? 0.95 });
+  }
+}
+const fe = (e) => e, pe = (e) => 1, ye = 1e-4;
+class q extends J {
+  static BOUNCES_KNOB = {
+    key: "bounces",
+    label: "Bounces",
+    type: "number",
+    default: 4,
+    min: 0,
+    max: 10,
+    step: 1,
+    isPrimary: !0
+  };
+  static DECAY_KNOB = {
+    key: "decay",
+    label: "Decay",
+    type: "percent",
+    default: 0.95,
+    min: 0,
+    max: 0.99,
+    step: 0.01
+  };
+  kind = "spring";
+  metadata = {
+    variants: { easeIn: !1, easeOut: !0 },
+    modes: { transition: !0, pulse: !0 }
+  };
+  knobSpecs = [
+    q.BOUNCES_KNOB,
+    q.DECAY_KNOB
+  ];
+  easeInBoundary = {
+    start: "nonzero",
+    end: "nonzero"
+  };
+  /** Cached standalone easeOut function built with minimal head defaults */
+  builtP;
+  builtV;
+  constructor(t) {
+    super(t);
+    const a = R.build({
+      joinTime: ye,
+      bounces: t.bounces,
+      decayPct: t.decay * 100,
+      // TailBuildParams uses 0-100
+      L: fe,
+      Ld: pe
+    });
+    this.builtP = a.p, this.builtV = a.v;
+  }
+  /** easeIn is the reverse of easeOut (not natively supported) */
+  easeIn = (t) => 1 - this.builtP(1 - t);
+  easeInVelocity = (t) => this.builtV(1 - t);
+  easeOut = (t) => this.builtP(t);
+  easeOutVelocity = (t) => this.builtV(t);
+  /** Access the underlying TailStrategy for full fuse composition */
+  static get tailStrategy() {
+    return R;
+  }
+  with(t) {
+    return new q({ ...this.params, ...t });
+  }
+  static create(t = {}) {
+    return new q({
+      bounces: t.bounces ?? 4,
+      decay: t.decay ?? 0.95
+    });
+  }
+}
+const ge = (e) => e, me = (e) => 1, Me = 1e-4;
+class U extends J {
+  static BOUNCES_KNOB = {
+    key: "bounces",
+    label: "Bounces",
+    type: "number",
+    default: 4,
+    min: 1,
+    max: 10,
+    step: 1,
+    isPrimary: !0
+  };
+  static DECAY_KNOB = {
+    key: "decay",
+    label: "Decay",
+    type: "percent",
+    default: 0.95,
+    min: 0,
+    max: 0.99,
+    step: 0.01
+  };
+  kind = "bounce";
+  metadata = {
+    variants: { easeIn: !1, easeOut: !0 },
+    modes: { transition: !0, pulse: !0 }
+  };
+  knobSpecs = [
+    U.BOUNCES_KNOB,
+    U.DECAY_KNOB
+  ];
+  easeInBoundary = {
+    start: "nonzero",
+    end: "nonzero"
+  };
+  /** Cached standalone easeOut function built with minimal head defaults */
+  builtP;
+  builtV;
+  constructor(t) {
+    super(t);
+    const a = tt.build({
+      joinTime: Me,
+      bounces: t.bounces,
+      decayPct: t.decay * 100,
+      L: ge,
+      Ld: me
+    });
+    this.builtP = a.p, this.builtV = a.v;
+  }
+  easeIn = (t) => 1 - this.builtP(1 - t);
+  easeInVelocity = (t) => this.builtV(1 - t);
+  easeOut = (t) => this.builtP(t);
+  easeOutVelocity = (t) => this.builtV(t);
+  /** Access the underlying TailStrategy for full fuse composition */
+  static get tailStrategy() {
+    return tt;
+  }
+  with(t) {
+    return new U({ ...this.params, ...t });
+  }
+  static create(t = {}) {
+    return new U({
+      bounces: t.bounces ?? 4,
+      decay: t.decay ?? 0.95
+    });
+  }
+}
+const be = {
+  power: W,
+  back: Z,
+  "power-back": X,
+  bezier: L,
+  expo: Q,
+  spring: q,
+  bounce: U,
+  swim: G
+};
+function yt(e, t) {
+  return be[e].create(t);
+}
+function gt(e) {
+  const { kind: t, ...a } = e;
+  return a;
+}
+function Se(e) {
+  const {
+    movement: t = "transition",
+    head: a,
+    tail: n,
+    joinTime: o = 0.5,
+    mirror: r = !1,
+    useBridge: s,
+    bridgeTuning: i,
+    allowGeneralizedBackTail: l,
+    maxSpeed: d
+  } = e, u = yt(a.kind, gt(a)), c = yt(n.kind, gt(n));
+  return oe(u, c, {
+    movement: t,
+    joinTime: o,
+    mirror: r,
+    useBridge: s,
+    bridgeTuning: i,
+    allowGeneralizedBackTail: l,
+    maxSpeed: d
+  });
+}
+const It = 1e-6, ut = It, Pt = 1 - It;
+function Ve(e, t, a = !1) {
+  return !a && (t === "power-back" || t === "back" || t === "power") ? Math.min(1, e) : e;
+}
+function we(e, t, a = !1) {
+  return !a && t === "power-back" ? Math.max(0, e) : e;
+}
+export {
+  Z as BackRem,
+  L as BezierRem,
+  U as BounceRem,
+  Q as ExpoRem,
+  X as PowerBackRem,
+  W as PowerRem,
+  q as SpringRem,
+  G as SwimRem,
+  ve as calculateHeadP2FromTailP1,
+  ke as calculateTailP1FromHeadP2,
+  we as clampBezierY1ForHead,
+  Ve as clampBezierY2ForTail,
+  At as evalPowerBackIn,
+  xe as findExponentForMinimumPosition,
+  Se as fuse,
+  yt as getEasingRem,
+  Pe as getLocalMinimumPosition,
+  Oe as getPowerCurveCanonicalPoint,
+  Ee as getTailStrategy,
+  st as solvePowerBackStrength
+};
+//# sourceMappingURL=index.es.js.map