//#region src/types.d.ts
type LiquidVariant = 'clear' | 'tinted';
type ElasticOptions = {
  /** How far the lean carries, 0 is rigid. */
  elasticity?: number;
  /** How far outside the element the pointer is still felt, in pixels. */
  reach?: number;
};
type ElasticPull = {
  offsetX: number;
  offsetY: number;
  stretchX: number;
  stretchY: number;
};
type ElasticSubscriber = (bounds: DOMRect, pointerX: number, pointerY: number) => void;
type LiquidMotionOptions = {
  bounce?: number;
  disabled?: boolean;
  /** How far the surface leans toward a pointer that has not reached it yet. */
  elasticity?: number;
  /** Lit rim glow that follows the pointer. */
  glow?: boolean;
  intensity?: number;
  /** How far outside the element the pointer is still felt, in pixels. */
  reach?: number;
  respectReducedMotion?: boolean;
  /** Ring that travels out from a press. */
  ripple?: boolean;
  /** Colour in the rim: an iridescent shift while wobbling, and a red/green/blue split at rest. Off by default. */
  shimmer?: boolean;
  /** Drifting specular glints across the face. */
  sparkle?: boolean;
  tilt?: number;
  tint?: string;
  webgl?: boolean;
  wobbliness?: number;
};
type LiquidMotionController = {
  destroy: () => void;
  pulse: (strength?: number) => void;
  setDisabled: (disabled: boolean) => void;
};
type LiquidRendererOptions = {
  /** Lit rim glow that follows the pointer. */
  glow?: boolean;
  intensity?: number;
  radius?: number;
  /** Ring that travels out from a press. */
  ripple?: boolean;
  /** Colour in the rim: an iridescent shift while wobbling, and a red/green/blue split at rest. Off by default. */
  shimmer?: boolean;
  /** Drifting specular glints across the face. */
  sparkle?: boolean;
  tint?: string;
};
type LensMapOptions = {
  bezel?: number;
  /** Exponent of the bezel cross-section: 1 is an even ramp, higher piles the bend against the rim. */
  curve?: number;
  height: number;
  radius: number;
  /** How much of the bend the material can take without folding to spend, 0 to 1. */
  strength?: number;
  width: number;
};
type LensMap = {
  height: number;
  scale: number;
  url: string;
  width: number;
};
type LensFilterOptions = {
  /** Width of the refracting band at the rim, in pixels. Defaults to 22% of the short side. */
  bezel?: number;
  blur?: number;
  /** Exponent of the bezel cross-section: 1 is an even ramp, higher piles the bend against the rim. */
  curve?: number;
  dispersion?: number;
  radius?: number;
  respectReducedTransparency?: boolean;
  saturation?: number;
  /** How much of the bend the material can take without folding to spend, 0 to 1. */
  strength?: number;
};
type LensFilterController = {
  destroy: () => void;
  refresh: () => void;
};
type LiquefyTokens = {
  accent: string;
  border: string;
  duration: string;
  easing: string;
  radius: string;
  shadow: string;
  text: string;
};
//#endregion
//#region src/lens-filter.d.ts
export declare const isLensSupported: () => boolean;
export declare const attachLiquidLens: (element: HTMLElement, options?: LensFilterOptions) => LensFilterController | null;
//#endregion
//#region src/elastic.d.ts
/**
 * How a surface leans toward a pointer that has not reached it yet.
 *
 * The falloff is measured from the element's *edge* rather than its centre, so
 * a wide card starts to lean when the pointer nears its side instead of waiting
 * for it to near the middle — which is what makes a dock of different-sized
 * things respond as one row. Squaring it keeps the pull from switching on at
 * the boundary of the reach.
 *
 * The stretch splits the lean between the two axes by the square of the
 * direction, and takes half of it back on the other axis, so a surface pulled
 * sideways goes wide and slightly flat instead of simply getting bigger.
 */
export declare const elasticPull: (bounds: DOMRect, pointerX: number, pointerY: number, options?: ElasticOptions) => ElasticPull;
/**
 * Subscribes an element to the pointer, wherever the pointer is on the page.
 *
 * One window listener serves every surface, because the alternative — a
 * listener per component — measures the same pointer dozens of times per move
 * and lays out the whole page doing it. Rects are cached until something that
 * can move them happens, and the fan-out runs on an animation frame, so a fast
 * sweep across the page costs one measurement pass per frame no matter how many
 * surfaces are mounted.
 */
export declare const observeElasticPointer: (element: HTMLElement, notify: ElasticSubscriber) => (() => void);
//#endregion
//#region src/motion.d.ts
export declare const attachLiquidMotion: (element: HTMLElement, canvas: HTMLCanvasElement | null, options?: LiquidMotionOptions) => LiquidMotionController;
//#endregion
//#region src/math.d.ts
export declare const clamp: (value: number, minimum?: number, maximum?: number) => number;
export declare const lerp: (from: number, to: number, progress: number) => number;
export declare const mapRange: (value: number, inputMinimum: number, inputMaximum: number, outputMinimum: number, outputMaximum: number) => number;
export declare const hexToRgb: (hex: string) => readonly [number, number, number];
//#endregion
//#region src/lens.d.ts
export declare const isLensRenderingSupported: () => boolean;
export declare const createLensMap: (options: LensMapOptions) => LensMap | null;
//#endregion
//#region src/renderer.d.ts
export declare class LiquidRenderer {
  private readonly canvas;
  private active;
  private animationFrame;
  private blitContext;
  private destroyed;
  private hovering;
  private intensity;
  private lastTime;
  private readonly ornaments;
  private pointer;
  private press;
  private pressTarget;
  private radius;
  private readonly resizeObserver;
  private rippleAge;
  private rippleOrigin;
  private rippleStrength;
  private stretch;
  private supported;
  private tint;
  private wobble;
  constructor(canvas: HTMLCanvasElement, options?: LiquidRendererOptions);
  destroy(): void;
  isSupported(): boolean;
  pulse(strength?: number): void;
  ripple(x: number, y: number, strength?: number): void;
  setActive(active: boolean): void;
  setIntensity(intensity: number): void;
  setPointer(x: number, y: number): void;
  setPress(pressed: boolean): void;
  setRadius(radius: number): void;
  setStretch(x: number, y: number): void;
  setTint(tint: string): void;
  setWobble(energy: number): void;
  private get pixelRatio();
  private resize;
  private render;
  private start;
}
//#endregion
//#region src/spring.d.ts
type SpringOptions = {
  damping?: number;
  mass?: number;
  stiffness?: number;
};
export declare class SpringValue {
  current: number;
  target: number;
  velocity: number;
  private readonly damping;
  private readonly mass;
  private readonly stiffness;
  constructor(initialValue?: number, options?: SpringOptions);
  set(value: number): void;
  setTarget(value: number): void;
  step(deltaSeconds: number): boolean;
}
//#endregion
//#region src/tokens.d.ts
export declare const defaultTokens: Readonly<LiquefyTokens>;
//#endregion
export type { ElasticOptions, ElasticPull, ElasticSubscriber, LensFilterController, LensFilterOptions, LensMap, LensMapOptions, LiquefyTokens, LiquidMotionController, LiquidMotionOptions, LiquidRendererOptions, LiquidVariant, SpringOptions };
//# sourceMappingURL=index.d.cts.map