@codexo/exojs 0.6.9 → 0.6.11

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;
@@ -706,7 +1151,7 @@ const trimRotation = (degrees) => {
 const degreesToRadians = (degree) => degree * radiansPerDegree;
 const radiansToDegrees = (radian) => radian * degreesPerRadian;
 const clamp = (value, min, max) => Math.min(max, Math.max(min, value));
-const sign$1 = (value) => (value && (value < 0 ? -1 : 1));
+const sign = (value) => (value && (value < 0 ? -1 : 1));
 const lerp = (startValue, endValue, ratio) => (((1 - ratio) * startValue) + (ratio * endValue));
 const isPowerOfTwo = (value) => ((value !== 0) && ((value & (value - 1)) === 0));
 const inRange = (value, min, max) => (value >= Math.min(min, max) && value <= Math.max(min, max));
@@ -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();
@@ -15452,636 +15900,166 @@ class Input {
     }
 }
 
-function earcut(data, holeIndices, dim = 2) {
-
-    const hasHoles = holeIndices && holeIndices.length;
-    const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
-    let outerNode = linkedList(data, 0, outerLen, dim, true);
-    const triangles = [];
-
-    if (!outerNode || outerNode.next === outerNode.prev) return triangles;
-
-    let minX, minY, invSize;
-
-    if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
-
-    // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
-    if (data.length > 80 * dim) {
-        minX = data[0];
-        minY = data[1];
-        let maxX = minX;
-        let maxY = minY;
-
-        for (let i = dim; i < outerLen; i += dim) {
-            const x = data[i];
-            const y = data[i + 1];
-            if (x < minX) minX = x;
-            if (y < minY) minY = y;
-            if (x > maxX) maxX = x;
-            if (y > maxY) maxY = y;
-        }
-
-        // minX, minY and invSize are later used to transform coords into integers for z-order calculation
-        invSize = Math.max(maxX - minX, maxY - minY);
-        invSize = invSize !== 0 ? 32767 / invSize : 0;
-    }
-
-    earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
-
-    return triangles;
-}
-
-// create a circular doubly linked list from polygon points in the specified winding order
-function linkedList(data, start, end, dim, clockwise) {
-    let last;
-
-    if (clockwise === (signedArea(data, start, end, dim) > 0)) {
-        for (let i = start; i < end; i += dim) last = insertNode(i / dim | 0, data[i], data[i + 1], last);
-    } else {
-        for (let i = end - dim; i >= start; i -= dim) last = insertNode(i / dim | 0, data[i], data[i + 1], last);
-    }
-
-    if (last && equals(last, last.next)) {
-        removeNode(last);
-        last = last.next;
-    }
-
-    return last;
-}
-
-// eliminate colinear or duplicate points
-function filterPoints(start, end) {
-    if (!start) return start;
-    if (!end) end = start;
-
-    let p = start,
-        again;
-    do {
-        again = false;
-
-        if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
-            removeNode(p);
-            p = end = p.prev;
-            if (p === p.next) break;
-            again = true;
-
-        } else {
-            p = p.next;
-        }
-    } while (again || p !== end);
-
-    return end;
-}
-
-// main ear slicing loop which triangulates a polygon (given as a linked list)
-function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
-    if (!ear) return;
-
-    // interlink polygon nodes in z-order
-    if (!pass && invSize) indexCurve(ear, minX, minY, invSize);
-
-    let stop = ear;
-
-    // iterate through ears, slicing them one by one
-    while (ear.prev !== ear.next) {
-        const prev = ear.prev;
-        const next = ear.next;
-
-        if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
-            triangles.push(prev.i, ear.i, next.i); // cut off the triangle
-
-            removeNode(ear);
-
-            // skipping the next vertex leads to less sliver triangles
-            ear = next.next;
-            stop = next.next;
-
-            continue;
-        }
-
-        ear = next;
-
-        // if we looped through the whole remaining polygon and can't find any more ears
-        if (ear === stop) {
-            // try filtering points and slicing again
-            if (!pass) {
-                earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
-
-            // if this didn't work, try curing all small self-intersections locally
-            } else if (pass === 1) {
-                ear = cureLocalIntersections(filterPoints(ear), triangles);
-                earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
-
-            // as a last resort, try splitting the remaining polygon into two
-            } else if (pass === 2) {
-                splitEarcut(ear, triangles, dim, minX, minY, invSize);
+/**
+ * Triangulate a simple 2D polygon by ear-clipping.
+ *
+ * Input: `vertices` is a flat sequence of (x, y) pairs (length must be even,
+ * minimum 6 = 3 vertices). Polygon may be CW or CCW; the algorithm normalises
+ * to CCW internally.
+ *
+ * Output: a `Uint32Array` of indices in groups of 3 (per triangle), referencing
+ * vertex positions (the i-th vertex spans `vertices[2*i], vertices[2*i + 1]`).
+ *
+ * Polygons that are degenerate (all collinear), zero-area, or self-intersecting
+ * may produce incomplete output but must not throw or hang.
+ *
+ * @param vertices flat (x, y) pairs
+ * @returns triangle index list (length is multiple of 3)
+ */
+function triangulate(vertices) {
+    const n = vertices.length >> 1;
+    if (n < 3) {
+        return new Uint32Array(0);
+    }
+    if (n === 3) {
+        // Return in CCW order; swap if input triangle is CW.
+        const ax = vertices[0], ay = vertices[1];
+        const bx = vertices[2], by = vertices[3];
+        const cx = vertices[4], cy = vertices[5];
+        return isCcwTriangle(ax, ay, bx, by, cx, cy)
+            ? new Uint32Array([0, 1, 2])
+            : new Uint32Array([2, 1, 0]);
+    }
+    // Build doubly-linked list of vertex indices.
+    const prev = new Uint32Array(n);
+    const next = new Uint32Array(n);
+    for (let i = 0; i < n; i++) {
+        prev[i] = (i + n - 1) % n;
+        next[i] = (i + 1) % n;
+    }
+    // Normalise to CCW: compute signed area; if negative (CW), reverse the list.
+    if (signedArea(vertices) < 0) {
+        for (let i = 0; i < n; i++) {
+            const tmp = prev[i];
+            prev[i] = next[i];
+            next[i] = tmp;
+        }
+    }
+    const maxTriangles = n - 2;
+    const out = new Uint32Array(maxTriangles * 3);
+    let outIdx = 0;
+    let remaining = n;
+    let current = 0;
+    // Ear-clipping: at most O(n^2) iterations; bail after one full pass finds no ear.
+    while (remaining > 3) {
+        // Try each remaining vertex as a potential ear, one full pass at a time.
+        let earFound = false;
+        const passStart = current;
+        do {
+            const p = prev[current];
+            const nx = next[current];
+            const v = current;
+            const ax = vertices[p * 2], ay = vertices[p * 2 + 1];
+            const bx = vertices[v * 2], by = vertices[v * 2 + 1];
+            const cx = vertices[nx * 2], cy = vertices[nx * 2 + 1];
+            if (isCcwTriangle(ax, ay, bx, by, cx, cy) && isEar(vertices, prev, next, p, v, nx)) {
+                // Emit triangle (prev, v, next).
+                out[outIdx++] = p;
+                out[outIdx++] = v;
+                out[outIdx++] = nx;
+                // Remove v from the list.
+                next[p] = nx;
+                prev[nx] = p;
+                remaining--;
+                earFound = true;
+                current = nx;
+                break;
             }
-
+            current = next[current];
+        } while (current !== passStart);
+        if (!earFound) {
+            // Degenerate polygon: no ear found in a full pass; bail out.
             break;
         }
     }
-}
-
-// check whether a polygon node forms a valid ear with adjacent nodes
-function isEar(ear) {
-    const a = ear.prev,
-        b = ear,
-        c = ear.next;
-
-    if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
-
-    // now make sure we don't have other points inside the potential ear
-    const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
-
-    // triangle bbox
-    const x0 = Math.min(ax, bx, cx),
-        y0 = Math.min(ay, by, cy),
-        x1 = Math.max(ax, bx, cx),
-        y1 = Math.max(ay, by, cy);
-
-    let p = c.next;
-    while (p !== a) {
-        if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 &&
-            pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) &&
-            area(p.prev, p, p.next) >= 0) return false;
-        p = p.next;
-    }
-
-    return true;
-}
-
-function isEarHashed(ear, minX, minY, invSize) {
-    const a = ear.prev,
-        b = ear,
-        c = ear.next;
-
-    if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
-
-    const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
-
-    // triangle bbox
-    const x0 = Math.min(ax, bx, cx),
-        y0 = Math.min(ay, by, cy),
-        x1 = Math.max(ax, bx, cx),
-        y1 = Math.max(ay, by, cy);
-
-    // z-order range for the current triangle bbox;
-    const minZ = zOrder(x0, y0, minX, minY, invSize),
-        maxZ = zOrder(x1, y1, minX, minY, invSize);
-
-    let p = ear.prevZ,
-        n = ear.nextZ;
-
-    // look for points inside the triangle in both directions
-    while (p && p.z >= minZ && n && n.z <= maxZ) {
-        if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&
-            pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
-        p = p.prevZ;
-
-        if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&
-            pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
-        n = n.nextZ;
-    }
-
-    // look for remaining points in decreasing z-order
-    while (p && p.z >= minZ) {
-        if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&
-            pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
-        p = p.prevZ;
-    }
-
-    // look for remaining points in increasing z-order
-    while (n && n.z <= maxZ) {
-        if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&
-            pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
-        n = n.nextZ;
-    }
-
-    return true;
-}
-
-// go through all polygon nodes and cure small local self-intersections
-function cureLocalIntersections(start, triangles) {
-    let p = start;
-    do {
-        const a = p.prev,
-            b = p.next.next;
-
-        if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
-
-            triangles.push(a.i, p.i, b.i);
-
-            // remove two nodes involved
-            removeNode(p);
-            removeNode(p.next);
-
-            p = start = b;
+    // Emit the final triangle if exactly 3 vertices remain.
+    // Emit in CCW order (the linked-list direction may be CW after prior clips on concave polygons).
+    if (remaining === 3) {
+        const pa = prev[current];
+        const nc = next[current];
+        const ax = vertices[pa * 2], ay = vertices[pa * 2 + 1];
+        const bx = vertices[current * 2], by = vertices[current * 2 + 1];
+        const cx = vertices[nc * 2], cy = vertices[nc * 2 + 1];
+        if (isCcwTriangle(ax, ay, bx, by, cx, cy)) {
+            out[outIdx++] = pa;
+            out[outIdx++] = current;
+            out[outIdx++] = nc;
         }
-        p = p.next;
-    } while (p !== start);
-
-    return filterPoints(p);
-}
-
-// try splitting polygon into two and triangulate them independently
-function splitEarcut(start, triangles, dim, minX, minY, invSize) {
-    // look for a valid diagonal that divides the polygon into two
-    let a = start;
-    do {
-        let b = a.next.next;
-        while (b !== a.prev) {
-            if (a.i !== b.i && isValidDiagonal(a, b)) {
-                // split the polygon in two by the diagonal
-                let c = splitPolygon(a, b);
-
-                // filter colinear points around the cuts
-                a = filterPoints(a, a.next);
-                c = filterPoints(c, c.next);
-
-                // run earcut on each half
-                earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
-                earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
-                return;
-            }
-            b = b.next;
-        }
-        a = a.next;
-    } while (a !== start);
-}
-
-// link every hole into the outer loop, producing a single-ring polygon without holes
-function eliminateHoles(data, holeIndices, outerNode, dim) {
-    const queue = [];
-
-    for (let i = 0, len = holeIndices.length; i < len; i++) {
-        const start = holeIndices[i] * dim;
-        const end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
-        const list = linkedList(data, start, end, dim, false);
-        if (list === list.next) list.steiner = true;
-        queue.push(getLeftmost(list));
-    }
-
-    queue.sort(compareXYSlope);
-
-    // process holes from left to right
-    for (let i = 0; i < queue.length; i++) {
-        outerNode = eliminateHole(queue[i], outerNode);
-    }
-
-    return outerNode;
-}
-
-function compareXYSlope(a, b) {
-    let result = a.x - b.x;
-    // when the left-most point of 2 holes meet at a vertex, sort the holes counterclockwise so that when we find
-    // the bridge to the outer shell is always the point that they meet at.
-    if (result === 0) {
-        result = a.y - b.y;
-        if (result === 0) {
-            const aSlope = (a.next.y - a.y) / (a.next.x - a.x);
-            const bSlope = (b.next.y - b.y) / (b.next.x - b.x);
-            result = aSlope - bSlope;
+        else {
+            out[outIdx++] = nc;
+            out[outIdx++] = current;
+            out[outIdx++] = pa;
         }
     }
-    return result;
-}
-
-// find a bridge between vertices that connects hole with an outer ring and link it
-function eliminateHole(hole, outerNode) {
-    const bridge = findHoleBridge(hole, outerNode);
-    if (!bridge) {
-        return outerNode;
-    }
-
-    const bridgeReverse = splitPolygon(bridge, hole);
-
-    // filter collinear points around the cuts
-    filterPoints(bridgeReverse, bridgeReverse.next);
-    return filterPoints(bridge, bridge.next);
+    return out.subarray(0, outIdx);
 }
-
-// David Eberly's algorithm for finding a bridge between hole and outer polygon
-function findHoleBridge(hole, outerNode) {
-    let p = outerNode;
-    const hx = hole.x;
-    const hy = hole.y;
-    let qx = -Infinity;
-    let m;
-
-    // find a segment intersected by a ray from the hole's leftmost point to the left;
-    // segment's endpoint with lesser x will be potential connection point
-    // unless they intersect at a vertex, then choose the vertex
-    if (equals(hole, p)) return p;
-    do {
-        if (equals(hole, p.next)) return p.next;
-        else if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
-            const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
-            if (x <= hx && x > qx) {
-                qx = x;
-                m = p.x < p.next.x ? p : p.next;
-                if (x === hx) return m; // hole touches outer segment; pick leftmost endpoint
-            }
-        }
-        p = p.next;
-    } while (p !== outerNode);
-
-    if (!m) return null;
-
-    // look for points inside the triangle of hole point, segment intersection and endpoint;
-    // if there are no points found, we have a valid connection;
-    // otherwise choose the point of the minimum angle with the ray as connection point
-
-    const stop = m;
-    const mx = m.x;
-    const my = m.y;
-    let tanMin = Infinity;
-
-    p = m;
-
-    do {
-        if (hx >= p.x && p.x >= mx && hx !== p.x &&
-                pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
-
-            const tan = Math.abs(hy - p.y) / (hx - p.x); // tangential
-
-            if (locallyInside(p, hole) &&
-                (tan < tanMin || (tan === tanMin && (p.x > m.x || (p.x === m.x && sectorContainsSector(m, p)))))) {
-                m = p;
-                tanMin = tan;
-            }
-        }
-
-        p = p.next;
-    } while (p !== stop);
-
-    return m;
+/** Shoelace signed area. Positive = CCW (mathematical orientation), negative = CW. */
+function signedArea(vertices) {
+    const n = vertices.length >> 1;
+    let area = 0;
+    for (let i = 0; i < n; i++) {
+        const j = (i + 1) % n;
+        const x0 = vertices[i * 2];
+        const y0 = vertices[i * 2 + 1];
+        const x1 = vertices[j * 2];
+        const y1 = vertices[j * 2 + 1];
+        area += (x0 * y1) - (x1 * y0);
+    }
+    return area; // Positive = CCW, negative = CW.
 }
-
-// whether sector in vertex m contains sector in vertex p in the same coordinates
-function sectorContainsSector(m, p) {
-    return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+/**
+ * Returns true if the triangle (a, b, c) has a counter-clockwise (CCW) winding.
+ * Uses the cross product of (b-a) × (c-a); positive = CCW.
+ */
+function isCcwTriangle(ax, ay, bx, by, cx, cy) {
+    return ((bx - ax) * (cy - ay) - (by - ay) * (cx - ax)) > 0;
 }
-
-// interlink polygon nodes in z-order
-function indexCurve(start, minX, minY, invSize) {
-    let p = start;
-    do {
-        if (p.z === 0) p.z = zOrder(p.x, p.y, minX, minY, invSize);
-        p.prevZ = p.prev;
-        p.nextZ = p.next;
-        p = p.next;
-    } while (p !== start);
-
-    p.prevZ.nextZ = null;
-    p.prevZ = null;
-
-    sortLinked(p);
+/**
+ * Returns true if point (px, py) lies strictly inside triangle (a, b, c).
+ * Uses sign-of-cross-products. Boundary points (including corners) return false.
+ */
+function pointInTriangle(px, py, ax, ay, bx, by, cx, cy) {
+    const d1 = (px - bx) * (ay - by) - (ax - bx) * (py - by);
+    const d2 = (px - cx) * (by - cy) - (bx - cx) * (py - cy);
+    const d3 = (px - ax) * (cy - ay) - (cx - ax) * (py - ay);
+    const hasNeg = (d1 < 0) || (d2 < 0) || (d3 < 0);
+    const hasPos = (d1 > 0) || (d2 > 0) || (d3 > 0);
+    // Strictly inside: all same sign and none are exactly zero (exclude boundary).
+    return !(hasNeg && hasPos) && (d1 !== 0) && (d2 !== 0) && (d3 !== 0);
 }
-
-// Simon Tatham's linked list merge sort algorithm
-// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
-function sortLinked(list) {
-    let numMerges;
-    let inSize = 1;
-
-    do {
-        let p = list;
-        let e;
-        list = null;
-        let tail = null;
-        numMerges = 0;
-
-        while (p) {
-            numMerges++;
-            let q = p;
-            let pSize = 0;
-            for (let i = 0; i < inSize; i++) {
-                pSize++;
-                q = q.nextZ;
-                if (!q) break;
-            }
-            let qSize = inSize;
-
-            while (pSize > 0 || (qSize > 0 && q)) {
-
-                if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
-                    e = p;
-                    p = p.nextZ;
-                    pSize--;
-                } else {
-                    e = q;
-                    q = q.nextZ;
-                    qSize--;
-                }
-
-                if (tail) tail.nextZ = e;
-                else list = e;
-
-                e.prevZ = tail;
-                tail = e;
+/**
+ * Returns true if vertex v is an ear: the triangle (prevIdx, v, nextIdx) contains
+ * no other polygon vertex strictly inside it.
+ */
+function isEar(vertices, prev, next, prevIdx, v, nextIdx) {
+    const ax = vertices[prevIdx * 2], ay = vertices[prevIdx * 2 + 1];
+    const bx = vertices[v * 2], by = vertices[v * 2 + 1];
+    const cx = vertices[nextIdx * 2], cy = vertices[nextIdx * 2 + 1];
+    // Walk all remaining vertices and check if any lie strictly inside the ear triangle.
+    // Skip the three ear vertices themselves — they can never be "inside" by strict test,
+    // but we exclude them explicitly for clarity and to avoid floating-point edge cases.
+    let node = next[nextIdx];
+    while (node !== prevIdx) {
+        if (node !== v) {
+            const px = vertices[node * 2];
+            const py = vertices[node * 2 + 1];
+            if (pointInTriangle(px, py, ax, ay, bx, by, cx, cy)) {
+                return false;
             }
-
-            p = q;
         }
-
-        tail.nextZ = null;
-        inSize *= 2;
-
-    } while (numMerges > 1);
-
-    return list;
-}
-
-// z-order of a point given coords and inverse of the longer side of data bbox
-function zOrder(x, y, minX, minY, invSize) {
-    // coords are transformed into non-negative 15-bit integer range
-    x = (x - minX) * invSize | 0;
-    y = (y - minY) * invSize | 0;
-
-    x = (x | (x << 8)) & 0x00FF00FF;
-    x = (x | (x << 4)) & 0x0F0F0F0F;
-    x = (x | (x << 2)) & 0x33333333;
-    x = (x | (x << 1)) & 0x55555555;
-
-    y = (y | (y << 8)) & 0x00FF00FF;
-    y = (y | (y << 4)) & 0x0F0F0F0F;
-    y = (y | (y << 2)) & 0x33333333;
-    y = (y | (y << 1)) & 0x55555555;
-
-    return x | (y << 1);
-}
-
-// find the leftmost node of a polygon ring
-function getLeftmost(start) {
-    let p = start,
-        leftmost = start;
-    do {
-        if (p.x < leftmost.x || (p.x === leftmost.x && p.y < leftmost.y)) leftmost = p;
-        p = p.next;
-    } while (p !== start);
-
-    return leftmost;
-}
-
-// check if a point lies within a convex triangle
-function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
-    return (cx - px) * (ay - py) >= (ax - px) * (cy - py) &&
-           (ax - px) * (by - py) >= (bx - px) * (ay - py) &&
-           (bx - px) * (cy - py) >= (cx - px) * (by - py);
-}
-
-// check if a point lies within a convex triangle but false if its equal to the first point of the triangle
-function pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, px, py) {
-    return !(ax === px && ay === py) && pointInTriangle(ax, ay, bx, by, cx, cy, px, py);
-}
-
-// check if a diagonal between two polygon nodes is valid (lies in polygon interior)
-function isValidDiagonal(a, b) {
-    return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && // doesn't intersect other edges
-           (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
-            (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors
-            equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0); // special zero-length case
-}
-
-// signed area of a triangle
-function area(p, q, r) {
-    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
-}
-
-// check if two points are equal
-function equals(p1, p2) {
-    return p1.x === p2.x && p1.y === p2.y;
-}
-
-// check if two segments intersect
-function intersects(p1, q1, p2, q2) {
-    const o1 = sign(area(p1, q1, p2));
-    const o2 = sign(area(p1, q1, q2));
-    const o3 = sign(area(p2, q2, p1));
-    const o4 = sign(area(p2, q2, q1));
-
-    if (o1 !== o2 && o3 !== o4) return true; // general case
-
-    if (o1 === 0 && onSegment(p1, p2, q1)) return true; // p1, q1 and p2 are collinear and p2 lies on p1q1
-    if (o2 === 0 && onSegment(p1, q2, q1)) return true; // p1, q1 and q2 are collinear and q2 lies on p1q1
-    if (o3 === 0 && onSegment(p2, p1, q2)) return true; // p2, q2 and p1 are collinear and p1 lies on p2q2
-    if (o4 === 0 && onSegment(p2, q1, q2)) return true; // p2, q2 and q1 are collinear and q1 lies on p2q2
-
-    return false;
-}
-
-// for collinear points p, q, r, check if point q lies on segment pr
-function onSegment(p, q, r) {
-    return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
-}
-
-function sign(num) {
-    return num > 0 ? 1 : num < 0 ? -1 : 0;
-}
-
-// check if a polygon diagonal intersects any polygon segments
-function intersectsPolygon(a, b) {
-    let p = a;
-    do {
-        if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&
-                intersects(p, p.next, a, b)) return true;
-        p = p.next;
-    } while (p !== a);
-
-    return false;
-}
-
-// check if a polygon diagonal is locally inside the polygon
-function locallyInside(a, b) {
-    return area(a.prev, a, a.next) < 0 ?
-        area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 :
-        area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
-}
-
-// check if the middle point of a polygon diagonal is inside the polygon
-function middleInside(a, b) {
-    let p = a;
-    let inside = false;
-    const px = (a.x + b.x) / 2;
-    const py = (a.y + b.y) / 2;
-    do {
-        if (((p.y > py) !== (p.next.y > py)) && p.next.y !== p.y &&
-                (px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x))
-            inside = !inside;
-        p = p.next;
-    } while (p !== a);
-
-    return inside;
-}
-
-// link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;
-// if one belongs to the outer ring and another to a hole, it merges it into a single ring
-function splitPolygon(a, b) {
-    const a2 = createNode(a.i, a.x, a.y),
-        b2 = createNode(b.i, b.x, b.y),
-        an = a.next,
-        bp = b.prev;
-
-    a.next = b;
-    b.prev = a;
-
-    a2.next = an;
-    an.prev = a2;
-
-    b2.next = a2;
-    a2.prev = b2;
-
-    bp.next = b2;
-    b2.prev = bp;
-
-    return b2;
-}
-
-// create a node and optionally link it with previous one (in a circular doubly linked list)
-function insertNode(i, x, y, last) {
-    const p = createNode(i, x, y);
-
-    if (!last) {
-        p.prev = p;
-        p.next = p;
-
-    } else {
-        p.next = last.next;
-        p.prev = last;
-        last.next.prev = p;
-        last.next = p;
+        node = next[node];
     }
-    return p;
-}
-
-function removeNode(p) {
-    p.next.prev = p.prev;
-    p.prev.next = p.next;
-
-    if (p.prevZ) p.prevZ.nextZ = p.nextZ;
-    if (p.nextZ) p.nextZ.prevZ = p.prevZ;
-}
-
-function createNode(i, x, y) {
-    return {
-        i, // vertex index in coordinates array
-        x, y, // vertex coordinates
-        prev: null, // previous and next vertex nodes in a polygon ring
-        next: null,
-        z: 0, // z-order curve value
-        prevZ: null, // previous and next nodes in z-order
-        nextZ: null,
-        steiner: false // indicates whether this is a steiner point
-    };
-}
-
-function signedArea(data, start, end, dim) {
-    let sum = 0;
-    for (let i = start, j = end - dim; i < end; i += dim) {
-        sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
-        j = i;
-    }
-    return sum;
+    return true;
 }
 
 const buildLine = (startX, startY, endX, endY, width) => {
@@ -16285,13 +16263,13 @@ const buildPolygon = (points) => {
         throw new Error('At least three X/Y pairs are required to build a polygon.');
     }
     const length = points.length / 2;
-    const triangles = earcut(points, [], 2);
+    const triangles = triangulate(points);
     const vertices = new Float32Array(points.length);
     for (let i = 0; i < length; i++) {
         vertices[i * 2] = points[i * 2];
         vertices[(i * 2) + 1] = points[(i * 2) + 1];
     }
-    const indices = triangles ? new Uint16Array(triangles) : new Uint16Array(0);
+    const indices = new Uint16Array(triangles);
     return { vertices, indices, points };
 };
 const buildRectangle = (x, y, width, height) => {
@@ -18759,5 +18737,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$1 as 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, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio, tau, trimRotation, webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl2PrimitiveTypeNames };
 //# sourceMappingURL=exo.esm.js.map