@flare-engine/math 0.2.1 → 0.3.1

package/dist/index.d.mts

@@ -1,244 +1,177 @@
-/** Clamps value between min and max. */
-declare function clamp(value: number, min: number, max: number): number;
-/** Linearly interpolates between a and b by t (unclamped). */
-declare function lerp(a: number, b: number, t: number): number;
-/** Returns the interpolation factor of value between a and b. */
-declare function inverseLerp(a: number, b: number, value: number): number;
-/** Maps value from [inMin, inMax] to [outMin, outMax]. */
-declare function map(value: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
-/** Converts degrees to radians. */
-declare function degToRad(degrees: number): number;
-/** Converts radians to degrees. */
-declare function radToDeg(radians: number): number;
-/** Returns true if a and b are approximately equal within epsilon. */
-declare function approxEquals(a: number, b: number, epsilon?: number): boolean;
-/** Wraps value into [min, max) range. */
-declare function wrap(value: number, min: number, max: number): number;
-/** PingPong — bounces value back and forth in [0, length]. */
-declare function pingPong(t: number, length: number): number;
-/** Hermite smooth interpolation (0→1) with zero first-derivative at edges. */
-declare function smoothStep(edge0: number, edge1: number, x: number): number;
-/** Returns -1, 0, or 1. Unlike Math.sign, returns 0 for NaN. */
-declare function sign(value: number): number;
-/** Shortest signed angle delta a - b, wrapped to [-pi, pi] (closed both ends — strict comparisons
- * leave exact +/-pi unwrapped). Branch form (single +/-2pi correction)
- * — byte-identical to hand-rolled aim/homing turn math; do NOT swap for a modulo form (it shifts
- * results by ULPs at the +/-pi boundary). */
-declare function angleDelta(a: number, b: number): number;
-/** Rotates angle cur toward target by at most maxStep radians, shortest direction. Returns the new
- * angle (NOT re-wrapped). Branch-form step clamp — byte-identical to hand-rolled homing steering. */
-declare function rotateTowards(cur: number, target: number, maxStep: number): number;
-
-/** Creates a Vec2 plain object. */
-declare function vec2(x?: number, y?: number): Vec2;
+//#region src/vec2.d.ts
 /** Vec2 plain object type — no class, no GC pressure. */
 type Vec2 = {
-    x: number;
-    y: number;
+  x: number;
+  y: number;
 };
+/** Creates a Vec2 plain object. */
+declare function vec2(x?: number, y?: number): Vec2;
 declare const Vec2: {
-    /** Returns { 0, 0 }. */
-    readonly zero: () => Vec2;
-    /** Returns { 1, 1 }. */
-    readonly one: () => Vec2;
-    /** Returns { 0, -1 }. */
-    readonly up: () => Vec2;
-    /** Returns { 0, 1 }. */
-    readonly down: () => Vec2;
-    /** Returns { -1, 0 }. */
-    readonly left: () => Vec2;
-    /** Returns { 1, 0 }. */
-    readonly right: () => Vec2;
-    /** Component-wise addition. Writes into out if provided. */
-    readonly add: (a: Vec2, b: Vec2, out?: Vec2) => Vec2;
-    /** Component-wise subtraction a - b. */
-    readonly sub: (a: Vec2, b: Vec2, out?: Vec2) => Vec2;
-    /** Scales a vector by a scalar. */
-    readonly scale: (v: Vec2, s: number, out?: Vec2) => Vec2;
-    /** Returns a unit vector. Returns zero vector if length is 0. */
-    readonly normalize: (v: Vec2, out?: Vec2) => Vec2;
-    /** Zero-alloc; writes into `out`. Mandatory `out` so callers avoid temporaries in hot paths. */
-    readonly normalizeOut: (dx: number, dy: number, speed: number, out: Vec2) => Vec2;
-    /** Dot product. */
-    readonly dot: (a: Vec2, b: Vec2) => number;
-    /** 2D cross product (z-component of the 3D cross). */
-    readonly cross: (a: Vec2, b: Vec2) => number;
-    /** Linearly interpolates between a and b (unclamped). */
-    readonly lerp: (a: Vec2, b: Vec2, t: number, out?: Vec2) => Vec2;
-    /** Spherical linear interpolation for unit vectors. */
-    readonly slerp: (a: Vec2, b: Vec2, t: number, out?: Vec2) => Vec2;
-    /** Euclidean distance between two points. */
-    readonly distance: (a: Vec2, b: Vec2) => number;
-    /** Squared distance (avoids sqrt). */
-    readonly distanceSq: (a: Vec2, b: Vec2) => number;
-    /** Length of a vector. */
-    readonly length: (v: Vec2) => number;
-    /** Squared length (avoids sqrt). */
-    readonly lengthSq: (v: Vec2) => number;
-    /** Angle of vector in radians (atan2). */
-    readonly angle: (v: Vec2) => number;
-    /** Rotates a vector by angle (radians) around origin. */
-    readonly rotate: (v: Vec2, angle: number, out?: Vec2) => Vec2;
-    /** Component-wise approximate equality. */
-    readonly equals: (a: Vec2, b: Vec2, epsilon?: number) => boolean;
-    /** Returns a copy of the vector. */
-    readonly clone: (v: Vec2) => Vec2;
-    /** Clamps the length of a vector to maxLength. */
-    readonly clampLength: (v: Vec2, maxLength: number, out?: Vec2) => Vec2;
-    /** Zero-alloc homing steer: rotate velocity (vx,vy) toward direction (dx,dy) by at most maxStep
-     * radians, preserving speed; writes into out. Mandatory out. Byte-identical to hand-rolled
-     * homing-bullet steering (Math.hypot speed + atan2 + branch-form turn + cos/sin * speed). */
-    readonly turnVelocityToward: (vx: number, vy: number, dx: number, dy: number, maxStep: number, out: Vec2) => Vec2;
+  /** Returns { 0, 0 }. */
+  readonly zero: () => Vec2;
+  /** Returns { 1, 1 }. */
+  readonly one: () => Vec2;
+  /** Returns { 0, -1 }. */
+  readonly up: () => Vec2;
+  /** Returns { 0, 1 }. */
+  readonly down: () => Vec2;
+  /** Returns { -1, 0 }. */
+  readonly left: () => Vec2;
+  /** Returns { 1, 0 }. */
+  readonly right: () => Vec2;
+  /** Component-wise addition. Writes into out if provided. */
+  readonly add: (a: Vec2, b: Vec2, out?: Vec2) => Vec2;
+  /** Component-wise subtraction a - b. */
+  readonly sub: (a: Vec2, b: Vec2, out?: Vec2) => Vec2;
+  /** Scales a vector by a scalar. */
+  readonly scale: (v: Vec2, s: number, out?: Vec2) => Vec2;
+  /** Returns a unit vector. Returns zero vector if length is 0. */
+  readonly normalize: (v: Vec2, out?: Vec2) => Vec2;
+  /** Zero-alloc; writes into `out`. Mandatory `out` so callers avoid temporaries in hot paths. */
+  readonly normalizeOut: (dx: number, dy: number, speed: number, out: Vec2) => Vec2;
+  /** Dot product. */
+  readonly dot: (a: Vec2, b: Vec2) => number;
+  /** 2D cross product (z-component of the 3D cross). */
+  readonly cross: (a: Vec2, b: Vec2) => number;
+  /** Perpendicular: (-y, x). In this engine's y-down screen space this is a 90° clockwise turn,
+   *  matching the Skia rotation convention used by `@flare-engine/render`. Writes into out if
+   *  provided. */
+  readonly perp: (v: Vec2, out?: Vec2) => Vec2;
+  /** Scalar × vector cross product: s × v = (-s·y, s·x). Writes into out if provided. */
+  readonly crossSV: (s: number, v: Vec2, out?: Vec2) => Vec2;
+  /** Linearly interpolates between a and b (unclamped). */
+  readonly lerp: (a: Vec2, b: Vec2, t: number, out?: Vec2) => Vec2;
+  /** Spherical linear interpolation for unit vectors. */
+  readonly slerp: (a: Vec2, b: Vec2, t: number, out?: Vec2) => Vec2;
+  /** Euclidean distance between two points. */
+  readonly distance: (a: Vec2, b: Vec2) => number;
+  /** Squared distance (avoids sqrt). */
+  readonly distanceSq: (a: Vec2, b: Vec2) => number;
+  /** Length of a vector. */
+  readonly length: (v: Vec2) => number;
+  /** Squared length (avoids sqrt). */
+  readonly lengthSq: (v: Vec2) => number;
+  /** Angle of vector in radians (atan2). */
+  readonly angle: (v: Vec2) => number;
+  /** Rotates a vector by angle (radians) around origin. */
+  readonly rotate: (v: Vec2, angle: number, out?: Vec2) => Vec2;
+  /** Component-wise approximate equality. */
+  readonly equals: (a: Vec2, b: Vec2, epsilon?: number) => boolean;
+  /** Returns a copy of the vector. */
+  readonly clone: (v: Vec2) => Vec2;
+  /** Clamps the length of a vector to maxLength. */
+  readonly clampLength: (v: Vec2, maxLength: number, out?: Vec2) => Vec2;
+  /** Zero-alloc homing steer: rotate velocity (vx,vy) toward direction (dx,dy) by at most maxStep
+   * radians, preserving speed; writes into out. Mandatory out. Byte-identical to hand-rolled
+   * homing-bullet steering (Math.hypot speed + atan2 + branch-form turn + cos/sin * speed). */
+  readonly turnVelocityToward: (vx: number, vy: number, dx: number, dy: number, maxStep: number, out: Vec2) => Vec2;
 };
-
+//#endregion
+//#region src/rect.d.ts
 /** Axis-aligned bounding box. */
 type Rect = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
 };
 declare const Rect: {
-    /** Returns true if point is inside rect (inclusive). */
-    readonly contains: (r: Rect, p: Vec2) => boolean;
-    /** Returns true if two rects overlap (share area). */
-    readonly intersects: (a: Rect, b: Rect) => boolean;
-    /** Returns the overlapping rect, or null if no overlap. */
-    readonly intersection: (a: Rect, b: Rect) => Rect | null;
-    /** Returns the smallest rect containing both rects. */
-    readonly union: (a: Rect, b: Rect) => Rect;
-    /** Creates a rect from an array of points (bounding box). */
-    readonly fromPoints: (points: readonly Vec2[]) => Rect;
-    /** Returns the center point of the rect. */
-    readonly center: (r: Rect) => Vec2;
-    /** Returns a new rect expanded by amount on each side. */
-    readonly expand: (r: Rect, amount: number) => Rect;
+  /** Returns true if point is inside rect (inclusive). */
+  readonly contains: (r: Rect, p: Vec2) => boolean;
+  /** Returns true if two rects overlap (share area). */
+  readonly intersects: (a: Rect, b: Rect) => boolean;
+  /** Returns the overlapping rect, or null if no overlap. */
+  readonly intersection: (a: Rect, b: Rect) => Rect | null;
+  /** Returns the smallest rect containing both rects. */
+  readonly union: (a: Rect, b: Rect) => Rect;
+  /** Creates a rect from an array of points (bounding box). */
+  readonly fromPoints: (points: readonly Vec2[]) => Rect;
+  /** Returns the center point of the rect. */
+  readonly center: (r: Rect) => Vec2;
+  /** Returns a new rect expanded by amount on each side. */
+  readonly expand: (r: Rect, amount: number) => Rect;
 };
-
+//#endregion
+//#region src/circle.d.ts
 /** Circle shape: center position + radius. */
 type Circle = {
-    x: number;
-    y: number;
-    radius: number;
+  x: number;
+  y: number;
+  radius: number;
 };
 declare const Circle: {
-    /** Returns true if point is inside or on the circle. */
-    readonly contains: (c: Circle, p: Vec2) => boolean;
-    /** Returns true if two circles overlap (share area). */
-    readonly intersects: (a: Circle, b: Circle) => boolean;
-    /** Returns true if a circle and rect overlap. */
-    readonly intersectsRect: (c: Circle, r: Rect) => boolean;
+  /** Returns true if point is inside or on the circle. */
+  readonly contains: (c: Circle, p: Vec2) => boolean;
+  /** Returns true if two circles overlap (share area). */
+  readonly intersects: (a: Circle, b: Circle) => boolean;
+  /** Returns true if a circle and rect overlap. */
+  readonly intersectsRect: (c: Circle, r: Rect) => boolean;
 };
-
-/** 2D transform: position, rotation (radians), and scale. */
-type Transform2D = {
-    position: Vec2;
-    rotation: number;
-    scale: Vec2;
-};
-declare const Transform2D: {
-    /** Creates an identity transform. */
-    readonly identity: () => Transform2D;
-    /** Creates a transform from components. */
-    readonly create: (x?: number, y?: number, rotation?: number, scaleX?: number, scaleY?: number) => Transform2D;
-    /** Transforms a local-space point to world-space. */
-    readonly localToWorld: (t: Transform2D, point: Vec2) => Vec2;
-    /** Transforms a world-space point to local-space. */
-    readonly worldToLocal: (t: Transform2D, point: Vec2) => Vec2;
-    /** Returns a copy of the transform. */
-    readonly clone: (t: Transform2D) => Transform2D;
-};
-
-/**
- * 3x3 matrix stored in column-major order on Float32Array.
- * Layout: [m00, m10, m20, m01, m11, m21, m02, m12, m22]
- *
- * | m00 m01 m02 |     indices: | 0 3 6 |
- * | m10 m11 m12 |              | 1 4 7 |
- * | m20 m21 m22 |              | 2 5 8 |
- */
-type Mat3 = Float32Array;
-declare const Mat3: {
-    /** Creates a new identity matrix. */
-    readonly create: () => Mat3;
-    /** Sets m to identity. */
-    readonly identity: (m: Mat3) => Mat3;
-    /** Multiplies a * b, writes into out (or allocates). */
-    readonly multiply: (a: Mat3, b: Mat3, out?: Mat3) => Mat3;
-    /** Creates a translation matrix. */
-    readonly translate: (tx: number, ty: number, out?: Mat3) => Mat3;
-    /** Creates a rotation matrix (radians). */
-    readonly rotate: (angle: number, out?: Mat3) => Mat3;
-    /** Creates a scale matrix. */
-    readonly scale: (sx: number, sy: number, out?: Mat3) => Mat3;
-    /** Inverts the matrix. Returns null if singular. */
-    readonly invert: (m: Mat3, out?: Mat3) => Mat3 | null;
-    /** Builds a matrix from a Transform2D (TRS order: translate * rotate * scale). */
-    readonly fromTransform: (t: Transform2D, out?: Mat3) => Mat3;
+//#endregion
+//#region src/color.d.ts
+/** RGBA color with components normalized to 0-1. */
+type Color = {
+  r: number;
+  g: number;
+  b: number;
+  a: number;
 };
-
 /** OKLab perceptual color space (L 0-1, a and b unbounded in practice ±0.5). */
 type Oklab = {
-    L: number;
-    a: number;
-    b: number;
+  L: number;
+  a: number;
+  b: number;
 };
 /** OKLCH polar form of OKLab (L 0-1, C >= 0, h degrees [0,360)). */
 type Oklch = {
-    L: number;
-    C: number;
-    h: number;
-};
-/** RGBA color with components normalized to 0-1. */
-type Color = {
-    r: number;
-    g: number;
-    b: number;
-    a: number;
+  L: number;
+  C: number;
+  h: number;
 };
 declare const Color: {
-    readonly WHITE: Color;
-    readonly BLACK: Color;
-    readonly TRANSPARENT: Color;
-    /** Creates a Color from normalized 0-1 components. */
-    readonly create: (r?: number, g?: number, b?: number, a?: number) => Color;
-    /** Parses a hex string (#RGB, #RGBA, #RRGGBB, #RRGGBBAA). */
-    readonly fromHex: (hex: string) => Color;
-    /** Converts to hex string #RRGGBB or #RRGGBBAA if alpha < 1. */
-    readonly toHex: (c: Color) => string;
-    /** Linearly interpolates between two colors. */
-    readonly lerp: (a: Color, b: Color, t: number) => Color;
-    /** Component-wise multiplication. */
-    readonly multiply: (a: Color, b: Color) => Color;
-    /**
-     * Converts to a Skia-compatible color number (0xAARRGGBB).
-     * Compatible with @shopify/react-native-skia Skia.Color() format.
-     */
-    readonly toSkColor: (c: Color) => number;
-    /** Converts sRGB Color to OKLab. Alpha is dropped. */
-    readonly toOklab: (c: Color) => Oklab;
-    /**
-     * Converts OKLab to sRGB Color. Out-of-gamut results are clamped to [0,1];
-     * round-trips are exact only for in-gamut colors.
-     */
-    readonly fromOklab: (lab: Oklab, alpha?: number) => Color;
-    /** Converts sRGB Color to OKLCH (polar OKLab). Achromatic colors get h = 0. */
-    readonly toOklch: (c: Color) => Oklch;
-    /**
-     * Converts OKLCH to sRGB Color. Hue is wrapped via ((h%360)+360)%360.
-     * Out-of-gamut results are clamped; round-trips exact only in-gamut.
-     */
-    readonly fromOklch: (lch: Oklch, alpha?: number) => Color;
-    /** Euclidean distance in OKLab space between two sRGB colors. */
-    readonly deltaEOk: (a: Color, b: Color) => number;
-    /** Euclidean distance between two OKLab values. */
-    readonly deltaEOkLab: (a: Oklab, b: Oklab) => number;
-    /** WCAG 2.x relative luminance. White = 1, black = 0. */
-    readonly relativeLuminance: (c: Color) => number;
-    /** WCAG 2.x contrast ratio. Order-independent; range [1, 21]. */
-    readonly contrastRatio: (fg: Color, bg: Color) => number;
+  readonly WHITE: Color;
+  readonly BLACK: Color;
+  readonly TRANSPARENT: Color;
+  /** Creates a Color from normalized 0-1 components. */
+  readonly create: (r?: number, g?: number, b?: number, a?: number) => Color;
+  /** Parses a hex string (#RGB, #RGBA, #RRGGBB, #RRGGBBAA). */
+  readonly fromHex: (hex: string) => Color;
+  /** Converts to hex string #RRGGBB or #RRGGBBAA if alpha < 1. */
+  readonly toHex: (c: Color) => string;
+  /** Linearly interpolates between two colors. */
+  readonly lerp: (a: Color, b: Color, t: number) => Color;
+  /** Component-wise multiplication. */
+  readonly multiply: (a: Color, b: Color) => Color;
+  /**
+   * Converts to a Skia-compatible color number (0xAARRGGBB).
+   * Compatible with @shopify/react-native-skia Skia.Color() format.
+   */
+  readonly toSkColor: (c: Color) => number;
+  /** Converts sRGB Color to OKLab. Alpha is dropped. */
+  readonly toOklab: (c: Color) => Oklab;
+  /**
+   * Converts OKLab to sRGB Color. Out-of-gamut results are clamped to [0,1];
+   * round-trips are exact only for in-gamut colors.
+   */
+  readonly fromOklab: (lab: Oklab, alpha?: number) => Color;
+  /** Converts sRGB Color to OKLCH (polar OKLab). Achromatic colors get h = 0. */
+  readonly toOklch: (c: Color) => Oklch;
+  /**
+   * Converts OKLCH to sRGB Color. Hue is wrapped via ((h%360)+360)%360.
+   * Out-of-gamut results are clamped; round-trips exact only in-gamut.
+   */
+  readonly fromOklch: (lch: Oklch, alpha?: number) => Color;
+  /** Euclidean distance in OKLab space between two sRGB colors. */
+  readonly deltaEOk: (a: Color, b: Color) => number;
+  /** Euclidean distance between two OKLab values. */
+  readonly deltaEOkLab: (a: Oklab, b: Oklab) => number;
+  /** WCAG 2.x relative luminance. White = 1, black = 0. */
+  readonly relativeLuminance: (c: Color) => number;
+  /** WCAG 2.x contrast ratio. Order-independent; range [1, 21]. */
+  readonly contrastRatio: (fg: Color, bg: Color) => number;
 };
-
+//#endregion
+//#region src/easings.d.ts
 declare function linear(t: number): number;
 declare function step(t: number): number;
 declare function easeInQuad(t: number): number;
@@ -275,17 +208,85 @@ declare function springIn(t: number): number;
 declare function springOut(t: number): number;
 declare function springInOut(t: number): number;
 type EasingFn = (t: number) => number;
-
+//#endregion
+//#region src/intersection.d.ts
+/** Returns true if point is inside rect (inclusive). */
+declare function pointInRect(p: Vec2, r: Rect): boolean;
+/** Returns true if point is inside circle (inclusive). */
+declare function pointInCircle(p: Vec2, c: Circle): boolean;
+/** Returns true if two rects overlap. */
+declare function rectVsRect(a: Rect, b: Rect): boolean;
+/** Returns true if rect and circle overlap. */
+declare function rectVsCircle(r: Rect, c: Circle): boolean;
+/** Returns true if two circles overlap. */
+declare function circleVsCircle(a: Circle, b: Circle): boolean;
+/** Line segment intersection with AABB. Uses Liang-Barsky algorithm. */
+declare function lineVsRect(x1: number, y1: number, x2: number, y2: number, r: Rect): boolean;
+/** Line segment intersection with circle. */
+declare function lineVsCircle(x1: number, y1: number, x2: number, y2: number, c: Circle): boolean;
+/** Ray intersection with AABB. Returns t (distance) or null if no hit. */
+declare function rayVsRect(originX: number, originY: number, dirX: number, dirY: number, r: Rect): number | null;
+//#endregion
+//#region src/transform2d.d.ts
+/** 2D transform: position, rotation (radians), and scale. */
+type Transform2D = {
+  position: Vec2;
+  rotation: number;
+  scale: Vec2;
+};
+declare const Transform2D: {
+  /** Creates an identity transform. */
+  readonly identity: () => Transform2D;
+  /** Creates a transform from components. */
+  readonly create: (x?: number, y?: number, rotation?: number, scaleX?: number, scaleY?: number) => Transform2D;
+  /** Transforms a local-space point to world-space. */
+  readonly localToWorld: (t: Transform2D, point: Vec2) => Vec2;
+  /** Transforms a world-space point to local-space. */
+  readonly worldToLocal: (t: Transform2D, point: Vec2) => Vec2;
+  /** Returns a copy of the transform. */
+  readonly clone: (t: Transform2D) => Transform2D;
+};
+//#endregion
+//#region src/mat3.d.ts
+/**
+ * 3x3 matrix stored in column-major order on Float32Array.
+ * Layout: [m00, m10, m20, m01, m11, m21, m02, m12, m22]
+ *
+ * | m00 m01 m02 |     indices: | 0 3 6 |
+ * | m10 m11 m12 |              | 1 4 7 |
+ * | m20 m21 m22 |              | 2 5 8 |
+ */
+type Mat3 = Float32Array;
+declare const Mat3: {
+  /** Creates a new identity matrix. */
+  readonly create: () => Mat3;
+  /** Sets m to identity. */
+  readonly identity: (m: Mat3) => Mat3;
+  /** Multiplies a * b, writes into out (or allocates). */
+  readonly multiply: (a: Mat3, b: Mat3, out?: Mat3) => Mat3;
+  /** Creates a translation matrix. */
+  readonly translate: (tx: number, ty: number, out?: Mat3) => Mat3;
+  /** Creates a rotation matrix (radians). */
+  readonly rotate: (angle: number, out?: Mat3) => Mat3;
+  /** Creates a scale matrix. */
+  readonly scale: (sx: number, sy: number, out?: Mat3) => Mat3;
+  /** Inverts the matrix. Returns null if singular. */
+  readonly invert: (m: Mat3, out?: Mat3) => Mat3 | null;
+  /** Builds a matrix from a Transform2D (TRS order: translate * rotate * scale). */
+  readonly fromTransform: (t: Transform2D, out?: Mat3) => Mat3;
+};
+//#endregion
+//#region src/random.d.ts
 /** Seeded PRNG using mulberry32 algorithm. */
 declare class SeededRNG {
-    private state;
-    constructor(seed: number);
-    /** Returns a float in [0, 1). */
-    next(): number;
-    /** Returns a float in [min, max). */
-    float(min: number, max: number): number;
-    /** Returns an integer in [min, max] (inclusive). */
-    int(min: number, max: number): number;
+  private state;
+  constructor(seed: number);
+  /** Returns a float in [0, 1). */
+  next(): number;
+  /** Returns a float in [min, max). */
+  float(min: number, max: number): number;
+  /** Returns an integer in [min, max] (inclusive). */
+  int(min: number, max: number): number;
 }
 /** Returns a random float in [min, max). */
 declare function randomFloat(min: number, max: number): number;
@@ -327,7 +328,8 @@ declare function hashU32(seed: number): number;
  * adjacent seeds before the modulo.
  */
 declare function seededIndex(seed: number, count: number): number;
-
+//#endregion
+//#region src/reward.d.ts
 /**
  * Timed-window and capped-bonus math — pure, zero-alloc scoring helpers.
  */
@@ -356,22 +358,38 @@ declare function windowExpired(elapsed: number, lastT: number, windowSec: number
  * already counted. Clamped to 0 — never negative.
  */
 declare function remainingInWindow(awarded: number, capPerWindow: number): number;
-
-/** Returns true if point is inside rect (inclusive). */
-declare function pointInRect(p: Vec2, r: Rect): boolean;
-/** Returns true if point is inside circle (inclusive). */
-declare function pointInCircle(p: Vec2, c: Circle): boolean;
-/** Returns true if two rects overlap. */
-declare function rectVsRect(a: Rect, b: Rect): boolean;
-/** Returns true if rect and circle overlap. */
-declare function rectVsCircle(r: Rect, c: Circle): boolean;
-/** Returns true if two circles overlap. */
-declare function circleVsCircle(a: Circle, b: Circle): boolean;
-/** Line segment intersection with AABB. Uses Liang-Barsky algorithm. */
-declare function lineVsRect(x1: number, y1: number, x2: number, y2: number, r: Rect): boolean;
-/** Line segment intersection with circle. */
-declare function lineVsCircle(x1: number, y1: number, x2: number, y2: number, c: Circle): boolean;
-/** Ray intersection with AABB. Returns t (distance) or null if no hit. */
-declare function rayVsRect(originX: number, originY: number, dirX: number, dirY: number, r: Rect): number | null;
-
+//#endregion
+//#region src/scalar.d.ts
+/** Clamps value between min and max. */
+declare function clamp(value: number, min: number, max: number): number;
+/** Linearly interpolates between a and b by t (unclamped). */
+declare function lerp(a: number, b: number, t: number): number;
+/** Returns the interpolation factor of value between a and b. */
+declare function inverseLerp(a: number, b: number, value: number): number;
+/** Maps value from [inMin, inMax] to [outMin, outMax]. */
+declare function map(value: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
+/** Converts degrees to radians. */
+declare function degToRad(degrees: number): number;
+/** Converts radians to degrees. */
+declare function radToDeg(radians: number): number;
+/** Returns true if a and b are approximately equal within epsilon. */
+declare function approxEquals(a: number, b: number, epsilon?: number): boolean;
+/** Wraps value into [min, max) range. */
+declare function wrap(value: number, min: number, max: number): number;
+/** PingPong — bounces value back and forth in [0, length]. */
+declare function pingPong(t: number, length: number): number;
+/** Hermite smooth interpolation (0→1) with zero first-derivative at edges. */
+declare function smoothStep(edge0: number, edge1: number, x: number): number;
+/** Returns -1, 0, or 1. Unlike Math.sign, returns 0 for NaN. */
+declare function sign(value: number): number;
+/** Shortest signed angle delta a - b, wrapped to [-pi, pi] (closed both ends — strict comparisons
+ * leave exact +/-pi unwrapped). Branch form (single +/-2pi correction)
+ * — byte-identical to hand-rolled aim/homing turn math; do NOT swap for a modulo form (it shifts
+ * results by ULPs at the +/-pi boundary). */
+declare function angleDelta(a: number, b: number): number;
+/** Rotates angle cur toward target by at most maxStep radians, shortest direction. Returns the new
+ * angle (NOT re-wrapped). Branch-form step clamp — byte-identical to hand-rolled homing steering. */
+declare function rotateTowards(cur: number, target: number, maxStep: number): number;
+//#endregion
 export { Circle, Color, type EasingFn, Mat3, type Oklab, type Oklch, Rect, SeededRNG, Transform2D, Vec2, advanceWindowedStreak, angleDelta, approxEquals, cappedBonus, choose, circleVsCircle, clamp, degToRad, 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, hashU32, inverseLerp, lerp, lineVsCircle, lineVsRect, linear, map, pingPong, pointInCircle, pointInRect, radToDeg, randomFloat, randomInt, randomPointInCircle, randomVec2InRect, rayVsRect, rectVsCircle, rectVsRect, remainingInWindow, rotateTowards, seededIndex, shuffle, sign, smoothStep, springIn, springInOut, springOut, step, vec2, weightedIndex, weightedIndexBy, weightedPick, windowExpired, wrap };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/vec2.ts","../src/rect.ts","../src/circle.ts","../src/color.ts","../src/easings.ts","../src/intersection.ts","../src/transform2d.ts","../src/mat3.ts","../src/random.ts","../src/reward.ts","../src/scalar.ts"],"mappings":"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"}