anim-engine 0.3.2 → 0.4.0

package/README.md

@@ -81,7 +81,7 @@ By restricting itself to numeric values, the engine eliminates string parsing, c
 | 🧩 **Composable models**     | Animations, keyframes, and timelines compose cleanly — put tweens inside timelines, nest keyframes anywhere.                        |
 | 🔄 **Continuous primitives** | Spring, smooth damp, and lerp chase live targets with zero setup — pass `() => value` for dynamic targets.                          |
 | 🚫 **No GC pressure**        | Zero object allocations in hot update paths. State is mutated in place.                                                             |
-| 🎨 **Perceptual color**      | Oklab interpolation via `lerpOklab` — no muddy browns. Compose it into any `onUpdate`.                                              |
+| 🎨 **Perceptual color**      | Oklab interpolation via `lerpRgba` — no muddy browns. Compose it into any `onUpdate`.                                               |
 | 📐 **TypeScript-first**      | Full type exports, exhaustive discriminated unions, no `any`.                                                                       |
 | 🔧 **Ticker control**        | Bring your own game loop or use the built-in rAF ticker. Explicit — never auto-starts.                                              |
 
@@ -112,7 +112,7 @@ Interpolations have `start()`/`stop()`/`kill()` controls, auto-start on creation
 | Primitive                                 | Returns              | Description                                   |
 | ----------------------------------------- | -------------------- | --------------------------------------------- |
 | [`createSmoothClamp`](#createsmoothclamp) | `(n: number) => n`   | Asymptotic clamp — saturates toward threshold |
-| [`lerpOklab` / `hexToRgba`](#color)       | `RgbaTuple` / parser | Perceptually uniform color interpolation      |
+| [`lerpRgba` / `hexToRgba`](#color)        | `RgbaTuple` / parser | Perceptually uniform color interpolation      |
 
 ## Usage
 
@@ -381,7 +381,7 @@ Uses `threshold * (normalized / (1 + |normalized|))` for asymptotic saturation.
 Perceptually uniform Oklab interpolation. Straight RGB lerp produces muddy transitions — red→green goes through brown, blue→yellow goes through grey. Oklab matches human perception: equal steps look like equal changes.
 
 ```ts
-import { lerpOklab, hexToRgba } from "anim-engine";
+import { lerpRgba, hexToRgba } from "anim-engine";
 
 hexToRgba("#ff6b6b"); // → [1, 0.42, 0.42, 1]
 hexToRgba("#f80"); // → [1, 0.533, 0, 1] (shorthand)
@@ -396,7 +396,7 @@ createAnimation({
   durationMs: 2000,
   ease: "outCubic",
   onUpdate: (t) => {
-    const [r, g, b, a] = lerpOklab(fromColor, toColor, t);
+    const [r, g, b, a] = lerpRgba(fromColor, toColor, t);
     sprite.setColor(r, g, b, a);
   },
 });
@@ -405,7 +405,7 @@ createAnimation({
 **With continuous primitives** — drive the blend factor via spring, damp, or lerp:
 
 ```ts
-import { createSpring, lerpOklab, hexToRgba } from "anim-engine";
+import { createSpring, lerpRgba, hexToRgba } from "anim-engine";
 
 const fromColor = hexToRgba("#ff6b6b");
 const toColor = hexToRgba("#4ecdc4");
@@ -416,7 +416,7 @@ const spring = createSpring({
   stiffness: 180,
   damping: 12,
   onUpdate: (t) => {
-    const [r, g, b] = lerpOklab(fromColor, toColor, t);
+    const [r, g, b] = lerpRgba(fromColor, toColor, t);
     sprite.setColor(r, g, b, 1);
   },
 });
@@ -658,7 +658,7 @@ requestAnimationFrame(gameLoop);
 | `createSmoothClamp(threshold)`     | Asymptotic clamp factory            |
 | `getTicker()`                      | Singleton ticker                    |
 | `cubicBezier(p1x, p1y, p2x, p2y)`  | Custom cubic bezier easing          |
-| `lerpOklab(from, to, t)`           | Oklab color interpolation           |
+| `lerpRgba(from, to, t)`            | Oklab color interpolation           |
 | `hexToRgba(hex)`                   | Parse hex color to normalized RGBA  |
 
 ### Type exports

package/dist/animation/create-animation.js

@@ -1,6 +1,6 @@
 import { resolveEasing } from "../domain/easing.js";
-import { getTicker } from "../domain/ticker.js";
 import { resolveValue } from "../domain/resolve-value.js";
+import { getTicker } from "../ticker/get-ticker.js";
 import { createKeyframeRunner, createTweenRunner } from "./runner.js";
 //#region src/animation/create-animation.ts
 var isKeyframeMode = (options) => {

package/dist/animation/index.d.ts

@@ -0,0 +1 @@
+export { createAnimation } from './create-animation';

package/dist/domain/color.d.ts

@@ -0,0 +1,2 @@
+export type RgbaTuple = readonly [number, number, number, number];
+export type LerpRgba = (from: RgbaTuple, to: RgbaTuple, progress: number) => RgbaTuple;

package/dist/domain/easing.js

@@ -18,40 +18,6 @@ var bounceOut = (x) => {
 	else if (x < 2.5 / d1) return n1 * (x -= 2.25 / d1) * x + .9375;
 	else return n1 * (x -= 2.625 / d1) * x + .984375;
 };
-/** All 31 named easing identifiers, ordered by type. */
-var EASE_NAMES = [
-	"linear",
-	"inQuad",
-	"outQuad",
-	"inOutQuad",
-	"inCubic",
-	"outCubic",
-	"inOutCubic",
-	"inQuart",
-	"outQuart",
-	"inOutQuart",
-	"inQuint",
-	"outQuint",
-	"inOutQuint",
-	"inSine",
-	"outSine",
-	"inOutSine",
-	"inExpo",
-	"outExpo",
-	"inOutExpo",
-	"inCirc",
-	"outCirc",
-	"inOutCirc",
-	"inBack",
-	"outBack",
-	"inOutBack",
-	"inElastic",
-	"outElastic",
-	"inOutElastic",
-	"inBounce",
-	"outBounce",
-	"inOutBounce"
-];
 var EASING_FUNCTIONS = {
 	linear: (x) => x,
 	inQuad: (x) => x * x,
@@ -152,4 +118,4 @@ var cubicBezier = (p1x, p1y, p2x, p2y) => {
 	};
 };
 //#endregion
-export { EASE_NAMES, EASING_FUNCTIONS, cubicBezier, resolveEasing };
+export { EASING_FUNCTIONS, cubicBezier, resolveEasing };

package/dist/domain/index.d.ts

@@ -1,10 +1,10 @@
 export type { AnimationStatus } from './animation';
-export type { InterpolationStatus, Interpolation } from './interpolation';
+export type { InterpolationStatus, Interpolation, LerpOptions, SmoothDampOptions, SpringOptions, } from './interpolation';
 export type { EaseName, EaseFunction } from './easing';
 export { EASE_NAMES, cubicBezier, EASING_FUNCTIONS, resolveEasing } from './easing';
-export { getTicker } from './ticker';
 export type { Ticker, TickHandler } from './ticker';
 export { resolveValue } from './resolve-value';
 export type { DynamicValue } from './resolve-value';
 export type { Animation, AnimationOptions, SingleTweenOptions, KeyframeAnimationOptions, Keyframe, } from './animation';
 export type { TimelineLayer, Timeline } from './timeline';
+export type { RgbaTuple, LerpRgba } from './color';

package/dist/domain/interpolation.d.ts

@@ -1,3 +1,4 @@
+import { DynamicValue } from './resolve-value';
 export type InterpolationStatus = "active" | "inactive" | "dead";
 export type Interpolation = {
     start: () => void;
@@ -8,3 +9,27 @@ export type Interpolation = {
     velocity: number;
     status: InterpolationStatus;
 };
+export type LerpOptions = {
+    to: () => number;
+    smoothTimeMs: DynamicValue;
+    precision?: number;
+    onUpdate?: (value: number, velocity: number) => void;
+    onEnded?: () => void;
+};
+export type SmoothDampOptions = {
+    to: () => number;
+    smoothTimeMs: DynamicValue;
+    maxSpeed?: DynamicValue;
+    precision?: number;
+    onUpdate?: (value: number, velocity: number) => void;
+    onEnded?: () => void;
+};
+export type SpringOptions = {
+    to: () => number;
+    stiffness?: DynamicValue;
+    damping?: DynamicValue;
+    mass?: DynamicValue;
+    precision?: number;
+    onUpdate?: (value: number, velocity: number) => void;
+    onEnded?: () => void;
+};

package/dist/domain/ticker.d.ts

@@ -6,19 +6,3 @@ export type Ticker = {
     add: (handler: TickHandler) => void;
     remove: (handler: TickHandler) => void;
 };
-/** Returns the default ticker singleton. Created lazily on first access. */
-export declare const getTicker: () => Ticker;
-/**
- * Create a ticker that drives active animations.
- *
- * Does NOT auto-start. The user must explicitly call either:
- * - `start()` — begins a `requestAnimationFrame` loop
- * - `update(deltaMs)` — drive manually from a game loop
- *
- * `add()` and `remove()` register/unregister animations without
- * side effects on the rAF loop.
- *
- * Uses a flat array with undefined-tombstone removal for safe concurrent
- * modification during iteration. Compacted after each frame.
- */
-export declare const createTicker: () => Ticker;

package/dist/index.d.ts

@@ -1,13 +1,10 @@
-export { createAnimation } from './animation/create-animation';
-export { createTimeline } from './timeline/create-timeline';
-export { createSpring } from './spring/create-spring';
-export { createSmoothDamp } from './smooth-damp/create-smooth-damp';
-export { createLerp } from './lerp/create-lerp';
-export { createSmoothClamp } from './smooth-clamp/smooth-clamp';
-export { lerpOklab, hexToRgba } from './color/lerp-oklab';
-export { getTicker, EASE_NAMES, cubicBezier } from './domain';
-export type { EaseName, Interpolation, AnimationStatus, InterpolationStatus, DynamicValue, Animation, Keyframe, AnimationOptions, KeyframeAnimationOptions, TimelineLayer, Timeline, Ticker, } from './domain';
-export type { SpringOptions } from './spring/create-spring';
-export type { SmoothDampOptions } from './smooth-damp/create-smooth-damp';
-export type { LerpOptions } from './lerp/create-lerp';
-export type { RgbaTuple } from './color/lerp-oklab';
+export { createAnimation } from './animation';
+export { createTimeline } from './timeline';
+export { createLerp } from './lerp';
+export { createSmoothDamp } from './smooth-damp';
+export { createSmoothClamp } from './smooth-clamp';
+export { createSpring } from './spring';
+export { lerpRgba, hexToRgba } from './lerp-rgba';
+export { getTicker } from './ticker';
+export { cubicBezier } from './domain';
+export type { EaseName, Interpolation, AnimationStatus, InterpolationStatus, DynamicValue, Animation, Keyframe, AnimationOptions, KeyframeAnimationOptions, TimelineLayer, Timeline, Ticker, LerpOptions, SmoothDampOptions, SpringOptions, RgbaTuple, } from './domain';

package/dist/index.js

@@ -1,10 +1,11 @@
-import { EASE_NAMES, cubicBezier } from "./domain/easing.js";
-import { getTicker } from "./domain/ticker.js";
+import { cubicBezier } from "./domain/easing.js";
+import { getTicker } from "./ticker/get-ticker.js";
 import { createAnimation } from "./animation/create-animation.js";
 import { createTimeline } from "./timeline/create-timeline.js";
-import { createSpring } from "./spring/create-spring.js";
-import { createSmoothDamp } from "./smooth-damp/create-smooth-damp.js";
 import { createLerp } from "./lerp/create-lerp.js";
-import { createSmoothClamp } from "./smooth-clamp/smooth-clamp.js";
-import { hexToRgba, lerpOklab } from "./color/lerp-oklab.js";
-export { EASE_NAMES, createAnimation, createLerp, createSmoothClamp, createSmoothDamp, createSpring, createTimeline, cubicBezier, getTicker, hexToRgba, lerpOklab };
+import { createSmoothDamp } from "./smooth-damp/create-smooth-damp.js";
+import { createSmoothClamp } from "./smooth-clamp/create-smooth-clamp.js";
+import { createSpring } from "./spring/create-spring.js";
+import { lerpRgba } from "./lerp-rgba/lerp-rgba.js";
+import { hexToRgba } from "./lerp-rgba/hex-to-rgba.js";
+export { createAnimation, createLerp, createSmoothClamp, createSmoothDamp, createSpring, createTimeline, cubicBezier, getTicker, hexToRgba, lerpRgba };

package/dist/lerp/create-lerp.d.ts

@@ -1,9 +1,2 @@
-import { Interpolation, DynamicValue } from '../domain';
-export type LerpOptions = {
-    to: () => number;
-    smoothTimeMs: DynamicValue;
-    precision?: number;
-    onUpdate?: (value: number, velocity: number) => void;
-    onEnded?: () => void;
-};
+import { Interpolation, LerpOptions } from '../domain';
 export declare const createLerp: (options: LerpOptions) => Interpolation;

package/dist/lerp/create-lerp.js

@@ -1,5 +1,5 @@
-import { getTicker } from "../domain/ticker.js";
 import { resolveValue } from "../domain/resolve-value.js";
+import { getTicker } from "../ticker/get-ticker.js";
 import { lerpStep } from "./step.js";
 //#region src/lerp/create-lerp.ts
 var createLerp = (options) => {

package/dist/lerp/index.d.ts

@@ -0,0 +1 @@
+export { createLerp } from './create-lerp';

package/dist/lerp-rgba/hex-to-rgba.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Parse a hex color string into an RGBA tuple.
+ *
+ * Accepts formats:
+ *   - `#RGB`
+ *   - `#RGBA`
+ *   - `#RRGGBB`
+ *   - `#RRGGBBAA`
+ *
+ * @param hex - Hex color string with optional leading `#`.
+ * @returns An RGBA tuple [R, G, B, A], each 0–1.
+ */
+export declare const hexToRgba: (hex: string) => [number, number, number, number];

package/dist/lerp-rgba/hex-to-rgba.js

@@ -0,0 +1,48 @@
+//#region src/lerp-rgba/hex-to-rgba.ts
+/**
+* Parse a hex color string into an RGBA tuple.
+*
+* Accepts formats:
+*   - `#RGB`
+*   - `#RGBA`
+*   - `#RRGGBB`
+*   - `#RRGGBBAA`
+*
+* @param hex - Hex color string with optional leading `#`.
+* @returns An RGBA tuple [R, G, B, A], each 0–1.
+*/
+var hexToRgba = (hex) => {
+	const cleaned = hex.startsWith("#") ? hex.slice(1) : hex;
+	if (!/^[0-9a-fA-F]+$/.test(cleaned)) return [
+		0,
+		0,
+		0,
+		1
+	];
+	if (cleaned.length === 3) return [
+		parseInt(cleaned[0] + cleaned[0], 16) / 255,
+		parseInt(cleaned[1] + cleaned[1], 16) / 255,
+		parseInt(cleaned[2] + cleaned[2], 16) / 255,
+		1
+	];
+	if (cleaned.length === 4) return [
+		parseInt(cleaned[0] + cleaned[0], 16) / 255,
+		parseInt(cleaned[1] + cleaned[1], 16) / 255,
+		parseInt(cleaned[2] + cleaned[2], 16) / 255,
+		parseInt(cleaned[3] + cleaned[3], 16) / 255
+	];
+	if (cleaned.length >= 6) return [
+		parseInt(cleaned.slice(0, 2), 16) / 255,
+		parseInt(cleaned.slice(2, 4), 16) / 255,
+		parseInt(cleaned.slice(4, 6), 16) / 255,
+		cleaned.length >= 8 ? parseInt(cleaned.slice(6, 8), 16) / 255 : 1
+	];
+	return [
+		0,
+		0,
+		0,
+		1
+	];
+};
+//#endregion
+export { hexToRgba };

package/dist/lerp-rgba/index.d.ts

@@ -0,0 +1,2 @@
+export { lerpRgba } from './lerp-rgba';
+export { hexToRgba } from './hex-to-rgba';

package/dist/lerp-rgba/lerp-rgba.d.ts

@@ -0,0 +1,13 @@
+import { LerpRgba } from '../domain';
+/**
+ * Interpolate between two RGBA colors in Oklab space.
+ *
+ * The RGB channels are converted to Oklab, lerped perceptually uniformly,
+ * and converted back. The alpha channel is lerped linearly.
+ *
+ * @param from - Starting RGBA tuple [R, G, B, A], each 0–1.
+ * @param to - Ending RGBA tuple [R, G, B, A], each 0–1.
+ * @param progress - Interpolation factor (0 = from, 1 = to).
+ * @returns A new RGBA tuple [R, G, B, A], each 0–1.
+ */
+export declare const lerpRgba: LerpRgba;

package/dist/{color/lerp-oklab.js → lerp-rgba/lerp-rgba.js}

@@ -1,4 +1,4 @@
-//#region src/color/lerp-oklab.ts
+//#region src/lerp-rgba/lerp-rgba.ts
 /**
 * Pre-computed constants for Oklab conversion.
 *
@@ -121,7 +121,7 @@ var clamp = (value) => {
 * @param progress - Interpolation factor (0 = from, 1 = to).
 * @returns A new RGBA tuple [R, G, B, A], each 0–1.
 */
-var lerpOklab = (from, to, progress) => {
+var lerpRgba = (from, to, progress) => {
 	const clampedProgress = clamp(progress);
 	const [lFrom, aFrom, bFrom] = rgbToOklab(from[0], from[1], from[2]);
 	const [lTo, aTo, bTo] = rgbToOklab(to[0], to[1], to[2]);
@@ -133,50 +133,5 @@ var lerpOklab = (from, to, progress) => {
 		clamp(from[3] + (to[3] - from[3]) * clampedProgress)
 	];
 };
-/**
-* Parse a hex color string into an RGBA tuple.
-*
-* Accepts formats:
-*   - `#RGB`
-*   - `#RGBA`
-*   - `#RRGGBB`
-*   - `#RRGGBBAA`
-*
-* @param hex - Hex color string with optional leading `#`.
-* @returns An RGBA tuple [R, G, B, A], each 0–1.
-*/
-var hexToRgba = (hex) => {
-	const cleaned = hex.startsWith("#") ? hex.slice(1) : hex;
-	if (!/^[0-9a-fA-F]+$/.test(cleaned)) return [
-		0,
-		0,
-		0,
-		1
-	];
-	if (cleaned.length === 3) return [
-		parseInt(cleaned[0] + cleaned[0], 16) / 255,
-		parseInt(cleaned[1] + cleaned[1], 16) / 255,
-		parseInt(cleaned[2] + cleaned[2], 16) / 255,
-		1
-	];
-	if (cleaned.length === 4) return [
-		parseInt(cleaned[0] + cleaned[0], 16) / 255,
-		parseInt(cleaned[1] + cleaned[1], 16) / 255,
-		parseInt(cleaned[2] + cleaned[2], 16) / 255,
-		parseInt(cleaned[3] + cleaned[3], 16) / 255
-	];
-	if (cleaned.length >= 6) return [
-		parseInt(cleaned.slice(0, 2), 16) / 255,
-		parseInt(cleaned.slice(2, 4), 16) / 255,
-		parseInt(cleaned.slice(4, 6), 16) / 255,
-		cleaned.length >= 8 ? parseInt(cleaned.slice(6, 8), 16) / 255 : 1
-	];
-	return [
-		0,
-		0,
-		0,
-		1
-	];
-};
 //#endregion
-export { hexToRgba, lerpOklab };
+export { lerpRgba };

package/dist/smooth-clamp/{smooth-clamp.js → create-smooth-clamp.js}

@@ -1,4 +1,4 @@
-//#region src/smooth-clamp/smooth-clamp.ts
+//#region src/smooth-clamp/create-smooth-clamp.ts
 /**
 * Creates a smooth clamp function that maps input toward a threshold
 * without ever exceeding it. Uses `x / (1 + |x|)` for a natural-feeling

package/dist/smooth-clamp/index.d.ts

@@ -0,0 +1 @@
+export { createSmoothClamp } from './create-smooth-clamp';

package/dist/smooth-damp/create-smooth-damp.d.ts

@@ -1,10 +1,2 @@
-import { Interpolation, DynamicValue } from '../domain';
-export type SmoothDampOptions = {
-    to: () => number;
-    smoothTimeMs: DynamicValue;
-    maxSpeed?: DynamicValue;
-    precision?: number;
-    onUpdate?: (value: number, velocity: number) => void;
-    onEnded?: () => void;
-};
+import { Interpolation, SmoothDampOptions } from '../domain';
 export declare const createSmoothDamp: (options: SmoothDampOptions) => Interpolation;

package/dist/smooth-damp/create-smooth-damp.js

@@ -1,5 +1,5 @@
-import { getTicker } from "../domain/ticker.js";
 import { resolveValue } from "../domain/resolve-value.js";
+import { getTicker } from "../ticker/get-ticker.js";
 import { smoothDampStep } from "./step.js";
 //#region src/smooth-damp/create-smooth-damp.ts
 var createSmoothDamp = (options) => {

package/dist/smooth-damp/index.d.ts

@@ -0,0 +1 @@
+export { createSmoothDamp } from './create-smooth-damp';

package/dist/spring/create-spring.d.ts

@@ -1,11 +1,2 @@
-import { Interpolation, DynamicValue } from '../domain';
-export type SpringOptions = {
-    to: () => number;
-    stiffness?: DynamicValue;
-    damping?: DynamicValue;
-    mass?: DynamicValue;
-    precision?: number;
-    onUpdate?: (value: number, velocity: number) => void;
-    onEnded?: () => void;
-};
+import { Interpolation, SpringOptions } from '../domain';
 export declare const createSpring: (options: SpringOptions) => Interpolation;

package/dist/spring/create-spring.js

@@ -1,5 +1,5 @@
-import { getTicker } from "../domain/ticker.js";
 import { resolveValue } from "../domain/resolve-value.js";
+import { getTicker } from "../ticker/get-ticker.js";
 import { verletStep } from "./verlet.js";
 //#region src/spring/create-spring.ts
 var createSpring = (options) => {

package/dist/spring/index.d.ts

@@ -0,0 +1 @@
+export { createSpring } from './create-spring';

package/dist/ticker/get-ticker.d.ts

@@ -0,0 +1,17 @@
+import { Ticker } from '../domain';
+/** Returns the default ticker singleton. Created lazily on first access. */
+export declare const getTicker: () => Ticker;
+/**
+ * Create a ticker that drives active animations.
+ *
+ * Does NOT auto-start. The user must explicitly call either:
+ * - `start()` — begins a `requestAnimationFrame` loop
+ * - `update(deltaMs)` — drive manually from a game loop
+ *
+ * `add()` and `remove()` register/unregister animations without
+ * side effects on the rAF loop.
+ *
+ * Uses a flat array with undefined-tombstone removal for safe concurrent
+ * modification during iteration. Compacted after each frame.
+ */
+export declare const createTicker: () => Ticker;

package/dist/{domain/ticker.js → ticker/get-ticker.js}

@@ -1,4 +1,4 @@
-//#region src/domain/ticker.ts
+//#region src/ticker/get-ticker.ts
 var singleton;
 /** Returns the default ticker singleton. Created lazily on first access. */
 var getTicker = () => {

package/dist/ticker/index.d.ts

@@ -0,0 +1 @@
+export { getTicker } from './get-ticker';

package/dist/timeline/create-timeline.js

@@ -1,9 +1,9 @@
 import { resolveEasing } from "../domain/easing.js";
-import { getTicker } from "../domain/ticker.js";
 import { resolveValue } from "../domain/resolve-value.js";
+import { getTicker } from "../ticker/get-ticker.js";
 import { createKeyframeRunner } from "../animation/runner.js";
 //#region src/timeline/create-timeline.ts
-var noop = () => {};
+var noOp = () => {};
 var buildFromConfigs = (rawLayers) => {
 	const activeLayers = [];
 	let previousEndAt = 0;
@@ -39,8 +39,7 @@ var buildFromConfigs = (rawLayers) => {
 	};
 };
 var createTimeline = (layers, options) => {
-	const { onStarted, onEnded } = options ?? {};
-	const onProgress = options?.onProgress ?? noop;
+	const { onStarted, onEnded, onProgress = noOp } = options ?? {};
 	const rawLayers = layers;
 	let state = buildFromConfigs(rawLayers);
 	let activeLayers = state.activeLayers;

package/dist/timeline/index.d.ts

@@ -0,0 +1 @@
+export { createTimeline } from './create-timeline';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anim-engine",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "private": false,
   "description": "JavaScript library for animating numbers",
   "license": "MIT",

package/dist/color/lerp-oklab.d.ts

@@ -1,26 +0,0 @@
-export type RgbaTuple = readonly [number, number, number, number];
-/**
- * Interpolate between two RGBA colors in Oklab space.
- *
- * The RGB channels are converted to Oklab, lerped perceptually uniformly,
- * and converted back. The alpha channel is lerped linearly.
- *
- * @param from - Starting RGBA tuple [R, G, B, A], each 0–1.
- * @param to - Ending RGBA tuple [R, G, B, A], each 0–1.
- * @param progress - Interpolation factor (0 = from, 1 = to).
- * @returns A new RGBA tuple [R, G, B, A], each 0–1.
- */
-export declare const lerpOklab: (from: RgbaTuple, to: RgbaTuple, progress: number) => [number, number, number, number];
-/**
- * Parse a hex color string into an RGBA tuple.
- *
- * Accepts formats:
- *   - `#RGB`
- *   - `#RGBA`
- *   - `#RRGGBB`
- *   - `#RRGGBBAA`
- *
- * @param hex - Hex color string with optional leading `#`.
- * @returns An RGBA tuple [R, G, B, A], each 0–1.
- */
-export declare const hexToRgba: (hex: string) => [number, number, number, number];