@ansh-ui/core 0.2.0

package/dist/chunk-GJRIHN76.cjs

@@ -0,0 +1,359 @@
+'use strict';
+
+var chunkILKUL7GD_cjs = require('./chunk-ILKUL7GD.cjs');
+
+// 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 = chunkILKUL7GD_cjs.clamp(x1, 0, 1);
+  const cx2 = chunkILKUL7GD_cjs.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 = chunkILKUL7GD_cjs.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 chunkILKUL7GD_cjs.clamp(step / (n + 1), 0, 1);
+      case "none":
+        step = Math.floor(raw);
+        return n === 1 ? 0 : chunkILKUL7GD_cjs.clamp(step / (n - 1), 0, 1);
+      case "end":
+      default:
+        step = Math.floor(raw);
+        break;
+    }
+    return chunkILKUL7GD_cjs.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 * chunkILKUL7GD_cjs.HALF_PI);
+var easeOutSine = (t) => Math.sin(t * chunkILKUL7GD_cjs.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 = chunkILKUL7GD_cjs.TAU / 3;
+var ELASTIC_C5 = chunkILKUL7GD_cjs.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) => chunkILKUL7GD_cjs.smoothstep(0, 1, t);
+var smootherstepEasing = (t) => chunkILKUL7GD_cjs.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 = chunkILKUL7GD_cjs.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}`);
+}
+
+exports.anticipate = anticipate;
+exports.cubicBezier = cubicBezier;
+exports.easeInBack = easeInBack;
+exports.easeInBounce = easeInBounce;
+exports.easeInCirc = easeInCirc;
+exports.easeInCubic = easeInCubic;
+exports.easeInElastic = easeInElastic;
+exports.easeInExpo = easeInExpo;
+exports.easeInOutBack = easeInOutBack;
+exports.easeInOutBounce = easeInOutBounce;
+exports.easeInOutCirc = easeInOutCirc;
+exports.easeInOutCubic = easeInOutCubic;
+exports.easeInOutElastic = easeInOutElastic;
+exports.easeInOutExpo = easeInOutExpo;
+exports.easeInOutQuad = easeInOutQuad;
+exports.easeInOutQuart = easeInOutQuart;
+exports.easeInOutQuint = easeInOutQuint;
+exports.easeInOutSine = easeInOutSine;
+exports.easeInQuad = easeInQuad;
+exports.easeInQuart = easeInQuart;
+exports.easeInQuint = easeInQuint;
+exports.easeInSine = easeInSine;
+exports.easeOutBack = easeOutBack;
+exports.easeOutBounce = easeOutBounce;
+exports.easeOutCirc = easeOutCirc;
+exports.easeOutCubic = easeOutCubic;
+exports.easeOutElastic = easeOutElastic;
+exports.easeOutExpo = easeOutExpo;
+exports.easeOutQuad = easeOutQuad;
+exports.easeOutQuart = easeOutQuart;
+exports.easeOutQuint = easeOutQuint;
+exports.easeOutSine = easeOutSine;
+exports.easings = easings;
+exports.linear = linear;
+exports.listEasings = listEasings;
+exports.mirrorEasing = mirrorEasing;
+exports.power = power;
+exports.readEasingTable = readEasingTable;
+exports.registerEasing = registerEasing;
+exports.resolveEasing = resolveEasing;
+exports.reverseEasing = reverseEasing;
+exports.sampleEasing = sampleEasing;
+exports.signature = signature;
+exports.steps = steps;
+exports.unregisterEasing = unregisterEasing;
+//# sourceMappingURL=chunk-GJRIHN76.cjs.map
+//# sourceMappingURL=chunk-GJRIHN76.cjs.map

package/dist/chunk-GJRIHN76.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/easing/bezier.ts","../src/easing/library.ts","../src/easing/resolve.ts"],"names":["clamp","HALF_PI","TAU","smoothstep","smootherstep"],"mappings":"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","file":"chunk-GJRIHN76.cjs","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-ILKUL7GD.cjs

@@ -0,0 +1,115 @@
+'use strict';
+
+// src/math/scalar.ts
+var PI = Math.PI;
+var TAU = Math.PI * 2;
+var HALF_PI = Math.PI / 2;
+var EPSILON = 1e-6;
+function clamp(value, min = 0, max = 1) {
+  return value < min ? min : value > max ? max : value;
+}
+function lerp(from, to, t) {
+  return from + (to - from) * t;
+}
+function inverseLerp(from, to, value) {
+  const span = to - from;
+  return Math.abs(span) < EPSILON ? 0 : (value - from) / span;
+}
+function remap(value, inMin, inMax, outMin, outMax, clampOutput = false) {
+  const t = inverseLerp(inMin, inMax, value);
+  const out = lerp(outMin, outMax, t);
+  return clampOutput ? clamp(out, Math.min(outMin, outMax), Math.max(outMin, outMax)) : out;
+}
+function damp(current, target, smoothing, dt) {
+  return lerp(target, current, Math.pow(clamp(smoothing, EPSILON, 1 - EPSILON), dt));
+}
+function smoothstep(edge0, edge1, x) {
+  const t = clamp(inverseLerp(edge0, edge1, x));
+  return t * t * (3 - 2 * t);
+}
+function smootherstep(edge0, edge1, x) {
+  const t = clamp(inverseLerp(edge0, edge1, x));
+  return t * t * t * (t * (t * 6 - 15) + 10);
+}
+function wrap(value, min, max) {
+  const span = max - min;
+  if (span <= 0) return min;
+  return ((value - min) % span + span) % span + min;
+}
+function pingPong(value, min, max) {
+  const span = max - min;
+  if (span <= 0) return min;
+  const t = wrap(value - min, 0, span * 2);
+  return min + (t > span ? span * 2 - t : t);
+}
+function moveTowards(current, target, maxDelta) {
+  const diff = target - current;
+  return Math.abs(diff) <= maxDelta ? target : current + Math.sign(diff) * maxDelta;
+}
+function angleDelta(a, b) {
+  return wrap(b - a + PI, 0, TAU) - PI;
+}
+function lerpAngle(from, to, t) {
+  return from + angleDelta(from, to) * t;
+}
+function degrees(radians2) {
+  return radians2 * 180 / PI;
+}
+function radians(degrees2) {
+  return degrees2 * PI / 180;
+}
+function roundTo(value, decimals = 2) {
+  const factor = 10 ** decimals;
+  return Math.round(value * factor) / factor;
+}
+function snap(value, step) {
+  return step === 0 ? value : Math.round(value / step) * step;
+}
+function approximately(a, b, epsilon = EPSILON) {
+  return Math.abs(a - b) < epsilon;
+}
+function finite(value, fallback = 0) {
+  return Number.isFinite(value) ? value : fallback;
+}
+function mean(values) {
+  if (values.length === 0) return 0;
+  let sum = 0;
+  for (let i = 0; i < values.length; i++) sum += values[i];
+  return sum / values.length;
+}
+function percentileSorted(sorted, p) {
+  const n = sorted.length;
+  if (n === 0) return 0;
+  if (n === 1) return sorted[0];
+  const rank = clamp(p, 0, 1) * (n - 1);
+  const low = Math.floor(rank);
+  const high = Math.ceil(rank);
+  return low === high ? sorted[low] : lerp(sorted[low], sorted[high], rank - low);
+}
+
+exports.EPSILON = EPSILON;
+exports.HALF_PI = HALF_PI;
+exports.PI = PI;
+exports.TAU = TAU;
+exports.angleDelta = angleDelta;
+exports.approximately = approximately;
+exports.clamp = clamp;
+exports.damp = damp;
+exports.degrees = degrees;
+exports.finite = finite;
+exports.inverseLerp = inverseLerp;
+exports.lerp = lerp;
+exports.lerpAngle = lerpAngle;
+exports.mean = mean;
+exports.moveTowards = moveTowards;
+exports.percentileSorted = percentileSorted;
+exports.pingPong = pingPong;
+exports.radians = radians;
+exports.remap = remap;
+exports.roundTo = roundTo;
+exports.smootherstep = smootherstep;
+exports.smoothstep = smoothstep;
+exports.snap = snap;
+exports.wrap = wrap;
+//# sourceMappingURL=chunk-ILKUL7GD.cjs.map
+//# sourceMappingURL=chunk-ILKUL7GD.cjs.map

package/dist/chunk-ILKUL7GD.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/math/scalar.ts"],"names":["radians","degrees"],"mappings":"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","file":"chunk-ILKUL7GD.cjs","sourcesContent":["/**\n * Scalar math primitives.\n *\n * Every function here is pure, allocation-free and safe to call inside a frame loop.\n * They are the vocabulary the rest of the engine is written in — if you find yourself\n * writing `Math.min(Math.max(...))` anywhere else, use `clamp` instead.\n */\n\nexport const PI = Math.PI\nexport const TAU = Math.PI * 2\nexport const HALF_PI = Math.PI / 2\nexport const EPSILON = 1e-6\n\n/** Constrain `value` to the inclusive range `[min, max]`. */\nexport function clamp(value: number, min = 0, max = 1): number {\n  return value < min ? min : value > max ? max : value\n}\n\n/** Linear interpolation. `t` is not clamped — pass values outside `[0,1]` to extrapolate. */\nexport function lerp(from: number, to: number, t: number): number {\n  return from + (to - from) * t\n}\n\n/** The inverse of {@link lerp}: where does `value` sit between `from` and `to`? */\nexport function inverseLerp(from: number, to: number, value: number): number {\n  const span = to - from\n  return Math.abs(span) < EPSILON ? 0 : (value - from) / span\n}\n\n/** Map `value` from one range to another. Set `clampOutput` to avoid extrapolation. */\nexport function remap(\n  value: number,\n  inMin: number,\n  inMax: number,\n  outMin: number,\n  outMax: number,\n  clampOutput = false,\n): number {\n  const t = inverseLerp(inMin, inMax, value)\n  const out = lerp(outMin, outMax, t)\n  return clampOutput ? clamp(out, Math.min(outMin, outMax), Math.max(outMin, outMax)) : out\n}\n\n/**\n * Frame-rate independent exponential smoothing.\n *\n * A naive `current += (target - current) * 0.1` moves twice as fast at 120 FPS as it does\n * at 60. `damp` reformulates it in terms of a half-life measured in seconds, so the motion\n * looks identical on every device.\n *\n * @param smoothing Fraction of the remaining distance left after one second. `0.001` is snappy,\n *                  `0.5` is languid. Must be in `(0, 1)`.\n * @param dt        Delta time in seconds.\n */\nexport function damp(current: number, target: number, smoothing: number, dt: number): number {\n  return lerp(target, current, Math.pow(clamp(smoothing, EPSILON, 1 - EPSILON), dt))\n}\n\n/** Hermite interpolation with zero first-derivative at both ends. */\nexport function smoothstep(edge0: number, edge1: number, x: number): number {\n  const t = clamp(inverseLerp(edge0, edge1, x))\n  return t * t * (3 - 2 * t)\n}\n\n/** Ken Perlin's quintic smoothstep — zero first *and* second derivative at both ends. */\nexport function smootherstep(edge0: number, edge1: number, x: number): number {\n  const t = clamp(inverseLerp(edge0, edge1, x))\n  return t * t * t * (t * (t * 6 - 15) + 10)\n}\n\n/** Wrap `value` into `[min, max)`, handling negative inputs correctly (unlike `%`). */\nexport function wrap(value: number, min: number, max: number): number {\n  const span = max - min\n  if (span <= 0) return min\n  return ((((value - min) % span) + span) % span) + min\n}\n\n/** Bounce `value` back and forth within `[min, max]` — a triangle wave. */\nexport function pingPong(value: number, min: number, max: number): number {\n  const span = max - min\n  if (span <= 0) return min\n  const t = wrap(value - min, 0, span * 2)\n  return min + (t > span ? span * 2 - t : t)\n}\n\n/** Move `current` toward `target` by at most `maxDelta`. */\nexport function moveTowards(current: number, target: number, maxDelta: number): number {\n  const diff = target - current\n  return Math.abs(diff) <= maxDelta ? target : current + Math.sign(diff) * maxDelta\n}\n\n/** Shortest signed angular distance from `a` to `b`, in radians. */\nexport function angleDelta(a: number, b: number): number {\n  return wrap(b - a + PI, 0, TAU) - PI\n}\n\n/** Interpolate between two angles along the shortest arc. */\nexport function lerpAngle(from: number, to: number, t: number): number {\n  return from + angleDelta(from, to) * t\n}\n\nexport function degrees(radians: number): number {\n  return (radians * 180) / PI\n}\n\nexport function radians(degrees: number): number {\n  return (degrees * PI) / 180\n}\n\n/** Round to a fixed number of decimal places, avoiding float dust in serialised output. */\nexport function roundTo(value: number, decimals = 2): number {\n  const factor = 10 ** decimals\n  return Math.round(value * factor) / factor\n}\n\n/** Round to the nearest multiple of `step`. */\nexport function snap(value: number, step: number): number {\n  return step === 0 ? value : Math.round(value / step) * step\n}\n\n/** Float comparison with a tolerance. */\nexport function approximately(a: number, b: number, epsilon = EPSILON): boolean {\n  return Math.abs(a - b) < epsilon\n}\n\n/** Guard against `NaN`/`Infinity` leaking out of a physics step. */\nexport function finite(value: number, fallback = 0): number {\n  return Number.isFinite(value) ? value : fallback\n}\n\n/** Arithmetic mean of an array. Returns `0` for an empty array. */\nexport function mean(values: readonly number[]): number {\n  if (values.length === 0) return 0\n  let sum = 0\n  for (let i = 0; i < values.length; i++) sum += values[i]\n  return sum / values.length\n}\n\n/**\n * Percentile of an *already sorted* ascending array, using linear interpolation between\n * neighbouring ranks. Used by the frame budget to compute p50/p95 costs.\n */\nexport function percentileSorted(sorted: readonly number[], p: number): number {\n  const n = sorted.length\n  if (n === 0) return 0\n  if (n === 1) return sorted[0]\n  const rank = clamp(p, 0, 1) * (n - 1)\n  const low = Math.floor(rank)\n  const high = Math.ceil(rank)\n  return low === high ? sorted[low] : lerp(sorted[low], sorted[high], rank - low)\n}\n"]}