@ansh-ui/core 0.2.0

package/dist/chunk-6PFYGJWD.cjs

@@ -0,0 +1,136 @@
+'use strict';
+
+var chunkILKUL7GD_cjs = require('./chunk-ILKUL7GD.cjs');
+
+// src/math/vector.ts
+function vec2(x = 0, y = x) {
+  return { x, y };
+}
+function cloneVec2(v) {
+  return { x: v.x, y: v.y };
+}
+function addVec2(a, b) {
+  return { x: a.x + b.x, y: a.y + b.y };
+}
+function subVec2(a, b) {
+  return { x: a.x - b.x, y: a.y - b.y };
+}
+function scaleVec2(v, s) {
+  return { x: v.x * s, y: v.y * s };
+}
+function dotVec2(a, b) {
+  return a.x * b.x + a.y * b.y;
+}
+function crossVec2(a, b) {
+  return a.x * b.y - a.y * b.x;
+}
+function lengthVec2(v) {
+  return Math.hypot(v.x, v.y);
+}
+function lengthSqVec2(v) {
+  return v.x * v.x + v.y * v.y;
+}
+function distanceVec2(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+function distanceSqVec2(a, b) {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  return dx * dx + dy * dy;
+}
+function normalizeVec2(v) {
+  const len = Math.hypot(v.x, v.y);
+  return len < chunkILKUL7GD_cjs.EPSILON ? { x: 0, y: 0 } : { x: v.x / len, y: v.y / len };
+}
+function rotateVec2(v, angle) {
+  const c = Math.cos(angle);
+  const s = Math.sin(angle);
+  return { x: v.x * c - v.y * s, y: v.x * s + v.y * c };
+}
+function angleOfVec2(v) {
+  return Math.atan2(v.y, v.x);
+}
+function fromAngle(angle, magnitude = 1) {
+  return { x: Math.cos(angle) * magnitude, y: Math.sin(angle) * magnitude };
+}
+function lerpVec2(a, b, t) {
+  return { x: chunkILKUL7GD_cjs.lerp(a.x, b.x, t), y: chunkILKUL7GD_cjs.lerp(a.y, b.y, t) };
+}
+function limitVec2(v, max) {
+  const lenSq = v.x * v.x + v.y * v.y;
+  if (lenSq <= max * max || lenSq < chunkILKUL7GD_cjs.EPSILON) return { x: v.x, y: v.y };
+  const scale = max / Math.sqrt(lenSq);
+  return { x: v.x * scale, y: v.y * scale };
+}
+function reflectVec2(v, normal) {
+  const d = 2 * (v.x * normal.x + v.y * normal.y);
+  return { x: v.x - d * normal.x, y: v.y - d * normal.y };
+}
+function setVec2(out, x, y) {
+  out.x = x;
+  out.y = y;
+  return out;
+}
+function addVec2Into(out, a, b) {
+  out.x = a.x + b.x;
+  out.y = a.y + b.y;
+  return out;
+}
+function subVec2Into(out, a, b) {
+  out.x = a.x - b.x;
+  out.y = a.y - b.y;
+  return out;
+}
+function scaleVec2Into(out, v, s) {
+  out.x = v.x * s;
+  out.y = v.y * s;
+  return out;
+}
+function lerpVec2Into(out, a, b, t) {
+  out.x = chunkILKUL7GD_cjs.lerp(a.x, b.x, t);
+  out.y = chunkILKUL7GD_cjs.lerp(a.y, b.y, t);
+  return out;
+}
+function addScaledVec2(out, b, s) {
+  out.x += b.x * s;
+  out.y += b.y * s;
+  return out;
+}
+function rectContains(rect, x, y) {
+  return x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height;
+}
+function normalizeInRect(rect, x, y) {
+  return {
+    x: rect.width === 0 ? 0 : chunkILKUL7GD_cjs.clamp((x - rect.x) / rect.width),
+    y: rect.height === 0 ? 0 : chunkILKUL7GD_cjs.clamp((y - rect.y) / rect.height)
+  };
+}
+
+exports.addScaledVec2 = addScaledVec2;
+exports.addVec2 = addVec2;
+exports.addVec2Into = addVec2Into;
+exports.angleOfVec2 = angleOfVec2;
+exports.cloneVec2 = cloneVec2;
+exports.crossVec2 = crossVec2;
+exports.distanceSqVec2 = distanceSqVec2;
+exports.distanceVec2 = distanceVec2;
+exports.dotVec2 = dotVec2;
+exports.fromAngle = fromAngle;
+exports.lengthSqVec2 = lengthSqVec2;
+exports.lengthVec2 = lengthVec2;
+exports.lerpVec2 = lerpVec2;
+exports.lerpVec2Into = lerpVec2Into;
+exports.limitVec2 = limitVec2;
+exports.normalizeInRect = normalizeInRect;
+exports.normalizeVec2 = normalizeVec2;
+exports.rectContains = rectContains;
+exports.reflectVec2 = reflectVec2;
+exports.rotateVec2 = rotateVec2;
+exports.scaleVec2 = scaleVec2;
+exports.scaleVec2Into = scaleVec2Into;
+exports.setVec2 = setVec2;
+exports.subVec2 = subVec2;
+exports.subVec2Into = subVec2Into;
+exports.vec2 = vec2;
+//# sourceMappingURL=chunk-6PFYGJWD.cjs.map
+//# sourceMappingURL=chunk-6PFYGJWD.cjs.map

package/dist/chunk-6PFYGJWD.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/math/vector.ts"],"names":["EPSILON","lerp","clamp"],"mappings":"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","file":"chunk-6PFYGJWD.cjs","sourcesContent":["import { EPSILON, clamp, lerp } from './scalar'\n\n/**\n * A 2D vector.\n *\n * Deliberately a plain object rather than a class: it serialises cleanly, is cheap for the\n * JIT to inline, and can be stored in component props without surprising anyone. Every\n * operation returns a new object except the `*Into` variants, which write into a target\n * and are used in hot loops to avoid allocation pressure.\n */\nexport interface Vec2 {\n  x: number\n  y: number\n}\n\nexport function vec2(x = 0, y = x): Vec2 {\n  return { x, y }\n}\n\nexport function cloneVec2(v: Vec2): Vec2 {\n  return { x: v.x, y: v.y }\n}\n\nexport function addVec2(a: Vec2, b: Vec2): Vec2 {\n  return { x: a.x + b.x, y: a.y + b.y }\n}\n\nexport function subVec2(a: Vec2, b: Vec2): Vec2 {\n  return { x: a.x - b.x, y: a.y - b.y }\n}\n\nexport function scaleVec2(v: Vec2, s: number): Vec2 {\n  return { x: v.x * s, y: v.y * s }\n}\n\nexport function dotVec2(a: Vec2, b: Vec2): number {\n  return a.x * b.x + a.y * b.y\n}\n\n/** 2D analogue of the cross product — the z component of the 3D result. */\nexport function crossVec2(a: Vec2, b: Vec2): number {\n  return a.x * b.y - a.y * b.x\n}\n\nexport function lengthVec2(v: Vec2): number {\n  return Math.hypot(v.x, v.y)\n}\n\n/** Squared length. Prefer this for comparisons — it avoids a square root. */\nexport function lengthSqVec2(v: Vec2): number {\n  return v.x * v.x + v.y * v.y\n}\n\nexport function distanceVec2(a: Vec2, b: Vec2): number {\n  return Math.hypot(a.x - b.x, a.y - b.y)\n}\n\nexport function distanceSqVec2(a: Vec2, b: Vec2): number {\n  const dx = a.x - b.x\n  const dy = a.y - b.y\n  return dx * dx + dy * dy\n}\n\n/** Unit vector. A zero-length input returns `(0, 0)` rather than `NaN`. */\nexport function normalizeVec2(v: Vec2): Vec2 {\n  const len = Math.hypot(v.x, v.y)\n  return len < EPSILON ? { x: 0, y: 0 } : { x: v.x / len, y: v.y / len }\n}\n\n/** Rotate counter-clockwise by `angle` radians. */\nexport function rotateVec2(v: Vec2, angle: number): Vec2 {\n  const c = Math.cos(angle)\n  const s = Math.sin(angle)\n  return { x: v.x * c - v.y * s, y: v.x * s + v.y * c }\n}\n\nexport function angleOfVec2(v: Vec2): number {\n  return Math.atan2(v.y, v.x)\n}\n\nexport function fromAngle(angle: number, magnitude = 1): Vec2 {\n  return { x: Math.cos(angle) * magnitude, y: Math.sin(angle) * magnitude }\n}\n\nexport function lerpVec2(a: Vec2, b: Vec2, t: number): Vec2 {\n  return { x: lerp(a.x, b.x, t), y: lerp(a.y, b.y, t) }\n}\n\n/** Clamp the vector's magnitude to `max`, preserving direction. */\nexport function limitVec2(v: Vec2, max: number): Vec2 {\n  const lenSq = v.x * v.x + v.y * v.y\n  if (lenSq <= max * max || lenSq < EPSILON) return { x: v.x, y: v.y }\n  const scale = max / Math.sqrt(lenSq)\n  return { x: v.x * scale, y: v.y * scale }\n}\n\n/** Reflect `v` about a unit-length `normal`. */\nexport function reflectVec2(v: Vec2, normal: Vec2): Vec2 {\n  const d = 2 * (v.x * normal.x + v.y * normal.y)\n  return { x: v.x - d * normal.x, y: v.y - d * normal.y }\n}\n\n// ---------------------------------------------------------------------------\n// Allocation-free variants for frame loops.\n// ---------------------------------------------------------------------------\n\nexport function setVec2(out: Vec2, x: number, y: number): Vec2 {\n  out.x = x\n  out.y = y\n  return out\n}\n\nexport function addVec2Into(out: Vec2, a: Vec2, b: Vec2): Vec2 {\n  out.x = a.x + b.x\n  out.y = a.y + b.y\n  return out\n}\n\nexport function subVec2Into(out: Vec2, a: Vec2, b: Vec2): Vec2 {\n  out.x = a.x - b.x\n  out.y = a.y - b.y\n  return out\n}\n\nexport function scaleVec2Into(out: Vec2, v: Vec2, s: number): Vec2 {\n  out.x = v.x * s\n  out.y = v.y * s\n  return out\n}\n\nexport function lerpVec2Into(out: Vec2, a: Vec2, b: Vec2, t: number): Vec2 {\n  out.x = lerp(a.x, b.x, t)\n  out.y = lerp(a.y, b.y, t)\n  return out\n}\n\n/** Add `b * s` to `out` in place — the fused multiply-add of vector code. */\nexport function addScaledVec2(out: Vec2, b: Vec2, s: number): Vec2 {\n  out.x += b.x * s\n  out.y += b.y * s\n  return out\n}\n\n/** A rectangle in the same coordinate space as its `Vec2` neighbours. */\nexport interface Rect {\n  x: number\n  y: number\n  width: number\n  height: number\n}\n\nexport function rectContains(rect: Rect, x: number, y: number): boolean {\n  return x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height\n}\n\n/** Position of `(x, y)` within `rect`, normalised to `[0,1]` on each axis. */\nexport function normalizeInRect(rect: Rect, x: number, y: number): Vec2 {\n  return {\n    x: rect.width === 0 ? 0 : clamp((x - rect.x) / rect.width),\n    y: rect.height === 0 ? 0 : clamp((y - rect.y) / rect.height),\n  }\n}\n"]}

package/dist/chunk-7MEIXWPH.js

@@ -0,0 +1,313 @@
+import { clamp, smootherstep, smoothstep, HALF_PI, TAU } from './chunk-KU2C6GEA.js';
+
+// src/easing/bezier.ts
+var SAMPLE_COUNT = 11;
+var SAMPLE_STEP = 1 / (SAMPLE_COUNT - 1);
+var NEWTON_ITERATIONS = 4;
+var NEWTON_MIN_SLOPE = 1e-3;
+var SUBDIVISION_EPSILON = 1e-7;
+var SUBDIVISION_MAX_ITERATIONS = 12;
+var A = (a1, a2) => 1 - 3 * a2 + 3 * a1;
+var B = (a1, a2) => 3 * a2 - 6 * a1;
+var C = (a1) => 3 * a1;
+function calcBezier(t, a1, a2) {
+  return ((A(a1, a2) * t + B(a1, a2)) * t + C(a1)) * t;
+}
+function calcSlope(t, a1, a2) {
+  return 3 * A(a1, a2) * t * t + 2 * B(a1, a2) * t + C(a1);
+}
+function binarySubdivide(x, lower, upper, x1, x2) {
+  let currentX;
+  let currentT;
+  let i = 0;
+  do {
+    currentT = lower + (upper - lower) / 2;
+    currentX = calcBezier(currentT, x1, x2) - x;
+    if (currentX > 0) upper = currentT;
+    else lower = currentT;
+  } while (Math.abs(currentX) > SUBDIVISION_EPSILON && ++i < SUBDIVISION_MAX_ITERATIONS);
+  return currentT;
+}
+function newtonRaphson(x, guess, x1, x2) {
+  let t = guess;
+  for (let i = 0; i < NEWTON_ITERATIONS; i++) {
+    const slope = calcSlope(t, x1, x2);
+    if (slope === 0) return t;
+    t -= (calcBezier(t, x1, x2) - x) / slope;
+  }
+  return t;
+}
+function cubicBezier(x1, y1, x2, y2) {
+  const cx1 = clamp(x1, 0, 1);
+  const cx2 = clamp(x2, 0, 1);
+  if (cx1 === y1 && cx2 === y2) return (t) => t;
+  const samples = new Float32Array(SAMPLE_COUNT);
+  for (let i = 0; i < SAMPLE_COUNT; i++) {
+    samples[i] = calcBezier(i * SAMPLE_STEP, cx1, cx2);
+  }
+  const solveT = (x) => {
+    let intervalStart = 0;
+    let currentSample = 1;
+    const lastSample = SAMPLE_COUNT - 1;
+    while (currentSample !== lastSample && samples[currentSample] <= x) {
+      intervalStart += SAMPLE_STEP;
+      currentSample++;
+    }
+    currentSample--;
+    const start = samples[currentSample];
+    const end = samples[currentSample + 1];
+    const dist = (x - start) / (end - start);
+    const guessForT = intervalStart + dist * SAMPLE_STEP;
+    const initialSlope = calcSlope(guessForT, cx1, cx2);
+    if (initialSlope >= NEWTON_MIN_SLOPE) return newtonRaphson(x, guessForT, cx1, cx2);
+    if (initialSlope === 0) return guessForT;
+    return binarySubdivide(x, intervalStart, intervalStart + SAMPLE_STEP, cx1, cx2);
+  };
+  return (t) => {
+    if (t <= 0) return 0;
+    if (t >= 1) return 1;
+    return calcBezier(solveT(t), y1, y2);
+  };
+}
+function steps(count, position = "end") {
+  const n = Math.max(1, Math.floor(count));
+  return (t) => {
+    const clamped = clamp(t, 0, 1);
+    const raw = clamped * n;
+    let step;
+    switch (position) {
+      case "start":
+        step = Math.ceil(raw);
+        break;
+      case "both":
+        step = Math.floor(raw) + 1;
+        return clamp(step / (n + 1), 0, 1);
+      case "none":
+        step = Math.floor(raw);
+        return n === 1 ? 0 : clamp(step / (n - 1), 0, 1);
+      case "end":
+      default:
+        step = Math.floor(raw);
+        break;
+    }
+    return clamp(step / n, 0, 1);
+  };
+}
+
+// src/easing/library.ts
+function reverseEasing(easeIn) {
+  return (t) => 1 - easeIn(1 - t);
+}
+function mirrorEasing(easeIn) {
+  return (t) => t < 0.5 ? easeIn(t * 2) / 2 : 1 - easeIn((1 - t) * 2) / 2;
+}
+function power(exponent) {
+  return (t) => t ** exponent;
+}
+var easeInSine = (t) => 1 - Math.cos(t * HALF_PI);
+var easeOutSine = (t) => Math.sin(t * HALF_PI);
+var easeInOutSine = (t) => -(Math.cos(Math.PI * t) - 1) / 2;
+var easeInQuad = (t) => t * t;
+var easeOutQuad = (t) => 1 - (1 - t) * (1 - t);
+var easeInOutQuad = (t) => t < 0.5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2;
+var easeInCubic = (t) => t * t * t;
+var easeOutCubic = (t) => 1 - (1 - t) ** 3;
+var easeInOutCubic = (t) => t < 0.5 ? 4 * t * t * t : 1 - (-2 * t + 2) ** 3 / 2;
+var easeInQuart = (t) => t ** 4;
+var easeOutQuart = (t) => 1 - (1 - t) ** 4;
+var easeInOutQuart = (t) => t < 0.5 ? 8 * t ** 4 : 1 - (-2 * t + 2) ** 4 / 2;
+var easeInQuint = (t) => t ** 5;
+var easeOutQuint = (t) => 1 - (1 - t) ** 5;
+var easeInOutQuint = (t) => t < 0.5 ? 16 * t ** 5 : 1 - (-2 * t + 2) ** 5 / 2;
+var easeInExpo = (t) => t === 0 ? 0 : 2 ** (10 * t - 10);
+var easeOutExpo = (t) => t === 1 ? 1 : 1 - 2 ** (-10 * t);
+var easeInOutExpo = (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;
+};
+var easeInCirc = (t) => 1 - Math.sqrt(1 - t * t);
+var easeOutCirc = (t) => Math.sqrt(1 - (t - 1) ** 2);
+var easeInOutCirc = (t) => t < 0.5 ? (1 - Math.sqrt(1 - (2 * t) ** 2)) / 2 : (Math.sqrt(1 - (-2 * t + 2) ** 2) + 1) / 2;
+var BACK_C1 = 1.70158;
+var BACK_C2 = BACK_C1 * 1.525;
+var BACK_C3 = BACK_C1 + 1;
+var easeInBack = (t) => BACK_C3 * t * t * t - BACK_C1 * t * t;
+var easeOutBack = (t) => 1 + BACK_C3 * (t - 1) ** 3 + BACK_C1 * (t - 1) ** 2;
+var easeInOutBack = (t) => t < 0.5 ? (2 * t) ** 2 * ((BACK_C2 + 1) * 2 * t - BACK_C2) / 2 : ((2 * t - 2) ** 2 * ((BACK_C2 + 1) * (t * 2 - 2) + BACK_C2) + 2) / 2;
+var anticipate = (t) => {
+  if (t <= 0) return 0;
+  if (t >= 1) return 1;
+  const scaled = t * 2;
+  return scaled < 1 ? 0.5 * easeInBack(scaled) : 0.5 * (2 - 2 ** (-10 * (scaled - 1)));
+};
+var ELASTIC_C4 = TAU / 3;
+var ELASTIC_C5 = TAU / 4.5;
+var easeInElastic = (t) => {
+  if (t === 0) return 0;
+  if (t === 1) return 1;
+  return -(2 ** (10 * t - 10)) * Math.sin((t * 10 - 10.75) * ELASTIC_C4);
+};
+var easeOutElastic = (t) => {
+  if (t === 0) return 0;
+  if (t === 1) return 1;
+  return 2 ** (-10 * t) * Math.sin((t * 10 - 0.75) * ELASTIC_C4) + 1;
+};
+var easeInOutElastic = (t) => {
+  if (t === 0) return 0;
+  if (t === 1) return 1;
+  return t < 0.5 ? -(2 ** (20 * t - 10) * Math.sin((20 * t - 11.125) * ELASTIC_C5)) / 2 : 2 ** (-20 * t + 10) * Math.sin((20 * t - 11.125) * ELASTIC_C5) / 2 + 1;
+};
+var BOUNCE_N1 = 7.5625;
+var BOUNCE_D1 = 2.75;
+var easeOutBounce = (t) => {
+  if (t < 1 / BOUNCE_D1) return BOUNCE_N1 * t * t;
+  if (t < 2 / BOUNCE_D1) return BOUNCE_N1 * (t -= 1.5 / BOUNCE_D1) * t + 0.75;
+  if (t < 2.5 / BOUNCE_D1) return BOUNCE_N1 * (t -= 2.25 / BOUNCE_D1) * t + 0.9375;
+  return BOUNCE_N1 * (t -= 2.625 / BOUNCE_D1) * t + 0.984375;
+};
+var easeInBounce = (t) => 1 - easeOutBounce(1 - t);
+var easeInOutBounce = (t) => t < 0.5 ? (1 - easeOutBounce(1 - 2 * t)) / 2 : (1 + easeOutBounce(2 * t - 1)) / 2;
+var linear = (t) => t;
+var smoothstepEasing = (t) => smoothstep(0, 1, t);
+var smootherstepEasing = (t) => smootherstep(0, 1, t);
+var easings = {
+  linear,
+  easeInSine,
+  easeOutSine,
+  easeInOutSine,
+  easeInQuad,
+  easeOutQuad,
+  easeInOutQuad,
+  easeInCubic,
+  easeOutCubic,
+  easeInOutCubic,
+  easeInQuart,
+  easeOutQuart,
+  easeInOutQuart,
+  easeInQuint,
+  easeOutQuint,
+  easeInOutQuint,
+  easeInExpo,
+  easeOutExpo,
+  easeInOutExpo,
+  easeInCirc,
+  easeOutCirc,
+  easeInOutCirc,
+  easeInBack,
+  easeOutBack,
+  easeInOutBack,
+  easeInElastic,
+  easeOutElastic,
+  easeInOutElastic,
+  easeInBounce,
+  easeOutBounce,
+  easeInOutBounce,
+  smoothstep: smoothstepEasing,
+  smootherstep: smootherstepEasing,
+  anticipate
+};
+var signature = {
+  /** Entrances. Fast out of the gate, long gentle settle. The Ansh house curve. */
+  emphasized: cubicBezier(0.22, 1, 0.36, 1),
+  /** UI state changes that should feel instant but not abrupt. */
+  standard: cubicBezier(0.4, 0, 0.2, 1),
+  /** Exits. Accelerates away — the element is leaving, don't linger on it. */
+  exit: cubicBezier(0.4, 0, 1, 1),
+  /** Entrances from off-screen. Decelerates in. */
+  enter: cubicBezier(0, 0, 0.2, 1),
+  /** A confident, slightly springy overshoot without full elastic wobble. */
+  overshoot: cubicBezier(0.34, 1.56, 0.64, 1),
+  /** Long, cinematic reveals — hero sections, scroll-driven scenes. */
+  cinematic: cubicBezier(0.16, 1, 0.3, 1)
+};
+Object.assign(easings, signature);
+function registerEasing(name, fn) {
+  if (name in easings && !customEasings.has(name)) {
+    throw new Error(
+      `[ansh] Cannot override the built-in easing "${name}". Choose a different name.`
+    );
+  }
+  customEasings.add(name);
+  easings[name] = fn;
+}
+var customEasings = /* @__PURE__ */ new Set();
+function unregisterEasing(name) {
+  if (!customEasings.has(name)) return;
+  customEasings.delete(name);
+  delete easings[name];
+}
+function listEasings() {
+  return Object.keys(easings).sort();
+}
+function sampleEasing(easing, resolution = 64) {
+  const table = new Float32Array(resolution + 1);
+  for (let i = 0; i <= resolution; i++) table[i] = easing(i / resolution);
+  return table;
+}
+function readEasingTable(table, t) {
+  const last = table.length - 1;
+  const pos = clamp(t, 0, 1) * last;
+  const i = Math.floor(pos);
+  if (i >= last) return table[last];
+  const frac = pos - i;
+  return table[i] + (table[i + 1] - table[i]) * frac;
+}
+
+// src/easing/resolve.ts
+function resolveEasing(input) {
+  if (input == null) return linear;
+  if (typeof input === "function") return input;
+  if (Array.isArray(input)) {
+    if (input.length !== 4 || input.some((n) => typeof n !== "number" || !Number.isFinite(n))) {
+      warnOnce(
+        `Invalid cubic-bezier coordinates: ${JSON.stringify(input)}. Expected four finite numbers, e.g. [0.22, 1, 0.36, 1]. Falling back to linear.`
+      );
+      return linear;
+    }
+    const [x1, y1, x2, y2] = input;
+    return cubicBezier(x1, y1, x2, y2);
+  }
+  if (typeof input === "string") {
+    const found = easings[input];
+    if (found) return found;
+    const css = parseCssEasing(input);
+    if (css) return css;
+    warnOnce(
+      `Unknown easing "${input}". Falling back to linear. Use one of the built-ins, register your own with registerEasing(), or pass bezier coordinates like [0.22, 1, 0.36, 1].`
+    );
+    return linear;
+  }
+  return linear;
+}
+var CSS_BEZIER = /^cubic-bezier\(\s*([^,]+),\s*([^,]+),\s*([^,]+),\s*([^)]+)\)$/i;
+function parseCssEasing(input) {
+  const trimmed = input.trim();
+  switch (trimmed.toLowerCase()) {
+    case "ease":
+      return cubicBezier(0.25, 0.1, 0.25, 1);
+    case "ease-in":
+      return cubicBezier(0.42, 0, 1, 1);
+    case "ease-out":
+      return cubicBezier(0, 0, 0.58, 1);
+    case "ease-in-out":
+      return cubicBezier(0.42, 0, 0.58, 1);
+    case "linear":
+      return linear;
+  }
+  const match = CSS_BEZIER.exec(trimmed);
+  if (!match) return null;
+  const nums = match.slice(1, 5).map((s) => Number.parseFloat(s.trim()));
+  if (nums.some((n) => !Number.isFinite(n))) return null;
+  return cubicBezier(nums[0], nums[1], nums[2], nums[3]);
+}
+var warned = /* @__PURE__ */ new Set();
+function warnOnce(message) {
+  if (warned.has(message)) return;
+  warned.add(message);
+  console.warn(`[ansh] ${message}`);
+}
+
+export { anticipate, cubicBezier, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, easings, linear, listEasings, mirrorEasing, power, readEasingTable, registerEasing, resolveEasing, reverseEasing, sampleEasing, signature, steps, unregisterEasing };
+//# sourceMappingURL=chunk-7MEIXWPH.js.map
+//# sourceMappingURL=chunk-7MEIXWPH.js.map

package/dist/chunk-7MEIXWPH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/easing/bezier.ts","../src/easing/library.ts","../src/easing/resolve.ts"],"names":[],"mappings":"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","file":"chunk-7MEIXWPH.js","sourcesContent":["import { clamp } from '../math/scalar'\nimport type { EasingFn } from './types'\n\n/**\n * A cubic-bézier easing solver matching the CSS `cubic-bezier()` timing function.\n *\n * The curve is defined by control points `(0,0), (x1,y1), (x2,y2), (1,1)`. Evaluating it\n * means solving `bezierX(t) = x` for the parameter `t`, then returning `bezierY(t)`.\n * There is no closed form, so we:\n *\n *  1. Precompute a sample table of `x` at 11 evenly spaced `t` values.\n *  2. Bracket the input against that table to get a good initial guess.\n *  3. Refine with Newton–Raphson, which converges quadratically where the derivative is healthy.\n *  4. Fall back to bisection when the derivative is near zero (very flat curve segments,\n *     where Newton would shoot off to infinity).\n *\n * This is the same strategy Chromium uses, and it is accurate to ~1e-7 in a handful of\n * iterations. The sample table is built once per curve and reused for every frame.\n */\n\nconst SAMPLE_COUNT = 11\nconst SAMPLE_STEP = 1 / (SAMPLE_COUNT - 1)\nconst NEWTON_ITERATIONS = 4\nconst NEWTON_MIN_SLOPE = 0.001\nconst SUBDIVISION_EPSILON = 1e-7\nconst SUBDIVISION_MAX_ITERATIONS = 12\n\nconst A = (a1: number, a2: number) => 1 - 3 * a2 + 3 * a1\nconst B = (a1: number, a2: number) => 3 * a2 - 6 * a1\nconst C = (a1: number) => 3 * a1\n\n/** Evaluate the bézier polynomial at `t` for one axis. */\nfunction calcBezier(t: number, a1: number, a2: number): number {\n  return ((A(a1, a2) * t + B(a1, a2)) * t + C(a1)) * t\n}\n\n/** First derivative of the above — the slope used by Newton–Raphson. */\nfunction calcSlope(t: number, a1: number, a2: number): number {\n  return 3 * A(a1, a2) * t * t + 2 * B(a1, a2) * t + C(a1)\n}\n\nfunction binarySubdivide(x: number, lower: number, upper: number, x1: number, x2: number): number {\n  let currentX: number\n  let currentT: number\n  let i = 0\n  do {\n    currentT = lower + (upper - lower) / 2\n    currentX = calcBezier(currentT, x1, x2) - x\n    if (currentX > 0) upper = currentT\n    else lower = currentT\n  } while (Math.abs(currentX) > SUBDIVISION_EPSILON && ++i < SUBDIVISION_MAX_ITERATIONS)\n  return currentT\n}\n\nfunction newtonRaphson(x: number, guess: number, x1: number, x2: number): number {\n  let t = guess\n  for (let i = 0; i < NEWTON_ITERATIONS; i++) {\n    const slope = calcSlope(t, x1, x2)\n    if (slope === 0) return t\n    t -= (calcBezier(t, x1, x2) - x) / slope\n  }\n  return t\n}\n\n/**\n * Build an easing function from four cubic-bézier control coordinates.\n *\n * @param x1 First control point's x, clamped to `[0,1]` (as CSS requires — an x outside\n *           that range makes the curve non-monotonic in time and thus not a valid timing\n *           function). y values are unconstrained, which is what allows overshoot curves\n *           like `easeOutBack`.\n */\nexport function cubicBezier(x1: number, y1: number, x2: number, y2: number): EasingFn {\n  const cx1 = clamp(x1, 0, 1)\n  const cx2 = clamp(x2, 0, 1)\n\n  // A linear curve needs no solving at all.\n  if (cx1 === y1 && cx2 === y2) return (t) => t\n\n  const samples = new Float32Array(SAMPLE_COUNT)\n  for (let i = 0; i < SAMPLE_COUNT; i++) {\n    samples[i] = calcBezier(i * SAMPLE_STEP, cx1, cx2)\n  }\n\n  const solveT = (x: number): number => {\n    let intervalStart = 0\n    let currentSample = 1\n    const lastSample = SAMPLE_COUNT - 1\n\n    while (currentSample !== lastSample && samples[currentSample] <= x) {\n      intervalStart += SAMPLE_STEP\n      currentSample++\n    }\n    currentSample--\n\n    // Linearly interpolate an initial guess within the bracketing interval.\n    const start = samples[currentSample]\n    const end = samples[currentSample + 1]\n    const dist = (x - start) / (end - start)\n    const guessForT = intervalStart + dist * SAMPLE_STEP\n\n    const initialSlope = calcSlope(guessForT, cx1, cx2)\n    if (initialSlope >= NEWTON_MIN_SLOPE) return newtonRaphson(x, guessForT, cx1, cx2)\n    if (initialSlope === 0) return guessForT\n    return binarySubdivide(x, intervalStart, intervalStart + SAMPLE_STEP, cx1, cx2)\n  }\n\n  return (t: number): number => {\n    // Endpoints are exact by definition; short-circuit to avoid float drift at 0 and 1.\n    if (t <= 0) return 0\n    if (t >= 1) return 1\n    return calcBezier(solveT(t), y1, y2)\n  }\n}\n\n/**\n * A stepped (staircase) timing function, matching CSS `steps()`.\n *\n * @param count Number of discrete steps. Must be >= 1.\n * @param position Where the jump happens within each step, matching the CSS keywords.\n */\nexport function steps(\n  count: number,\n  position: 'start' | 'end' | 'both' | 'none' = 'end',\n): EasingFn {\n  const n = Math.max(1, Math.floor(count))\n  return (t: number): number => {\n    const clamped = clamp(t, 0, 1)\n    const raw = clamped * n\n    let step: number\n    switch (position) {\n      case 'start':\n        step = Math.ceil(raw)\n        break\n      case 'both':\n        step = Math.floor(raw) + 1\n        return clamp(step / (n + 1), 0, 1)\n      case 'none':\n        step = Math.floor(raw)\n        return n === 1 ? 0 : clamp(step / (n - 1), 0, 1)\n      case 'end':\n      default:\n        step = Math.floor(raw)\n        break\n    }\n    return clamp(step / n, 0, 1)\n  }\n}\n","import { HALF_PI, TAU, clamp, smootherstep as ss2, smoothstep as ss1 } from '../math/scalar'\nimport { cubicBezier } from './bezier'\nimport type { EasingFn, EasingName } from './types'\n\n/**\n * The built-in easing library.\n *\n * Curves follow the Penner definitions, which is what CSS, GSAP and Framer Motion all\n * converged on — so `easeOutCubic` here is numerically identical to `easeOutCubic` there.\n * Every function is exact at both endpoints.\n */\n\n// --- Helpers -----------------------------------------------------------------\n\n/** Turn an \"in\" curve into its mirrored \"out\" counterpart. */\nexport function reverseEasing(easeIn: EasingFn): EasingFn {\n  return (t) => 1 - easeIn(1 - t)\n}\n\n/** Compose an \"in\" curve into a symmetric \"in-out\" curve. */\nexport function mirrorEasing(easeIn: EasingFn): EasingFn {\n  return (t) => (t < 0.5 ? easeIn(t * 2) / 2 : 1 - easeIn((1 - t) * 2) / 2)\n}\n\n/** Raise progress to a power — the family behind quad/cubic/quart/quint. */\nexport function power(exponent: number): EasingFn {\n  return (t) => t ** exponent\n}\n\n// --- Sine --------------------------------------------------------------------\n\nexport const easeInSine: EasingFn = (t) => 1 - Math.cos(t * HALF_PI)\nexport const easeOutSine: EasingFn = (t) => Math.sin(t * HALF_PI)\nexport const easeInOutSine: EasingFn = (t) => -(Math.cos(Math.PI * t) - 1) / 2\n\n// --- Polynomial --------------------------------------------------------------\n\nexport const easeInQuad: EasingFn = (t) => t * t\nexport const easeOutQuad: EasingFn = (t) => 1 - (1 - t) * (1 - t)\nexport const easeInOutQuad: EasingFn = (t) => (t < 0.5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2)\n\nexport const easeInCubic: EasingFn = (t) => t * t * t\nexport const easeOutCubic: EasingFn = (t) => 1 - (1 - t) ** 3\nexport const easeInOutCubic: EasingFn = (t) => (t < 0.5 ? 4 * t * t * t : 1 - (-2 * t + 2) ** 3 / 2)\n\nexport const easeInQuart: EasingFn = (t) => t ** 4\nexport const easeOutQuart: EasingFn = (t) => 1 - (1 - t) ** 4\nexport const easeInOutQuart: EasingFn = (t) => (t < 0.5 ? 8 * t ** 4 : 1 - (-2 * t + 2) ** 4 / 2)\n\nexport const easeInQuint: EasingFn = (t) => t ** 5\nexport const easeOutQuint: EasingFn = (t) => 1 - (1 - t) ** 5\nexport const easeInOutQuint: EasingFn = (t) => (t < 0.5 ? 16 * t ** 5 : 1 - (-2 * t + 2) ** 5 / 2)\n\n// --- Exponential -------------------------------------------------------------\n\nexport const easeInExpo: EasingFn = (t) => (t === 0 ? 0 : 2 ** (10 * t - 10))\nexport const easeOutExpo: EasingFn = (t) => (t === 1 ? 1 : 1 - 2 ** (-10 * t))\nexport const easeInOutExpo: EasingFn = (t) => {\n  if (t === 0) return 0\n  if (t === 1) return 1\n  return t < 0.5 ? 2 ** (20 * t - 10) / 2 : (2 - 2 ** (-20 * t + 10)) / 2\n}\n\n// --- Circular ----------------------------------------------------------------\n\nexport const easeInCirc: EasingFn = (t) => 1 - Math.sqrt(1 - t * t)\nexport const easeOutCirc: EasingFn = (t) => Math.sqrt(1 - (t - 1) ** 2)\nexport const easeInOutCirc: EasingFn = (t) =>\n  t < 0.5 ? (1 - Math.sqrt(1 - (2 * t) ** 2)) / 2 : (Math.sqrt(1 - (-2 * t + 2) ** 2) + 1) / 2\n\n// --- Back (overshoot) --------------------------------------------------------\n\n/** Overshoot magnitude. 1.70158 gives a ~10% overshoot, the Penner default. */\nconst BACK_C1 = 1.70158\nconst BACK_C2 = BACK_C1 * 1.525\nconst BACK_C3 = BACK_C1 + 1\n\nexport const easeInBack: EasingFn = (t) => BACK_C3 * t * t * t - BACK_C1 * t * t\nexport const easeOutBack: EasingFn = (t) => 1 + BACK_C3 * (t - 1) ** 3 + BACK_C1 * (t - 1) ** 2\nexport const easeInOutBack: EasingFn = (t) =>\n  t < 0.5\n    ? ((2 * t) ** 2 * ((BACK_C2 + 1) * 2 * t - BACK_C2)) / 2\n    : ((2 * t - 2) ** 2 * ((BACK_C2 + 1) * (t * 2 - 2) + BACK_C2) + 2) / 2\n\n/**\n * A brief pull-back before moving forward. Reads as \"gathering intent\".\n *\n * The second half is an exponential decay, which approaches 1 asymptotically and never reaches it —\n * at `t = 1` the raw expression gives `1 - 2⁻¹¹`. The explicit endpoint keeps the curve exact, which\n * the animation driver relies on to land values on their targets rather than a fraction short.\n */\nexport const anticipate: EasingFn = (t) => {\n  if (t <= 0) return 0\n  if (t >= 1) return 1\n  const scaled = t * 2\n  return scaled < 1 ? 0.5 * easeInBack(scaled) : 0.5 * (2 - 2 ** (-10 * (scaled - 1)))\n}\n\n// --- Elastic -----------------------------------------------------------------\n\nconst ELASTIC_C4 = TAU / 3\nconst ELASTIC_C5 = TAU / 4.5\n\nexport const easeInElastic: EasingFn = (t) => {\n  if (t === 0) return 0\n  if (t === 1) return 1\n  return -(2 ** (10 * t - 10)) * Math.sin((t * 10 - 10.75) * ELASTIC_C4)\n}\n\nexport const easeOutElastic: EasingFn = (t) => {\n  if (t === 0) return 0\n  if (t === 1) return 1\n  return 2 ** (-10 * t) * Math.sin((t * 10 - 0.75) * ELASTIC_C4) + 1\n}\n\nexport const easeInOutElastic: EasingFn = (t) => {\n  if (t === 0) return 0\n  if (t === 1) return 1\n  return t < 0.5\n    ? -(2 ** (20 * t - 10) * Math.sin((20 * t - 11.125) * ELASTIC_C5)) / 2\n    : (2 ** (-20 * t + 10) * Math.sin((20 * t - 11.125) * ELASTIC_C5)) / 2 + 1\n}\n\n// --- Bounce ------------------------------------------------------------------\n\nconst BOUNCE_N1 = 7.5625\nconst BOUNCE_D1 = 2.75\n\nexport const easeOutBounce: EasingFn = (t) => {\n  if (t < 1 / BOUNCE_D1) return BOUNCE_N1 * t * t\n  if (t < 2 / BOUNCE_D1) return BOUNCE_N1 * (t -= 1.5 / BOUNCE_D1) * t + 0.75\n  if (t < 2.5 / BOUNCE_D1) return BOUNCE_N1 * (t -= 2.25 / BOUNCE_D1) * t + 0.9375\n  return BOUNCE_N1 * (t -= 2.625 / BOUNCE_D1) * t + 0.984375\n}\n\nexport const easeInBounce: EasingFn = (t) => 1 - easeOutBounce(1 - t)\n\nexport const easeInOutBounce: EasingFn = (t) =>\n  t < 0.5 ? (1 - easeOutBounce(1 - 2 * t)) / 2 : (1 + easeOutBounce(2 * t - 1)) / 2\n\n// --- Interpolation curves ----------------------------------------------------\n\nexport const linear: EasingFn = (t) => t\n\n/**\n * The smoothstep curves are *not* re-exported under their bare names here.\n *\n * `math/scalar` already owns `smoothstep(edge0, edge1, x)` with the GLSL signature, and exporting\n * a one-argument function of the same name from the package root would be genuinely ambiguous at\n * the call site — the reader could not tell which they had imported. Reach for them as\n * `easings.smoothstep` when an `EasingFn` is wanted, or call the 3-argument form directly.\n */\nconst smoothstepEasing: EasingFn = (t) => ss1(0, 1, t)\nconst smootherstepEasing: EasingFn = (t) => ss2(0, 1, t)\n\n// --- Registry ----------------------------------------------------------------\n\n/**\n * Named curve lookup.\n *\n * Kept as a mutable record so `registerEasing()` can extend it. Consumers should go through\n * `resolveEasing()` rather than reading this directly.\n */\nexport const easings: Record<string, EasingFn> = {\n  linear,\n  easeInSine,\n  easeOutSine,\n  easeInOutSine,\n  easeInQuad,\n  easeOutQuad,\n  easeInOutQuad,\n  easeInCubic,\n  easeOutCubic,\n  easeInOutCubic,\n  easeInQuart,\n  easeOutQuart,\n  easeInOutQuart,\n  easeInQuint,\n  easeOutQuint,\n  easeInOutQuint,\n  easeInExpo,\n  easeOutExpo,\n  easeInOutExpo,\n  easeInCirc,\n  easeOutCirc,\n  easeInOutCirc,\n  easeInBack,\n  easeOutBack,\n  easeInOutBack,\n  easeInElastic,\n  easeOutElastic,\n  easeInOutElastic,\n  easeInBounce,\n  easeOutBounce,\n  easeInOutBounce,\n  smoothstep: smoothstepEasing,\n  smootherstep: smootherstepEasing,\n  anticipate,\n}\n\n/**\n * Signature curves used by the design system's motion hierarchy.\n *\n * These are the ones you should reach for by default. They are named for intent rather than\n * for maths, because \"what is this motion communicating\" is the useful question at a call site.\n */\nexport const signature = {\n  /** Entrances. Fast out of the gate, long gentle settle. The Ansh house curve. */\n  emphasized: cubicBezier(0.22, 1, 0.36, 1),\n  /** UI state changes that should feel instant but not abrupt. */\n  standard: cubicBezier(0.4, 0, 0.2, 1),\n  /** Exits. Accelerates away — the element is leaving, don't linger on it. */\n  exit: cubicBezier(0.4, 0, 1, 1),\n  /** Entrances from off-screen. Decelerates in. */\n  enter: cubicBezier(0, 0, 0.2, 1),\n  /** A confident, slightly springy overshoot without full elastic wobble. */\n  overshoot: cubicBezier(0.34, 1.56, 0.64, 1),\n  /** Long, cinematic reveals — hero sections, scroll-driven scenes. */\n  cinematic: cubicBezier(0.16, 1, 0.3, 1),\n} satisfies Record<string, EasingFn>\n\nObject.assign(easings, signature)\n\n/**\n * Register a custom named curve, making it resolvable everywhere an easing is accepted.\n *\n * @throws if the name collides with a built-in, to prevent one plugin silently changing\n *         the meaning of `easeOutCubic` for the whole application.\n */\nexport function registerEasing(name: string, fn: EasingFn): void {\n  if (name in easings && !customEasings.has(name)) {\n    throw new Error(\n      `[ansh] Cannot override the built-in easing \"${name}\". Choose a different name.`,\n    )\n  }\n  customEasings.add(name)\n  easings[name] = fn\n}\n\nconst customEasings = new Set<string>()\n\n/** Remove a previously registered custom curve. Built-ins cannot be removed. */\nexport function unregisterEasing(name: string): void {\n  if (!customEasings.has(name)) return\n  customEasings.delete(name)\n  delete easings[name]\n}\n\n/** Every currently resolvable easing name, built-in and custom. */\nexport function listEasings(): string[] {\n  return Object.keys(easings).sort()\n}\n\nexport type { EasingName }\n\n/**\n * Sample a curve into a lookup table.\n *\n * Useful for expensive curves evaluated per-particle per-frame, and for rendering easing\n * previews in the docs site.\n */\nexport function sampleEasing(easing: EasingFn, resolution = 64): Float32Array {\n  const table = new Float32Array(resolution + 1)\n  for (let i = 0; i <= resolution; i++) table[i] = easing(i / resolution)\n  return table\n}\n\n/** Read a table produced by {@link sampleEasing}, interpolating between samples. */\nexport function readEasingTable(table: Float32Array, t: number): number {\n  const last = table.length - 1\n  const pos = clamp(t, 0, 1) * last\n  const i = Math.floor(pos)\n  if (i >= last) return table[last]\n  const frac = pos - i\n  return table[i] + (table[i + 1] - table[i]) * frac\n}\n","import { cubicBezier } from './bezier'\nimport { easings, linear } from './library'\nimport type { EasingFn, EasingInput } from './types'\n\n/**\n * Normalise any accepted easing shape into a callable function.\n *\n * This is the single entry point every part of the engine uses, so authors can pass a name,\n * a function, or bézier coordinates interchangeably and it always works the same way.\n *\n * An unknown *name* is a developer mistake worth surfacing loudly — silently falling back to\n * linear would produce motion that looks subtly wrong with no explanation. We warn and fall\n * back rather than throw, because a bad easing name should never take down a page in production.\n */\nexport function resolveEasing(input: EasingInput | undefined | null): EasingFn {\n  if (input == null) return linear\n\n  if (typeof input === 'function') return input\n\n  if (Array.isArray(input)) {\n    if (input.length !== 4 || input.some((n) => typeof n !== 'number' || !Number.isFinite(n))) {\n      warnOnce(\n        `Invalid cubic-bezier coordinates: ${JSON.stringify(input)}. ` +\n          `Expected four finite numbers, e.g. [0.22, 1, 0.36, 1]. Falling back to linear.`,\n      )\n      return linear\n    }\n    const [x1, y1, x2, y2] = input as readonly [number, number, number, number]\n    return cubicBezier(x1, y1, x2, y2)\n  }\n\n  if (typeof input === 'string') {\n    const found = easings[input]\n    if (found) return found\n\n    // Accept raw CSS syntax so authors can paste from a design tool.\n    const css = parseCssEasing(input)\n    if (css) return css\n\n    warnOnce(\n      `Unknown easing \"${input}\". Falling back to linear. ` +\n        `Use one of the built-ins, register your own with registerEasing(), ` +\n        `or pass bezier coordinates like [0.22, 1, 0.36, 1].`,\n    )\n    return linear\n  }\n\n  return linear\n}\n\nconst CSS_BEZIER = /^cubic-bezier\\(\\s*([^,]+),\\s*([^,]+),\\s*([^,]+),\\s*([^)]+)\\)$/i\n\n/** Parse `cubic-bezier(...)` and the CSS keyword timing functions. */\nfunction parseCssEasing(input: string): EasingFn | null {\n  const trimmed = input.trim()\n\n  switch (trimmed.toLowerCase()) {\n    case 'ease':\n      return cubicBezier(0.25, 0.1, 0.25, 1)\n    case 'ease-in':\n      return cubicBezier(0.42, 0, 1, 1)\n    case 'ease-out':\n      return cubicBezier(0, 0, 0.58, 1)\n    case 'ease-in-out':\n      return cubicBezier(0.42, 0, 0.58, 1)\n    case 'linear':\n      return linear\n  }\n\n  const match = CSS_BEZIER.exec(trimmed)\n  if (!match) return null\n\n  const nums = match.slice(1, 5).map((s) => Number.parseFloat(s.trim()))\n  if (nums.some((n) => !Number.isFinite(n))) return null\n  return cubicBezier(nums[0], nums[1], nums[2], nums[3])\n}\n\nconst warned = new Set<string>()\n\n/**\n * Warn at most once per unique message.\n *\n * A bad easing name inside a frame loop would otherwise emit 60 warnings per second and make\n * the console unusable — which is how a helpful message becomes a hostile one.\n */\nfunction warnOnce(message: string): void {\n  if (warned.has(message)) return\n  warned.add(message)\n  console.warn(`[ansh] ${message}`)\n}\n"]}

package/dist/chunk-7MYTSAPR.js

@@ -0,0 +1,83 @@
+import { composite, oklchToRgbMapped } from './chunk-KTUBCQC3.js';
+import { parseColor, relativeLuminance, rgbToOklch } from './chunk-QALZKHWH.js';
+import { clamp } from './chunk-KU2C6GEA.js';
+
+// src/color/contrast.ts
+function contrastRatio(foreground, background) {
+  const bg = parseColor(background);
+  const fgRaw = parseColor(foreground);
+  const fg = fgRaw.a < 1 ? composite(bg, fgRaw) : fgRaw;
+  const l1 = relativeLuminance(fg);
+  const l2 = relativeLuminance(bg);
+  const lighter = Math.max(l1, l2);
+  const darker = Math.min(l1, l2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+function requiredRatio(level, size) {
+  if (level === "AAA") return size === "large" ? 4.5 : 7;
+  return size === "large" ? 3 : 4.5;
+}
+function checkContrast(foreground, background, level = "AA", size = "normal") {
+  const ratio = contrastRatio(foreground, background);
+  const required = requiredRatio(level, size);
+  return { ratio, passes: ratio >= required, required, level, size };
+}
+function pickReadable(background, light = "#ffffff", dark = "#0b0b0f") {
+  const lightRatio = contrastRatio(light, background);
+  const darkRatio = contrastRatio(dark, background);
+  return parseColor(lightRatio >= darkRatio ? light : dark);
+}
+function ensureContrast(foreground, background, target = 4.5) {
+  const fg = parseColor(foreground);
+  const bg = parseColor(background);
+  const initial = contrastRatio(fg, bg);
+  if (initial >= target) return { color: fg, ratio: initial, achieved: true };
+  const lch = rgbToOklch(fg);
+  const bgLuminance = relativeLuminance(bg);
+  const direction = bgLuminance > 0.35 ? -1 : 1;
+  let best = fg;
+  let bestRatio = initial;
+  const STEPS = 24;
+  const limit = direction > 0 ? 1 - lch.l : lch.l;
+  for (let i = 1; i <= STEPS; i++) {
+    const l = clamp(lch.l + direction * (limit * (i / STEPS)), 0, 1);
+    const candidate = oklchToRgbMapped({ l, c: lch.c, h: lch.h, alpha: fg.a });
+    const ratio = contrastRatio(candidate, bg);
+    if (ratio > bestRatio) {
+      bestRatio = ratio;
+      best = candidate;
+      if (ratio >= target) return { color: candidate, ratio, achieved: true };
+    }
+  }
+  for (let i = 1; i <= 8; i++) {
+    const c = lch.c * (1 - i / 8);
+    const l = direction > 0 ? 1 : 0;
+    const candidate = oklchToRgbMapped({ l, c, h: lch.h, alpha: fg.a });
+    const ratio = contrastRatio(candidate, bg);
+    if (ratio > bestRatio) {
+      bestRatio = ratio;
+      best = candidate;
+      if (ratio >= target) return { color: candidate, ratio, achieved: true };
+    }
+  }
+  return { color: best, ratio: bestRatio, achieved: bestRatio >= target };
+}
+function worstContrast(foreground, backgrounds) {
+  let worst = Infinity;
+  let against = null;
+  for (const bg of backgrounds) {
+    const ratio = contrastRatio(foreground, bg);
+    if (ratio < worst) {
+      worst = ratio;
+      against = parseColor(bg);
+    }
+  }
+  return { ratio: Number.isFinite(worst) ? worst : 21, against };
+}
+function perceivedLightness(color) {
+  return rgbToOklch(parseColor(color)).l;
+}
+
+export { checkContrast, contrastRatio, ensureContrast, perceivedLightness, pickReadable, requiredRatio, worstContrast };
+//# sourceMappingURL=chunk-7MYTSAPR.js.map
+//# sourceMappingURL=chunk-7MYTSAPR.js.map

package/dist/chunk-7MYTSAPR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/color/contrast.ts"],"names":[],"mappings":"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","file":"chunk-7MYTSAPR.js","sourcesContent":["import { clamp } from '../math/scalar'\nimport { relativeLuminance, rgbToOklch } from './convert'\nimport { oklchToRgbMapped } from './gamut'\nimport { parseColor } from './parse'\nimport { composite } from './interpolate'\nimport type { ColorInput, Rgb } from './types'\n\n/**\n * Contrast and legibility.\n *\n * Animated backgrounds are the single most common way a design ends up failing WCAG: the text\n * was legible against the mockup's midpoint and illegible against the animation's brightest\n * frame. These helpers let components check contrast against the *extremes* of their own\n * palette and adapt, rather than hoping.\n */\n\nexport type WcagLevel = 'AA' | 'AAA'\nexport type TextSize = 'normal' | 'large'\n\n/**\n * WCAG 2.x contrast ratio, from 1 (identical) to 21 (black on white).\n *\n * Semi-transparent colours are composited over `background` first, because a ratio computed\n * from a colour's own alpha is meaningless — what matters is what the eye actually receives.\n */\nexport function contrastRatio(foreground: ColorInput, background: ColorInput): number {\n  const bg = parseColor(background)\n  const fgRaw = parseColor(foreground)\n  const fg = fgRaw.a < 1 ? composite(bg, fgRaw) : fgRaw\n\n  const l1 = relativeLuminance(fg)\n  const l2 = relativeLuminance(bg)\n  const lighter = Math.max(l1, l2)\n  const darker = Math.min(l1, l2)\n  return (lighter + 0.05) / (darker + 0.05)\n}\n\n/** Minimum ratio required by WCAG 2.2 for the given level and text size. */\nexport function requiredRatio(level: WcagLevel, size: TextSize): number {\n  if (level === 'AAA') return size === 'large' ? 4.5 : 7\n  return size === 'large' ? 3 : 4.5\n}\n\nexport interface ContrastResult {\n  ratio: number\n  passes: boolean\n  required: number\n  level: WcagLevel\n  size: TextSize\n}\n\n/** Check a foreground/background pair against a WCAG threshold. */\nexport function checkContrast(\n  foreground: ColorInput,\n  background: ColorInput,\n  level: WcagLevel = 'AA',\n  size: TextSize = 'normal',\n): ContrastResult {\n  const ratio = contrastRatio(foreground, background)\n  const required = requiredRatio(level, size)\n  return { ratio, passes: ratio >= required, required, level, size }\n}\n\n/**\n * Pick whichever of `light`/`dark` reads better on `background`.\n *\n * This is the function to reach for when a component renders text over a user-supplied\n * colour, which is most of them.\n */\nexport function pickReadable(\n  background: ColorInput,\n  light: ColorInput = '#ffffff',\n  dark: ColorInput = '#0b0b0f',\n): Rgb {\n  const lightRatio = contrastRatio(light, background)\n  const darkRatio = contrastRatio(dark, background)\n  return parseColor(lightRatio >= darkRatio ? light : dark)\n}\n\n/**\n * Adjust a colour's lightness until it meets a contrast target against `background`.\n *\n * Works in OKLCH so hue and chroma survive the adjustment — the brand colour stays\n * recognisably itself, it just gets light or dark enough to read. Searches in whichever\n * direction has more headroom, and returns the best achievable colour if the target is\n * unreachable (a mid-grey background cannot support 7:1 with a saturated hue at any lightness).\n */\nexport function ensureContrast(\n  foreground: ColorInput,\n  background: ColorInput,\n  target = 4.5,\n): { color: Rgb; ratio: number; achieved: boolean } {\n  const fg = parseColor(foreground)\n  const bg = parseColor(background)\n\n  const initial = contrastRatio(fg, bg)\n  if (initial >= target) return { color: fg, ratio: initial, achieved: true }\n\n  const lch = rgbToOklch(fg)\n  const bgLuminance = relativeLuminance(bg)\n  // Move away from the background: darken against a light background, lighten against a dark one.\n  const direction = bgLuminance > 0.35 ? -1 : 1\n\n  let best = fg\n  let bestRatio = initial\n\n  // 24 steps across the available lightness range lands within ~4% of optimal, which is\n  // finer than the eye can distinguish and costs 24 cheap conversions.\n  const STEPS = 24\n  const limit = direction > 0 ? 1 - lch.l : lch.l\n\n  for (let i = 1; i <= STEPS; i++) {\n    const l = clamp(lch.l + direction * (limit * (i / STEPS)), 0, 1)\n    const candidate = oklchToRgbMapped({ l, c: lch.c, h: lch.h, alpha: fg.a })\n    const ratio = contrastRatio(candidate, bg)\n    if (ratio > bestRatio) {\n      bestRatio = ratio\n      best = candidate\n      if (ratio >= target) return { color: candidate, ratio, achieved: true }\n    }\n  }\n\n  // Last resort: drop chroma too. Desaturating buys real lightness range at the extremes.\n  for (let i = 1; i <= 8; i++) {\n    const c = lch.c * (1 - i / 8)\n    const l = direction > 0 ? 1 : 0\n    const candidate = oklchToRgbMapped({ l, c, h: lch.h, alpha: fg.a })\n    const ratio = contrastRatio(candidate, bg)\n    if (ratio > bestRatio) {\n      bestRatio = ratio\n      best = candidate\n      if (ratio >= target) return { color: candidate, ratio, achieved: true }\n    }\n  }\n\n  return { color: best, ratio: bestRatio, achieved: bestRatio >= target }\n}\n\n/**\n * Worst-case contrast of a foreground against every colour in a set.\n *\n * An animated gradient background cycles through many colours; text must be legible against\n * all of them. Components call this with their resolved palette and surface a dev warning when\n * it fails, which turns an invisible accessibility bug into a console message during development.\n */\nexport function worstContrast(\n  foreground: ColorInput,\n  backgrounds: readonly ColorInput[],\n): { ratio: number; against: Rgb | null } {\n  let worst = Infinity\n  let against: Rgb | null = null\n  for (const bg of backgrounds) {\n    const ratio = contrastRatio(foreground, bg)\n    if (ratio < worst) {\n      worst = ratio\n      against = parseColor(bg)\n    }\n  }\n  return { ratio: Number.isFinite(worst) ? worst : 21, against }\n}\n\n/**\n * APCA-style perceptual lightness, used for ordering colours by visual weight.\n *\n * Not a WCAG 3 implementation — that specification is still in flux and we won't ship a\n * moving target as if it were stable. This is OKLab's `L`, which is a better predictor of\n * perceived lightness than WCAG's relative luminance and is entirely sufficient for the\n * internal job of sorting a palette light-to-dark.\n */\nexport function perceivedLightness(color: ColorInput): number {\n  return rgbToOklch(parseColor(color)).l\n}\n"]}