@vysmo/easings 0.1.0

package/src/builders/slow.ts

@@ -0,0 +1,72 @@
+import { defineParametricEasing } from "../define.js";
+
+export type SlowParams = {
+  /** Fraction of duration spent in the slow linear middle. 0–1. Default 0.7. */
+  linearRatio: number;
+  /** Strength of the fast edges. Higher = more dramatic edges + slower middle. Default 0.7. */
+  power: number;
+  /** If true, reverse the second half so the curve returns to start. */
+  yoyoMode: boolean;
+};
+
+const DEFAULTS: SlowParams = {
+  linearRatio: 0.7,
+  power: 0.7,
+  yoyoMode: false,
+};
+
+/**
+ * "Slow motion" ease: fast at the start and end, slow (nearly constant)
+ * through the middle. Opposite of an inOut shape — the linear middle
+ * section lives off the diagonal, so the midpoint value changes slowly
+ * with time.
+ */
+export const slow = defineParametricEasing(
+  "slow",
+  DEFAULTS,
+  ({ linearRatio, power, yoyoMode }) => {
+    const lr = Math.max(0, Math.min(1, linearRatio));
+    const p = Math.max(0, power);
+    const edge = (1 - lr) / 2;
+    // Off-diagonal offset of the linear section. At power=0 the linear
+    // section sits ON the diagonal (slow degenerates to linear); at higher
+    // powers it collapses toward y=0.5, making the middle genuinely slow.
+    const edgeY = (0.5 - edge) / (1 + p * 2);
+    const mid1 = 0.5 - edgeY;
+    const mid2 = 0.5 + edgeY;
+    const middleSpan = mid2 - mid1;
+    const middleSlope = lr === 0 ? 0 : middleSpan / lr;
+    // Edges blend a power-n ease-out with a linear segment whose slope
+    // matches the middle. That way the corner is a smooth curve, not a
+    // visible kink. Higher `power` sharpens the edge initial rise.
+    const edgeN = 2 + p * 6;
+    // Fraction contributed by the linear component of the blend, chosen so
+    // that the edge's end-slope equals the middle slope exactly → C¹
+    // continuity at the join. (Derived: y'(u=1) in edge = mid1 * (1-a) / edge.)
+    const linearShare = edge === 0 || mid1 === 0 ? 0 : Math.min(1, (middleSlope * edge) / mid1);
+    const powerShare = 1 - linearShare;
+
+    return (t: number) => {
+      let result: number;
+      if (edge === 0) {
+        result = t;
+      } else if (t < edge) {
+        const u = t / edge;
+        const v = powerShare * (1 - (1 - u) ** edgeN) + linearShare * u;
+        result = mid1 * v;
+      } else if (t > 1 - edge) {
+        const u = (t - (1 - edge)) / edge;
+        const v = powerShare * (u ** edgeN) + linearShare * u;
+        result = mid2 + (1 - mid2) * v;
+      } else {
+        const u = (t - edge) / lr;
+        result = mid1 + middleSpan * u;
+      }
+      if (yoyoMode) {
+        return result < 0.5 ? result * 2 : (1 - result) * 2;
+      }
+      return result;
+    };
+  },
+  { exactEndpoints: false },
+);

package/src/builders/spring-presets.ts

@@ -0,0 +1,20 @@
+import { spring, type SpringParams } from "./spring.js";
+
+/**
+ * Pre-configured spring feels matching React Spring's well-known configs.
+ * Import directly when you want a named spring rather than tuning by hand.
+ */
+export const SPRING_PRESETS = {
+  gentle: { stiffness: 100, damping: 15, mass: 1, velocity: 0 },
+  default: { stiffness: 170, damping: 26, mass: 1, velocity: 0 },
+  wobbly: { stiffness: 180, damping: 12, mass: 1, velocity: 0 },
+  stiff: { stiffness: 210, damping: 20, mass: 1, velocity: 0 },
+  slow: { stiffness: 80, damping: 20, mass: 1, velocity: 0 },
+  molasses: { stiffness: 280, damping: 120, mass: 1, velocity: 0 },
+} as const satisfies Record<string, SpringParams>;
+
+export const gentleSpring = spring.with(SPRING_PRESETS.gentle);
+export const wobblySpring = spring.with(SPRING_PRESETS.wobbly);
+export const stiffSpring = spring.with(SPRING_PRESETS.stiff);
+export const slowSpring = spring.with(SPRING_PRESETS.slow);
+export const molassesSpring = spring.with(SPRING_PRESETS.molasses);

package/src/builders/spring.ts

@@ -0,0 +1,61 @@
+import { defineParametricEasing } from "../define.js";
+
+export type SpringParams = {
+  /** Spring stiffness (higher = faster, more aggressive). Default 170 matches Framer Motion. */
+  stiffness: number;
+  /** Damping coefficient (higher = less oscillation). Default 26 is underdamped but close to critical. */
+  damping: number;
+  /** Object mass (higher = slower, more inertia). Default 1. */
+  mass: number;
+  /** Initial velocity at t=0. Default 0. */
+  velocity: number;
+};
+
+const DEFAULTS: SpringParams = {
+  stiffness: 170,
+  damping: 26,
+  mass: 1,
+  velocity: 0,
+};
+
+const SETTLE_EPSILON = 1e-4;
+const MAX_SETTLE_TIME = 10;
+const SETTLE_SAMPLES = 1000;
+
+function makeSpringFunction({ stiffness, damping, mass, velocity }: SpringParams) {
+  const w0 = Math.sqrt(stiffness / mass);
+  const zeta = damping / (2 * Math.sqrt(stiffness * mass));
+
+  if (zeta < 1) {
+    const wd = w0 * Math.sqrt(1 - zeta * zeta);
+    const B = (velocity - zeta * w0 * -1) / wd;
+    return (t: number) => 1 + Math.exp(-zeta * w0 * t) * (-Math.cos(wd * t) + B * Math.sin(wd * t));
+  }
+  if (zeta === 1) {
+    const B = velocity - w0;
+    return (t: number) => 1 + (-1 + B * t) * Math.exp(-w0 * t);
+  }
+  const r = w0 * Math.sqrt(zeta * zeta - 1);
+  const lPlus = -zeta * w0 + r;
+  const lMinus = -zeta * w0 - r;
+  const det = lMinus - lPlus;
+  const A = (-lMinus - velocity) / det;
+  const B = (lPlus + velocity) / det;
+  return (t: number) => 1 + A * Math.exp(lPlus * t) + B * Math.exp(lMinus * t);
+}
+
+function findSettleTime(fn: (t: number) => number): number {
+  let lastUnsettled = 0;
+  const step = MAX_SETTLE_TIME / SETTLE_SAMPLES;
+  for (let i = 1; i <= SETTLE_SAMPLES; i++) {
+    const t = i * step;
+    if (Math.abs(fn(t) - 1) > SETTLE_EPSILON) lastUnsettled = t;
+  }
+  return Math.max(lastUnsettled + step * 2, step * 10);
+}
+
+export const spring = defineParametricEasing("spring", DEFAULTS, (params) => {
+  const raw = makeSpringFunction(params);
+  const settle = findSettleTime(raw);
+  return (t) => raw(t * settle);
+});

package/src/builders/wiggle.ts

@@ -0,0 +1,40 @@
+import { defineParametricEasing } from "../define.js";
+
+export type WiggleType = "easeOut" | "easeInOut" | "anticipate" | "uniform";
+
+export type WiggleParams = {
+  /** Number of back-and-forth oscillations across [0, 1]. Default 10. */
+  wiggles: number;
+  /** Envelope shape. */
+  type: WiggleType;
+};
+
+const DEFAULTS: WiggleParams = {
+  wiggles: 10,
+  type: "easeOut",
+};
+
+const TAU = Math.PI * 2;
+
+function envelope(type: WiggleType, t: number): number {
+  switch (type) {
+    case "easeOut":
+      return 1 - t;
+    case "easeInOut":
+      return 4 * t * (1 - t);
+    case "anticipate":
+      return t < 0.5 ? 2 * t : 2 - 2 * t;
+    case "uniform":
+      return 1;
+  }
+}
+
+export const wiggle = defineParametricEasing(
+  "wiggle",
+  DEFAULTS,
+  ({ wiggles, type }) => {
+    const n = Math.max(1, wiggles);
+    return (t: number) => envelope(type, t) * Math.sin(t * TAU * n);
+  },
+  { exactEndpoints: false },
+);

package/src/css.ts

@@ -0,0 +1,79 @@
+import type { EasingFn } from "./types.js";
+
+/**
+ * Convert any easing to a CSS `linear()` timing-function value by sampling
+ * the curve at evenly-spaced points.
+ *
+ * ```css
+ * animation-timing-function: linear(0, 0.3, 0.7, 1);
+ * ```
+ *
+ * CSS interpolates linearly between the sampled points, so higher sample
+ * counts produce smoother-looking motion. 40 samples is a good default
+ * balance between fidelity and string length. Requires browsers that
+ * support CSS Easing Functions Level 2 (~all majors since 2024).
+ *
+ * @param ease  An EasingFn or plain (t: number) => number
+ * @param samples  Number of samples + 1 across [0, 1]. Default 40.
+ */
+export function toCSSLinear(ease: EasingFn | ((t: number) => number), samples = 40): string {
+  if (samples < 1 || !Number.isInteger(samples)) {
+    throw new RangeError(`toCSSLinear: samples must be a positive integer; got ${samples}`);
+  }
+  const values: string[] = [];
+  for (let i = 0; i <= samples; i++) {
+    const t = i / samples;
+    values.push(formatNumber(ease(t)));
+  }
+  return `linear(${values.join(", ")})`;
+}
+
+/**
+ * Emit a CSS cubic-bezier() timing function. Exact representation; no
+ * sampling. Use this when you'd otherwise build an easing via `bezier()`
+ * from this package.
+ *
+ * ```css
+ * animation-timing-function: cubic-bezier(0.42, 0, 0.58, 1);
+ * ```
+ */
+export function toCSSBezier(p1x: number, p1y: number, p2x: number, p2y: number): string {
+  return `cubic-bezier(${formatNumber(p1x)}, ${formatNumber(p1y)}, ${formatNumber(p2x)}, ${formatNumber(p2y)})`;
+}
+
+/**
+ * Emit a `@keyframes` block driving a numeric CSS property (e.g. translate,
+ * opacity) through an ease. The animation should be declared with
+ * `animation-timing-function: linear` because the easing is pre-baked into
+ * the keyframes.
+ *
+ * ```css
+ * ${toCSSKeyframes("slideIn", "transform", (v) => `translateX(${v * 100}%)`, ease)}
+ * ```
+ */
+export function toCSSKeyframes(
+  name: string,
+  property: string,
+  valueForProgress: (easedValue: number) => string,
+  ease: EasingFn | ((t: number) => number),
+  samples = 20,
+): string {
+  if (samples < 2) {
+    throw new RangeError(`toCSSKeyframes: samples must be >= 2; got ${samples}`);
+  }
+  const lines: string[] = [`@keyframes ${name} {`];
+  for (let i = 0; i <= samples; i++) {
+    const t = i / samples;
+    const pct = (t * 100).toFixed(2).replace(/\.?0+$/, "");
+    const value = valueForProgress(ease(t));
+    lines.push(`  ${pct}% { ${property}: ${value}; }`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+
+function formatNumber(n: number): string {
+  if (!Number.isFinite(n)) return "0";
+  if (Number.isInteger(n)) return n.toString();
+  return Number(n.toFixed(5)).toString();
+}

package/src/define.ts

@@ -0,0 +1,49 @@
+import type { EasingFn, ParametricEasing } from "./types.js";
+
+export type DefineEasingOptions = {
+  /**
+   * When true (default), t ≤ 0 returns 0 and t ≥ 1 returns 1 regardless of
+   * the underlying formula. Disable for easings that intentionally don't
+   * hit (0, 0) or (1, 1) — notably `steps(n, "start")`.
+   */
+  exactEndpoints?: boolean;
+};
+
+export function defineEasing(
+  name: string,
+  fn: (t: number) => number,
+  options: DefineEasingOptions = {},
+): EasingFn {
+  const { exactEndpoints = true } = options;
+  const wrapped = ((t: number) => {
+    // Defensive: NaN and non-finite inputs collapse to 0. Better than
+    // propagating NaN through a whole animation pipeline.
+    if (!Number.isFinite(t)) return 0;
+    if (exactEndpoints) {
+      if (t <= 0) return 0;
+      if (t >= 1) return 1;
+    }
+    return fn(t);
+  }) as EasingFn;
+  Object.defineProperty(wrapped, "easingName", { value: name, enumerable: true });
+  return wrapped;
+}
+
+export function defineParametricEasing<P extends object>(
+  name: string,
+  defaults: P,
+  build: (params: P) => (t: number) => number,
+  options: DefineEasingOptions = {},
+): ParametricEasing<P> {
+  const base = defineEasing(name, build(defaults), options) as ParametricEasing<P>;
+  Object.defineProperty(base, "defaults", {
+    value: Object.freeze({ ...defaults }),
+    enumerable: true,
+  });
+  Object.defineProperty(base, "with", {
+    value: (params: Partial<P>): EasingFn =>
+      defineEasing(name, build({ ...defaults, ...params }), options),
+    enumerable: true,
+  });
+  return base;
+}

package/src/easings/back.ts

@@ -0,0 +1,24 @@
+import { defineParametricEasing } from "../define.js";
+
+type BackParams = { overshoot: number };
+
+const DEFAULTS: BackParams = { overshoot: 1.70158 };
+
+export const backIn = defineParametricEasing("back.in", DEFAULTS, ({ overshoot: s }) => (t) => {
+  return t * t * ((s + 1) * t - s);
+});
+
+export const backOut = defineParametricEasing("back.out", DEFAULTS, ({ overshoot: s }) => (t) => {
+  const u = t - 1;
+  return u * u * ((s + 1) * u + s) + 1;
+});
+
+export const backInOut = defineParametricEasing("back.inOut", DEFAULTS, ({ overshoot }) => {
+  const s = overshoot * 1.525;
+  return (t) => {
+    const u = t * 2;
+    if (u < 1) return 0.5 * (u * u * ((s + 1) * u - s));
+    const v = u - 2;
+    return 0.5 * (v * v * ((s + 1) * v + s) + 2);
+  };
+});

package/src/easings/bounce.ts

@@ -0,0 +1,23 @@
+import { defineEasing } from "../define.js";
+
+function bounceOutImpl(t: number): number {
+  const n = 7.5625;
+  const d = 2.75;
+  if (t < 1 / d) return n * t * t;
+  if (t < 2 / d) {
+    const u = t - 1.5 / d;
+    return n * u * u + 0.75;
+  }
+  if (t < 2.5 / d) {
+    const u = t - 2.25 / d;
+    return n * u * u + 0.9375;
+  }
+  const u = t - 2.625 / d;
+  return n * u * u + 0.984375;
+}
+
+export const bounceOut = defineEasing("bounce.out", bounceOutImpl);
+export const bounceIn = defineEasing("bounce.in", (t) => 1 - bounceOutImpl(1 - t));
+export const bounceInOut = defineEasing("bounce.inOut", (t) =>
+  t < 0.5 ? (1 - bounceOutImpl(1 - 2 * t)) / 2 : (1 + bounceOutImpl(2 * t - 1)) / 2,
+);

package/src/easings/circ.ts

@@ -0,0 +1,9 @@
+import { defineEasing } from "../define.js";
+
+export const circIn = defineEasing("circ.in", (t) => 1 - Math.sqrt(1 - t * t));
+export const circOut = defineEasing("circ.out", (t) => Math.sqrt(1 - (t - 1) * (t - 1)));
+export const circInOut = defineEasing("circ.inOut", (t) =>
+  t < 0.5
+    ? (1 - Math.sqrt(1 - (2 * t) ** 2)) / 2
+    : (Math.sqrt(1 - (-2 * t + 2) ** 2) + 1) / 2,
+);

package/src/easings/elastic.ts

@@ -0,0 +1,52 @@
+import { defineParametricEasing } from "../define.js";
+
+type ElasticParams = { amplitude: number; period: number };
+
+const DEFAULTS: ElasticParams = { amplitude: 1, period: 0.3 };
+const TAU = Math.PI * 2;
+
+function resolveAmplitude(a: number): number {
+  return a < 1 ? 1 : a;
+}
+
+function resolvePhase(a: number, p: number): number {
+  return a < 1 ? p / 4 : (p / TAU) * Math.asin(1 / a);
+}
+
+export const elasticIn = defineParametricEasing(
+  "elastic.in",
+  DEFAULTS,
+  ({ amplitude, period }) => {
+    const a = resolveAmplitude(amplitude);
+    const s = resolvePhase(amplitude, period);
+    return (t) => -(a * 2 ** (10 * (t - 1)) * Math.sin(((t - 1 - s) * TAU) / period));
+  },
+);
+
+export const elasticOut = defineParametricEasing(
+  "elastic.out",
+  DEFAULTS,
+  ({ amplitude, period }) => {
+    const a = resolveAmplitude(amplitude);
+    const s = resolvePhase(amplitude, period);
+    return (t) => a * 2 ** (-10 * t) * Math.sin(((t - s) * TAU) / period) + 1;
+  },
+);
+
+export const elasticInOut = defineParametricEasing(
+  "elastic.inOut",
+  DEFAULTS,
+  ({ amplitude, period }) => {
+    const a = resolveAmplitude(amplitude);
+    const p = period * 1.5;
+    const s = resolvePhase(amplitude, p);
+    return (t) => {
+      const u = t * 2;
+      if (u < 1) {
+        return -0.5 * (a * 2 ** (10 * (u - 1)) * Math.sin(((u - 1 - s) * TAU) / p));
+      }
+      const v = u - 1;
+      return 0.5 * a * 2 ** (-10 * v) * Math.sin(((v - s) * TAU) / p) + 1;
+    };
+  },
+);

package/src/easings/expo.ts

@@ -0,0 +1,9 @@
+import { defineEasing } from "../define.js";
+
+export const expoIn = defineEasing("expo.in", (t) => (t === 0 ? 0 : 2 ** (10 * t - 10)));
+export const expoOut = defineEasing("expo.out", (t) => (t === 1 ? 1 : 1 - 2 ** (-10 * t)));
+export const expoInOut = defineEasing("expo.inOut", (t) => {
+  if (t === 0) return 0;
+  if (t === 1) return 1;
+  return t < 0.5 ? 2 ** (20 * t - 10) / 2 : (2 - 2 ** (-20 * t + 10)) / 2;
+});

package/src/easings/index.ts

@@ -0,0 +1,35 @@
+export { linear, none } from "./linear.js";
+export {
+  power1In,
+  power1Out,
+  power1InOut,
+  power2In,
+  power2Out,
+  power2InOut,
+  power3In,
+  power3Out,
+  power3InOut,
+  power4In,
+  power4Out,
+  power4InOut,
+  quadIn,
+  quadOut,
+  quadInOut,
+  cubicIn,
+  cubicOut,
+  cubicInOut,
+  quartIn,
+  quartOut,
+  quartInOut,
+  quintIn,
+  quintOut,
+  quintInOut,
+} from "./power.js";
+export { sineIn, sineOut, sineInOut } from "./sine.js";
+export { circIn, circOut, circInOut } from "./circ.js";
+export { expoIn, expoOut, expoInOut } from "./expo.js";
+export { smoothIn, smoothOut, smoothInOut } from "./smooth.js";
+export { backIn, backOut, backInOut } from "./back.js";
+export { elasticIn, elasticOut, elasticInOut } from "./elastic.js";
+export { bounceIn, bounceOut, bounceInOut } from "./bounce.js";
+export { steps, type StepPosition } from "./steps.js";

package/src/easings/linear.ts

@@ -0,0 +1,4 @@
+import { defineEasing } from "../define.js";
+
+export const linear = defineEasing("linear", (t) => t);
+export const none = linear;

package/src/easings/power.ts

@@ -0,0 +1,38 @@
+import { defineEasing } from "../define.js";
+
+const makeIn = (n: number) => (t: number) => t ** n;
+const makeOut = (n: number) => (t: number) => 1 - (1 - t) ** n;
+const makeInOut = (n: number) => (t: number) =>
+  t < 0.5 ? 2 ** (n - 1) * t ** n : 1 - (-2 * t + 2) ** n / 2;
+
+export const power1In = defineEasing("power1.in", makeIn(2));
+export const power1Out = defineEasing("power1.out", makeOut(2));
+export const power1InOut = defineEasing("power1.inOut", makeInOut(2));
+
+export const power2In = defineEasing("power2.in", makeIn(3));
+export const power2Out = defineEasing("power2.out", makeOut(3));
+export const power2InOut = defineEasing("power2.inOut", makeInOut(3));
+
+export const power3In = defineEasing("power3.in", makeIn(4));
+export const power3Out = defineEasing("power3.out", makeOut(4));
+export const power3InOut = defineEasing("power3.inOut", makeInOut(4));
+
+export const power4In = defineEasing("power4.in", makeIn(5));
+export const power4Out = defineEasing("power4.out", makeOut(5));
+export const power4InOut = defineEasing("power4.inOut", makeInOut(5));
+
+export const quadIn = power1In;
+export const quadOut = power1Out;
+export const quadInOut = power1InOut;
+
+export const cubicIn = power2In;
+export const cubicOut = power2Out;
+export const cubicInOut = power2InOut;
+
+export const quartIn = power3In;
+export const quartOut = power3Out;
+export const quartInOut = power3InOut;
+
+export const quintIn = power4In;
+export const quintOut = power4Out;
+export const quintInOut = power4InOut;

package/src/easings/sine.ts

@@ -0,0 +1,7 @@
+import { defineEasing } from "../define.js";
+
+const HALF_PI = Math.PI / 2;
+
+export const sineIn = defineEasing("sine.in", (t) => 1 - Math.cos(t * HALF_PI));
+export const sineOut = defineEasing("sine.out", (t) => Math.sin(t * HALF_PI));
+export const sineInOut = defineEasing("sine.inOut", (t) => -(Math.cos(Math.PI * t) - 1) / 2);

package/src/easings/smooth.ts

@@ -0,0 +1,25 @@
+import { defineEasing } from "../define.js";
+
+// Hermite smoothstep. C¹-continuous at both endpoints — zero velocity
+// at t=0 AND t=1. The canonical inOut shape from GLSL `smoothstep`,
+// distinct from `power2.inOut` whose first derivative is non-zero at
+// the endpoints. The in/out variants are derived by rescaling halves
+// of the smoothstep curve, so they preserve Hermite smoothness on the
+// "interior" endpoint (t=0 for in, t=1 for out).
+
+const smoothstep = (t: number) => t * t * (3 - 2 * t);
+
+export const smoothInOut = defineEasing("smooth.inOut", smoothstep);
+
+// 2·smoothstep(t/2): first half of the inOut curve, scaled to [0, 1].
+// f(0)=0, f(1)=1, f'(0)=0, f'(1)=1.5 — slow start, accelerates out.
+export const smoothIn = defineEasing("smooth.in", (t) => {
+  const u = t / 2;
+  return 2 * smoothstep(u);
+});
+
+// Mirror of smoothIn. Fast start, decelerates to zero velocity at t=1.
+export const smoothOut = defineEasing("smooth.out", (t) => {
+  const u = (1 - t) / 2;
+  return 1 - 2 * smoothstep(u);
+});

package/src/easings/steps.ts

@@ -0,0 +1,25 @@
+import { defineParametricEasing } from "../define.js";
+
+export type StepPosition = "start" | "end" | "none";
+
+type StepsParams = { count: number; position: StepPosition };
+
+const DEFAULTS: StepsParams = { count: 5, position: "end" };
+
+export const steps = defineParametricEasing(
+  "steps",
+  DEFAULTS,
+  ({ count, position }) => {
+    const n = Math.max(1, Math.floor(count));
+    switch (position) {
+      case "end":
+        return (t) => Math.min(Math.floor(t * n), n) / n;
+      case "start":
+        return (t) => Math.min(Math.floor(t * n) + 1, n) / n;
+      case "none":
+        if (n === 1) return () => 0;
+        return (t) => Math.min(Math.floor(t * n), n - 1) / (n - 1);
+    }
+  },
+  { exactEndpoints: false },
+);

package/src/index.ts

@@ -0,0 +1,9 @@
+export type { EasingFn, ParametricEasing } from "./types.js";
+export { defineEasing, defineParametricEasing } from "./define.js";
+export type { DefineEasingOptions } from "./define.js";
+export * from "./easings/index.js";
+export * from "./builders/index.js";
+export * from "./modifiers/index.js";
+export { toCSSLinear, toCSSBezier, toCSSKeyframes } from "./css.js";
+export { parseEasing } from "./parse.js";
+export { prefersReducedMotion, respectReducedMotion } from "./reduced-motion.js";

package/src/modifiers/blend.ts

@@ -0,0 +1,24 @@
+import { defineEasing } from "../define.js";
+import type { EasingFn } from "../types.js";
+
+/**
+ * Linearly interpolate between two eases. At weight=0 returns pure `a`;
+ * at weight=1 returns pure `b`; between is the weighted sum. Useful for
+ * morphing between easings or dialling in a custom shape from known eases.
+ */
+export function blend(a: EasingFn, b: EasingFn, weight: number): EasingFn {
+  if (weight <= 0) return a;
+  if (weight >= 1) return b;
+  return defineEasing(
+    `blend(${a.easingName}, ${b.easingName}, ${weight})`,
+    (t) => a(t) * (1 - weight) + b(t) * weight,
+  );
+}
+
+/**
+ * Compose two eases: apply `a` first, then `b` to `a`'s output. The result
+ * is `b(a(t))`. Useful for doubly-applied curves ("ease then ease again").
+ */
+export function compose(a: EasingFn, b: EasingFn): EasingFn {
+  return defineEasing(`compose(${b.easingName}, ${a.easingName})`, (t) => b(a(t)));
+}