@flare-engine/math 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,1199 +1,1330 @@
-"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 });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/circle.ts
+const 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;
+	}
 };
-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,
-  advanceWindowedStreak: () => advanceWindowedStreak,
-  angleDelta: () => angleDelta,
-  approxEquals: () => approxEquals,
-  cappedBonus: () => cappedBonus,
-  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,
-  hashU32: () => hashU32,
-  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,
-  remainingInWindow: () => remainingInWindow,
-  rotateTowards: () => rotateTowards,
-  seededIndex: () => seededIndex,
-  shuffle: () => shuffle,
-  sign: () => sign,
-  smoothStep: () => smoothStep,
-  springIn: () => springIn,
-  springInOut: () => springInOut,
-  springOut: () => springOut,
-  step: () => step,
-  vec2: () => vec2,
-  weightedIndex: () => weightedIndex,
-  weightedIndexBy: () => weightedIndexBy,
-  weightedPick: () => weightedPick,
-  windowExpired: () => windowExpired,
-  wrap: () => wrap
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/scalar.ts
+//#endregion
+//#region src/scalar.ts
+/** Clamps value between min and max. */
 function clamp(value, min, max) {
-  return value < min ? min : value > max ? max : value;
+	return value < min ? min : value > max ? max : value;
 }
+/** Linearly interpolates between a and b by t (unclamped). */
 function lerp(a, b, t) {
-  return a + (b - a) * t;
+	return a + (b - a) * t;
 }
+/** Returns the interpolation factor of value between a and b. */
 function inverseLerp(a, b, value) {
-  const range = b - a;
-  if (range === 0) return 0;
-  return (value - a) / range;
+	const range = b - a;
+	if (range === 0) return 0;
+	return (value - a) / range;
 }
+/** Maps value from [inMin, inMax] to [outMin, outMax]. */
 function map(value, inMin, inMax, outMin, outMax) {
-  return lerp(outMin, outMax, inverseLerp(inMin, inMax, value));
+	return lerp(outMin, outMax, inverseLerp(inMin, inMax, value));
 }
-var DEG_TO_RAD = Math.PI / 180;
-var RAD_TO_DEG = 180 / Math.PI;
+const DEG_TO_RAD = Math.PI / 180;
+const RAD_TO_DEG = 180 / Math.PI;
+/** Converts degrees to radians. */
 function degToRad(degrees) {
-  return degrees * DEG_TO_RAD;
+	return degrees * DEG_TO_RAD;
 }
+/** Converts radians to degrees. */
 function radToDeg(radians) {
-  return radians * RAD_TO_DEG;
+	return radians * RAD_TO_DEG;
 }
+/** Returns true if a and b are approximately equal within epsilon. */
 function approxEquals(a, b, epsilon = 1e-6) {
-  return Math.abs(a - b) <= epsilon;
+	return Math.abs(a - b) <= epsilon;
 }
+/** Wraps value into [min, max) range. */
 function wrap(value, min, max) {
-  const range = max - min;
-  if (range === 0) return min;
-  return min + ((value - min) % range + range) % range;
+	const range = max - min;
+	if (range === 0) return min;
+	return min + ((value - min) % range + range) % range;
 }
+/** PingPong — bounces value back and forth in [0, length]. */
 function pingPong(t, length) {
-  if (length === 0) return 0;
-  const tt = wrap(t, 0, length * 2);
-  return length - Math.abs(tt - length);
+	if (length === 0) return 0;
+	const tt = wrap(t, 0, length * 2);
+	return length - Math.abs(tt - length);
 }
+/** Hermite smooth interpolation (0→1) with zero first-derivative at edges. */
 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);
+	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);
 }
+/** Returns -1, 0, or 1. Unlike Math.sign, returns 0 for NaN. */
 function sign(value) {
-  if (Number.isNaN(value)) return 0;
-  return value > 0 ? 1 : value < 0 ? -1 : 0;
+	if (Number.isNaN(value)) return 0;
+	return value > 0 ? 1 : value < 0 ? -1 : 0;
 }
+/** 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). */
 function angleDelta(a, b) {
-  let diff = a - b;
-  if (diff > Math.PI) diff -= 2 * Math.PI;
-  else if (diff < -Math.PI) diff += 2 * Math.PI;
-  return diff;
+	let diff = a - b;
+	if (diff > Math.PI) diff -= 2 * Math.PI;
+	else if (diff < -Math.PI) diff += 2 * Math.PI;
+	return diff;
 }
+/** 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. */
 function rotateTowards(cur, target, maxStep) {
-  const diff = angleDelta(target, cur);
-  const turn = diff > maxStep ? maxStep : diff < -maxStep ? -maxStep : diff;
-  return cur + turn;
-}
-
-// 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 };
-  },
-  /** 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). */
-  turnVelocityToward(vx, vy, dx, dy, maxStep, out) {
-    const speed = Math.hypot(vx, vy);
-    const newAng = rotateTowards(Math.atan2(vy, vx), Math.atan2(dy, dx), maxStep);
-    out.x = Math.cos(newAng) * speed;
-    out.y = Math.sin(newAng) * speed;
-    return out;
-  }
-};
-
-// 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
+	const diff = angleDelta(target, cur);
+	return cur + (diff > maxStep ? maxStep : diff < -maxStep ? -maxStep : diff);
+}
+//#endregion
+//#region src/color.ts
+/**
+* Converts a single sRGB channel to linear light.
+* The 0.04045 threshold (modern WCAG errata) is numerically identical to the
+* older 0.03928 for 8-bit inputs and is shared by OKLab and WCAG luminance.
+*/
 function srgbToLinear(c) {
-  return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+	return c <= .04045 ? c / 12.92 : ((c + .055) / 1.055) ** 2.4;
 }
+/** Converts a single linear-light channel back to sRGB. */
 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);
-  }
+	return c <= .0031308 ? 12.92 * c : 1.055 * c ** (1 / 2.4) - .055;
+}
+const 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];
+		return {
+			r: Number.parseInt(h.slice(0, 2), 16) / 255,
+			g: Number.parseInt(h.slice(2, 4), 16) / 255,
+			b: Number.parseInt(h.slice(4, 6), 16) / 255,
+			a: h.length >= 8 ? Number.parseInt(h.slice(6, 8), 16) / 255 : 1
+		};
+	},
+	/** 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) return `#${r}${g}${b}${Math.round(clamp(c.a, 0, 1) * 255).toString(16).padStart(2, "0")}`;
+		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;
+		return ((Math.round(clamp(c.a, 0, 1) * 255) & 255) << 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 = .4122214708 * rl + .5363325363 * gl + .0514459929 * bl;
+		const m = .2119034982 * rl + .6806995451 * gl + .1073969566 * bl;
+		const s = .0883024619 * rl + .2817188376 * gl + .6299787005 * bl;
+		const l_ = Math.cbrt(l);
+		const m_ = Math.cbrt(m);
+		const s_ = Math.cbrt(s);
+		return {
+			L: .2104542553 * l_ + .793617785 * m_ - .0040720468 * s_,
+			a: 1.9779984951 * l_ - 2.428592205 * m_ + .4505937099 * s_,
+			b: .0259040371 * l_ + .7827717662 * m_ - .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 + .3963377774 * lab.a + .2158037573 * lab.b;
+		const m_ = lab.L - .1055613458 * lab.a - .0638541728 * lab.b;
+		const s_ = lab.L - .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 + .2309699292 * s;
+		const gl = -1.2684380046 * l + 2.6097574011 * m - .3413193965 * s;
+		const bl = -.0041960863 * l - .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 hRad = (lch.h % 360 + 360) % 360 * 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 .2126 * srgbToLinear(c.r) + .7152 * srgbToLinear(c.g) + .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 + .05) / (lMin + .05);
+	}
 };
-
-// src/easings.ts
-var PI = Math.PI;
-var HALF_PI = PI / 2;
-var TAU = PI * 2;
+//#endregion
+//#region src/easings.ts
+const PI = Math.PI;
+const HALF_PI = PI / 2;
+const TAU = PI * 2;
 function linear(t) {
-  return t;
+	return t;
 }
 function step(t) {
-  return t < 1 ? 0 : 1;
+	return t < 1 ? 0 : 1;
 }
 function easeInQuad(t) {
-  return t * t;
+	return t * t;
 }
 function easeOutQuad(t) {
-  return t * (2 - t);
+	return t * (2 - t);
 }
 function easeInOutQuad(t) {
-  return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+	return t < .5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
 }
 function easeInCubic(t) {
-  return t * t * t;
+	return t * t * t;
 }
 function easeOutCubic(t) {
-  const t1 = t - 1;
-  return t1 * t1 * t1 + 1;
+	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);
+	return t < .5 ? 4 * t * t * t : 1 + (t - 1) * (2 * t - 2) * (2 * t - 2);
 }
 function easeInQuart(t) {
-  return t * t * t * t;
+	return t * t * t * t;
 }
 function easeOutQuart(t) {
-  const t1 = t - 1;
-  return 1 - t1 * t1 * t1 * t1;
+	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;
+	const t1 = t - 1;
+	return t < .5 ? 8 * t * t * t * t : 1 - 8 * t1 * t1 * t1 * t1;
 }
 function easeInQuint(t) {
-  return t * t * t * t * t;
+	return t * t * t * t * t;
 }
 function easeOutQuint(t) {
-  const t1 = t - 1;
-  return 1 + t1 * t1 * t1 * t1 * t1;
+	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;
+	const t1 = t - 1;
+	return t < .5 ? 16 * t * t * t * t * t : 1 + 16 * t1 * t1 * t1 * t1 * t1;
 }
 function easeInSine(t) {
-  return 1 - Math.cos(t * HALF_PI);
+	return 1 - Math.cos(t * HALF_PI);
 }
 function easeOutSine(t) {
-  return Math.sin(t * HALF_PI);
+	return Math.sin(t * HALF_PI);
 }
 function easeInOutSine(t) {
-  return 0.5 * (1 - Math.cos(PI * t));
+	return .5 * (1 - Math.cos(PI * t));
 }
 function easeInExpo(t) {
-  return t === 0 ? 0 : 2 ** (10 * (t - 1));
+	return t === 0 ? 0 : 2 ** (10 * (t - 1));
 }
 function easeOutExpo(t) {
-  return t === 1 ? 1 : 1 - 2 ** (-10 * 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);
+	if (t === 0) return 0;
+	if (t === 1) return 1;
+	return t < .5 ? .5 * 2 ** (20 * t - 10) : 1 - .5 * 2 ** (-20 * t + 10);
 }
 function easeInCirc(t) {
-  return 1 - Math.sqrt(1 - t * t);
+	return 1 - Math.sqrt(1 - t * t);
 }
 function easeOutCirc(t) {
-  const t1 = t - 1;
-  return Math.sqrt(1 - t1 * t1);
+	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);
+	return t < .5 ? .5 * (1 - Math.sqrt(1 - 4 * t * t)) : .5 * (Math.sqrt(1 - (2 * t - 2) * (2 * t - 2)) + 1);
 }
-var S = 1.70158;
-var S2 = S * 1.525;
+const S = 1.70158;
+const S2 = S * 1.525;
 function easeInBack(t) {
-  return t * t * ((S + 1) * t - S);
+	return t * t * (2.70158 * t - S);
 }
 function easeOutBack(t) {
-  const t1 = t - 1;
-  return t1 * t1 * ((S + 1) * t1 + S) + 1;
+	const t1 = t - 1;
+	return t1 * t1 * (2.70158 * 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);
+	if (t < .5) {
+		const t2 = 2 * t;
+		return .5 * (t2 * t2 * (3.5949095 * t2 - S2));
+	}
+	const t2 = 2 * t - 2;
+	return .5 * (t2 * t2 * (3.5949095 * 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));
+	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;
+	if (t === 0 || t === 1) return t;
+	return 2 ** (-10 * t) * Math.sin((t * 10 - .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;
+	if (t === 0 || t === 1) return t;
+	const p = TAU / 4.5;
+	return t < .5 ? -.5 * 2 ** (20 * t - 10) * Math.sin((20 * t - 11.125) * p) : .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;
+	if (t < 1 / 2.75) return 7.5625 * t * t;
+	if (t < 2 / 2.75) {
+		const t2 = t - 1.5 / 2.75;
+		return 7.5625 * t2 * t2 + .75;
+	}
+	if (t < 2.5 / 2.75) {
+		const t2 = t - 2.25 / 2.75;
+		return 7.5625 * t2 * t2 + .9375;
+	}
+	const t2 = t - 2.625 / 2.75;
+	return 7.5625 * t2 * t2 + .984375;
 }
 function easeInBounce(t) {
-  return 1 - easeOutBounce(1 - 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;
+	return t < .5 ? .5 * easeInBounce(t * 2) : .5 * easeOutBounce(t * 2 - 1) + .5;
 }
 function springIn(t) {
-  return t * t * ((1.70158 + 1) * t - 1.70158);
+	return t * t * (2.70158 * t - 1.70158);
 }
 function springOut(t) {
-  const t1 = t - 1;
-  return t1 * t1 * ((1.70158 + 1) * t1 + 1.70158) + 1;
+	const t1 = t - 1;
+	return t1 * t1 * (2.70158 * 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);
+	if (t < .5) {
+		const t2 = 2 * t;
+		return .5 * t2 * t2 * (3.5949095 * t2 - S2);
+	}
+	const t2 = 2 * t - 2;
+	return .5 * (t2 * t2 * (3.5949095 * t2 + S2) + 2);
+}
+//#endregion
+//#region src/intersection.ts
+/** Returns true if point is inside rect (inclusive). */
+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;
 }
-
-// src/random.ts
+/** Returns true if point is inside circle (inclusive). */
+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;
+}
+/** Returns true if two rects overlap. */
+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;
+}
+/** Returns true if rect and circle overlap. */
+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;
+}
+/** Returns true if two circles overlap. */
+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;
+}
+/** Line segment intersection with AABB. Uses Liang-Barsky algorithm. */
+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;
+}
+/** Line segment intersection with circle. */
+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;
+}
+/** Ray intersection with AABB. Returns t (distance) or null if no hit. */
+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;
+}
+//#endregion
+//#region src/mat3.ts
+const Mat3 = {
+	/** Creates a new identity matrix. */
+	create() {
+		const m = /* @__PURE__ */ 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 ?? /* @__PURE__ */ 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 ?? /* @__PURE__ */ 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 ?? /* @__PURE__ */ 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 ?? /* @__PURE__ */ 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 ?? /* @__PURE__ */ 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 ?? /* @__PURE__ */ 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;
+	}
+};
+//#endregion
+//#region src/random.ts
+/** Seeded PRNG using mulberry32 algorithm. */
 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));
-  }
+	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));
+	}
 };
+/** Returns a random float in [min, max). */
 function randomFloat(min, max) {
-  return min + Math.random() * (max - min);
+	return min + Math.random() * (max - min);
 }
+/** Returns a random integer in [min, max] (inclusive). */
 function randomInt(min, max) {
-  return Math.floor(randomFloat(min, max + 1));
+	return Math.floor(randomFloat(min, max + 1));
 }
+/** Returns a random Vec2 within a rect. */
 function randomVec2InRect(r) {
-  return {
-    x: r.x + Math.random() * r.width,
-    y: r.y + Math.random() * r.height
-  };
+	return {
+		x: r.x + Math.random() * r.width,
+		y: r.y + Math.random() * r.height
+	};
 }
+/** Returns a random point inside a circle (uniform distribution). */
 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)
-  };
-}
+	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)
+	};
+}
+/** Fisher-Yates shuffle (in-place). Returns the array. */
 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;
-}
+	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;
+}
+/** Returns a random element from the array. */
 function choose(array) {
-  if (array.length === 0) return void 0;
-  return array[Math.floor(Math.random() * array.length)];
+	if (array.length === 0) return void 0;
+	return array[Math.floor(Math.random() * array.length)];
 }
+/**
+* Picks an index from a weight array using a cumulative walk.
+* `roll01` must be in [0, 1); returns 0 for an empty or all-zero array.
+*/
 function weightedIndex(weights, roll01) {
-  let total = 0;
-  for (let i = 0; i < weights.length; i++) total += weights[i] ?? 0;
-  if (total <= 0) return 0;
-  const target = roll01 * total;
-  let acc = 0;
-  for (let i = 0; i < weights.length; i++) {
-    acc += weights[i] ?? 0;
-    if (target < acc) return i;
-  }
-  return weights.length - 1;
-}
+	let total = 0;
+	for (let i = 0; i < weights.length; i++) total += weights[i] ?? 0;
+	if (total <= 0) return 0;
+	const target = roll01 * total;
+	let acc = 0;
+	for (let i = 0; i < weights.length; i++) {
+		acc += weights[i] ?? 0;
+		if (target < acc) return i;
+	}
+	return weights.length - 1;
+}
+/**
+* Picks an index from `items` using a per-item weight accessor.
+* `roll01` must be in [0, 1); returns 0 for an empty or all-zero-weight array.
+*/
 function weightedIndexBy(items, weight, roll01) {
-  let total = 0;
-  for (let i = 0; i < items.length; i++) total += weight(items[i]);
-  if (total <= 0) return 0;
-  const target = roll01 * total;
-  let acc = 0;
-  for (let i = 0; i < items.length; i++) {
-    acc += weight(items[i]);
-    if (target < acc) return i;
-  }
-  return items.length - 1;
-}
+	let total = 0;
+	for (let i = 0; i < items.length; i++) total += weight(items[i]);
+	if (total <= 0) return 0;
+	const target = roll01 * total;
+	let acc = 0;
+	for (let i = 0; i < items.length; i++) {
+		acc += weight(items[i]);
+		if (target < acc) return i;
+	}
+	return items.length - 1;
+}
+/**
+* Picks an item from `items` using a per-item weight accessor.
+* Returns `undefined` for an empty array; returns the last item on float-edge.
+*/
 function weightedPick(items, weight, roll01) {
-  if (items.length === 0) return void 0;
-  return items[weightedIndexBy(items, weight, roll01)];
-}
+	if (items.length === 0) return void 0;
+	return items[weightedIndexBy(items, weight, roll01)];
+}
+/**
+* 32-bit avalanche finalizer (lowbias32). Mixes `seed` so that adjacent seeds
+* decorrelate into different output values. Returns an unsigned 32-bit integer.
+*
+* Constants from https://nullprogram.com/blog/2018/07/31/ (lowbias32).
+*/
 function hashU32(seed) {
-  let h = (seed | 0) >>> 0;
-  h = Math.imul(h ^ h >>> 16, 73244475) >>> 0;
-  h = Math.imul(h ^ h >>> 16, 73244475) >>> 0;
-  return (h ^ h >>> 16) >>> 0;
-}
+	let h = (seed | 0) >>> 0;
+	h = Math.imul(h ^ h >>> 16, 73244475) >>> 0;
+	h = Math.imul(h ^ h >>> 16, 73244475) >>> 0;
+	return (h ^ h >>> 16) >>> 0;
+}
+/**
+* Deterministically maps `seed` to an index in [0, count).
+* Single-entry pools short-circuit to 0. Uses `hashU32` to decorrelate
+* adjacent seeds before the modulo.
+*/
 function seededIndex(seed, count) {
-  if (count <= 1) return 0;
-  return hashU32(seed) % count;
-}
-
-// src/reward.ts
+	if (count <= 1) return 0;
+	return hashU32(seed) % count;
+}
+//#endregion
+//#region src/rect.ts
+const 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 * .5,
+			y: r.y + r.height * .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
+		};
+	}
+};
+//#endregion
+//#region src/reward.ts
+/**
+* Timed-window and capped-bonus math — pure, zero-alloc scoring helpers.
+*/
+/**
+* Bonus pay floored to an integer: `pay × min(frac, capFrac)`.
+* `frac` is the current multiplier (e.g. `streak * fracPerStep`);
+* `capFrac` bounds the multiplier so it cannot grow unboundedly.
+* Returns 0 for zero or negative `pay`.
+*/
 function cappedBonus(pay, frac, capFrac) {
-  if (pay <= 0) return 0;
-  return Math.floor(pay * Math.min(frac, capFrac));
-}
+	if (pay <= 0) return 0;
+	return Math.floor(pay * Math.min(frac, capFrac));
+}
+/**
+* Advances a timed streak counter. A new event within `windowSec` of `lastT`
+* increments `prev`; a gap (or `lastT < 0` meaning "no prior event") resets
+* to 1. Pure — the caller stores the returned value and stamps the new time.
+* `elapsed` is the monotonic clock at the new event.
+*/
 function advanceWindowedStreak(prev, elapsed, lastT, windowSec) {
-  if (lastT >= 0 && elapsed - lastT <= windowSec) return prev + 1;
-  return 1;
-}
+	if (lastT >= 0 && elapsed - lastT <= windowSec) return prev + 1;
+	return 1;
+}
+/**
+* Returns true when a streak window has lapsed: a window was open (`lastT >= 0`)
+* and more than `windowSec` seconds have passed since `lastT`.
+* `lastT < 0` means no event has ever occurred — never expired.
+*/
 function windowExpired(elapsed, lastT, windowSec) {
-  return lastT >= 0 && elapsed - lastT > windowSec;
+	return lastT >= 0 && elapsed - lastT > windowSec;
 }
+/**
+* How many more events may be awarded in the current window given `awarded`
+* already counted. Clamped to 0 — never negative.
+*/
 function remainingInWindow(awarded, capPerWindow) {
-  return Math.max(0, capPerWindow - awarded);
-}
+	return Math.max(0, capPerWindow - awarded);
+}
+//#endregion
+//#region src/transform2d.ts
+const 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
+			}
+		};
+	}
+};
+//#endregion
+//#region src/vec2.ts
+/** Creates a Vec2 plain object. */
+function vec2(x = 0, y = 0) {
+	return {
+		x,
+		y
+	};
+}
+const 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;
+	},
+	/** 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. */
+	perp(v, out) {
+		const x = -v.y;
+		const y = v.x;
+		if (out) {
+			out.x = x;
+			out.y = y;
+			return out;
+		}
+		return {
+			x,
+			y
+		};
+	},
+	/** Scalar × vector cross product: s × v = (-s·y, s·x). Writes into out if provided. */
+	crossSV(s, v, out) {
+		const x = -s * v.y;
+		const y = s * v.x;
+		if (out) {
+			out.x = x;
+			out.y = y;
+			return out;
+		}
+		return {
+			x,
+			y
+		};
+	},
+	/** 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 inv = maxLength / Math.sqrt(lenSq);
+		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 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). */
+	turnVelocityToward(vx, vy, dx, dy, maxStep, out) {
+		const speed = Math.hypot(vx, vy);
+		const newAng = rotateTowards(Math.atan2(vy, vx), Math.atan2(dy, dx), maxStep);
+		out.x = Math.cos(newAng) * speed;
+		out.y = Math.sin(newAng) * speed;
+		return out;
+	}
+};
+//#endregion
+exports.Circle = Circle;
+exports.Color = Color;
+exports.Mat3 = Mat3;
+exports.Rect = Rect;
+exports.SeededRNG = SeededRNG;
+exports.Transform2D = Transform2D;
+exports.Vec2 = Vec2;
+exports.advanceWindowedStreak = advanceWindowedStreak;
+exports.angleDelta = angleDelta;
+exports.approxEquals = approxEquals;
+exports.cappedBonus = cappedBonus;
+exports.choose = choose;
+exports.circleVsCircle = circleVsCircle;
+exports.clamp = clamp;
+exports.degToRad = degToRad;
+exports.easeInBack = easeInBack;
+exports.easeInBounce = easeInBounce;
+exports.easeInCirc = easeInCirc;
+exports.easeInCubic = easeInCubic;
+exports.easeInElastic = easeInElastic;
+exports.easeInExpo = easeInExpo;
+exports.easeInOutBack = easeInOutBack;
+exports.easeInOutBounce = easeInOutBounce;
+exports.easeInOutCirc = easeInOutCirc;
+exports.easeInOutCubic = easeInOutCubic;
+exports.easeInOutElastic = easeInOutElastic;
+exports.easeInOutExpo = easeInOutExpo;
+exports.easeInOutQuad = easeInOutQuad;
+exports.easeInOutQuart = easeInOutQuart;
+exports.easeInOutQuint = easeInOutQuint;
+exports.easeInOutSine = easeInOutSine;
+exports.easeInQuad = easeInQuad;
+exports.easeInQuart = easeInQuart;
+exports.easeInQuint = easeInQuint;
+exports.easeInSine = easeInSine;
+exports.easeOutBack = easeOutBack;
+exports.easeOutBounce = easeOutBounce;
+exports.easeOutCirc = easeOutCirc;
+exports.easeOutCubic = easeOutCubic;
+exports.easeOutElastic = easeOutElastic;
+exports.easeOutExpo = easeOutExpo;
+exports.easeOutQuad = easeOutQuad;
+exports.easeOutQuart = easeOutQuart;
+exports.easeOutQuint = easeOutQuint;
+exports.easeOutSine = easeOutSine;
+exports.hashU32 = hashU32;
+exports.inverseLerp = inverseLerp;
+exports.lerp = lerp;
+exports.lineVsCircle = lineVsCircle;
+exports.lineVsRect = lineVsRect;
+exports.linear = linear;
+exports.map = map;
+exports.pingPong = pingPong;
+exports.pointInCircle = pointInCircle;
+exports.pointInRect = pointInRect;
+exports.radToDeg = radToDeg;
+exports.randomFloat = randomFloat;
+exports.randomInt = randomInt;
+exports.randomPointInCircle = randomPointInCircle;
+exports.randomVec2InRect = randomVec2InRect;
+exports.rayVsRect = rayVsRect;
+exports.rectVsCircle = rectVsCircle;
+exports.rectVsRect = rectVsRect;
+exports.remainingInWindow = remainingInWindow;
+exports.rotateTowards = rotateTowards;
+exports.seededIndex = seededIndex;
+exports.shuffle = shuffle;
+exports.sign = sign;
+exports.smoothStep = smoothStep;
+exports.springIn = springIn;
+exports.springInOut = springInOut;
+exports.springOut = springOut;
+exports.step = step;
+exports.vec2 = vec2;
+exports.weightedIndex = weightedIndex;
+exports.weightedIndexBy = weightedIndexBy;
+exports.weightedPick = weightedPick;
+exports.windowExpired = windowExpired;
+exports.wrap = wrap;
 
-// 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,
-  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.js.map