@ansh-ui/core 0.2.0

package/dist/color.d.ts

@@ -0,0 +1,303 @@
+import { c as Hsl, R as Rgb, d as Hsv, L as LinearRgb, O as Oklab, f as Oklch, a as ColorInput, C as ColorSpace, e as HueDirection } from './palette-6HkVltYU.js';
+export { b as ColorScale, H as HarmonyKind, P as PaletteName, g as PaletteOptions, S as ScaleOptions, h as createScale, i as expandPalette, j as generatePalette, k as harmony, l as invertForSurface, p as palettes, r as resolvePalette, s as sortByLightness } from './palette-6HkVltYU.js';
+import { E as EasingInput } from './types-B1FLLf3-.js';
+
+/**
+ * Colour space conversions.
+ *
+ * Matrices for OKLab are Björn Ottosson's published values. They are reproduced to full
+ * precision deliberately — truncating them introduces a visible hue shift in saturated blues.
+ */
+/** Remove the sRGB gamma curve from a single channel. */
+declare function srgbToLinearChannel(c: number): number;
+/** Apply the sRGB gamma curve to a single channel. */
+declare function linearToSrgbChannel(c: number): number;
+declare function rgbToLinear(rgb: Rgb): LinearRgb;
+declare function linearToRgb(lin: LinearRgb): Rgb;
+declare function linearToOklab(lin: LinearRgb): Oklab;
+declare function oklabToLinear(lab: Oklab): LinearRgb;
+declare function rgbToOklab(rgb: Rgb): Oklab;
+/**
+ * OKLab → sRGB.
+ *
+ * The result may fall outside the sRGB gamut, in which case channels are simply clipped.
+ * Use {@link import('./gamut').gamutMapOklch} when you need a perceptually sensible
+ * in-gamut colour rather than a clipped one.
+ */
+declare function oklabToRgb(lab: Oklab): Rgb;
+declare function oklabToOklch(lab: Oklab): Oklch;
+declare function oklchToOklab(lch: Oklch): Oklab;
+declare function rgbToOklch(rgb: Rgb): Oklch;
+declare function oklchToRgb(lch: Oklch): Rgb;
+declare function rgbToHsl(rgb: Rgb): Hsl;
+declare function hslToRgb(hsl: Hsl): Rgb;
+declare function rgbToHsv(rgb: Rgb): Hsv;
+declare function hsvToRgb(hsv: Hsv): Rgb;
+/**
+ * Relative luminance per WCAG 2.x — the Y component of CIEXYZ from linear sRGB.
+ * This is the quantity contrast ratios are built from.
+ */
+declare function relativeLuminance(rgb: Rgb): number;
+
+declare class ColorParseError extends Error {
+    readonly input: string;
+    constructor(input: string);
+}
+/**
+ * Parse any accepted colour into {@link Rgb}.
+ *
+ * @throws {ColorParseError} on unparseable input. Ansh throws here rather than falling back
+ * to black: a silently-black gradient is far harder to debug than a thrown error pointing at
+ * the offending string, and colour props are validated at mount, not inside a frame loop.
+ */
+declare function parseColor(input: ColorInput): Rgb;
+/** Like {@link parseColor} but returns `null` instead of throwing. */
+declare function tryParseColor(input: ColorInput): Rgb | null;
+/**
+ * Resolve a colour the parser can't handle itself by asking the browser.
+ *
+ * Covers `var(--token)`, `currentcolor`, `color-mix()`, `lab()` and anything else CSS gains
+ * in future. We set the value on a detached element and read back the computed style — the
+ * browser normalises it to `rgb()`/`rgba()`, which we can then parse.
+ *
+ * Returns `null` during SSR, where there is no document to consult. Callers should keep the
+ * original string in that case and let CSS resolve it at paint time; only effects that need
+ * numeric colour access (canvas gradients) require a resolved value, and those run client-side.
+ */
+declare function resolveComputed(value: string): Rgb | null;
+/**
+ * Resolve a CSS custom property against a specific element's cascade.
+ *
+ * Needed because `var(--surface)` means different things inside a `.dark` subtree. Effects
+ * pass their own host element so themed colours resolve correctly.
+ */
+declare function resolveCssVariable(name: string, element?: Element | null): Rgb | null;
+/** Clear the parse cache. Exposed for tests and for theme switches that change `var()` output. */
+declare function clearColorCache(): void;
+
+/** `#rrggbb`, or `#rrggbbaa` when not fully opaque (or when `forceAlpha` is set). */
+declare function toHex(color: Rgb, forceAlpha?: boolean): string;
+/**
+ * `rgb(r g b)` / `rgb(r g b / a)`.
+ *
+ * Uses the legacy comma form because it is what every canvas implementation and every
+ * browser back to 2015 accepts; the space-separated form is newer than our support target.
+ */
+declare function toRgbString(color: Rgb): string;
+declare function toHslString(color: Rgb): string;
+/** `oklch(l% c h)` — the modern authoring form, and what the theme generator emits. */
+declare function toOklchString(color: Rgb): string;
+/**
+ * Pack into a 32-bit integer as `0xAABBGGRR`.
+ *
+ * This is the byte order a `Uint32Array` view over `ImageData` expects on little-endian
+ * machines, which is every platform we target. Effects that write pixels directly — the noise
+ * layer, the grain overlay — use this to fill a row with one store per pixel instead of four.
+ */
+declare function toUint32(color: Rgb): number;
+declare function fromUint32(packed: number): Rgb;
+/** Replace a colour's alpha, leaving its hue and lightness untouched. */
+declare function withAlpha(color: Rgb, alpha: number): Rgb;
+/** Scale a colour's existing alpha — useful for fading a whole palette at once. */
+declare function fadeBy(color: Rgb, factor: number): Rgb;
+
+/** Is this OKLCH colour displayable in sRGB? */
+declare function inSrgbGamut(lch: Oklch): boolean;
+/**
+ * Reduce chroma until the colour fits in sRGB, preserving lightness and hue.
+ *
+ * Returns the input unchanged when it is already in gamut, so this is safe to call
+ * unconditionally.
+ */
+declare function gamutMapOklch(lch: Oklch): Oklch;
+/**
+ * The maximum chroma sRGB can display at a given lightness and hue.
+ *
+ * This is what makes "vivid" palette generation possible: rather than picking an arbitrary
+ * chroma and hoping, you can ask for the most saturated colour available at each hue and get
+ * a palette with consistent, maximal punch.
+ */
+declare function maxChroma(l: number, h: number): number;
+/** Gamut-map, then convert to sRGB. The safe path from OKLCH to a displayable colour. */
+declare function oklchToRgbMapped(lch: Oklch): Rgb;
+/**
+ * How far outside sRGB a colour sits, as a rough distance in chroma units.
+ * `0` means in gamut. Used by the docs site to warn about unrenderable theme colours.
+ */
+declare function gamutError(lch: Oklch): number;
+/** Does this sRGB colour survive a round trip through OKLCH unchanged? Diagnostic helper. */
+declare function isGamutStable(rgb: Rgb): boolean;
+
+/**
+ * Colour interpolation and gradient construction.
+ *
+ * The default space is OKLab, and that default is load-bearing — but it is worth being precise
+ * about *when* it matters, because the difference is not uniform.
+ *
+ * **Where sRGB fails badly: opposing hues.** Interpolating `#0000ff → #ffff00` in sRGB passes
+ * through exactly `#808080` — a dead grey — because the channels cancel. In OKLab the same
+ * transition keeps measurable chroma the whole way across. Any gradient spanning more than about a
+ * quadrant of the hue circle hits some version of this.
+ *
+ * **Where sRGB merely differs: neighbouring hues.** For `#0275f4 → #9f0550` (blue to crimson,
+ * ~104° apart) sRGB actually produces a *more* saturated midpoint, because it cuts the chord
+ * straight through the colour solid. What it does not preserve is perceived *lightness* — the sRGB
+ * path dips darker in the middle, so the transition reads as uneven even though it is vivid. OKLab
+ * holds lightness steady, which is what makes a gradient feel smooth rather than lumpy.
+ *
+ * Use `oklch` when you want maximum vividness across distant hues; it travels the hue circle rather
+ * than cutting across it, keeping chroma high throughout.
+ */
+interface MixOptions {
+    /** Space to interpolate through. Default `'oklab'`. */
+    space?: ColorSpace;
+    /** Which way around the hue circle, for cylindrical spaces. Default `'shorter'`. */
+    hue?: HueDirection;
+    /**
+     * Gamut-map the result rather than clipping it.
+     *
+     * Slightly more expensive (a short binary search) but preserves hue and lightness for
+     * out-of-gamut intermediates. Default `true` for `oklch`, `false` otherwise — `oklch`
+     * interpolation is the one that routinely leaves the gamut.
+     */
+    gamutMap?: boolean;
+}
+/**
+ * Interpolate between two colours.
+ *
+ * `t` is clamped to `[0, 1]`. Alpha is always interpolated linearly, independent of space —
+ * premultiplying would darken transitions to transparent, which is almost never wanted for
+ * UI gradients.
+ */
+declare function mixColors(from: ColorInput, to: ColorInput, t: number, options?: MixOptions): Rgb;
+/** The allocation-light path used by gradients, which have already parsed their stops. */
+declare function mixParsed(a: Rgb, b: Rgb, t: number, options?: MixOptions): Rgb;
+/** Interpolate two hue angles, honouring the requested direction of travel. */
+declare function lerpHue(from: number, to: number, t: number, direction: HueDirection): number;
+interface GradientStop {
+    /** Position in `[0, 1]`. */
+    offset: number;
+    color: ColorInput;
+}
+interface GradientOptions extends MixOptions {
+    /**
+     * Easing applied to the position *within each segment*, not across the whole gradient.
+     *
+     * This is how you get a gradient that lingers near one colour: `easeInQuad` compresses
+     * the transition toward the end of each segment. Default linear.
+     */
+    easing?: EasingInput;
+}
+interface Gradient {
+    /** Colour at position `t` in `[0, 1]`. */
+    at(t: number): Rgb;
+    /** Colour at position `t`, formatted for `fillStyle`. */
+    cssAt(t: number): string;
+    /** Evenly sample the gradient into `count` colours. */
+    sample(count: number): Rgb[];
+    /** A `linear-gradient(...)` string with `count` stops, for CSS backgrounds. */
+    toCss(direction?: string, count?: number): string;
+    readonly stops: readonly GradientStop[];
+}
+/**
+ * Build a multi-stop gradient.
+ *
+ * Accepts either a flat list of colours (distributed evenly) or explicit stops. Any number of
+ * colours is supported — there is no cap, and no assumption of two.
+ */
+declare function createGradient(input: readonly ColorInput[] | readonly GradientStop[], options?: GradientOptions): Gradient;
+/**
+ * Apply the gradient's stops to a native canvas gradient object.
+ *
+ * We can't hand the canvas our stops directly — it would interpolate them in sRGB and undo
+ * the whole point. Instead we sample our own interpolation into `resolution` intermediate
+ * stops, so the browser only ever interpolates over tiny intervals where the space barely
+ * matters. 24 stops is visually indistinguishable from continuous.
+ */
+declare function applyGradientStops(target: CanvasGradient, gradient: Gradient, resolution?: number): CanvasGradient;
+/**
+ * Blend a colour toward another by a fixed amount, in a chosen space.
+ * Shorthand for the common "10% lighter" adjustment.
+ */
+declare function blend(base: ColorInput, over: ColorInput, amount?: number, space?: ColorSpace): Rgb;
+/**
+ * Composite `over` onto `base` using its alpha — the "source-over" Porter-Duff operator,
+ * evaluated in linear light so it matches what the GPU does.
+ */
+declare function composite(base: ColorInput, over: ColorInput): Rgb;
+
+/**
+ * Contrast and legibility.
+ *
+ * Animated backgrounds are the single most common way a design ends up failing WCAG: the text
+ * was legible against the mockup's midpoint and illegible against the animation's brightest
+ * frame. These helpers let components check contrast against the *extremes* of their own
+ * palette and adapt, rather than hoping.
+ */
+type WcagLevel = 'AA' | 'AAA';
+type TextSize = 'normal' | 'large';
+/**
+ * WCAG 2.x contrast ratio, from 1 (identical) to 21 (black on white).
+ *
+ * Semi-transparent colours are composited over `background` first, because a ratio computed
+ * from a colour's own alpha is meaningless — what matters is what the eye actually receives.
+ */
+declare function contrastRatio(foreground: ColorInput, background: ColorInput): number;
+/** Minimum ratio required by WCAG 2.2 for the given level and text size. */
+declare function requiredRatio(level: WcagLevel, size: TextSize): number;
+interface ContrastResult {
+    ratio: number;
+    passes: boolean;
+    required: number;
+    level: WcagLevel;
+    size: TextSize;
+}
+/** Check a foreground/background pair against a WCAG threshold. */
+declare function checkContrast(foreground: ColorInput, background: ColorInput, level?: WcagLevel, size?: TextSize): ContrastResult;
+/**
+ * Pick whichever of `light`/`dark` reads better on `background`.
+ *
+ * This is the function to reach for when a component renders text over a user-supplied
+ * colour, which is most of them.
+ */
+declare function pickReadable(background: ColorInput, light?: ColorInput, dark?: ColorInput): Rgb;
+/**
+ * Adjust a colour's lightness until it meets a contrast target against `background`.
+ *
+ * Works in OKLCH so hue and chroma survive the adjustment — the brand colour stays
+ * recognisably itself, it just gets light or dark enough to read. Searches in whichever
+ * direction has more headroom, and returns the best achievable colour if the target is
+ * unreachable (a mid-grey background cannot support 7:1 with a saturated hue at any lightness).
+ */
+declare function ensureContrast(foreground: ColorInput, background: ColorInput, target?: number): {
+    color: Rgb;
+    ratio: number;
+    achieved: boolean;
+};
+/**
+ * Worst-case contrast of a foreground against every colour in a set.
+ *
+ * An animated gradient background cycles through many colours; text must be legible against
+ * all of them. Components call this with their resolved palette and surface a dev warning when
+ * it fails, which turns an invisible accessibility bug into a console message during development.
+ */
+declare function worstContrast(foreground: ColorInput, backgrounds: readonly ColorInput[]): {
+    ratio: number;
+    against: Rgb | null;
+};
+/**
+ * APCA-style perceptual lightness, used for ordering colours by visual weight.
+ *
+ * Not a WCAG 3 implementation — that specification is still in flux and we won't ship a
+ * moving target as if it were stable. This is OKLab's `L`, which is a better predictor of
+ * perceived lightness than WCAG's relative luminance and is entirely sufficient for the
+ * internal job of sorting a palette light-to-dark.
+ */
+declare function perceivedLightness(color: ColorInput): number;
+
+/** Resolve a CSS colour keyword to its hex value, or `undefined` if it isn't one. */
+declare function namedColorToHex(name: string): string | undefined;
+/** Every recognised colour keyword. Powers autocomplete in the docs playground. */
+declare function listNamedColors(): string[];
+
+export { ColorInput, ColorParseError, ColorSpace, type ContrastResult, type Gradient, type GradientOptions, type GradientStop, Hsl, Hsv, HueDirection, LinearRgb, type MixOptions, Oklab, Oklch, Rgb, type TextSize, type WcagLevel, applyGradientStops, blend, checkContrast, clearColorCache, composite, contrastRatio, createGradient, ensureContrast, fadeBy, fromUint32, gamutError, gamutMapOklch, hslToRgb, hsvToRgb, inSrgbGamut, isGamutStable, lerpHue, linearToOklab, linearToRgb, linearToSrgbChannel, listNamedColors, maxChroma, mixColors, mixParsed, namedColorToHex, oklabToLinear, oklabToOklch, oklabToRgb, oklchToOklab, oklchToRgb, oklchToRgbMapped, parseColor, perceivedLightness, pickReadable, relativeLuminance, requiredRatio, resolveComputed, resolveCssVariable, rgbToHsl, rgbToHsv, rgbToLinear, rgbToOklab, rgbToOklch, srgbToLinearChannel, toHex, toHslString, toOklchString, toRgbString, toUint32, tryParseColor, withAlpha, worstContrast };

package/dist/color.js

@@ -0,0 +1,8 @@
+export { checkContrast, contrastRatio, ensureContrast, perceivedLightness, pickReadable, requiredRatio, worstContrast } from './chunk-7MYTSAPR.js';
+export { applyGradientStops, blend, composite, createGradient, createScale, expandPalette, fadeBy, fromUint32, gamutError, gamutMapOklch, generatePalette, harmony, inSrgbGamut, invertForSurface, isGamutStable, lerpHue, maxChroma, mixColors, mixParsed, oklchToRgbMapped, palettes, resolvePalette, sortByLightness, toHex, toHslString, toOklchString, toRgbString, toUint32, withAlpha } from './chunk-KTUBCQC3.js';
+import './chunk-YFQXRC5R.js';
+export { ColorParseError, clearColorCache, hslToRgb, hsvToRgb, linearToOklab, linearToRgb, linearToSrgbChannel, listNamedColors, namedColorToHex, oklabToLinear, oklabToOklch, oklabToRgb, oklchToOklab, oklchToRgb, parseColor, relativeLuminance, resolveComputed, resolveCssVariable, rgbToHsl, rgbToHsv, rgbToLinear, rgbToOklab, rgbToOklch, srgbToLinearChannel, tryParseColor } from './chunk-QALZKHWH.js';
+import './chunk-7MEIXWPH.js';
+import './chunk-KU2C6GEA.js';
+//# sourceMappingURL=color.js.map
+//# sourceMappingURL=color.js.map

package/dist/color.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"color.js"}

package/dist/easing.cjs

@@ -0,0 +1,189 @@
+'use strict';
+
+var chunkGJRIHN76_cjs = require('./chunk-GJRIHN76.cjs');
+require('./chunk-ILKUL7GD.cjs');
+
+
+
+Object.defineProperty(exports, "anticipate", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.anticipate; }
+});
+Object.defineProperty(exports, "cubicBezier", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.cubicBezier; }
+});
+Object.defineProperty(exports, "easeInBack", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInBack; }
+});
+Object.defineProperty(exports, "easeInBounce", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInBounce; }
+});
+Object.defineProperty(exports, "easeInCirc", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInCirc; }
+});
+Object.defineProperty(exports, "easeInCubic", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInCubic; }
+});
+Object.defineProperty(exports, "easeInElastic", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInElastic; }
+});
+Object.defineProperty(exports, "easeInExpo", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInExpo; }
+});
+Object.defineProperty(exports, "easeInOutBack", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInOutBack; }
+});
+Object.defineProperty(exports, "easeInOutBounce", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInOutBounce; }
+});
+Object.defineProperty(exports, "easeInOutCirc", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInOutCirc; }
+});
+Object.defineProperty(exports, "easeInOutCubic", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInOutCubic; }
+});
+Object.defineProperty(exports, "easeInOutElastic", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInOutElastic; }
+});
+Object.defineProperty(exports, "easeInOutExpo", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInOutExpo; }
+});
+Object.defineProperty(exports, "easeInOutQuad", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInOutQuad; }
+});
+Object.defineProperty(exports, "easeInOutQuart", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInOutQuart; }
+});
+Object.defineProperty(exports, "easeInOutQuint", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInOutQuint; }
+});
+Object.defineProperty(exports, "easeInOutSine", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInOutSine; }
+});
+Object.defineProperty(exports, "easeInQuad", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInQuad; }
+});
+Object.defineProperty(exports, "easeInQuart", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInQuart; }
+});
+Object.defineProperty(exports, "easeInQuint", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInQuint; }
+});
+Object.defineProperty(exports, "easeInSine", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeInSine; }
+});
+Object.defineProperty(exports, "easeOutBack", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeOutBack; }
+});
+Object.defineProperty(exports, "easeOutBounce", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeOutBounce; }
+});
+Object.defineProperty(exports, "easeOutCirc", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeOutCirc; }
+});
+Object.defineProperty(exports, "easeOutCubic", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeOutCubic; }
+});
+Object.defineProperty(exports, "easeOutElastic", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeOutElastic; }
+});
+Object.defineProperty(exports, "easeOutExpo", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeOutExpo; }
+});
+Object.defineProperty(exports, "easeOutQuad", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeOutQuad; }
+});
+Object.defineProperty(exports, "easeOutQuart", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeOutQuart; }
+});
+Object.defineProperty(exports, "easeOutQuint", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeOutQuint; }
+});
+Object.defineProperty(exports, "easeOutSine", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easeOutSine; }
+});
+Object.defineProperty(exports, "easings", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.easings; }
+});
+Object.defineProperty(exports, "linear", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.linear; }
+});
+Object.defineProperty(exports, "listEasings", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.listEasings; }
+});
+Object.defineProperty(exports, "mirrorEasing", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.mirrorEasing; }
+});
+Object.defineProperty(exports, "power", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.power; }
+});
+Object.defineProperty(exports, "readEasingTable", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.readEasingTable; }
+});
+Object.defineProperty(exports, "registerEasing", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.registerEasing; }
+});
+Object.defineProperty(exports, "resolveEasing", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.resolveEasing; }
+});
+Object.defineProperty(exports, "reverseEasing", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.reverseEasing; }
+});
+Object.defineProperty(exports, "sampleEasing", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.sampleEasing; }
+});
+Object.defineProperty(exports, "signature", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.signature; }
+});
+Object.defineProperty(exports, "steps", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.steps; }
+});
+Object.defineProperty(exports, "unregisterEasing", {
+  enumerable: true,
+  get: function () { return chunkGJRIHN76_cjs.unregisterEasing; }
+});
+//# sourceMappingURL=easing.cjs.map
+//# sourceMappingURL=easing.cjs.map

package/dist/easing.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"easing.cjs"}

package/dist/easing.d.cts

@@ -0,0 +1,134 @@
+import { a as EasingFn, E as EasingInput } from './types-B1FLLf3-.cjs';
+export { b as EasingName } from './types-B1FLLf3-.cjs';
+
+/**
+ * Build an easing function from four cubic-bézier control coordinates.
+ *
+ * @param x1 First control point's x, clamped to `[0,1]` (as CSS requires — an x outside
+ *           that range makes the curve non-monotonic in time and thus not a valid timing
+ *           function). y values are unconstrained, which is what allows overshoot curves
+ *           like `easeOutBack`.
+ */
+declare function cubicBezier(x1: number, y1: number, x2: number, y2: number): EasingFn;
+/**
+ * A stepped (staircase) timing function, matching CSS `steps()`.
+ *
+ * @param count Number of discrete steps. Must be >= 1.
+ * @param position Where the jump happens within each step, matching the CSS keywords.
+ */
+declare function steps(count: number, position?: 'start' | 'end' | 'both' | 'none'): EasingFn;
+
+/**
+ * The built-in easing library.
+ *
+ * Curves follow the Penner definitions, which is what CSS, GSAP and Framer Motion all
+ * converged on — so `easeOutCubic` here is numerically identical to `easeOutCubic` there.
+ * Every function is exact at both endpoints.
+ */
+/** Turn an "in" curve into its mirrored "out" counterpart. */
+declare function reverseEasing(easeIn: EasingFn): EasingFn;
+/** Compose an "in" curve into a symmetric "in-out" curve. */
+declare function mirrorEasing(easeIn: EasingFn): EasingFn;
+/** Raise progress to a power — the family behind quad/cubic/quart/quint. */
+declare function power(exponent: number): EasingFn;
+declare const easeInSine: EasingFn;
+declare const easeOutSine: EasingFn;
+declare const easeInOutSine: EasingFn;
+declare const easeInQuad: EasingFn;
+declare const easeOutQuad: EasingFn;
+declare const easeInOutQuad: EasingFn;
+declare const easeInCubic: EasingFn;
+declare const easeOutCubic: EasingFn;
+declare const easeInOutCubic: EasingFn;
+declare const easeInQuart: EasingFn;
+declare const easeOutQuart: EasingFn;
+declare const easeInOutQuart: EasingFn;
+declare const easeInQuint: EasingFn;
+declare const easeOutQuint: EasingFn;
+declare const easeInOutQuint: EasingFn;
+declare const easeInExpo: EasingFn;
+declare const easeOutExpo: EasingFn;
+declare const easeInOutExpo: EasingFn;
+declare const easeInCirc: EasingFn;
+declare const easeOutCirc: EasingFn;
+declare const easeInOutCirc: EasingFn;
+declare const easeInBack: EasingFn;
+declare const easeOutBack: EasingFn;
+declare const easeInOutBack: EasingFn;
+/**
+ * A brief pull-back before moving forward. Reads as "gathering intent".
+ *
+ * The second half is an exponential decay, which approaches 1 asymptotically and never reaches it —
+ * at `t = 1` the raw expression gives `1 - 2⁻¹¹`. The explicit endpoint keeps the curve exact, which
+ * the animation driver relies on to land values on their targets rather than a fraction short.
+ */
+declare const anticipate: EasingFn;
+declare const easeInElastic: EasingFn;
+declare const easeOutElastic: EasingFn;
+declare const easeInOutElastic: EasingFn;
+declare const easeOutBounce: EasingFn;
+declare const easeInBounce: EasingFn;
+declare const easeInOutBounce: EasingFn;
+declare const linear: EasingFn;
+/**
+ * Named curve lookup.
+ *
+ * Kept as a mutable record so `registerEasing()` can extend it. Consumers should go through
+ * `resolveEasing()` rather than reading this directly.
+ */
+declare const easings: Record<string, EasingFn>;
+/**
+ * Signature curves used by the design system's motion hierarchy.
+ *
+ * These are the ones you should reach for by default. They are named for intent rather than
+ * for maths, because "what is this motion communicating" is the useful question at a call site.
+ */
+declare const signature: {
+    /** Entrances. Fast out of the gate, long gentle settle. The Ansh house curve. */
+    emphasized: EasingFn;
+    /** UI state changes that should feel instant but not abrupt. */
+    standard: EasingFn;
+    /** Exits. Accelerates away — the element is leaving, don't linger on it. */
+    exit: EasingFn;
+    /** Entrances from off-screen. Decelerates in. */
+    enter: EasingFn;
+    /** A confident, slightly springy overshoot without full elastic wobble. */
+    overshoot: EasingFn;
+    /** Long, cinematic reveals — hero sections, scroll-driven scenes. */
+    cinematic: EasingFn;
+};
+/**
+ * Register a custom named curve, making it resolvable everywhere an easing is accepted.
+ *
+ * @throws if the name collides with a built-in, to prevent one plugin silently changing
+ *         the meaning of `easeOutCubic` for the whole application.
+ */
+declare function registerEasing(name: string, fn: EasingFn): void;
+/** Remove a previously registered custom curve. Built-ins cannot be removed. */
+declare function unregisterEasing(name: string): void;
+/** Every currently resolvable easing name, built-in and custom. */
+declare function listEasings(): string[];
+
+/**
+ * Sample a curve into a lookup table.
+ *
+ * Useful for expensive curves evaluated per-particle per-frame, and for rendering easing
+ * previews in the docs site.
+ */
+declare function sampleEasing(easing: EasingFn, resolution?: number): Float32Array;
+/** Read a table produced by {@link sampleEasing}, interpolating between samples. */
+declare function readEasingTable(table: Float32Array, t: number): number;
+
+/**
+ * Normalise any accepted easing shape into a callable function.
+ *
+ * This is the single entry point every part of the engine uses, so authors can pass a name,
+ * a function, or bézier coordinates interchangeably and it always works the same way.
+ *
+ * An unknown *name* is a developer mistake worth surfacing loudly — silently falling back to
+ * linear would produce motion that looks subtly wrong with no explanation. We warn and fall
+ * back rather than throw, because a bad easing name should never take down a page in production.
+ */
+declare function resolveEasing(input: EasingInput | undefined | null): EasingFn;
+
+export { EasingFn, EasingInput, 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 };