@flighthq/easing 0.1.0

package/dist/easeSmoothstep.js

@@ -0,0 +1,17 @@
+// Perlin's smootherstep: a higher-order variant with zero first- and
+// second-derivatives at both endpoints, for a gentler approach to 0 and 1.
+// Like the other families here, input is assumed pre-clamped to [0,1].
+export const easeSmootherstep = (t) => t * t * t * (t * (t * 6 - 15) + 10);
+// Hermite smoothstep: a sigmoid-like ease with zero first-derivative at both endpoints.
+export const easeSmoothstep = (t) => t * t * (3 - 2 * t);
+// Returns a smoothstep remap over an arbitrary domain [edge0, edge1].
+// The returned function clamps its input to [edge0, edge1], maps to [0, 1],
+// and applies the Hermite smoothstep. Unlike EasingFunction (domain [0,1]),
+// the result is a ScalarRemap whose domain is [edge0, edge1].
+export function easeSmoothstepRange(edge0, edge1) {
+    return (x) => {
+        const t = Math.max(0, Math.min(1, (x - edge0) / (edge1 - edge0)));
+        return t * t * (3 - 2 * t);
+    };
+}
+//# sourceMappingURL=easeSmoothstep.js.map

package/dist/easeSmoothstep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"easeSmoothstep.js","sourceRoot":"","sources":["../src/easeSmoothstep.ts"],"names":[],"mappings":"AAEA,qEAAqE;AACrE,2EAA2E;AAC3E,uEAAuE;AACvE,MAAM,CAAC,MAAM,gBAAgB,GAAmB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;AAE3F,wFAAwF;AACxF,MAAM,CAAC,MAAM,cAAc,GAAmB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;AAEzE,sEAAsE;AACtE,4EAA4E;AAC5E,4EAA4E;AAC5E,8DAA8D;AAC9D,MAAM,UAAU,mBAAmB,CAAC,KAAa,EAAE,KAAa;IAC9D,OAAO,CAAC,CAAC,EAAE,EAAE;QACX,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QAClE,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7B,CAAC,CAAC;AACJ,CAAC"}

package/dist/easeSteps.d.ts

@@ -0,0 +1,3 @@
+import type { EasingFunction, StepPosition } from '@flighthq/types';
+export declare function easeSteps(count: number, position?: StepPosition): EasingFunction;
+//# sourceMappingURL=easeSteps.d.ts.map

package/dist/easeSteps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"easeSteps.d.ts","sourceRoot":"","sources":["../src/easeSteps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAcpE,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,GAAE,YAAwB,GAAG,cAAc,CAc3F"}

package/dist/easeSteps.js

@@ -0,0 +1,27 @@
+// Returns a stepped easing function that quantizes [0,1] into `count` equal
+// intervals, jumping at the position(s) selected by `position`:
+//   jumpStart - jump at t=0; the first interval already outputs 1/count.
+//   jumpEnd   - jump at t=1 (default); output stays 0 over the first interval.
+//   jumpNone  - no jump at either edge; output spans 0..1 with count-1 interior jumps.
+//   jumpBoth  - jump at both edges; count+1 levels from 0 to 1 inclusive.
+// Follows the CSS Easing Level 1 step algorithm.
+//
+// Sharp edge: easeSteps(1, 'jumpNone') has jumps = count - 1 = 0, so the returned
+// function divides by zero and yields NaN. This mirrors the CSS spec, which forbids
+// steps(1, jump-none) for the same reason. Callers must pass count >= 2 with
+// 'jumpNone'; every other position is well-defined for count >= 1.
+export function easeSteps(count, position = 'jumpEnd') {
+    const jumps = position === 'jumpNone' ? count - 1 : position === 'jumpBoth' ? count + 1 : count;
+    const startOffset = position === 'jumpStart' || position === 'jumpBoth' ? 1 : 0;
+    return (t) => {
+        let step = Math.floor(t * count) + startOffset;
+        if (t >= 0 && step < 0) {
+            step = 0;
+        }
+        if (t <= 1 && step > jumps) {
+            step = jumps;
+        }
+        return step / jumps;
+    };
+}
+//# sourceMappingURL=easeSteps.js.map

package/dist/easeSteps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"easeSteps.js","sourceRoot":"","sources":["../src/easeSteps.ts"],"names":[],"mappings":"AAEA,4EAA4E;AAC5E,gEAAgE;AAChE,yEAAyE;AACzE,+EAA+E;AAC/E,uFAAuF;AACvF,0EAA0E;AAC1E,iDAAiD;AACjD,EAAE;AACF,kFAAkF;AAClF,oFAAoF;AACpF,6EAA6E;AAC7E,mEAAmE;AACnE,MAAM,UAAU,SAAS,CAAC,KAAa,EAAE,WAAyB,SAAS;IACzE,MAAM,KAAK,GAAG,QAAQ,KAAK,UAAU,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,KAAK,UAAU,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IAChG,MAAM,WAAW,GAAG,QAAQ,KAAK,WAAW,IAAI,QAAQ,KAAK,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAEhF,OAAO,CAAC,CAAC,EAAE,EAAE;QACX,IAAI,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,WAAW,CAAC;QAC/C,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC,EAAE,CAAC;YACvB,IAAI,GAAG,CAAC,CAAC;QACX,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,KAAK,EAAE,CAAC;YAC3B,IAAI,GAAG,KAAK,CAAC;QACf,CAAC;QACD,OAAO,IAAI,GAAG,KAAK,CAAC;IACtB,CAAC,CAAC;AACJ,CAAC"}

package/dist/getEasingDerivative.d.ts

@@ -0,0 +1,3 @@
+import type { EasingFunction } from '@flighthq/types';
+export declare function getEasingDerivative(ease: EasingFunction, t: number, epsilon?: number): number;
+//# sourceMappingURL=getEasingDerivative.d.ts.map

package/dist/getEasingDerivative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getEasingDerivative.d.ts","sourceRoot":"","sources":["../src/getEasingDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AActD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,cAAc,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,GAAE,MAAuB,GAAG,MAAM,CAW7G"}

package/dist/getEasingDerivative.js

@@ -0,0 +1,28 @@
+// Returns the numerical derivative (instantaneous velocity) of `ease` at the
+// given `t` using a centered finite-difference approximation:
+//   (ease(t + epsilon) - ease(t - epsilon)) / (2 * epsilon)
+//
+// This is the slope of the easing curve at `t`, useful for handing off
+// velocity when transitioning between animations (e.g. from a finishing tween
+// to a starting spring). The endpoint boundary is handled by clamping: at
+// `t ≤ epsilon` a forward difference is used; at `t ≥ 1 - epsilon` a backward
+// difference is used.
+//
+// `epsilon` defaults to 1e-6. Pass a smaller value for smoother curves or a
+// larger one for noisy/discretized curves. The function never throws.
+export function getEasingDerivative(ease, t, epsilon = defaultEpsilon) {
+    if (t <= epsilon) {
+        // Forward difference at the left boundary.
+        return (ease(epsilon * 2) - ease(0)) / (epsilon * 2);
+    }
+    if (t >= 1 - epsilon) {
+        // Backward difference at the right boundary.
+        return (ease(1) - ease(1 - epsilon * 2)) / (epsilon * 2);
+    }
+    // Central difference in the interior.
+    return (ease(t + epsilon) - ease(t - epsilon)) / (2 * epsilon);
+}
+// Default step size for numerical differentiation. Small enough for smooth
+// curves but large enough to avoid cancellation errors in Float64.
+const defaultEpsilon = 1e-6;
+//# sourceMappingURL=getEasingDerivative.js.map

package/dist/getEasingDerivative.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getEasingDerivative.js","sourceRoot":"","sources":["../src/getEasingDerivative.ts"],"names":[],"mappings":"AAEA,6EAA6E;AAC7E,8DAA8D;AAC9D,4DAA4D;AAC5D,EAAE;AACF,uEAAuE;AACvE,8EAA8E;AAC9E,0EAA0E;AAC1E,8EAA8E;AAC9E,sBAAsB;AACtB,EAAE;AACF,4EAA4E;AAC5E,sEAAsE;AACtE,MAAM,UAAU,mBAAmB,CAAC,IAAoB,EAAE,CAAS,EAAE,UAAkB,cAAc;IACnG,IAAI,CAAC,IAAI,OAAO,EAAE,CAAC;QACjB,2CAA2C;QAC3C,OAAO,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;IACvD,CAAC;IACD,IAAI,CAAC,IAAI,CAAC,GAAG,OAAO,EAAE,CAAC;QACrB,6CAA6C;QAC7C,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,OAAO,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;IAC3D,CAAC;IACD,sCAAsC;IACtC,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC;AACjE,CAAC;AAED,2EAA2E;AAC3E,mEAAmE;AACnE,MAAM,cAAc,GAAG,IAAI,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+export * from './createEasingSamples';
+export * from './easeBack';
+export * from './easeBounce';
+export * from './easeCircular';
+export * from './easeCombinators';
+export * from './easeCubic';
+export * from './easeCubicBezier';
+export * from './easeElastic';
+export * from './easeExponential';
+export * from './easeLinear';
+export * from './easePiecewise';
+export * from './easePower';
+export * from './easeQuadratic';
+export * from './easeQuartic';
+export * from './easeQuintic';
+export * from './easeSine';
+export * from './easeSmoothstep';
+export * from './easeSteps';
+export * from './getEasingDerivative';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC"}

package/dist/index.js

@@ -0,0 +1,20 @@
+export * from './createEasingSamples';
+export * from './easeBack';
+export * from './easeBounce';
+export * from './easeCircular';
+export * from './easeCombinators';
+export * from './easeCubic';
+export * from './easeCubicBezier';
+export * from './easeElastic';
+export * from './easeExponential';
+export * from './easeLinear';
+export * from './easePiecewise';
+export * from './easePower';
+export * from './easeQuadratic';
+export * from './easeQuartic';
+export * from './easeQuintic';
+export * from './easeSine';
+export * from './easeSmoothstep';
+export * from './easeSteps';
+export * from './getEasingDerivative';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC"}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@flighthq/easing",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/types": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "description": "Easing functions for animation",
+  "sideEffects": false
+}

package/src/createEasingSamples.test.ts

@@ -0,0 +1,51 @@
+import { createEasingSamples } from './createEasingSamples';
+import { easeInCubic } from './easeCubic';
+import { easeLinear } from './easeLinear';
+
+describe('createEasingSamples', () => {
+  it('throws for count < 1', () => {
+    expect(() => createEasingSamples(easeLinear, 0)).toThrow();
+    expect(() => createEasingSamples(easeLinear, -1)).toThrow();
+  });
+  it('throws for non-finite count', () => {
+    expect(() => createEasingSamples(easeLinear, Infinity)).toThrow();
+    expect(() => createEasingSamples(easeLinear, NaN)).toThrow();
+  });
+  it('allocates a Float32Array when out is omitted', () => {
+    const result = createEasingSamples(easeLinear, 5);
+    expect(result).toBeInstanceOf(Float32Array);
+    expect(result.length).toBe(5);
+  });
+  it('writes into the provided out array and returns it', () => {
+    const out = new Float32Array(5);
+    const result = createEasingSamples(easeLinear, 5, out);
+    expect(result).toBe(out);
+  });
+  it('first sample is ease(0) and last is ease(1)', () => {
+    const result = createEasingSamples(easeInCubic, 11);
+    expect(result[0]).toBeCloseTo(easeInCubic(0));
+    expect(result[10]).toBeCloseTo(easeInCubic(1));
+  });
+  it('samples easeLinear uniformly: result[i] ≈ i/(count-1)', () => {
+    const count = 6;
+    const result = createEasingSamples(easeLinear, count);
+    for (let i = 0; i < count; i++) {
+      expect(result[i]).toBeCloseTo(i / (count - 1), 5);
+    }
+  });
+  it('count=1 samples at the midpoint (t=0.5)', () => {
+    const result = createEasingSamples(easeInCubic, 1);
+    expect(result[0]).toBeCloseTo(easeInCubic(0.5));
+  });
+  it('is alias-safe: out can be any Float32Array length >= count', () => {
+    const out = new Float32Array(10);
+    const result = createEasingSamples(easeLinear, 5, out);
+    // Only the first 5 entries are written; the rest are still 0.
+    expect(result[4]).toBeCloseTo(1);
+    expect(result[5]).toBe(0);
+  });
+  it('floor(count) is used for fractional counts', () => {
+    const result = createEasingSamples(easeLinear, 5.9);
+    expect(result.length).toBe(5);
+  });
+});

package/src/easeBack.test.ts

@@ -0,0 +1,30 @@
+import { easeInBack, easeInOutBack, easeOutBack } from './easeBack';
+
+describe('easeInBack', () => {
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    expect(easeInBack(0)).toBeCloseTo(0);
+    expect(easeInBack(1)).toBeCloseTo(1);
+  });
+
+  it('undershoots below 0 before settling', () => {
+    expect(easeInBack(0.3)).toBeLessThan(0);
+  });
+});
+
+describe('easeInOutBack', () => {
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    expect(easeInOutBack(0)).toBeCloseTo(0);
+    expect(easeInOutBack(1)).toBeCloseTo(1);
+  });
+});
+
+describe('easeOutBack', () => {
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    expect(easeOutBack(0)).toBeCloseTo(0);
+    expect(easeOutBack(1)).toBeCloseTo(1);
+  });
+
+  it('overshoots past 1 before settling', () => {
+    expect(easeOutBack(0.7)).toBeGreaterThan(1);
+  });
+});

package/src/easeBounce.test.ts

@@ -0,0 +1,30 @@
+import { easeInBounce, easeInOutBounce, easeOutBounce } from './easeBounce';
+
+describe('easeInBounce', () => {
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    expect(easeInBounce(0)).toBeCloseTo(0);
+    expect(easeInBounce(1)).toBeCloseTo(1);
+  });
+
+  it('is slow at start (value below 0.5 at midpoint)', () => {
+    expect(easeInBounce(0.5)).toBeLessThan(0.5);
+  });
+});
+
+describe('easeInOutBounce', () => {
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    expect(easeInOutBounce(0)).toBeCloseTo(0);
+    expect(easeInOutBounce(1)).toBeCloseTo(1);
+  });
+});
+
+describe('easeOutBounce', () => {
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    expect(easeOutBounce(0)).toBeCloseTo(0);
+    expect(easeOutBounce(1)).toBeCloseTo(1);
+  });
+
+  it('is fast at start (value above 0.5 at midpoint)', () => {
+    expect(easeOutBounce(0.5)).toBeGreaterThan(0.5);
+  });
+});

package/src/easeCircular.test.ts

@@ -0,0 +1,44 @@
+import { easeInCircular, easeInOutCircular, easeOutCircular } from './easeCircular';
+
+describe('easeInCircular', () => {
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    expect(easeInCircular(0)).toBeCloseTo(0);
+    expect(easeInCircular(1)).toBeCloseTo(1);
+  });
+
+  it('is slow at start (value below 0.5 at midpoint)', () => {
+    expect(easeInCircular(0.5)).toBeLessThan(0.5);
+    expect(easeInCircular(0.5)).toBeCloseTo(1 - Math.sqrt(0.75));
+  });
+
+  it('is monotonically increasing', () => {
+    let prev = easeInCircular(0);
+    for (let i = 1; i <= 20; i++) {
+      const value = easeInCircular(i / 20);
+      expect(value).toBeGreaterThanOrEqual(prev);
+      prev = value;
+    }
+  });
+});
+
+describe('easeInOutCircular', () => {
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    expect(easeInOutCircular(0)).toBeCloseTo(0);
+    expect(easeInOutCircular(1)).toBeCloseTo(1);
+  });
+
+  it('is symmetric at midpoint', () => {
+    expect(easeInOutCircular(0.5)).toBeCloseTo(0.5);
+  });
+});
+
+describe('easeOutCircular', () => {
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    expect(easeOutCircular(0)).toBeCloseTo(0);
+    expect(easeOutCircular(1)).toBeCloseTo(1);
+  });
+
+  it('is fast at start (value above 0.5 at midpoint)', () => {
+    expect(easeOutCircular(0.5)).toBeGreaterThan(0.5);
+  });
+});

package/src/easeCombinators.test.ts

@@ -0,0 +1,119 @@
+import { easeClamp, easeClampOutput, easeInvert, easeMirror, easeReverse, easeScaleOutput } from './easeCombinators';
+import { easeInCubic, easeOutCubic } from './easeCubic';
+
+describe('easeClamp', () => {
+  it('passes through values already in [0,1]', () => {
+    const clamped = easeClamp(easeInCubic);
+    expect(clamped(0)).toBeCloseTo(easeInCubic(0));
+    expect(clamped(0.5)).toBeCloseTo(easeInCubic(0.5));
+    expect(clamped(1)).toBeCloseTo(easeInCubic(1));
+  });
+  it('clamps negative t to 0', () => {
+    const clamped = easeClamp(easeInCubic);
+    expect(clamped(-0.5)).toBeCloseTo(easeInCubic(0));
+  });
+  it('clamps t above 1 to 1', () => {
+    const clamped = easeClamp(easeInCubic);
+    expect(clamped(1.5)).toBeCloseTo(easeInCubic(1));
+  });
+  it('is safe when composed: easeClamp(easeClamp(fn))', () => {
+    const double = easeClamp(easeClamp(easeInCubic));
+    expect(double(-1)).toBeCloseTo(easeInCubic(0));
+    expect(double(2)).toBeCloseTo(easeInCubic(1));
+  });
+});
+
+describe('easeClampOutput', () => {
+  it('does not clamp when output is within range', () => {
+    const fn = easeClampOutput(easeInCubic, 0, 1);
+    expect(fn(0.5)).toBeCloseTo(easeInCubic(0.5));
+  });
+  it('clamps output below min', () => {
+    // a constant function returning -0.5 for the test
+    const below = easeClampOutput(() => -0.5, 0, 1);
+    expect(below(0.5)).toBe(0);
+  });
+  it('clamps output above max', () => {
+    const above = easeClampOutput(() => 1.5, 0, 1);
+    expect(above(0.5)).toBe(1);
+  });
+  it('respects custom range', () => {
+    const fn = easeClampOutput(easeInCubic, 0.2, 0.8);
+    expect(fn(0)).toBe(0.2);
+    expect(fn(1)).toBe(0.8);
+  });
+});
+
+describe('easeInvert', () => {
+  it('maps 0 to 1 and 1 to 0', () => {
+    const inv = easeInvert(easeInCubic);
+    expect(inv(0)).toBeCloseTo(1);
+    expect(inv(1)).toBeCloseTo(0);
+  });
+  it('is the vertical mirror: easeInvert(f)(t) = 1 - f(t)', () => {
+    const inv = easeInvert(easeInCubic);
+    expect(inv(0.5)).toBeCloseTo(1 - easeInCubic(0.5));
+    expect(inv(0.3)).toBeCloseTo(1 - easeInCubic(0.3));
+  });
+  it('double inversion is the identity', () => {
+    const id = easeInvert(easeInvert(easeInCubic));
+    expect(id(0.4)).toBeCloseTo(easeInCubic(0.4));
+  });
+});
+
+describe('easeMirror', () => {
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    const fn = easeMirror(easeInCubic);
+    expect(fn(0)).toBeCloseTo(0);
+    expect(fn(1)).toBeCloseTo(1);
+  });
+  it('passes through 0.5 at t=0.5', () => {
+    const fn = easeMirror(easeInCubic);
+    expect(fn(0.5)).toBeCloseTo(0.5);
+  });
+  it('is symmetric: f(t) + f(1-t) = 1', () => {
+    const fn = easeMirror(easeInCubic);
+    expect(fn(0.3) + fn(0.7)).toBeCloseTo(1);
+    expect(fn(0.1) + fn(0.9)).toBeCloseTo(1);
+  });
+});
+
+describe('easeReverse', () => {
+  it('converts an In curve to an Out curve: f(t) = 1 - easeIn(1 - t)', () => {
+    const reversed = easeReverse(easeInCubic);
+    expect(reversed(0.3)).toBeCloseTo(1 - easeInCubic(0.7));
+    expect(reversed(0.7)).toBeCloseTo(1 - easeInCubic(0.3));
+  });
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    const reversed = easeReverse(easeInCubic);
+    expect(reversed(0)).toBeCloseTo(0);
+    expect(reversed(1)).toBeCloseTo(1);
+  });
+  it('easeReverse(easeInCubic) approximates easeOutCubic', () => {
+    const reversed = easeReverse(easeInCubic);
+    expect(reversed(0.5)).toBeCloseTo(easeOutCubic(0.5), 10);
+    expect(reversed(0.3)).toBeCloseTo(easeOutCubic(0.3), 10);
+  });
+  it('double reverse is the identity', () => {
+    const id = easeReverse(easeReverse(easeInCubic));
+    expect(id(0.4)).toBeCloseTo(easeInCubic(0.4));
+  });
+});
+
+describe('easeScaleOutput', () => {
+  it('maps [0,1] output to [fromValue, toValue]', () => {
+    const fn = easeScaleOutput(easeInCubic, 100, 300);
+    expect(fn(0)).toBeCloseTo(100);
+    expect(fn(1)).toBeCloseTo(300);
+    expect(fn(0.5)).toBeCloseTo(100 + easeInCubic(0.5) * 200);
+  });
+  it('handles inverted ranges (toValue < fromValue)', () => {
+    const fn = easeScaleOutput(easeInCubic, 300, 100);
+    expect(fn(0)).toBeCloseTo(300);
+    expect(fn(1)).toBeCloseTo(100);
+  });
+  it('is alias-safe: same result when composed', () => {
+    const fn = easeScaleOutput(easeInCubic, 0, 1);
+    expect(fn(0.5)).toBeCloseTo(easeInCubic(0.5));
+  });
+});

package/src/easeCubic.test.ts

@@ -0,0 +1,34 @@
+import { easeInCubic, easeInOutCubic, easeOutCubic } from './easeCubic';
+
+describe('easeInCubic', () => {
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    expect(easeInCubic(0)).toBe(0);
+    expect(easeInCubic(1)).toBe(1);
+  });
+
+  it('is slow at start (value below 0.5 at midpoint)', () => {
+    expect(easeInCubic(0.5)).toBeLessThan(0.5);
+  });
+});
+
+describe('easeInOutCubic', () => {
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    expect(easeInOutCubic(0)).toBe(0);
+    expect(easeInOutCubic(1)).toBe(1);
+  });
+
+  it('is symmetric at midpoint', () => {
+    expect(easeInOutCubic(0.5)).toBeCloseTo(0.5);
+  });
+});
+
+describe('easeOutCubic', () => {
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    expect(easeOutCubic(0)).toBe(0);
+    expect(easeOutCubic(1)).toBe(1);
+  });
+
+  it('is fast at start (value above 0.5 at midpoint)', () => {
+    expect(easeOutCubic(0.5)).toBeGreaterThan(0.5);
+  });
+});

package/src/easeCubicBezier.test.ts

@@ -0,0 +1,47 @@
+import { easeCubicBezier } from './easeCubicBezier';
+
+describe('easeCubicBezier', () => {
+  it('returns exact endpoints regardless of control points', () => {
+    const ease = easeCubicBezier(0.25, 0.1, 0.25, 1.0);
+    expect(ease(0)).toBe(0);
+    expect(ease(1)).toBe(1);
+  });
+
+  it('clamps out-of-range input to the endpoints', () => {
+    const ease = easeCubicBezier(0.42, 0, 0.58, 1);
+    expect(ease(-0.5)).toBe(0);
+    expect(ease(1.5)).toBe(1);
+  });
+
+  it('approximates the identity for the diagonal control points', () => {
+    const linear = easeCubicBezier(0, 0, 1, 1);
+    for (let i = 0; i <= 10; i++) {
+      const t = i / 10;
+      expect(linear(t)).toBeCloseTo(t, 3);
+    }
+  });
+
+  it('matches the CSS "ease" curve at a sampled point', () => {
+    const ease = easeCubicBezier(0.25, 0.1, 0.25, 1.0);
+    // The CSS default "ease" front-loads progress; at the midpoint it is well
+    // ahead of linear. Reference value from a WebKit UnitBezier evaluation.
+    expect(ease(0.5)).toBeCloseTo(0.8024, 2);
+    expect(ease(0.5)).toBeGreaterThan(0.5);
+  });
+
+  it('is monotonically non-decreasing across the interval', () => {
+    const ease = easeCubicBezier(0.25, 0.1, 0.25, 1.0);
+    let prev = ease(0);
+    for (let i = 1; i <= 50; i++) {
+      const value = ease(i / 50);
+      expect(value).toBeGreaterThanOrEqual(prev - 1e-6);
+      prev = value;
+    }
+  });
+
+  it('inverts x correctly for an asymmetric curve', () => {
+    const ease = easeCubicBezier(0.42, 0, 0.58, 1);
+    // ease-in-out is symmetric about the midpoint.
+    expect(ease(0.5)).toBeCloseTo(0.5, 2);
+  });
+});

package/src/easeElastic.test.ts

@@ -0,0 +1,30 @@
+import { easeInElastic, easeInOutElastic, easeOutElastic } from './easeElastic';
+
+describe('easeInElastic', () => {
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    expect(easeInElastic(0)).toBe(0);
+    expect(easeInElastic(1)).toBe(1);
+  });
+
+  it('oscillates below 0 before reaching target', () => {
+    expect(easeInElastic(0.8)).toBeLessThan(0);
+  });
+});
+
+describe('easeInOutElastic', () => {
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    expect(easeInOutElastic(0)).toBe(0);
+    expect(easeInOutElastic(1)).toBe(1);
+  });
+});
+
+describe('easeOutElastic', () => {
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    expect(easeOutElastic(0)).toBe(0);
+    expect(easeOutElastic(1)).toBe(1);
+  });
+
+  it('oscillates past 1 near the end', () => {
+    expect(easeOutElastic(0.6)).toBeGreaterThan(1);
+  });
+});

package/src/easeExponential.test.ts

@@ -0,0 +1,34 @@
+import { easeInExponential, easeInOutExponential, easeOutExponential } from './easeExponential';
+
+describe('easeInExponential', () => {
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    expect(easeInExponential(0)).toBe(0);
+    expect(easeInExponential(1)).toBeCloseTo(1);
+  });
+
+  it('is slow at start (value below 0.5 at midpoint)', () => {
+    expect(easeInExponential(0.5)).toBeLessThan(0.5);
+  });
+});
+
+describe('easeInOutExponential', () => {
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    expect(easeInOutExponential(0)).toBe(0);
+    expect(easeInOutExponential(1)).toBe(1);
+  });
+
+  it('is symmetric at midpoint', () => {
+    expect(easeInOutExponential(0.5)).toBeCloseTo(0.5);
+  });
+});
+
+describe('easeOutExponential', () => {
+  it('returns 0 at t=0 and 1 at t=1', () => {
+    expect(easeOutExponential(0)).toBeCloseTo(0);
+    expect(easeOutExponential(1)).toBe(1);
+  });
+
+  it('is fast at start (value above 0.5 at midpoint)', () => {
+    expect(easeOutExponential(0.5)).toBeGreaterThan(0.5);
+  });
+});

package/src/easeLinear.test.ts

@@ -0,0 +1,17 @@
+import { easeLinear } from './easeLinear';
+
+describe('easeLinear', () => {
+  it('returns 0 at t=0', () => {
+    expect(easeLinear(0)).toBe(0);
+  });
+
+  it('returns 1 at t=1', () => {
+    expect(easeLinear(1)).toBe(1);
+  });
+
+  it('returns t unchanged', () => {
+    expect(easeLinear(0.5)).toBe(0.5);
+    expect(easeLinear(0.25)).toBe(0.25);
+    expect(easeLinear(0.75)).toBe(0.75);
+  });
+});