@flare-engine/math 0.1.0

package/dist/index.js

@@ -0,0 +1,1102 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Circle: () => Circle,
+  Color: () => Color,
+  Mat3: () => Mat3,
+  Rect: () => Rect,
+  SeededRNG: () => SeededRNG,
+  Transform2D: () => Transform2D,
+  Vec2: () => Vec2,
+  approxEquals: () => approxEquals,
+  choose: () => choose,
+  circleVsCircle: () => circleVsCircle,
+  clamp: () => clamp,
+  degToRad: () => degToRad,
+  easeInBack: () => easeInBack,
+  easeInBounce: () => easeInBounce,
+  easeInCirc: () => easeInCirc,
+  easeInCubic: () => easeInCubic,
+  easeInElastic: () => easeInElastic,
+  easeInExpo: () => easeInExpo,
+  easeInOutBack: () => easeInOutBack,
+  easeInOutBounce: () => easeInOutBounce,
+  easeInOutCirc: () => easeInOutCirc,
+  easeInOutCubic: () => easeInOutCubic,
+  easeInOutElastic: () => easeInOutElastic,
+  easeInOutExpo: () => easeInOutExpo,
+  easeInOutQuad: () => easeInOutQuad,
+  easeInOutQuart: () => easeInOutQuart,
+  easeInOutQuint: () => easeInOutQuint,
+  easeInOutSine: () => easeInOutSine,
+  easeInQuad: () => easeInQuad,
+  easeInQuart: () => easeInQuart,
+  easeInQuint: () => easeInQuint,
+  easeInSine: () => easeInSine,
+  easeOutBack: () => easeOutBack,
+  easeOutBounce: () => easeOutBounce,
+  easeOutCirc: () => easeOutCirc,
+  easeOutCubic: () => easeOutCubic,
+  easeOutElastic: () => easeOutElastic,
+  easeOutExpo: () => easeOutExpo,
+  easeOutQuad: () => easeOutQuad,
+  easeOutQuart: () => easeOutQuart,
+  easeOutQuint: () => easeOutQuint,
+  easeOutSine: () => easeOutSine,
+  inverseLerp: () => inverseLerp,
+  lerp: () => lerp,
+  lineVsCircle: () => lineVsCircle,
+  lineVsRect: () => lineVsRect,
+  linear: () => linear,
+  map: () => map,
+  pingPong: () => pingPong,
+  pointInCircle: () => pointInCircle,
+  pointInRect: () => pointInRect,
+  radToDeg: () => radToDeg,
+  randomFloat: () => randomFloat,
+  randomInt: () => randomInt,
+  randomPointInCircle: () => randomPointInCircle,
+  randomVec2InRect: () => randomVec2InRect,
+  rayVsRect: () => rayVsRect,
+  rectVsCircle: () => rectVsCircle,
+  rectVsRect: () => rectVsRect,
+  shuffle: () => shuffle,
+  sign: () => sign,
+  smoothStep: () => smoothStep,
+  springIn: () => springIn,
+  springInOut: () => springInOut,
+  springOut: () => springOut,
+  step: () => step,
+  vec2: () => vec2,
+  wrap: () => wrap
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/scalar.ts
+function clamp(value, min, max) {
+  return value < min ? min : value > max ? max : value;
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function inverseLerp(a, b, value) {
+  const range = b - a;
+  if (range === 0) return 0;
+  return (value - a) / range;
+}
+function map(value, inMin, inMax, outMin, outMax) {
+  return lerp(outMin, outMax, inverseLerp(inMin, inMax, value));
+}
+var DEG_TO_RAD = Math.PI / 180;
+var RAD_TO_DEG = 180 / Math.PI;
+function degToRad(degrees) {
+  return degrees * DEG_TO_RAD;
+}
+function radToDeg(radians) {
+  return radians * RAD_TO_DEG;
+}
+function approxEquals(a, b, epsilon = 1e-6) {
+  return Math.abs(a - b) <= epsilon;
+}
+function wrap(value, min, max) {
+  const range = max - min;
+  if (range === 0) return min;
+  return min + ((value - min) % range + range) % range;
+}
+function pingPong(t, length) {
+  if (length === 0) return 0;
+  const tt = wrap(t, 0, length * 2);
+  return length - Math.abs(tt - length);
+}
+function smoothStep(edge0, edge1, x) {
+  const range = edge1 - edge0;
+  if (range === 0) return x >= edge1 ? 1 : 0;
+  const t = clamp((x - edge0) / range, 0, 1);
+  return t * t * (3 - 2 * t);
+}
+function sign(value) {
+  if (Number.isNaN(value)) return 0;
+  return value > 0 ? 1 : value < 0 ? -1 : 0;
+}
+
+// src/vec2.ts
+function vec2(x = 0, y = 0) {
+  return { x, y };
+}
+var Vec2 = {
+  /** Returns { 0, 0 }. */
+  zero() {
+    return { x: 0, y: 0 };
+  },
+  /** Returns { 1, 1 }. */
+  one() {
+    return { x: 1, y: 1 };
+  },
+  /** Returns { 0, -1 }. */
+  up() {
+    return { x: 0, y: -1 };
+  },
+  /** Returns { 0, 1 }. */
+  down() {
+    return { x: 0, y: 1 };
+  },
+  /** Returns { -1, 0 }. */
+  left() {
+    return { x: -1, y: 0 };
+  },
+  /** Returns { 1, 0 }. */
+  right() {
+    return { x: 1, y: 0 };
+  },
+  /** Component-wise addition. Writes into out if provided. */
+  add(a, b, out) {
+    if (out) {
+      out.x = a.x + b.x;
+      out.y = a.y + b.y;
+      return out;
+    }
+    return { x: a.x + b.x, y: a.y + b.y };
+  },
+  /** Component-wise subtraction a - b. */
+  sub(a, b, out) {
+    if (out) {
+      out.x = a.x - b.x;
+      out.y = a.y - b.y;
+      return out;
+    }
+    return { x: a.x - b.x, y: a.y - b.y };
+  },
+  /** Scales a vector by a scalar. */
+  scale(v, s, out) {
+    if (out) {
+      out.x = v.x * s;
+      out.y = v.y * s;
+      return out;
+    }
+    return { x: v.x * s, y: v.y * s };
+  },
+  /** Returns a unit vector. Returns zero vector if length is 0. */
+  normalize(v, out) {
+    const len = Math.sqrt(v.x * v.x + v.y * v.y);
+    if (len === 0) {
+      if (out) {
+        out.x = 0;
+        out.y = 0;
+        return out;
+      }
+      return { x: 0, y: 0 };
+    }
+    const inv = 1 / len;
+    if (out) {
+      out.x = v.x * inv;
+      out.y = v.y * inv;
+      return out;
+    }
+    return { x: v.x * inv, y: v.y * inv };
+  },
+  /** Zero-alloc; writes into `out`. Mandatory `out` so callers avoid temporaries in hot paths. */
+  normalizeOut(dx, dy, speed, out) {
+    const len = Math.sqrt(dx * dx + dy * dy);
+    if (len <= 1e-6) {
+      out.x = 0;
+      out.y = 0;
+      return out;
+    }
+    const inv = speed / len;
+    out.x = dx * inv;
+    out.y = dy * inv;
+    return out;
+  },
+  /** Dot product. */
+  dot(a, b) {
+    return a.x * b.x + a.y * b.y;
+  },
+  /** 2D cross product (z-component of the 3D cross). */
+  cross(a, b) {
+    return a.x * b.y - a.y * b.x;
+  },
+  /** Linearly interpolates between a and b (unclamped). */
+  lerp(a, b, t, out) {
+    const x = a.x + (b.x - a.x) * t;
+    const y = a.y + (b.y - a.y) * t;
+    if (out) {
+      out.x = x;
+      out.y = y;
+      return out;
+    }
+    return { x, y };
+  },
+  /** Spherical linear interpolation for unit vectors. */
+  slerp(a, b, t, out) {
+    let d = a.x * b.x + a.y * b.y;
+    d = d < -1 ? -1 : d > 1 ? 1 : d;
+    const theta = Math.acos(d);
+    if (theta < 1e-6) {
+      return Vec2.lerp(a, b, t, out);
+    }
+    const sinTheta = Math.sin(theta);
+    const wa = Math.sin((1 - t) * theta) / sinTheta;
+    const wb = Math.sin(t * theta) / sinTheta;
+    const x = a.x * wa + b.x * wb;
+    const y = a.y * wa + b.y * wb;
+    if (out) {
+      out.x = x;
+      out.y = y;
+      return out;
+    }
+    return { x, y };
+  },
+  /** Euclidean distance between two points. */
+  distance(a, b) {
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    return Math.sqrt(dx * dx + dy * dy);
+  },
+  /** Squared distance (avoids sqrt). */
+  distanceSq(a, b) {
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    return dx * dx + dy * dy;
+  },
+  /** Length of a vector. */
+  length(v) {
+    return Math.sqrt(v.x * v.x + v.y * v.y);
+  },
+  /** Squared length (avoids sqrt). */
+  lengthSq(v) {
+    return v.x * v.x + v.y * v.y;
+  },
+  /** Angle of vector in radians (atan2). */
+  angle(v) {
+    return Math.atan2(v.y, v.x);
+  },
+  /** Rotates a vector by angle (radians) around origin. */
+  rotate(v, angle, out) {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    const x = v.x * c - v.y * s;
+    const y = v.x * s + v.y * c;
+    if (out) {
+      out.x = x;
+      out.y = y;
+      return out;
+    }
+    return { x, y };
+  },
+  /** Component-wise approximate equality. */
+  equals(a, b, epsilon = 1e-6) {
+    return approxEquals(a.x, b.x, epsilon) && approxEquals(a.y, b.y, epsilon);
+  },
+  /** Returns a copy of the vector. */
+  clone(v) {
+    return { x: v.x, y: v.y };
+  },
+  /** Clamps the length of a vector to maxLength. */
+  clampLength(v, maxLength, out) {
+    const lenSq = v.x * v.x + v.y * v.y;
+    if (lenSq <= maxLength * maxLength) {
+      if (out) {
+        out.x = v.x;
+        out.y = v.y;
+        return out;
+      }
+      return { x: v.x, y: v.y };
+    }
+    const len = Math.sqrt(lenSq);
+    const inv = maxLength / len;
+    if (out) {
+      out.x = v.x * inv;
+      out.y = v.y * inv;
+      return out;
+    }
+    return { x: v.x * inv, y: v.y * inv };
+  }
+};
+
+// src/rect.ts
+var Rect = {
+  /** Returns true if point is inside rect (inclusive). */
+  contains(r, p) {
+    return p.x >= r.x && p.x <= r.x + r.width && p.y >= r.y && p.y <= r.y + r.height;
+  },
+  /** Returns true if two rects overlap (share area). */
+  intersects(a, b) {
+    return a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
+  },
+  /** Returns the overlapping rect, or null if no overlap. */
+  intersection(a, b) {
+    const x = Math.max(a.x, b.x);
+    const y = Math.max(a.y, b.y);
+    const right = Math.min(a.x + a.width, b.x + b.width);
+    const bottom = Math.min(a.y + a.height, b.y + b.height);
+    if (right <= x || bottom <= y) return null;
+    return { x, y, width: right - x, height: bottom - y };
+  },
+  /** Returns the smallest rect containing both rects. */
+  union(a, b) {
+    const x = Math.min(a.x, b.x);
+    const y = Math.min(a.y, b.y);
+    const right = Math.max(a.x + a.width, b.x + b.width);
+    const bottom = Math.max(a.y + a.height, b.y + b.height);
+    return { x, y, width: right - x, height: bottom - y };
+  },
+  /** Creates a rect from an array of points (bounding box). */
+  fromPoints(points) {
+    if (points.length === 0) return { x: 0, y: 0, width: 0, height: 0 };
+    let minX = points[0].x;
+    let minY = points[0].y;
+    let maxX = minX;
+    let maxY = minY;
+    for (let i = 1; i < points.length; i++) {
+      const p = points[i];
+      if (p.x < minX) minX = p.x;
+      if (p.y < minY) minY = p.y;
+      if (p.x > maxX) maxX = p.x;
+      if (p.y > maxY) maxY = p.y;
+    }
+    return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+  },
+  /** Returns the center point of the rect. */
+  center(r) {
+    return { x: r.x + r.width * 0.5, y: r.y + r.height * 0.5 };
+  },
+  /** Returns a new rect expanded by amount on each side. */
+  expand(r, amount) {
+    return {
+      x: r.x - amount,
+      y: r.y - amount,
+      width: r.width + amount * 2,
+      height: r.height + amount * 2
+    };
+  }
+};
+
+// src/circle.ts
+var Circle = {
+  /** Returns true if point is inside or on the circle. */
+  contains(c, p) {
+    const dx = p.x - c.x;
+    const dy = p.y - c.y;
+    return dx * dx + dy * dy <= c.radius * c.radius;
+  },
+  /** Returns true if two circles overlap (share area). */
+  intersects(a, b) {
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const distSq = dx * dx + dy * dy;
+    const radSum = a.radius + b.radius;
+    return distSq < radSum * radSum;
+  },
+  /** Returns true if a circle and rect overlap. */
+  intersectsRect(c, r) {
+    const closestX = c.x < r.x ? r.x : c.x > r.x + r.width ? r.x + r.width : c.x;
+    const closestY = c.y < r.y ? r.y : c.y > r.y + r.height ? r.y + r.height : c.y;
+    const dx = c.x - closestX;
+    const dy = c.y - closestY;
+    return dx * dx + dy * dy <= c.radius * c.radius;
+  }
+};
+
+// src/transform2d.ts
+var Transform2D = {
+  /** Creates an identity transform. */
+  identity() {
+    return { position: { x: 0, y: 0 }, rotation: 0, scale: { x: 1, y: 1 } };
+  },
+  /** Creates a transform from components. */
+  create(x = 0, y = 0, rotation = 0, scaleX = 1, scaleY = 1) {
+    return {
+      position: { x, y },
+      rotation,
+      scale: { x: scaleX, y: scaleY }
+    };
+  },
+  /** Transforms a local-space point to world-space. */
+  localToWorld(t, point) {
+    const c = Math.cos(t.rotation);
+    const s = Math.sin(t.rotation);
+    const sx = point.x * t.scale.x;
+    const sy = point.y * t.scale.y;
+    return {
+      x: sx * c - sy * s + t.position.x,
+      y: sx * s + sy * c + t.position.y
+    };
+  },
+  /** Transforms a world-space point to local-space. */
+  worldToLocal(t, point) {
+    const dx = point.x - t.position.x;
+    const dy = point.y - t.position.y;
+    const c = Math.cos(-t.rotation);
+    const s = Math.sin(-t.rotation);
+    const rx = dx * c - dy * s;
+    const ry = dx * s + dy * c;
+    return {
+      x: t.scale.x !== 0 ? rx / t.scale.x : 0,
+      y: t.scale.y !== 0 ? ry / t.scale.y : 0
+    };
+  },
+  /** Returns a copy of the transform. */
+  clone(t) {
+    return {
+      position: { x: t.position.x, y: t.position.y },
+      rotation: t.rotation,
+      scale: { x: t.scale.x, y: t.scale.y }
+    };
+  }
+};
+
+// src/mat3.ts
+var Mat3 = {
+  /** Creates a new identity matrix. */
+  create() {
+    const m = new Float32Array(9);
+    m[0] = 1;
+    m[4] = 1;
+    m[8] = 1;
+    return m;
+  },
+  /** Sets m to identity. */
+  identity(m) {
+    m[0] = 1;
+    m[1] = 0;
+    m[2] = 0;
+    m[3] = 0;
+    m[4] = 1;
+    m[5] = 0;
+    m[6] = 0;
+    m[7] = 0;
+    m[8] = 1;
+    return m;
+  },
+  /** Multiplies a * b, writes into out (or allocates). */
+  multiply(a, b, out) {
+    const a00 = a[0], a01 = a[3], a02 = a[6];
+    const a10 = a[1], a11 = a[4], a12 = a[7];
+    const a20 = a[2], a21 = a[5], a22 = a[8];
+    const b00 = b[0], b01 = b[3], b02 = b[6];
+    const b10 = b[1], b11 = b[4], b12 = b[7];
+    const b20 = b[2], b21 = b[5], b22 = b[8];
+    const o = out ?? new Float32Array(9);
+    o[0] = a00 * b00 + a01 * b10 + a02 * b20;
+    o[1] = a10 * b00 + a11 * b10 + a12 * b20;
+    o[2] = a20 * b00 + a21 * b10 + a22 * b20;
+    o[3] = a00 * b01 + a01 * b11 + a02 * b21;
+    o[4] = a10 * b01 + a11 * b11 + a12 * b21;
+    o[5] = a20 * b01 + a21 * b11 + a22 * b21;
+    o[6] = a00 * b02 + a01 * b12 + a02 * b22;
+    o[7] = a10 * b02 + a11 * b12 + a12 * b22;
+    o[8] = a20 * b02 + a21 * b12 + a22 * b22;
+    return o;
+  },
+  /** Creates a translation matrix. */
+  translate(tx, ty, out) {
+    const m = out ?? new Float32Array(9);
+    m[0] = 1;
+    m[1] = 0;
+    m[2] = 0;
+    m[3] = 0;
+    m[4] = 1;
+    m[5] = 0;
+    m[6] = tx;
+    m[7] = ty;
+    m[8] = 1;
+    return m;
+  },
+  /** Creates a rotation matrix (radians). */
+  rotate(angle, out) {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    const m = out ?? new Float32Array(9);
+    m[0] = c;
+    m[1] = s;
+    m[2] = 0;
+    m[3] = -s;
+    m[4] = c;
+    m[5] = 0;
+    m[6] = 0;
+    m[7] = 0;
+    m[8] = 1;
+    return m;
+  },
+  /** Creates a scale matrix. */
+  scale(sx, sy, out) {
+    const m = out ?? new Float32Array(9);
+    m[0] = sx;
+    m[1] = 0;
+    m[2] = 0;
+    m[3] = 0;
+    m[4] = sy;
+    m[5] = 0;
+    m[6] = 0;
+    m[7] = 0;
+    m[8] = 1;
+    return m;
+  },
+  /** Inverts the matrix. Returns null if singular. */
+  invert(m, out) {
+    const a00 = m[0], a01 = m[3], a02 = m[6];
+    const a10 = m[1], a11 = m[4], a12 = m[7];
+    const a20 = m[2], a21 = m[5], a22 = m[8];
+    const det = a00 * (a11 * a22 - a12 * a21) - a01 * (a10 * a22 - a12 * a20) + a02 * (a10 * a21 - a11 * a20);
+    if (Math.abs(det) < 1e-8) return null;
+    const invDet = 1 / det;
+    const o = out ?? new Float32Array(9);
+    o[0] = (a11 * a22 - a12 * a21) * invDet;
+    o[1] = (a12 * a20 - a10 * a22) * invDet;
+    o[2] = (a10 * a21 - a11 * a20) * invDet;
+    o[3] = (a02 * a21 - a01 * a22) * invDet;
+    o[4] = (a00 * a22 - a02 * a20) * invDet;
+    o[5] = (a01 * a20 - a00 * a21) * invDet;
+    o[6] = (a01 * a12 - a02 * a11) * invDet;
+    o[7] = (a02 * a10 - a00 * a12) * invDet;
+    o[8] = (a00 * a11 - a01 * a10) * invDet;
+    return o;
+  },
+  /** Builds a matrix from a Transform2D (TRS order: translate * rotate * scale). */
+  fromTransform(t, out) {
+    const c = Math.cos(t.rotation);
+    const s = Math.sin(t.rotation);
+    const sx = t.scale.x;
+    const sy = t.scale.y;
+    const m = out ?? new Float32Array(9);
+    m[0] = c * sx;
+    m[1] = s * sx;
+    m[2] = 0;
+    m[3] = -s * sy;
+    m[4] = c * sy;
+    m[5] = 0;
+    m[6] = t.position.x;
+    m[7] = t.position.y;
+    m[8] = 1;
+    return m;
+  }
+};
+
+// src/color.ts
+function srgbToLinear(c) {
+  return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+function linearToSrgb(c) {
+  return c <= 31308e-7 ? 12.92 * c : 1.055 * c ** (1 / 2.4) - 0.055;
+}
+var Color = {
+  WHITE: { r: 1, g: 1, b: 1, a: 1 },
+  BLACK: { r: 0, g: 0, b: 0, a: 1 },
+  TRANSPARENT: { r: 0, g: 0, b: 0, a: 0 },
+  /** Creates a Color from normalized 0-1 components. */
+  create(r = 0, g = 0, b = 0, a = 1) {
+    return { r, g, b, a };
+  },
+  /** Parses a hex string (#RGB, #RGBA, #RRGGBB, #RRGGBBAA). */
+  fromHex(hex) {
+    let h = hex.startsWith("#") ? hex.slice(1) : hex;
+    if (h.length === 3) {
+      h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+    } else if (h.length === 4) {
+      h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2] + h[3] + h[3];
+    }
+    const r = Number.parseInt(h.slice(0, 2), 16) / 255;
+    const g = Number.parseInt(h.slice(2, 4), 16) / 255;
+    const b = Number.parseInt(h.slice(4, 6), 16) / 255;
+    const a = h.length >= 8 ? Number.parseInt(h.slice(6, 8), 16) / 255 : 1;
+    return { r, g, b, a };
+  },
+  /** Converts to hex string #RRGGBB or #RRGGBBAA if alpha < 1. */
+  toHex(c) {
+    const r = Math.round(clamp(c.r, 0, 1) * 255).toString(16).padStart(2, "0");
+    const g = Math.round(clamp(c.g, 0, 1) * 255).toString(16).padStart(2, "0");
+    const b = Math.round(clamp(c.b, 0, 1) * 255).toString(16).padStart(2, "0");
+    if (c.a < 1) {
+      const a = Math.round(clamp(c.a, 0, 1) * 255).toString(16).padStart(2, "0");
+      return `#${r}${g}${b}${a}`;
+    }
+    return `#${r}${g}${b}`;
+  },
+  /** Linearly interpolates between two colors. */
+  lerp(a, b, t) {
+    return {
+      r: a.r + (b.r - a.r) * t,
+      g: a.g + (b.g - a.g) * t,
+      b: a.b + (b.b - a.b) * t,
+      a: a.a + (b.a - a.a) * t
+    };
+  },
+  /** Component-wise multiplication. */
+  multiply(a, b) {
+    return {
+      r: a.r * b.r,
+      g: a.g * b.g,
+      b: a.b * b.b,
+      a: a.a * b.a
+    };
+  },
+  /**
+   * Converts to a Skia-compatible color number (0xAARRGGBB).
+   * Compatible with @shopify/react-native-skia Skia.Color() format.
+   */
+  toSkColor(c) {
+    const r = Math.round(clamp(c.r, 0, 1) * 255) & 255;
+    const g = Math.round(clamp(c.g, 0, 1) * 255) & 255;
+    const b = Math.round(clamp(c.b, 0, 1) * 255) & 255;
+    const a = Math.round(clamp(c.a, 0, 1) * 255) & 255;
+    return (a << 24 | r << 16 | g << 8 | b) >>> 0;
+  },
+  /** Converts sRGB Color to OKLab. Alpha is dropped. */
+  toOklab(c) {
+    const rl = srgbToLinear(c.r);
+    const gl = srgbToLinear(c.g);
+    const bl = srgbToLinear(c.b);
+    const l = 0.4122214708 * rl + 0.5363325363 * gl + 0.0514459929 * bl;
+    const m = 0.2119034982 * rl + 0.6806995451 * gl + 0.1073969566 * bl;
+    const s = 0.0883024619 * rl + 0.2817188376 * gl + 0.6299787005 * bl;
+    const l_ = Math.cbrt(l);
+    const m_ = Math.cbrt(m);
+    const s_ = Math.cbrt(s);
+    return {
+      L: 0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,
+      a: 1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,
+      b: 0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_
+    };
+  },
+  /**
+   * Converts OKLab to sRGB Color. Out-of-gamut results are clamped to [0,1];
+   * round-trips are exact only for in-gamut colors.
+   */
+  fromOklab(lab, alpha = 1) {
+    const l_ = lab.L + 0.3963377774 * lab.a + 0.2158037573 * lab.b;
+    const m_ = lab.L - 0.1055613458 * lab.a - 0.0638541728 * lab.b;
+    const s_ = lab.L - 0.0894841775 * lab.a - 1.291485548 * lab.b;
+    const l = l_ ** 3;
+    const m = m_ ** 3;
+    const s = s_ ** 3;
+    const rl = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;
+    const gl = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;
+    const bl = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;
+    return {
+      r: clamp(linearToSrgb(rl), 0, 1),
+      g: clamp(linearToSrgb(gl), 0, 1),
+      b: clamp(linearToSrgb(bl), 0, 1),
+      a: alpha
+    };
+  },
+  /** Converts sRGB Color to OKLCH (polar OKLab). Achromatic colors get h = 0. */
+  toOklch(c) {
+    const lab = Color.toOklab(c);
+    const C = Math.hypot(lab.a, lab.b);
+    const h = C < 1e-7 ? 0 : (Math.atan2(lab.b, lab.a) * 180 / Math.PI + 360) % 360;
+    return { L: lab.L, C, h };
+  },
+  /**
+   * 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.
+   */
+  fromOklch(lch, alpha = 1) {
+    const hWrapped = (lch.h % 360 + 360) % 360;
+    const hRad = hWrapped * Math.PI / 180;
+    return Color.fromOklab(
+      { L: lch.L, a: lch.C * Math.cos(hRad), b: lch.C * Math.sin(hRad) },
+      alpha
+    );
+  },
+  /** Euclidean distance in OKLab space between two sRGB colors. */
+  deltaEOk(a, b) {
+    return Color.deltaEOkLab(Color.toOklab(a), Color.toOklab(b));
+  },
+  /** Euclidean distance between two OKLab values. */
+  deltaEOkLab(a, b) {
+    return Math.hypot(a.L - b.L, a.a - b.a, a.b - b.b);
+  },
+  /** WCAG 2.x relative luminance. White = 1, black = 0. */
+  relativeLuminance(c) {
+    return 0.2126 * srgbToLinear(c.r) + 0.7152 * srgbToLinear(c.g) + 0.0722 * srgbToLinear(c.b);
+  },
+  /** WCAG 2.x contrast ratio. Order-independent; range [1, 21]. */
+  contrastRatio(fg, bg) {
+    const l1 = Color.relativeLuminance(fg);
+    const l2 = Color.relativeLuminance(bg);
+    const lMax = Math.max(l1, l2);
+    const lMin = Math.min(l1, l2);
+    return (lMax + 0.05) / (lMin + 0.05);
+  }
+};
+
+// src/easings.ts
+var PI = Math.PI;
+var HALF_PI = PI / 2;
+var TAU = PI * 2;
+function linear(t) {
+  return t;
+}
+function step(t) {
+  return t < 1 ? 0 : 1;
+}
+function easeInQuad(t) {
+  return t * t;
+}
+function easeOutQuad(t) {
+  return t * (2 - t);
+}
+function easeInOutQuad(t) {
+  return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+}
+function easeInCubic(t) {
+  return t * t * t;
+}
+function easeOutCubic(t) {
+  const t1 = t - 1;
+  return t1 * t1 * t1 + 1;
+}
+function easeInOutCubic(t) {
+  return t < 0.5 ? 4 * t * t * t : 1 + (t - 1) * (2 * t - 2) * (2 * t - 2);
+}
+function easeInQuart(t) {
+  return t * t * t * t;
+}
+function easeOutQuart(t) {
+  const t1 = t - 1;
+  return 1 - t1 * t1 * t1 * t1;
+}
+function easeInOutQuart(t) {
+  const t1 = t - 1;
+  return t < 0.5 ? 8 * t * t * t * t : 1 - 8 * t1 * t1 * t1 * t1;
+}
+function easeInQuint(t) {
+  return t * t * t * t * t;
+}
+function easeOutQuint(t) {
+  const t1 = t - 1;
+  return 1 + t1 * t1 * t1 * t1 * t1;
+}
+function easeInOutQuint(t) {
+  const t1 = t - 1;
+  return t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * t1 * t1 * t1 * t1 * t1;
+}
+function easeInSine(t) {
+  return 1 - Math.cos(t * HALF_PI);
+}
+function easeOutSine(t) {
+  return Math.sin(t * HALF_PI);
+}
+function easeInOutSine(t) {
+  return 0.5 * (1 - Math.cos(PI * t));
+}
+function easeInExpo(t) {
+  return t === 0 ? 0 : 2 ** (10 * (t - 1));
+}
+function easeOutExpo(t) {
+  return t === 1 ? 1 : 1 - 2 ** (-10 * t);
+}
+function easeInOutExpo(t) {
+  if (t === 0) return 0;
+  if (t === 1) return 1;
+  return t < 0.5 ? 0.5 * 2 ** (20 * t - 10) : 1 - 0.5 * 2 ** (-20 * t + 10);
+}
+function easeInCirc(t) {
+  return 1 - Math.sqrt(1 - t * t);
+}
+function easeOutCirc(t) {
+  const t1 = t - 1;
+  return Math.sqrt(1 - t1 * t1);
+}
+function easeInOutCirc(t) {
+  return t < 0.5 ? 0.5 * (1 - Math.sqrt(1 - 4 * t * t)) : 0.5 * (Math.sqrt(1 - (2 * t - 2) * (2 * t - 2)) + 1);
+}
+var S = 1.70158;
+var S2 = S * 1.525;
+function easeInBack(t) {
+  return t * t * ((S + 1) * t - S);
+}
+function easeOutBack(t) {
+  const t1 = t - 1;
+  return t1 * t1 * ((S + 1) * t1 + S) + 1;
+}
+function easeInOutBack(t) {
+  if (t < 0.5) {
+    const t22 = 2 * t;
+    return 0.5 * (t22 * t22 * ((S2 + 1) * t22 - S2));
+  }
+  const t2 = 2 * t - 2;
+  return 0.5 * (t2 * t2 * ((S2 + 1) * t2 + S2) + 2);
+}
+function easeInElastic(t) {
+  if (t === 0 || t === 1) return t;
+  return -(2 ** (10 * t - 10)) * Math.sin((t * 10 - 10.75) * (TAU / 3));
+}
+function easeOutElastic(t) {
+  if (t === 0 || t === 1) return t;
+  return 2 ** (-10 * t) * Math.sin((t * 10 - 0.75) * (TAU / 3)) + 1;
+}
+function easeInOutElastic(t) {
+  if (t === 0 || t === 1) return t;
+  const p = TAU / 4.5;
+  return t < 0.5 ? -0.5 * 2 ** (20 * t - 10) * Math.sin((20 * t - 11.125) * p) : 0.5 * 2 ** (-20 * t + 10) * Math.sin((20 * t - 11.125) * p) + 1;
+}
+function easeOutBounce(t) {
+  if (t < 1 / 2.75) {
+    return 7.5625 * t * t;
+  }
+  if (t < 2 / 2.75) {
+    const t22 = t - 1.5 / 2.75;
+    return 7.5625 * t22 * t22 + 0.75;
+  }
+  if (t < 2.5 / 2.75) {
+    const t22 = t - 2.25 / 2.75;
+    return 7.5625 * t22 * t22 + 0.9375;
+  }
+  const t2 = t - 2.625 / 2.75;
+  return 7.5625 * t2 * t2 + 0.984375;
+}
+function easeInBounce(t) {
+  return 1 - easeOutBounce(1 - t);
+}
+function easeInOutBounce(t) {
+  return t < 0.5 ? 0.5 * easeInBounce(t * 2) : 0.5 * easeOutBounce(t * 2 - 1) + 0.5;
+}
+function springIn(t) {
+  return t * t * ((1.70158 + 1) * t - 1.70158);
+}
+function springOut(t) {
+  const t1 = t - 1;
+  return t1 * t1 * ((1.70158 + 1) * t1 + 1.70158) + 1;
+}
+function springInOut(t) {
+  if (t < 0.5) {
+    const t22 = 2 * t;
+    return 0.5 * t22 * t22 * ((S2 + 1) * t22 - S2);
+  }
+  const t2 = 2 * t - 2;
+  return 0.5 * (t2 * t2 * ((S2 + 1) * t2 + S2) + 2);
+}
+
+// src/random.ts
+var SeededRNG = class {
+  state;
+  constructor(seed) {
+    this.state = seed | 0;
+  }
+  /** Returns a float in [0, 1). */
+  next() {
+    this.state = this.state + 1831565813 | 0;
+    let t = Math.imul(this.state ^ this.state >>> 15, 1 | this.state);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  }
+  /** Returns a float in [min, max). */
+  float(min, max) {
+    return min + this.next() * (max - min);
+  }
+  /** Returns an integer in [min, max] (inclusive). */
+  int(min, max) {
+    return Math.floor(this.float(min, max + 1));
+  }
+};
+function randomFloat(min, max) {
+  return min + Math.random() * (max - min);
+}
+function randomInt(min, max) {
+  return Math.floor(randomFloat(min, max + 1));
+}
+function randomVec2InRect(r) {
+  return {
+    x: r.x + Math.random() * r.width,
+    y: r.y + Math.random() * r.height
+  };
+}
+function randomPointInCircle(cx, cy, radius) {
+  const r = radius * Math.sqrt(Math.random());
+  const angle = Math.random() * Math.PI * 2;
+  return {
+    x: cx + r * Math.cos(angle),
+    y: cy + r * Math.sin(angle)
+  };
+}
+function shuffle(array) {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    const tmp = array[i];
+    array[i] = array[j];
+    array[j] = tmp;
+  }
+  return array;
+}
+function choose(array) {
+  if (array.length === 0) return void 0;
+  return array[Math.floor(Math.random() * array.length)];
+}
+
+// src/intersection.ts
+function pointInRect(p, r) {
+  return p.x >= r.x && p.x <= r.x + r.width && p.y >= r.y && p.y <= r.y + r.height;
+}
+function pointInCircle(p, c) {
+  const dx = p.x - c.x;
+  const dy = p.y - c.y;
+  return dx * dx + dy * dy <= c.radius * c.radius;
+}
+function rectVsRect(a, b) {
+  return a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
+}
+function rectVsCircle(r, c) {
+  const closestX = c.x < r.x ? r.x : c.x > r.x + r.width ? r.x + r.width : c.x;
+  const closestY = c.y < r.y ? r.y : c.y > r.y + r.height ? r.y + r.height : c.y;
+  const dx = c.x - closestX;
+  const dy = c.y - closestY;
+  return dx * dx + dy * dy <= c.radius * c.radius;
+}
+function circleVsCircle(a, b) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const radSum = a.radius + b.radius;
+  return dx * dx + dy * dy < radSum * radSum;
+}
+function lineVsRect(x1, y1, x2, y2, r) {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  let tMin = 0;
+  let tMax = 1;
+  const edges = [
+    { p: -dx, q: x1 - r.x },
+    { p: dx, q: r.x + r.width - x1 },
+    { p: -dy, q: y1 - r.y },
+    { p: dy, q: r.y + r.height - y1 }
+  ];
+  for (const { p, q } of edges) {
+    if (Math.abs(p) < 1e-12) {
+      if (q < 0) return false;
+    } else {
+      const t = q / p;
+      if (p < 0) {
+        if (t > tMax) return false;
+        if (t > tMin) tMin = t;
+      } else {
+        if (t < tMin) return false;
+        if (t < tMax) tMax = t;
+      }
+    }
+  }
+  return tMin <= tMax;
+}
+function lineVsCircle(x1, y1, x2, y2, c) {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  const fx = x1 - c.x;
+  const fy = y1 - c.y;
+  const a = dx * dx + dy * dy;
+  const b = 2 * (fx * dx + fy * dy);
+  const cc = fx * fx + fy * fy - c.radius * c.radius;
+  if (a < 1e-12) {
+    return cc <= 0;
+  }
+  let discriminant = b * b - 4 * a * cc;
+  if (discriminant < 0) return false;
+  discriminant = Math.sqrt(discriminant);
+  const t1 = (-b - discriminant) / (2 * a);
+  const t2 = (-b + discriminant) / (2 * a);
+  if (t1 >= 0 && t1 <= 1) return true;
+  if (t2 >= 0 && t2 <= 1) return true;
+  if (t1 < 0 && t2 > 1) return true;
+  return false;
+}
+function rayVsRect(originX, originY, dirX, dirY, r) {
+  const invDx = dirX !== 0 ? 1 / dirX : Number.POSITIVE_INFINITY;
+  const invDy = dirY !== 0 ? 1 / dirY : Number.POSITIVE_INFINITY;
+  const tx1 = (r.x - originX) * invDx;
+  const tx2 = (r.x + r.width - originX) * invDx;
+  const ty1 = (r.y - originY) * invDy;
+  const ty2 = (r.y + r.height - originY) * invDy;
+  const tMin = Math.max(Math.min(tx1, tx2), Math.min(ty1, ty2));
+  const tMax = Math.min(Math.max(tx1, tx2), Math.max(ty1, ty2));
+  if (tMax < 0 || tMin > tMax) return null;
+  return tMin >= 0 ? tMin : tMax;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Circle,
+  Color,
+  Mat3,
+  Rect,
+  SeededRNG,
+  Transform2D,
+  Vec2,
+  approxEquals,
+  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,
+  inverseLerp,
+  lerp,
+  lineVsCircle,
+  lineVsRect,
+  linear,
+  map,
+  pingPong,
+  pointInCircle,
+  pointInRect,
+  radToDeg,
+  randomFloat,
+  randomInt,
+  randomPointInCircle,
+  randomVec2InRect,
+  rayVsRect,
+  rectVsCircle,
+  rectVsRect,
+  shuffle,
+  sign,
+  smoothStep,
+  springIn,
+  springInOut,
+  springOut,
+  step,
+  vec2,
+  wrap
+});
+//# sourceMappingURL=index.js.map