@codexo/exojs 0.6.10 → 0.6.12

package/dist/exo.esm.js

@@ -1,3 +1,448 @@
+const bounceOutFn = (t) => {
+    const n1 = 7.5625;
+    const d1 = 2.75;
+    if (t < 1 / d1) {
+        return n1 * t * t;
+    }
+    else if (t < 2 / d1) {
+        return n1 * (t -= 1.5 / d1) * t + 0.75;
+    }
+    else if (t < 2.5 / d1) {
+        return n1 * (t -= 2.25 / d1) * t + 0.9375;
+    }
+    else {
+        return n1 * (t -= 2.625 / d1) * t + 0.984375;
+    }
+};
+/**
+ * Standard Robert Penner easing functions as static methods.
+ * Each function accepts a normalized time `t` in [0, 1] and returns a value
+ * that equals 0 at t=0 and 1 at t=1 (overshoot functions like back/elastic
+ * may exceed that range between the endpoints).
+ *
+ * Usage: `Ease.cubicOut`, `Ease.bounceIn`, etc.
+ *
+ * Note: only scalar numeric properties are supported in v1. Vector, Color, and
+ * Matrix interpolation are out of scope.
+ */
+class Ease {
+    static linear = (t) => t;
+    static quadIn = (t) => t * t;
+    static quadOut = (t) => t * (2 - t);
+    static quadInOut = (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+    static cubicIn = (t) => t * t * t;
+    static cubicOut = (t) => (--t) * t * t + 1;
+    static cubicInOut = (t) => t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+    static quartIn = (t) => t * t * t * t;
+    static quartOut = (t) => 1 - (--t) * t * t * t;
+    static quartInOut = (t) => t < 0.5 ? 8 * t * t * t * t : 1 - Math.pow(-2 * t + 2, 4) / 2;
+    static quintIn = (t) => t * t * t * t * t;
+    static quintOut = (t) => 1 + (--t) * t * t * t * t;
+    static quintInOut = (t) => t < 0.5 ? 16 * t * t * t * t * t : 1 - Math.pow(-2 * t + 2, 5) / 2;
+    static sineIn = (t) => 1 - Math.cos((t * Math.PI) / 2);
+    static sineOut = (t) => Math.sin((t * Math.PI) / 2);
+    static sineInOut = (t) => -(Math.cos(Math.PI * t) - 1) / 2;
+    static expoIn = (t) => t === 0 ? 0 : Math.pow(2, 10 * t - 10);
+    static expoOut = (t) => t === 1 ? 1 : 1 - Math.pow(2, -10 * t);
+    static expoInOut = (t) => {
+        if (t === 0)
+            return 0;
+        if (t === 1)
+            return 1;
+        return t < 0.5
+            ? Math.pow(2, 20 * t - 10) / 2
+            : (2 - Math.pow(2, -20 * t + 10)) / 2;
+    };
+    static circIn = (t) => 1 - Math.sqrt(1 - Math.pow(t, 2));
+    static circOut = (t) => Math.sqrt(1 - Math.pow(t - 1, 2));
+    static circInOut = (t) => t < 0.5
+        ? (1 - Math.sqrt(1 - Math.pow(2 * t, 2))) / 2
+        : (Math.sqrt(1 - Math.pow(-2 * t + 2, 2)) + 1) / 2;
+    static backIn = (t) => {
+        const c1 = 1.70158;
+        const c3 = c1 + 1;
+        return c3 * t * t * t - c1 * t * t;
+    };
+    static backOut = (t) => {
+        const c1 = 1.70158;
+        const c3 = c1 + 1;
+        return 1 + c3 * Math.pow(t - 1, 3) + c1 * Math.pow(t - 1, 2);
+    };
+    static backInOut = (t) => {
+        const c1 = 1.70158;
+        const c2 = c1 * 1.525;
+        return t < 0.5
+            ? (Math.pow(2 * t, 2) * ((c2 + 1) * 2 * t - c2)) / 2
+            : (Math.pow(2 * t - 2, 2) * ((c2 + 1) * (2 * t - 2) + c2) + 2) / 2;
+    };
+    static bounceOut = bounceOutFn;
+    static bounceIn = (t) => 1 - bounceOutFn(1 - t);
+    static bounceInOut = (t) => t < 0.5
+        ? (1 - bounceOutFn(1 - 2 * t)) / 2
+        : (1 + bounceOutFn(2 * t - 1)) / 2;
+    static elasticIn = (t) => {
+        if (t === 0)
+            return 0;
+        if (t === 1)
+            return 1;
+        const c4 = (2 * Math.PI) / 3;
+        return -Math.pow(2, 10 * t - 10) * Math.sin((t * 10 - 10.75) * c4);
+    };
+    static elasticOut = (t) => {
+        if (t === 0)
+            return 0;
+        if (t === 1)
+            return 1;
+        const c4 = (2 * Math.PI) / 3;
+        return Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * c4) + 1;
+    };
+    static elasticInOut = (t) => {
+        if (t === 0)
+            return 0;
+        if (t === 1)
+            return 1;
+        const c5 = (2 * Math.PI) / 4.5;
+        return t < 0.5
+            ? -(Math.pow(2, 20 * t - 10) * Math.sin((20 * t - 11.125) * c5)) / 2
+            : (Math.pow(2, -20 * t + 10) * Math.sin((20 * t - 11.125) * c5)) / 2 + 1;
+    };
+}
+
+var TweenState;
+(function (TweenState) {
+    TweenState["Idle"] = "idle";
+    TweenState["Active"] = "active";
+    TweenState["Paused"] = "paused";
+    TweenState["Complete"] = "complete";
+    TweenState["Stopped"] = "stopped";
+})(TweenState || (TweenState = {}));
+
+class Tween {
+    _target;
+    _state = TweenState.Idle;
+    _properties = {};
+    _startValues = null;
+    _duration = 0;
+    _delay = 0;
+    _easing = Ease.linear;
+    _elapsed = 0;
+    _delayElapsed = 0;
+    /**
+     * Remaining repeat cycles. -1 = infinite.
+     * At start this is set to _repeatTotal. Decremented on each cycle boundary.
+     */
+    _repeatCount = 0;
+    /** The value as configured by .repeat(). Preserved for reset. */
+    _repeatTotal = 0;
+    _yoyo = false;
+    /** Current playback direction: 1 = forward, -1 = reverse. */
+    _direction = 1;
+    _onStart = null;
+    _onUpdate = null;
+    _onComplete = null;
+    _onRepeat = null;
+    _chained = null;
+    _manager = null;
+    /** Whether onStart has already fired this tween lifecycle. */
+    _startFired = false;
+    constructor(target) {
+        this._target = target;
+    }
+    get target() {
+        return this._target;
+    }
+    get state() {
+        return this._state;
+    }
+    /**
+     * Current eased progress in 0..1. Reflects the eased t after applying the
+     * easing function, not the raw elapsed/duration ratio.
+     */
+    get progress() {
+        if (this._duration === 0)
+            return 1;
+        const rawT = Math.min(this._elapsed / this._duration, 1);
+        const t = this._direction === 1 ? rawT : 1 - rawT;
+        return this._easing(t);
+    }
+    /**
+     * Set target end-values and duration in seconds. Replaces any prior to().
+     * The starting values are captured lazily on first update() after start(),
+     * so mutating target between to() and start() is safe.
+     */
+    to(properties, duration) {
+        this._properties = { ...properties };
+        this._duration = duration;
+        this._startValues = null;
+        return this;
+    }
+    /** Delay in seconds before the tween begins interpolating. Default 0. */
+    delay(seconds) {
+        this._delay = seconds;
+        return this;
+    }
+    /** Easing function applied to the normalized time. Default Ease.linear. */
+    easing(fn) {
+        this._easing = fn;
+        return this;
+    }
+    /**
+     * Number of additional repeat cycles. -1 = infinite. Default 0 (runs once).
+     * Note: repeat(2) means the animation runs 3 times total.
+     */
+    repeat(count) {
+        this._repeatTotal = count;
+        return this;
+    }
+    /**
+     * Reverse playback direction on each repeat cycle. Only meaningful when
+     * combined with repeat(). Calling yoyo() without repeat() is a no-op.
+     */
+    yoyo(enabled = true) {
+        this._yoyo = enabled;
+        return this;
+    }
+    onStart(callback) {
+        this._onStart = callback;
+        return this;
+    }
+    onUpdate(callback) {
+        this._onUpdate = callback;
+        return this;
+    }
+    onComplete(callback) {
+        this._onComplete = callback;
+        return this;
+    }
+    onRepeat(callback) {
+        this._onRepeat = callback;
+        return this;
+    }
+    /**
+     * Start the tween. If a manager owns this tween it is already tracked;
+     * otherwise this is a stand-alone tween driven by manual update() calls.
+     */
+    start() {
+        this._state = TweenState.Active;
+        this._elapsed = 0;
+        this._delayElapsed = 0;
+        this._startValues = null;
+        this._startFired = false;
+        this._direction = 1;
+        this._repeatCount = this._repeatTotal;
+        return this;
+    }
+    /** Pause the tween. update() calls are ignored while paused. */
+    pause() {
+        if (this._state === TweenState.Active) {
+            this._state = TweenState.Paused;
+        }
+        return this;
+    }
+    /** Resume a paused tween from where it left off. */
+    resume() {
+        if (this._state === TweenState.Paused) {
+            this._state = TweenState.Active;
+        }
+        return this;
+    }
+    /**
+     * Stop the tween without finishing. Target properties stay at their
+     * current interpolated values. onComplete does NOT fire. The tween is
+     * removed from its manager if one is assigned.
+     */
+    stop() {
+        if (this._state === TweenState.Active || this._state === TweenState.Paused) {
+            this._state = TweenState.Stopped;
+            this._manager?.remove(this);
+        }
+        return this;
+    }
+    /**
+     * When this tween completes naturally, automatically start `next`.
+     * Returns `next` for fluent chaining:
+     *   `fadeIn.chain(moveOut).start()` — note that start() here starts moveOut,
+     *   so typically you only call start() on the first tween.
+     */
+    chain(next) {
+        this._chained = next;
+        return next;
+    }
+    /**
+     * Attach this tween to a manager. Called by TweenManager.create() and
+     * TweenManager.add(). Not part of the public fluent API.
+     * @internal
+     */
+    _attachManager(manager) {
+        this._manager = manager;
+    }
+    /**
+     * Advance the tween by deltaSeconds. Called by TweenManager each frame, or
+     * manually for stand-alone usage. No-ops when Paused, Stopped, or Complete.
+     */
+    update(deltaSeconds) {
+        if (this._state !== TweenState.Active)
+            return;
+        // Handle delay phase.
+        if (this._delayElapsed < this._delay) {
+            this._delayElapsed += deltaSeconds;
+            if (this._delayElapsed < this._delay)
+                return;
+            // Carry overflow past delay into elapsed.
+            const overflow = this._delayElapsed - this._delay;
+            this._delayElapsed = this._delay;
+            deltaSeconds = overflow;
+        }
+        // Lazy snapshot of start values on the first update after delay.
+        if (this._startValues === null) {
+            this._captureStartValues();
+        }
+        // Fire onStart once.
+        if (!this._startFired) {
+            this._startFired = true;
+            this._onStart?.();
+        }
+        this._elapsed += deltaSeconds;
+        // Clamp to duration for this cycle.
+        if (this._elapsed >= this._duration) {
+            this._elapsed = this._duration;
+        }
+        // Apply interpolation.
+        this._applyProgress();
+        if (this._elapsed >= this._duration) {
+            // Cycle complete.
+            const hasMoreRepeats = this._repeatCount === -1 || this._repeatCount > 0;
+            if (hasMoreRepeats) {
+                // Decrement repeat counter (skip for infinite).
+                if (this._repeatCount !== -1) {
+                    this._repeatCount--;
+                }
+                this._onRepeat?.();
+                // Flip direction for yoyo.
+                if (this._yoyo) {
+                    this._direction = this._direction === 1 ? -1 : 1;
+                }
+                // Reset elapsed for next cycle; carry overflow.
+                const overflow = this._elapsed - this._duration;
+                this._elapsed = overflow > 0 ? Math.min(overflow, this._duration) : 0;
+                this._startFired = false; // allow onStart to re-fire next cycle? No — spec says once.
+                // Actually spec says onStart fires when actual interpolation begins.
+                // For repeats it fires once total at the very first cycle.
+                // Re-reading spec: "onStart fires AFTER the delay (when actual interpolation begins)".
+                // We'll keep it as one-shot across the full lifecycle; don't reset _startFired.
+                this._startFired = true;
+                // Apply progress for any overflow.
+                if (overflow > 0) {
+                    this._applyProgress();
+                }
+            }
+            else {
+                // All cycles done.
+                this._complete();
+            }
+        }
+    }
+    _captureStartValues() {
+        const snap = {};
+        const keys = Object.keys(this._properties);
+        for (const key of keys) {
+            const val = this._target[key];
+            if (typeof val !== 'number') {
+                console.warn(`Tween: property "${String(key)}" is not a number on target ` +
+                    `(got ${typeof val}). It will be skipped.`);
+                continue;
+            }
+            snap[String(key)] = val;
+        }
+        this._startValues = snap;
+    }
+    _applyProgress() {
+        if (this._startValues === null)
+            return;
+        const rawT = this._duration === 0 ? 1 : Math.min(this._elapsed / this._duration, 1);
+        const t = this._direction === 1 ? rawT : 1 - rawT;
+        const easedT = this._easing(t);
+        const keys = Object.keys(this._startValues);
+        for (const key of keys) {
+            const start = this._startValues[key];
+            const end = this._properties[key];
+            this._target[key] = start + (end - start) * easedT;
+        }
+        this._onUpdate?.(easedT);
+    }
+    _complete() {
+        // Ensure the target is at its final interpolated position.
+        this._elapsed = this._duration;
+        this._applyProgress();
+        this._state = TweenState.Complete;
+        this._manager?.remove(this);
+        this._onComplete?.();
+        // Fire chained tween, if any.
+        this._chained?.start();
+    }
+}
+
+class TweenManager {
+    _tweens = [];
+    _destroyed = false;
+    /**
+     * Create a new Tween targeting `target`, register it with this manager, and
+     * return it. Call .to(...).start() on the result to begin animating.
+     */
+    create(target) {
+        const tween = new Tween(target);
+        tween._attachManager(this);
+        this._tweens.push(tween);
+        return tween;
+    }
+    /**
+     * Explicitly add a stand-alone Tween (created via `new Tween(target)`)
+     * to this manager so it participates in the update loop.
+     */
+    add(tween) {
+        tween._attachManager(this);
+        if (!this._tweens.includes(tween)) {
+            this._tweens.push(tween);
+        }
+        return this;
+    }
+    /** Remove a tween from the manager. Called automatically on stop/complete. */
+    remove(tween) {
+        const index = this._tweens.indexOf(tween);
+        if (index !== -1) {
+            this._tweens.splice(index, 1);
+        }
+        return this;
+    }
+    /**
+     * Advance all active tweens by deltaSeconds. Called once per frame by
+     * Application.update(). Uses a snapshot of the list so that callbacks that
+     * add or remove tweens do not corrupt mid-iteration.
+     */
+    update(deltaSeconds) {
+        if (this._destroyed)
+            return this;
+        const snapshot = this._tweens.slice();
+        for (const tween of snapshot) {
+            tween.update(deltaSeconds);
+        }
+        return this;
+    }
+    /**
+     * Remove all tweens immediately. No callbacks (onComplete etc.) fire.
+     * The tweens' states are left as-is; they are simply evicted from the list.
+     */
+    clear() {
+        this._tweens = [];
+        return this;
+    }
+    /** Tear down the manager. Clears tweens and makes subsequent updates no-ops. */
+    destroy() {
+        this.clear();
+        this._destroyed = true;
+    }
+}
+
 let temp$9 = null;
 class Size {
     _width;
@@ -14578,6 +15023,7 @@ class Application {
     loader;
     inputManager;
     sceneManager;
+    tweens = new TweenManager();
     onResize = new Signal();
     _updateHandler;
     _startupClock = new Clock();
@@ -14669,6 +15115,7 @@ class Application {
             const frameStart = performance.now();
             this.backend.resetStats();
             this.inputManager.update();
+            this.tweens.update(frameDelta.seconds);
             const runtimeView = this.backend.view;
             if (runtimeView && typeof runtimeView.update === 'function') {
                 runtimeView.update(frameDelta.milliseconds);
@@ -14704,6 +15151,7 @@ class Application {
         this.stop();
         this.loader.destroy();
         this.inputManager.destroy();
+        this.tweens.destroy();
         this._backend.destroy();
         this.sceneManager.destroy();
         this._startupClock.destroy();
@@ -16434,6 +16882,257 @@ class PolarVector {
     }
 }
 
+// ---------------------------------------------------------------------------
+// sweepRectangle — AABB vs AABB slab method
+// ---------------------------------------------------------------------------
+/**
+ * Swept axis-aligned box vs. axis-aligned box.
+ *
+ * Uses the separating-axis slab method: for each axis we compute the entry
+ * and exit times of the moving box's slab vs the static box's slab, then
+ * combine.  `t` is the fraction of the requested move at which first contact
+ * occurs (0 = already overlapping at start, 1 = just barely reaches).
+ *
+ * Already-overlapping case (tEntry < 0 overall): returns `t = 0` with the
+ * normal of the deepest-penetration axis, allowing callers to handle the
+ * "I'm already inside" situation without a separate discrete test.
+ */
+function sweepRectangle(moving, deltaX, deltaY, target) {
+    const movMinX = moving.x;
+    const movMaxX = moving.x + moving.width;
+    const movMinY = moving.y;
+    const movMaxY = moving.y + moving.height;
+    const tarMinX = target.x;
+    const tarMaxX = target.x + target.width;
+    const tarMinY = target.y;
+    const tarMaxY = target.y + target.height;
+    // X axis
+    let tEntryX = -Infinity;
+    let tExitX = Infinity;
+    if (deltaX > 0) {
+        tEntryX = (tarMinX - movMaxX) / deltaX;
+        tExitX = (tarMaxX - movMinX) / deltaX;
+    }
+    else if (deltaX < 0) {
+        tEntryX = (tarMaxX - movMinX) / deltaX;
+        tExitX = (tarMinX - movMaxX) / deltaX;
+    }
+    else if (movMaxX <= tarMinX || movMinX >= tarMaxX) {
+        // No movement on X and no static overlap — can never collide
+        return null;
+    }
+    // Y axis
+    let tEntryY = -Infinity;
+    let tExitY = Infinity;
+    if (deltaY > 0) {
+        tEntryY = (tarMinY - movMaxY) / deltaY;
+        tExitY = (tarMaxY - movMinY) / deltaY;
+    }
+    else if (deltaY < 0) {
+        tEntryY = (tarMaxY - movMinY) / deltaY;
+        tExitY = (tarMinY - movMaxY) / deltaY;
+    }
+    else if (movMaxY <= tarMinY || movMinY >= tarMaxY) {
+        // No movement on Y and no static overlap — can never collide
+        return null;
+    }
+    const tEntry = Math.max(tEntryX, tEntryY);
+    const tExit = Math.min(tExitX, tExitY);
+    // No overlap window
+    if (tEntry > tExit || tExit < 0 || tEntry > 1) {
+        return null;
+    }
+    const t = Math.max(0, tEntry);
+    const hitX = moving.x + deltaX * t;
+    const hitY = moving.y + deltaY * t;
+    // Normal is on the axis whose slab entry was latest.
+    // Already-overlapping: use the deepest-penetration axis normal.
+    let normalX = 0;
+    let normalY = 0;
+    if (tEntry <= 0) {
+        // Already overlapping — pick the axis with least penetration
+        const overlapX = Math.min(movMaxX - tarMinX, tarMaxX - movMinX);
+        const overlapY = Math.min(movMaxY - tarMinY, tarMaxY - movMinY);
+        if (overlapX < overlapY) {
+            normalX = movMinX < tarMinX ? -1 : 1;
+        }
+        else {
+            normalY = movMinY < tarMinY ? -1 : 1;
+        }
+    }
+    else if (tEntryX > tEntryY) {
+        // X axis had the latest entry
+        normalX = deltaX > 0 ? -1 : 1;
+    }
+    else {
+        // Y axis had the latest entry
+        normalY = deltaY > 0 ? -1 : 1;
+    }
+    return { t, x: hitX, y: hitY, normalX, normalY };
+}
+// ---------------------------------------------------------------------------
+// sweepCircleVsRectangle — expanded-AABB simple fallback (V1)
+// ---------------------------------------------------------------------------
+/**
+ * Swept circle vs. axis-aligned box.
+ *
+ * **V1 implementation** uses the simple Minkowski expansion fallback:
+ * the target rectangle is expanded by `circle.radius` on all sides, then
+ * `sweepRectangle` is run treating the circle centre as a zero-sized moving
+ * box.  This over-collides at rectangle corners (the circle collides with the
+ * expanded-rect's flat face when geometrically it should curve around the
+ * corner), producing slightly early hits in corner-quadrant trajectories —
+ * a known and acceptable accuracy trade-off for V1.
+ *
+ * TODO (V2): Replace with the full Minkowski rounded-rectangle formulation
+ * that handles the four corner quadrants with per-corner circle-vs-circle
+ * sub-tests.
+ */
+function sweepCircleVsRectangle(moving, deltaX, deltaY, target) {
+    const r = moving.radius;
+    // Expanded target: grow each side by the circle radius
+    const expanded = new Rectangle(target.x - r, target.y - r, target.width + r * 2, target.height + r * 2);
+    // Treat the circle centre as a zero-sized moving box
+    const centreBox = new Rectangle(moving.x, moving.y, 0, 0);
+    return sweepRectangle(centreBox, deltaX, deltaY, expanded);
+}
+// ---------------------------------------------------------------------------
+// sweepCircleVsCircle — quadratic equation
+// ---------------------------------------------------------------------------
+/**
+ * Swept circle vs. stationary circle.
+ *
+ * Solves `|(moving.centre + delta*t) − target.centre|² = (r1+r2)²` for t,
+ * yielding a quadratic.  Returns the smaller root if it is in [0, 1].
+ *
+ * Already-overlapping case: returns `{ t: 0 }` with the normal pointing from
+ * target → moving (or an arbitrary normal if both centres coincide).
+ */
+function sweepCircleVsCircle(moving, deltaX, deltaY, target) {
+    const dx = moving.x - target.x;
+    const dy = moving.y - target.y;
+    const r = moving.radius + target.radius;
+    const a = deltaX * deltaX + deltaY * deltaY;
+    const b = 2 * (dx * deltaX + dy * deltaY);
+    const c = dx * dx + dy * dy - r * r;
+    // Already overlapping at start
+    if (c <= 0) {
+        const dist = Math.sqrt(dx * dx + dy * dy);
+        const normalX = dist > 0 ? dx / dist : 1;
+        const normalY = dist > 0 ? dy / dist : 0;
+        return { t: 0, x: moving.x, y: moving.y, normalX, normalY };
+    }
+    // No movement
+    if (a === 0) {
+        return null;
+    }
+    const disc = b * b - 4 * a * c;
+    if (disc < 0) {
+        return null;
+    }
+    const t = (-b - Math.sqrt(disc)) / (2 * a);
+    if (t < 0 || t > 1) {
+        return null;
+    }
+    const hitX = moving.x + deltaX * t;
+    const hitY = moving.y + deltaY * t;
+    // Normal points from target centre → hit circle centre
+    const normalX = (hitX - target.x) / r;
+    const normalY = (hitY - target.y) / r;
+    return { t, x: hitX, y: hitY, normalX, normalY };
+}
+// ---------------------------------------------------------------------------
+// Batch helpers — sweep a shape against multiple targets
+// ---------------------------------------------------------------------------
+/**
+ * Returns the earliest `SweptHit` against an array of rectangle targets, or
+ * `null` if none are hit.
+ *
+ * Optimisation: before testing each target individually the swept AABB of the
+ * moving rectangle is computed once; targets whose AABB does not overlap the
+ * swept AABB are skipped.
+ */
+function sweepRectangleAgainst(moving, deltaX, deltaY, targets) {
+    if (targets.length === 0) {
+        return null;
+    }
+    // Swept AABB of the moving rectangle (broad-phase skip)
+    const sweptMinX = Math.min(moving.x, moving.x + deltaX);
+    const sweptMaxX = Math.max(moving.x + moving.width, moving.x + moving.width + deltaX);
+    const sweptMinY = Math.min(moving.y, moving.y + deltaY);
+    const sweptMaxY = Math.max(moving.y + moving.height, moving.y + moving.height + deltaY);
+    let earliest = null;
+    for (const target of targets) {
+        // Broad-phase: skip if swept AABB doesn't overlap target AABB
+        if (sweptMaxX <= target.x
+            || sweptMinX >= target.x + target.width
+            || sweptMaxY <= target.y
+            || sweptMinY >= target.y + target.height) {
+            continue;
+        }
+        const hit = sweepRectangle(moving, deltaX, deltaY, target);
+        if (hit !== null && (earliest === null || hit.t < earliest.t)) {
+            earliest = hit;
+        }
+    }
+    return earliest;
+}
+/**
+ * Returns the earliest `SweptHit` against an array of circle targets, or
+ * `null` if none are hit.
+ *
+ * Optimisation: the swept AABB of the moving circle is computed once and used
+ * to skip targets that cannot possibly be reached.
+ */
+function sweepCircleAgainst(moving, deltaX, deltaY, targets) {
+    if (targets.length === 0) {
+        return null;
+    }
+    // Swept AABB of the moving circle
+    const sweptMinX = Math.min(moving.x, moving.x + deltaX) - moving.radius;
+    const sweptMaxX = Math.max(moving.x, moving.x + deltaX) + moving.radius;
+    const sweptMinY = Math.min(moving.y, moving.y + deltaY) - moving.radius;
+    const sweptMaxY = Math.max(moving.y, moving.y + deltaY) + moving.radius;
+    let earliest = null;
+    for (const target of targets) {
+        // Broad-phase: skip if swept AABB doesn't overlap target's AABB
+        if (sweptMaxX <= target.x - target.radius
+            || sweptMinX >= target.x + target.radius
+            || sweptMaxY <= target.y - target.radius
+            || sweptMinY >= target.y + target.radius) {
+            continue;
+        }
+        const hit = sweepCircleVsCircle(moving, deltaX, deltaY, target);
+        if (hit !== null && (earliest === null || hit.t < earliest.t)) {
+            earliest = hit;
+        }
+    }
+    return earliest;
+}
+// ---------------------------------------------------------------------------
+// substepSweep — generic fallback iterator
+// ---------------------------------------------------------------------------
+/**
+ * Generator that yields evenly-spaced position snapshots along a movement
+ * vector so the caller can run their own discrete intersection check at each
+ * step.  Useful for arbitrary shape pairs that lack a closed-form swept test.
+ *
+ * `maxStepSize` controls the step granularity — smaller values produce more
+ * accurate detection but more iterations.  Use the smallest dimension of the
+ * smaller collider as a sensible default.
+ *
+ * Always yields at least 2 snapshots (t=0 and t=1), even for zero-length
+ * deltas.
+ */
+function* substepSweep(fromX, fromY, deltaX, deltaY, maxStepSize) {
+    const length = Math.hypot(deltaX, deltaY);
+    const stepCount = Math.max(1, Math.ceil(length / maxStepSize));
+    for (let i = 0; i <= stepCount; i++) {
+        const t = i / stepCount;
+        yield { x: fromX + deltaX * t, y: fromY + deltaY * t, t };
+    }
+}
+
 class ColorAffector {
     _fromColor;
     _toColor;
@@ -18289,5 +18988,5 @@ class IndexedDbStore {
     }
 }
 
-export { AbstractAssetFactory, AbstractMedia, AbstractWebGl2BatchedRenderer, AbstractWebGl2Renderer, AbstractWebGpuRenderer, AnimatedSprite, Application, ApplicationStatus, ArcadeStickGamepadMapping, AudioAnalyser, BinaryFactory, BlendModes, BlurFilter, Bounds, BufferTypes, BufferUsage, BundleLoadError, CacheFirstStrategy, CallbackRenderPass, Capabilities, ChannelOffset, ChannelSize, Circle, Clock, CollisionType, Color, ColorAffector, ColorFilter, Container, Drawable, DynamicGlyphAtlas, Ellipse, FactoryRegistry, Filter, Flags, FontFactory, ForceAffector, GameCubeGamepadMapping, Gamepad, GamepadChannel, GamepadControl, GamepadMapping, GamepadMappingFamily, GamepadPromptLayouts, GenericDualAnalogGamepadMapping, Graphics, ImageFactory, IndexedDbDatabase, IndexedDbStore, Input, InputManager, Interval, JoyConLeftGamepadMapping, JoyConRightGamepadMapping, Json, JsonFactory, Keyboard, Line, Loader, Matrix, Mesh, Music, MusicFactory, NetworkOnlyStrategy, ObservableSize, ObservableVector, Particle, ParticleOptions, ParticleSystem, PlayStationGamepadMapping, Pointer, PointerState, PointerStateFlag, PolarVector, Polygon, Quadtree, Random, Rectangle, RenderBackendType, RenderNode, RenderTarget, RenderTargetPass, RenderTexture, RendererRegistry, RenderingPrimitives, Sampler, ScaleAffector, ScaleModes, Scene, SceneManager, SceneNode, Segment, Shader, ShaderAttribute, ShaderPrimitives, ShaderUniform, Signal, Size, Sound, SoundFactory, Sprite, SpriteFlags, Spritesheet, SteamControllerGamepadMapping, SvgAsset, SvgFactory, SwitchProGamepadMapping, Text, TextAsset, TextFactory, TextStyle, Texture, TextureFactory, Time, Timer, TorqueAffector, UniversalEmitter, Vector, Video, VideoFactory, View, ViewFlags, VoronoiRegion, VttAsset, VttFactory, WasmFactory, WebGl2Backend, WebGl2MeshRenderer, WebGl2ParticleRenderer, WebGl2RenderBuffer, WebGl2ShaderBlock, WebGl2SpriteRenderer, WebGl2VertexArrayObject, WebGpuBackend, WebGpuMeshRenderer, WebGpuParticleRenderer, WebGpuSpriteRenderer, WrapModes, XboxGamepadMapping, bezierCurveTo, buildCircle, buildEllipse, buildLine, buildPath, buildPolygon, buildRectangle, buildStar, builtInGamepadDefinitions, canvasSourceToDataUrl, clamp, createRenderStats, createWebGl2ShaderProgram, decodeAudioData, defineAssetManifest, degreesPerRadian, degreesToRadians, determineMimeType, emptyArrayBuffer, getAudioContext, getCanvasSourceSize, getCollisionCircleCircle, getCollisionCircleRectangle, getCollisionPolygonCircle, getCollisionRectangleRectangle, getCollisionSat, getDistance, getOfflineAudioContext, getPreciseTime, getTextureSourceSize, getVoronoiRegion$1 as getVoronoiRegion, getWebGpuBlendState, hours, inRange, intersectionCircleCircle, intersectionCircleEllipse, intersectionCirclePoly, intersectionEllipseEllipse, intersectionEllipsePoly, intersectionLineCircle, intersectionLineEllipse, intersectionLineLine, intersectionLinePoly, intersectionLineRect, intersectionPointCircle, intersectionPointEllipse, intersectionPointLine, intersectionPointPoint, intersectionPointPoly, intersectionPointRect, intersectionPolyPoly, intersectionRectCircle, intersectionRectEllipse, intersectionRectPoly, intersectionRectRect, intersectionSat, isAudioContextReady, isPowerOfTwo, layoutText, lerp, matchesIds, maxPointers, milliseconds, minutes, noop$1 as noop, normalizeIds, onAudioContextReady, parseGamepadDescriptor, pointerSlotSize, quadraticCurveTo, radiansPerDegree, radiansToDegrees, rand, removeArrayItems, resetRenderStats, resolveDefinition, resolveGamepadDefinition, seconds, sign, stopEvent, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio, tau, trimRotation, webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl2PrimitiveTypeNames };
+export { AbstractAssetFactory, AbstractMedia, AbstractWebGl2BatchedRenderer, AbstractWebGl2Renderer, AbstractWebGpuRenderer, AnimatedSprite, Application, ApplicationStatus, ArcadeStickGamepadMapping, AudioAnalyser, BinaryFactory, BlendModes, BlurFilter, Bounds, BufferTypes, BufferUsage, BundleLoadError, CacheFirstStrategy, CallbackRenderPass, Capabilities, ChannelOffset, ChannelSize, Circle, Clock, CollisionType, Color, ColorAffector, ColorFilter, Container, Drawable, DynamicGlyphAtlas, Ease, Ellipse, FactoryRegistry, Filter, Flags, FontFactory, ForceAffector, GameCubeGamepadMapping, Gamepad, GamepadChannel, GamepadControl, GamepadMapping, GamepadMappingFamily, GamepadPromptLayouts, GenericDualAnalogGamepadMapping, Graphics, ImageFactory, IndexedDbDatabase, IndexedDbStore, Input, InputManager, Interval, JoyConLeftGamepadMapping, JoyConRightGamepadMapping, Json, JsonFactory, Keyboard, Line, Loader, Matrix, Mesh, Music, MusicFactory, NetworkOnlyStrategy, ObservableSize, ObservableVector, Particle, ParticleOptions, ParticleSystem, PlayStationGamepadMapping, Pointer, PointerState, PointerStateFlag, PolarVector, Polygon, Quadtree, Random, Rectangle, RenderBackendType, RenderNode, RenderTarget, RenderTargetPass, RenderTexture, RendererRegistry, RenderingPrimitives, Sampler, ScaleAffector, ScaleModes, Scene, SceneManager, SceneNode, Segment, Shader, ShaderAttribute, ShaderPrimitives, ShaderUniform, Signal, Size, Sound, SoundFactory, Sprite, SpriteFlags, Spritesheet, SteamControllerGamepadMapping, SvgAsset, SvgFactory, SwitchProGamepadMapping, Text, TextAsset, TextFactory, TextStyle, Texture, TextureFactory, Time, Timer, TorqueAffector, Tween, TweenManager, TweenState, UniversalEmitter, Vector, Video, VideoFactory, View, ViewFlags, VoronoiRegion, VttAsset, VttFactory, WasmFactory, WebGl2Backend, WebGl2MeshRenderer, WebGl2ParticleRenderer, WebGl2RenderBuffer, WebGl2ShaderBlock, WebGl2SpriteRenderer, WebGl2VertexArrayObject, WebGpuBackend, WebGpuMeshRenderer, WebGpuParticleRenderer, WebGpuSpriteRenderer, WrapModes, XboxGamepadMapping, bezierCurveTo, buildCircle, buildEllipse, buildLine, buildPath, buildPolygon, buildRectangle, buildStar, builtInGamepadDefinitions, canvasSourceToDataUrl, clamp, createRenderStats, createWebGl2ShaderProgram, decodeAudioData, defineAssetManifest, degreesPerRadian, degreesToRadians, determineMimeType, emptyArrayBuffer, getAudioContext, getCanvasSourceSize, getCollisionCircleCircle, getCollisionCircleRectangle, getCollisionPolygonCircle, getCollisionRectangleRectangle, getCollisionSat, getDistance, getOfflineAudioContext, getPreciseTime, getTextureSourceSize, getVoronoiRegion$1 as getVoronoiRegion, getWebGpuBlendState, hours, inRange, intersectionCircleCircle, intersectionCircleEllipse, intersectionCirclePoly, intersectionEllipseEllipse, intersectionEllipsePoly, intersectionLineCircle, intersectionLineEllipse, intersectionLineLine, intersectionLinePoly, intersectionLineRect, intersectionPointCircle, intersectionPointEllipse, intersectionPointLine, intersectionPointPoint, intersectionPointPoly, intersectionPointRect, intersectionPolyPoly, intersectionRectCircle, intersectionRectEllipse, intersectionRectPoly, intersectionRectRect, intersectionSat, isAudioContextReady, isPowerOfTwo, layoutText, lerp, matchesIds, maxPointers, milliseconds, minutes, noop$1 as noop, normalizeIds, onAudioContextReady, parseGamepadDescriptor, pointerSlotSize, quadraticCurveTo, radiansPerDegree, radiansToDegrees, rand, removeArrayItems, resetRenderStats, resolveDefinition, resolveGamepadDefinition, seconds, sign, stopEvent, substepSweep, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio, sweepCircleAgainst, sweepCircleVsCircle, sweepCircleVsRectangle, sweepRectangle, sweepRectangleAgainst, tau, trimRotation, webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl2PrimitiveTypeNames };
 //# sourceMappingURL=exo.esm.js.map