@codexo/exojs 2.1.1 → 2.1.2

package/dist/exo.global.js

@@ -3,6 +3,8 @@ var Exo = (function (exports) {
 
     let temp$9 = null;
     class Size {
+        _width;
+        _height;
         constructor(width = 0, height = 0) {
             this._width = width;
             this._height = height;
@@ -59,6 +61,7 @@ var Exo = (function (exports) {
         destroy() {
             // todo - check if destroy is needed
         }
+        static zero = new Size(0, 0);
         static get temp() {
             if (temp$9 === null) {
                 temp$9 = new Size();
@@ -66,15 +69,14 @@ var Exo = (function (exports) {
             return temp$9;
         }
     }
-    Size.zero = new Size(0, 0);
 
     const limit = (2 ** 32) - 1;
     class Random {
+        _state = new Uint32Array(624);
+        _iteration = 0;
+        _seed = 0;
+        _value = 0;
         constructor(seed = Date.now()) {
-            this._state = new Uint32Array(624);
-            this._iteration = 0;
-            this._seed = 0;
-            this._value = 0;
             this.setSeed(seed);
             this._twist();
         }
@@ -140,6 +142,7 @@ var Exo = (function (exports) {
 
     let temp$8 = null;
     class Time {
+        _milliseconds;
         constructor(time = 0, factor = Time.milliseconds) {
             this._milliseconds = time * factor;
         }
@@ -225,6 +228,15 @@ var Exo = (function (exports) {
         destroy() {
             // todo - check if destroy is needed
         }
+        static milliseconds = 1;
+        static seconds = 1000;
+        static minutes = 60000;
+        static hours = 3600000;
+        static zero = new Time(0);
+        static oneMillisecond = new Time(1);
+        static oneSecond = new Time(1, Time.seconds);
+        static oneMinute = new Time(1, Time.minutes);
+        static oneHour = new Time(1, Time.hours);
         static get temp() {
             if (temp$8 === null) {
                 temp$8 = new Time();
@@ -232,15 +244,6 @@ var Exo = (function (exports) {
             return temp$8;
         }
     }
-    Time.milliseconds = 1;
-    Time.seconds = 1000;
-    Time.minutes = 60000;
-    Time.hours = 3600000;
-    Time.zero = new Time(0);
-    Time.oneMillisecond = new Time(1);
-    Time.oneSecond = new Time(1, Time.seconds);
-    Time.oneMinute = new Time(1, Time.minutes);
-    Time.oneHour = new Time(1, Time.hours);
 
     const codecNotSupportedPattern = /^no$/;
     let internalAudioElement = null;
@@ -373,9 +376,10 @@ var Exo = (function (exports) {
     };
 
     class Clock {
+        _startTime;
+        _elapsedTime = new Time(0);
+        _running = false;
         constructor(startTime = Time.zero, autoStart = false) {
-            this._elapsedTime = new Time(0);
-            this._running = false;
             this._startTime = startTime.clone();
             if (autoStart) {
                 this.start();
@@ -435,9 +439,7 @@ var Exo = (function (exports) {
     }
 
     class Signal {
-        constructor() {
-            this._bindings = new Array();
-        }
+        _bindings = new Array();
         get bindings() {
             return this._bindings;
         }
@@ -478,7 +480,11 @@ var Exo = (function (exports) {
         }
         dispatch(...params) {
             if (this._bindings.length) {
-                for (const binding of this._bindings) {
+                // Snapshot bindings because handlers may mutate the array mid-dispatch
+                // (notably `once()` wrappers that remove themselves), which would otherwise
+                // cause the iterator to skip the binding shifted into the vacated slot.
+                const bindings = this._bindings.slice();
+                for (const binding of bindings) {
                     if (binding.handler.call(binding.context, ...params) === false) {
                         break;
                     }
@@ -494,6 +500,12 @@ var Exo = (function (exports) {
     const tau = Math.PI * 2;
     const radiansPerDegree = Math.PI / 180;
     const degreesPerRadian = 180 / Math.PI;
+    exports.VoronoiRegion = void 0;
+    (function (VoronoiRegion) {
+        VoronoiRegion[VoronoiRegion["left"] = -1] = "left";
+        VoronoiRegion[VoronoiRegion["middle"] = 0] = "middle";
+        VoronoiRegion[VoronoiRegion["right"] = 1] = "right";
+    })(exports.VoronoiRegion || (exports.VoronoiRegion = {}));
     const trimRotation = (degrees) => {
         const rotation = degrees % 360;
         return rotation < 0 ? rotation + 360 : rotation;
@@ -501,7 +513,7 @@ var Exo = (function (exports) {
     const degreesToRadians = (degree) => degree * radiansPerDegree;
     const radiansToDegrees = (radian) => radian * degreesPerRadian;
     const clamp = (value, min, max) => Math.min(max, Math.max(min, value));
-    const sign = (value) => (value && (value < 0 ? -1 : 1));
+    const sign$1 = (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));
@@ -512,13 +524,13 @@ var Exo = (function (exports) {
     };
     const bezierCurveTo = (fromX, fromY, cpX1, cpY1, cpX2, cpY2, toX, toY, path = [], len = 20) => {
         path.push(fromX, fromY);
-        for (let i = 1, j = 0, dt1 = 0, dt2 = 0, dt3 = 0, t2 = 0, t3 = 0; i <= len; i++) {
-            j = i / len;
-            dt1 = (1 - j);
-            dt2 = dt1 * dt1;
-            dt3 = dt2 * dt1;
-            t2 = j * j;
-            t3 = t2 * j;
+        for (let i = 1; i <= len; i++) {
+            const j = i / len;
+            const dt1 = (1 - j);
+            const dt2 = dt1 * dt1;
+            const dt3 = dt2 * dt1;
+            const t2 = j * j;
+            const t3 = t2 * j;
             path.push((dt3 * fromX) + (3 * dt2 * j * cpX1) + (3 * dt1 * t2 * cpX2) + (t3 * toX), (dt3 * fromY) + (3 * dt2 * j * cpY1) + (3 * dt1 * t2 * cpY2) + (t3 * toY));
         }
         return path;
@@ -533,20 +545,24 @@ var Exo = (function (exports) {
     const getVoronoiRegion$1 = (line, point) => {
         const product = point.dot(line.x, line.y);
         if (product < 0) {
-            return -1 /* VoronoiRegion.left */;
+            return exports.VoronoiRegion.left;
         }
         else if (product > line.lengthSq) {
-            return 1 /* VoronoiRegion.right */;
+            return exports.VoronoiRegion.right;
         }
         else {
-            return 0 /* VoronoiRegion.middle */;
+            return exports.VoronoiRegion.middle;
         }
     };
 
     class Color {
+        _r;
+        _g;
+        _b;
+        _a;
+        _rgba = null;
+        _array = null;
         constructor(r = 0, g = 0, b = 0, a = 1) {
-            this._rgba = null;
-            this._array = null;
             this._r = r & 255;
             this._g = g & 255;
             this._b = b & 255;
@@ -656,149 +672,149 @@ var Exo = (function (exports) {
                 this._array = null;
             }
         }
+        static aliceBlue = new Color(240, 248, 255, 1);
+        static antiqueWhite = new Color(250, 235, 215, 1);
+        static aqua = new Color(0, 255, 255, 1);
+        static aquamarine = new Color(127, 255, 212, 1);
+        static azure = new Color(240, 255, 255, 1);
+        static beige = new Color(245, 245, 220, 1);
+        static bisque = new Color(255, 228, 196, 1);
+        static black = new Color(0, 0, 0, 1);
+        static blanchedAlmond = new Color(255, 235, 205, 1);
+        static blue = new Color(0, 0, 255, 1);
+        static blueViolet = new Color(138, 43, 226, 1);
+        static brown = new Color(165, 42, 42, 1);
+        static burlyWood = new Color(222, 184, 135, 1);
+        static cadetBlue = new Color(95, 158, 160, 1);
+        static chartreuse = new Color(127, 255, 0, 1);
+        static chocolate = new Color(210, 105, 30, 1);
+        static coral = new Color(255, 127, 80, 1);
+        static cornflowerBlue = new Color(100, 149, 237, 1);
+        static cornsilk = new Color(255, 248, 220, 1);
+        static crimson = new Color(220, 20, 60, 1);
+        static cyan = new Color(0, 255, 255, 1);
+        static darkBlue = new Color(0, 0, 139, 1);
+        static darkCyan = new Color(0, 139, 139, 1);
+        static darkGoldenrod = new Color(184, 134, 11, 1);
+        static darkGray = new Color(169, 169, 169, 1);
+        static darkGreen = new Color(0, 100, 0, 1);
+        static darkKhaki = new Color(189, 183, 107, 1);
+        static darkMagenta = new Color(139, 0, 139, 1);
+        static darkOliveGreen = new Color(85, 107, 47, 1);
+        static darkOrange = new Color(255, 140, 0, 1);
+        static darkOrchid = new Color(153, 50, 204, 1);
+        static darkRed = new Color(139, 0, 0, 1);
+        static darkSalmon = new Color(233, 150, 122, 1);
+        static darkSeaGreen = new Color(143, 188, 139, 1);
+        static darkSlateBlue = new Color(72, 61, 139, 1);
+        static darkSlateGray = new Color(47, 79, 79, 1);
+        static darkTurquoise = new Color(0, 206, 209, 1);
+        static darkViolet = new Color(148, 0, 211, 1);
+        static deepPink = new Color(255, 20, 147, 1);
+        static deepSkyBlue = new Color(0, 191, 255, 1);
+        static dimGray = new Color(105, 105, 105, 1);
+        static dodgerBlue = new Color(30, 144, 255, 1);
+        static firebrick = new Color(178, 34, 34, 1);
+        static floralWhite = new Color(255, 250, 240, 1);
+        static forestGreen = new Color(34, 139, 34, 1);
+        static fuchsia = new Color(255, 0, 255, 1);
+        static gainsboro = new Color(220, 220, 220, 1);
+        static ghostWhite = new Color(248, 248, 255, 1);
+        static gold = new Color(255, 215, 0, 1);
+        static goldenrod = new Color(218, 165, 32, 1);
+        static gray = new Color(128, 128, 128, 1);
+        static green = new Color(0, 128, 0, 1);
+        static greenYellow = new Color(173, 255, 47, 1);
+        static honeydew = new Color(240, 255, 240, 1);
+        static hotPink = new Color(255, 105, 180, 1);
+        static indianRed = new Color(205, 92, 92, 1);
+        static indigo = new Color(75, 0, 130, 1);
+        static ivory = new Color(255, 255, 240, 1);
+        static khaki = new Color(240, 230, 140, 1);
+        static lavender = new Color(230, 230, 250, 1);
+        static lavenderBlush = new Color(255, 240, 245, 1);
+        static lawnGreen = new Color(124, 252, 0, 1);
+        static lemonChiffon = new Color(255, 250, 205, 1);
+        static lightBlue = new Color(173, 216, 230, 1);
+        static lightCoral = new Color(240, 128, 128, 1);
+        static lightCyan = new Color(224, 255, 255, 1);
+        static lightGoldenrodYellow = new Color(250, 250, 210, 1);
+        static lightGray = new Color(211, 211, 211, 1);
+        static lightGreen = new Color(144, 238, 144, 1);
+        static lightPink = new Color(255, 182, 193, 1);
+        static lightSalmon = new Color(255, 160, 122, 1);
+        static lightSeaGreen = new Color(32, 178, 170, 1);
+        static lightSkyBlue = new Color(135, 206, 250, 1);
+        static lightSlateGray = new Color(119, 136, 153, 1);
+        static lightSteelBlue = new Color(176, 196, 222, 1);
+        static lightYellow = new Color(255, 255, 224, 1);
+        static lime = new Color(0, 255, 0, 1);
+        static limeGreen = new Color(50, 205, 50, 1);
+        static linen = new Color(250, 240, 230, 1);
+        static magenta = new Color(255, 0, 255, 1);
+        static maroon = new Color(128, 0, 0, 1);
+        static mediumAquamarine = new Color(102, 205, 170, 1);
+        static mediumBlue = new Color(0, 0, 205, 1);
+        static mediumOrchid = new Color(186, 85, 211, 1);
+        static mediumPurple = new Color(147, 112, 219, 1);
+        static mediumSeaGreen = new Color(60, 179, 113, 1);
+        static mediumSlateBlue = new Color(123, 104, 238, 1);
+        static mediumSpringGreen = new Color(0, 250, 154, 1);
+        static mediumTurquoise = new Color(72, 209, 204, 1);
+        static mediumVioletRed = new Color(199, 21, 133, 1);
+        static midnightBlue = new Color(25, 25, 112, 1);
+        static mintCream = new Color(245, 255, 250, 1);
+        static mistyRose = new Color(255, 228, 225, 1);
+        static moccasin = new Color(255, 228, 181, 1);
+        static navajoWhite = new Color(255, 222, 173, 1);
+        static navy = new Color(0, 0, 128, 1);
+        static oldLace = new Color(253, 245, 230, 1);
+        static olive = new Color(128, 128, 0, 1);
+        static oliveDrab = new Color(107, 142, 35, 1);
+        static orange = new Color(255, 165, 0, 1);
+        static orangeRed = new Color(255, 69, 0, 1);
+        static orchid = new Color(218, 112, 214, 1);
+        static paleGoldenrod = new Color(238, 232, 170, 1);
+        static paleGreen = new Color(152, 251, 152, 1);
+        static paleTurquoise = new Color(175, 238, 238, 1);
+        static paleVioletRed = new Color(219, 112, 147, 1);
+        static papayaWhip = new Color(255, 239, 213, 1);
+        static peachPuff = new Color(255, 218, 185, 1);
+        static peru = new Color(205, 133, 63, 1);
+        static pink = new Color(255, 192, 203, 1);
+        static plum = new Color(221, 160, 221, 1);
+        static powderBlue = new Color(176, 224, 230, 1);
+        static purple = new Color(128, 0, 128, 1);
+        static red = new Color(255, 0, 0, 1);
+        static rosyBrown = new Color(188, 143, 143, 1);
+        static royalBlue = new Color(65, 105, 225, 1);
+        static saddleBrown = new Color(139, 69, 19, 1);
+        static salmon = new Color(250, 128, 114, 1);
+        static sandyBrown = new Color(244, 164, 96, 1);
+        static seaGreen = new Color(46, 139, 87, 1);
+        static seaShell = new Color(255, 245, 238, 1);
+        static sienna = new Color(160, 82, 45, 1);
+        static silver = new Color(192, 192, 192, 1);
+        static skyBlue = new Color(135, 206, 235, 1);
+        static slateBlue = new Color(106, 90, 205, 1);
+        static slateGray = new Color(112, 128, 144, 1);
+        static snow = new Color(255, 250, 250, 1);
+        static springGreen = new Color(0, 255, 127, 1);
+        static steelBlue = new Color(70, 130, 180, 1);
+        static tan = new Color(210, 180, 140, 1);
+        static teal = new Color(0, 128, 128, 1);
+        static thistle = new Color(216, 191, 216, 1);
+        static tomato = new Color(255, 99, 71, 1);
+        static transparentBlack = new Color(0, 0, 0, 0);
+        static transparentWhite = new Color(255, 255, 255, 0);
+        static turquoise = new Color(64, 224, 208, 1);
+        static violet = new Color(238, 130, 238, 1);
+        static wheat = new Color(245, 222, 179, 1);
+        static white = new Color(255, 255, 255, 1);
+        static whiteSmoke = new Color(245, 245, 245, 1);
+        static yellow = new Color(255, 255, 0, 1);
+        static yellowGreen = new Color(154, 205, 50, 1);
     }
-    Color.aliceBlue = new Color(240, 248, 255, 1);
-    Color.antiqueWhite = new Color(250, 235, 215, 1);
-    Color.aqua = new Color(0, 255, 255, 1);
-    Color.aquamarine = new Color(127, 255, 212, 1);
-    Color.azure = new Color(240, 255, 255, 1);
-    Color.beige = new Color(245, 245, 220, 1);
-    Color.bisque = new Color(255, 228, 196, 1);
-    Color.black = new Color(0, 0, 0, 1);
-    Color.blanchedAlmond = new Color(255, 235, 205, 1);
-    Color.blue = new Color(0, 0, 255, 1);
-    Color.blueViolet = new Color(138, 43, 226, 1);
-    Color.brown = new Color(165, 42, 42, 1);
-    Color.burlyWood = new Color(222, 184, 135, 1);
-    Color.cadetBlue = new Color(95, 158, 160, 1);
-    Color.chartreuse = new Color(127, 255, 0, 1);
-    Color.chocolate = new Color(210, 105, 30, 1);
-    Color.coral = new Color(255, 127, 80, 1);
-    Color.cornflowerBlue = new Color(100, 149, 237, 1);
-    Color.cornsilk = new Color(255, 248, 220, 1);
-    Color.crimson = new Color(220, 20, 60, 1);
-    Color.cyan = new Color(0, 255, 255, 1);
-    Color.darkBlue = new Color(0, 0, 139, 1);
-    Color.darkCyan = new Color(0, 139, 139, 1);
-    Color.darkGoldenrod = new Color(184, 134, 11, 1);
-    Color.darkGray = new Color(169, 169, 169, 1);
-    Color.darkGreen = new Color(0, 100, 0, 1);
-    Color.darkKhaki = new Color(189, 183, 107, 1);
-    Color.darkMagenta = new Color(139, 0, 139, 1);
-    Color.darkOliveGreen = new Color(85, 107, 47, 1);
-    Color.darkOrange = new Color(255, 140, 0, 1);
-    Color.darkOrchid = new Color(153, 50, 204, 1);
-    Color.darkRed = new Color(139, 0, 0, 1);
-    Color.darkSalmon = new Color(233, 150, 122, 1);
-    Color.darkSeaGreen = new Color(143, 188, 139, 1);
-    Color.darkSlateBlue = new Color(72, 61, 139, 1);
-    Color.darkSlateGray = new Color(47, 79, 79, 1);
-    Color.darkTurquoise = new Color(0, 206, 209, 1);
-    Color.darkViolet = new Color(148, 0, 211, 1);
-    Color.deepPink = new Color(255, 20, 147, 1);
-    Color.deepSkyBlue = new Color(0, 191, 255, 1);
-    Color.dimGray = new Color(105, 105, 105, 1);
-    Color.dodgerBlue = new Color(30, 144, 255, 1);
-    Color.firebrick = new Color(178, 34, 34, 1);
-    Color.floralWhite = new Color(255, 250, 240, 1);
-    Color.forestGreen = new Color(34, 139, 34, 1);
-    Color.fuchsia = new Color(255, 0, 255, 1);
-    Color.gainsboro = new Color(220, 220, 220, 1);
-    Color.ghostWhite = new Color(248, 248, 255, 1);
-    Color.gold = new Color(255, 215, 0, 1);
-    Color.goldenrod = new Color(218, 165, 32, 1);
-    Color.gray = new Color(128, 128, 128, 1);
-    Color.green = new Color(0, 128, 0, 1);
-    Color.greenYellow = new Color(173, 255, 47, 1);
-    Color.honeydew = new Color(240, 255, 240, 1);
-    Color.hotPink = new Color(255, 105, 180, 1);
-    Color.indianRed = new Color(205, 92, 92, 1);
-    Color.indigo = new Color(75, 0, 130, 1);
-    Color.ivory = new Color(255, 255, 240, 1);
-    Color.khaki = new Color(240, 230, 140, 1);
-    Color.lavender = new Color(230, 230, 250, 1);
-    Color.lavenderBlush = new Color(255, 240, 245, 1);
-    Color.lawnGreen = new Color(124, 252, 0, 1);
-    Color.lemonChiffon = new Color(255, 250, 205, 1);
-    Color.lightBlue = new Color(173, 216, 230, 1);
-    Color.lightCoral = new Color(240, 128, 128, 1);
-    Color.lightCyan = new Color(224, 255, 255, 1);
-    Color.lightGoldenrodYellow = new Color(250, 250, 210, 1);
-    Color.lightGray = new Color(211, 211, 211, 1);
-    Color.lightGreen = new Color(144, 238, 144, 1);
-    Color.lightPink = new Color(255, 182, 193, 1);
-    Color.lightSalmon = new Color(255, 160, 122, 1);
-    Color.lightSeaGreen = new Color(32, 178, 170, 1);
-    Color.lightSkyBlue = new Color(135, 206, 250, 1);
-    Color.lightSlateGray = new Color(119, 136, 153, 1);
-    Color.lightSteelBlue = new Color(176, 196, 222, 1);
-    Color.lightYellow = new Color(255, 255, 224, 1);
-    Color.lime = new Color(0, 255, 0, 1);
-    Color.limeGreen = new Color(50, 205, 50, 1);
-    Color.linen = new Color(250, 240, 230, 1);
-    Color.magenta = new Color(255, 0, 255, 1);
-    Color.maroon = new Color(128, 0, 0, 1);
-    Color.mediumAquamarine = new Color(102, 205, 170, 1);
-    Color.mediumBlue = new Color(0, 0, 205, 1);
-    Color.mediumOrchid = new Color(186, 85, 211, 1);
-    Color.mediumPurple = new Color(147, 112, 219, 1);
-    Color.mediumSeaGreen = new Color(60, 179, 113, 1);
-    Color.mediumSlateBlue = new Color(123, 104, 238, 1);
-    Color.mediumSpringGreen = new Color(0, 250, 154, 1);
-    Color.mediumTurquoise = new Color(72, 209, 204, 1);
-    Color.mediumVioletRed = new Color(199, 21, 133, 1);
-    Color.midnightBlue = new Color(25, 25, 112, 1);
-    Color.mintCream = new Color(245, 255, 250, 1);
-    Color.mistyRose = new Color(255, 228, 225, 1);
-    Color.moccasin = new Color(255, 228, 181, 1);
-    Color.navajoWhite = new Color(255, 222, 173, 1);
-    Color.navy = new Color(0, 0, 128, 1);
-    Color.oldLace = new Color(253, 245, 230, 1);
-    Color.olive = new Color(128, 128, 0, 1);
-    Color.oliveDrab = new Color(107, 142, 35, 1);
-    Color.orange = new Color(255, 165, 0, 1);
-    Color.orangeRed = new Color(255, 69, 0, 1);
-    Color.orchid = new Color(218, 112, 214, 1);
-    Color.paleGoldenrod = new Color(238, 232, 170, 1);
-    Color.paleGreen = new Color(152, 251, 152, 1);
-    Color.paleTurquoise = new Color(175, 238, 238, 1);
-    Color.paleVioletRed = new Color(219, 112, 147, 1);
-    Color.papayaWhip = new Color(255, 239, 213, 1);
-    Color.peachPuff = new Color(255, 218, 185, 1);
-    Color.peru = new Color(205, 133, 63, 1);
-    Color.pink = new Color(255, 192, 203, 1);
-    Color.plum = new Color(221, 160, 221, 1);
-    Color.powderBlue = new Color(176, 224, 230, 1);
-    Color.purple = new Color(128, 0, 128, 1);
-    Color.red = new Color(255, 0, 0, 1);
-    Color.rosyBrown = new Color(188, 143, 143, 1);
-    Color.royalBlue = new Color(65, 105, 225, 1);
-    Color.saddleBrown = new Color(139, 69, 19, 1);
-    Color.salmon = new Color(250, 128, 114, 1);
-    Color.sandyBrown = new Color(244, 164, 96, 1);
-    Color.seaGreen = new Color(46, 139, 87, 1);
-    Color.seaShell = new Color(255, 245, 238, 1);
-    Color.sienna = new Color(160, 82, 45, 1);
-    Color.silver = new Color(192, 192, 192, 1);
-    Color.skyBlue = new Color(135, 206, 235, 1);
-    Color.slateBlue = new Color(106, 90, 205, 1);
-    Color.slateGray = new Color(112, 128, 144, 1);
-    Color.snow = new Color(255, 250, 250, 1);
-    Color.springGreen = new Color(0, 255, 127, 1);
-    Color.steelBlue = new Color(70, 130, 180, 1);
-    Color.tan = new Color(210, 180, 140, 1);
-    Color.teal = new Color(0, 128, 128, 1);
-    Color.thistle = new Color(216, 191, 216, 1);
-    Color.tomato = new Color(255, 99, 71, 1);
-    Color.transparentBlack = new Color(0, 0, 0, 0);
-    Color.transparentWhite = new Color(255, 255, 255, 0);
-    Color.turquoise = new Color(64, 224, 208, 1);
-    Color.violet = new Color(238, 130, 238, 1);
-    Color.wheat = new Color(245, 222, 179, 1);
-    Color.white = new Color(255, 255, 255, 1);
-    Color.whiteSmoke = new Color(245, 245, 245, 1);
-    Color.yellow = new Color(255, 255, 0, 1);
-    Color.yellowGreen = new Color(154, 205, 50, 1);
 
     exports.BlendModes = void 0;
     (function (BlendModes) {
@@ -980,6 +996,9 @@ var Exo = (function (exports) {
     }
 
     class ObservableVector extends AbstractVector {
+        _x;
+        _y;
+        _callback;
         constructor(callback, x = 0, y = 0) {
             super();
             this._x = x;
@@ -1053,8 +1072,17 @@ var Exo = (function (exports) {
      * | e | f | z |
      */
     class Matrix {
+        a;
+        b;
+        x;
+        c;
+        d;
+        y;
+        e;
+        f;
+        z;
+        _array = null;
         constructor(a = 1, b = 0, x = 0, c = 0, d = 1, y = 0, e = 0, f = 0, z = 1) {
-            this._array = null;
             this.a = a;
             this.b = b;
             this.x = x;
@@ -1158,6 +1186,7 @@ var Exo = (function (exports) {
                 this._array = null;
             }
         }
+        static identity = new Matrix(1, 0, 0, 0, 1, 0, 0, 0, 1);
         static get temp() {
             if (temp$7 === null) {
                 temp$7 = new Matrix();
@@ -1165,14 +1194,13 @@ var Exo = (function (exports) {
             return temp$7;
         }
     }
-    Matrix.identity = new Matrix(1, 0, 0, 0, 1, 0, 0, 0, 1);
 
     class Flags {
+        _value = 0;
         get value() {
             return this._value;
         }
         constructor(...flags) {
-            this._value = 0;
             if (flags.length) {
                 this.push(...flags);
             }
@@ -1217,16 +1245,14 @@ var Exo = (function (exports) {
         TransformableFlags[TransformableFlags["TransformInverse"] = 16] = "TransformInverse";
     })(exports.TransformableFlags || (exports.TransformableFlags = {}));
     class Transformable {
-        constructor() {
-            this.flags = new Flags(exports.TransformableFlags.Transform);
-            this._transform = new Matrix();
-            this._position = new ObservableVector(this._setPositionDirty.bind(this), 0, 0);
-            this._scale = new ObservableVector(this._setScalingDirty.bind(this), 1, 1);
-            this._origin = new ObservableVector(this._setOriginDirty.bind(this), 0, 0);
-            this._rotation = 0;
-            this._sin = 0;
-            this._cos = 1;
-        }
+        flags = new Flags(exports.TransformableFlags.Transform);
+        _transform = new Matrix();
+        _position = new ObservableVector(this._setPositionDirty.bind(this), 0, 0);
+        _scale = new ObservableVector(this._setScalingDirty.bind(this), 1, 1);
+        _origin = new ObservableVector(this._setOriginDirty.bind(this), 0, 0);
+        _rotation = 0;
+        _sin = 0;
+        _cos = 1;
         get position() {
             return this._position;
         }
@@ -1343,6 +1369,8 @@ var Exo = (function (exports) {
 
     let temp$6 = null;
     class Interval {
+        min;
+        max;
         constructor(min = 0, max = min) {
             this.min = min;
             this.max = max;
@@ -1373,6 +1401,7 @@ var Exo = (function (exports) {
         destroy() {
             // todo - check if destroy is needed
         }
+        static zero = new Interval(0, 0);
         static get temp() {
             if (temp$6 === null) {
                 temp$6 = new Interval();
@@ -1380,7 +1409,17 @@ var Exo = (function (exports) {
             return temp$6;
         }
     }
-    Interval.zero = new Interval(0, 0);
+
+    exports.CollisionType = void 0;
+    (function (CollisionType) {
+        CollisionType[CollisionType["Point"] = 0] = "Point";
+        CollisionType[CollisionType["Line"] = 1] = "Line";
+        CollisionType[CollisionType["Rectangle"] = 2] = "Rectangle";
+        CollisionType[CollisionType["Circle"] = 3] = "Circle";
+        CollisionType[CollisionType["Ellipse"] = 4] = "Ellipse";
+        CollisionType[CollisionType["Polygon"] = 5] = "Polygon";
+        CollisionType[CollisionType["SceneNode"] = 6] = "SceneNode";
+    })(exports.CollisionType || (exports.CollisionType = {}));
 
     const epsilon = 1e-10;
     const getCurveSegments = (radiusA, radiusB = radiusA) => (Math.max(16, Math.ceil(Math.sqrt(Math.max(radiusA, radiusB)) * 8)));
@@ -1534,12 +1573,12 @@ var Exo = (function (exports) {
         const product = getDotProduct(pointX, pointY, lineX, lineY);
         const lengthSq = getVectorLengthSquared(lineX, lineY);
         if (product < 0) {
-            return -1 /* VoronoiRegion.left */;
+            return exports.VoronoiRegion.left;
         }
         if (product > lengthSq) {
-            return 1 /* VoronoiRegion.right */;
+            return exports.VoronoiRegion.right;
         }
-        return 0 /* VoronoiRegion.middle */;
+        return exports.VoronoiRegion.middle;
     };
 
     /**
@@ -1654,18 +1693,18 @@ var Exo = (function (exports) {
     const intersectionCircleCircle = ({ x: x1, y: y1, radius: r1 }, { x: x2, y: y2, radius: r2 }) => (getDistance(x1, y1, x2, y2) <= (r1 + r2));
     const intersectionCircleEllipse = (circle, ellipse) => (polygonsIntersect(buildCirclePoints(circle), buildEllipsePoints(ellipse)));
     const shouldExcludeLeftVoronoi = (circleX, circleY, prevPoint, prevEdge, pointX, pointY, radius, edgeX, edgeY) => {
-        if (getVoronoiRegion(edgeX, edgeY, pointX, pointY) !== -1 /* VoronoiRegion.left */) {
+        if (getVoronoiRegion(edgeX, edgeY, pointX, pointY) !== exports.VoronoiRegion.left) {
             return false;
         }
         const region = getVoronoiRegion(prevEdge.x, prevEdge.y, circleX - prevPoint.x, circleY - prevPoint.y);
-        return region === 1 /* VoronoiRegion.right */ && getVectorLength(pointX, pointY) > radius;
+        return region === exports.VoronoiRegion.right && getVectorLength(pointX, pointY) > radius;
     };
     const shouldExcludeRightVoronoi = (circleX, circleY, nextPoint, nextEdge, pointX, pointY, radius, edgeX, edgeY) => {
-        if (getVoronoiRegion(edgeX, edgeY, pointX, pointY) !== 1 /* VoronoiRegion.right */) {
+        if (getVoronoiRegion(edgeX, edgeY, pointX, pointY) !== exports.VoronoiRegion.right) {
             return false;
         }
         const region = getVoronoiRegion(nextEdge.x, nextEdge.y, circleX - nextPoint.x, circleY - nextPoint.y);
-        return region === -1 /* VoronoiRegion.left */ && getVectorLength(pointX, pointY) > radius;
+        return region === exports.VoronoiRegion.left && getVectorLength(pointX, pointY) > radius;
     };
     const shouldExcludeMiddleVoronoi = (pointX, pointY, radius, edgeX, edgeY) => {
         const normalX = edgeY;
@@ -1789,13 +1828,13 @@ var Exo = (function (exports) {
             if (pointDistanceA > radius) {
                 containsA = false;
             }
-            if (region === -1 /* VoronoiRegion.left */) {
+            if (region === exports.VoronoiRegion.left) {
                 const prev = points[i === 0 ? len - 1 : i - 1];
                 const edgeBx = pointA.x - prev.x;
                 const edgeBy = pointA.y - prev.y;
                 const positionBx = x - prev.x;
                 const positionBy = y - prev.y;
-                if (getVoronoiRegion(edgeBx, edgeBy, positionBx, positionBy) === 1 /* VoronoiRegion.right */) {
+                if (getVoronoiRegion(edgeBx, edgeBy, positionBx, positionBy) === exports.VoronoiRegion.right) {
                     if (pointDistanceA > radius) {
                         projection.destroy();
                         return null;
@@ -1808,14 +1847,14 @@ var Exo = (function (exports) {
                     containsB = false;
                 }
             }
-            else if (region === 1 /* VoronoiRegion.right */) {
+            else if (region === exports.VoronoiRegion.right) {
                 const next = points[(i + 2) % len];
                 const edgeBx = next.x - pointB.x;
                 const edgeBy = next.y - pointB.y;
                 const positionBx = x - pointB.x;
                 const positionBy = y - pointB.y;
                 const pointDistanceB = getVectorLength(positionBx, positionBy);
-                if (getVoronoiRegion(edgeBx, edgeBy, positionBx, positionBy) === -1 /* VoronoiRegion.left */) {
+                if (getVoronoiRegion(edgeBx, edgeBy, positionBx, positionBy) === exports.VoronoiRegion.left) {
                     if (pointDistanceB > radius) {
                         projection.destroy();
                         return null;
@@ -1934,10 +1973,12 @@ var Exo = (function (exports) {
     const noop = () => { };
     const tempPoint = new ObservableVector(noop);
     class Rectangle {
+        collisionType = exports.CollisionType.Rectangle;
+        _position;
+        _size;
+        _normals = null;
+        _normalsDirty = false;
         constructor(x = 0, y = x, width = 0, height = width) {
-            this.collisionType = 2 /* CollisionType.Rectangle */;
-            this._normals = null;
-            this._normalsDirty = false;
             this._position = new ObservableVector(() => {
                 this._normalsDirty = true;
             }, x, y);
@@ -2078,28 +2119,28 @@ var Exo = (function (exports) {
         }
         intersectsWith(target) {
             switch (target.collisionType) {
-                case 6 /* CollisionType.SceneNode */:
+                case exports.CollisionType.SceneNode:
                     return target.isAlignedBox
                         ? intersectionRectRect(this, target.getBounds())
                         : intersectionSat(this, target);
-                case 2 /* CollisionType.Rectangle */: return intersectionRectRect(this, target);
-                case 5 /* CollisionType.Polygon */: return intersectionRectPoly(this, target);
-                case 3 /* CollisionType.Circle */: return intersectionRectCircle(this, target);
-                case 4 /* CollisionType.Ellipse */: return intersectionRectEllipse(this, target);
-                case 1 /* CollisionType.Line */: return intersectionLineRect(target, this);
-                case 0 /* CollisionType.Point */: return intersectionPointRect(target, this);
+                case exports.CollisionType.Rectangle: return intersectionRectRect(this, target);
+                case exports.CollisionType.Polygon: return intersectionRectPoly(this, target);
+                case exports.CollisionType.Circle: return intersectionRectCircle(this, target);
+                case exports.CollisionType.Ellipse: return intersectionRectEllipse(this, target);
+                case exports.CollisionType.Line: return intersectionLineRect(target, this);
+                case exports.CollisionType.Point: return intersectionPointRect(target, this);
                 default: return false;
             }
         }
         collidesWith(target) {
             switch (target.collisionType) {
-                case 6 /* CollisionType.SceneNode */:
+                case exports.CollisionType.SceneNode:
                     return target.isAlignedBox
                         ? getCollisionRectangleRectangle(this, target.getBounds())
                         : getCollisionSat(this, target);
-                case 2 /* CollisionType.Rectangle */: return getCollisionRectangleRectangle(this, target);
-                case 5 /* CollisionType.Polygon */: return getCollisionSat(this, target);
-                case 3 /* CollisionType.Circle */: return getCollisionCircleRectangle(target, this, true);
+                case exports.CollisionType.Rectangle: return getCollisionRectangleRectangle(this, target);
+                case exports.CollisionType.Polygon: return getCollisionSat(this, target);
+                case exports.CollisionType.Circle: return getCollisionCircleRectangle(target, this, true);
                 // case CollisionType.Ellipse: return intersectionRectEllipse(this, target as Ellipse);
                 // case CollisionType.Line: return intersectionLineRect(target as Line, this);
                 // case CollisionType.Point: return intersectionPointRect(target as Vector, this);
@@ -2128,14 +2169,12 @@ var Exo = (function (exports) {
     }
 
     class Bounds {
-        constructor() {
-            this._minX = Infinity;
-            this._minY = Infinity;
-            this._maxX = -Infinity;
-            this._maxY = -Infinity;
-            this._dirty = true;
-            this._rect = new Rectangle();
-        }
+        _minX = Infinity;
+        _minY = Infinity;
+        _maxX = -Infinity;
+        _maxY = -Infinity;
+        _dirty = true;
+        _rect = new Rectangle();
         get minX() {
             return this._minX;
         }
@@ -2185,19 +2224,16 @@ var Exo = (function (exports) {
     }
 
     class SceneNode extends Transformable {
-        constructor() {
-            super(...arguments);
-            this.collisionType = 6 /* CollisionType.SceneNode */;
-            this._bounds = new Bounds();
-            this._visible = true;
-            this._globalTransform = new Matrix();
-            this._localBounds = new Rectangle();
-            this._anchor = new ObservableVector(this._updateOrigin.bind(this), 0, 0);
-            this._parentNode = null;
-            this._zIndex = 0;
-            this._childOrder = 0;
-            this._cullable = true;
-        }
+        collisionType = exports.CollisionType.SceneNode;
+        _bounds = new Bounds();
+        _visible = true;
+        _globalTransform = new Matrix();
+        _localBounds = new Rectangle();
+        _anchor = new ObservableVector(this._updateOrigin.bind(this), 0, 0);
+        _parentNode = null;
+        _zIndex = 0;
+        _childOrder = 0;
+        _cullable = true;
         get anchor() {
             return this._anchor;
         }
@@ -2302,13 +2338,13 @@ var Exo = (function (exports) {
                 return this.getBounds().intersectsWith(target);
             }
             switch (target.collisionType) {
-                case 6 /* CollisionType.SceneNode */: return intersectionSat(this, target);
-                case 2 /* CollisionType.Rectangle */: return intersectionSat(this, target);
-                case 5 /* CollisionType.Polygon */: return intersectionSat(this, target);
-                case 3 /* CollisionType.Circle */: return intersectionRectCircle(this.getBounds(), target);
-                case 4 /* CollisionType.Ellipse */: return intersectionRectEllipse(this.getBounds(), target);
-                case 1 /* CollisionType.Line */: return intersectionLineRect(target, this.getBounds());
-                case 0 /* CollisionType.Point */: return intersectionPointRect(target, this.getBounds());
+                case exports.CollisionType.SceneNode: return intersectionSat(this, target);
+                case exports.CollisionType.Rectangle: return intersectionSat(this, target);
+                case exports.CollisionType.Polygon: return intersectionSat(this, target);
+                case exports.CollisionType.Circle: return intersectionRectCircle(this.getBounds(), target);
+                case exports.CollisionType.Ellipse: return intersectionRectEllipse(this.getBounds(), target);
+                case exports.CollisionType.Line: return intersectionLineRect(target, this.getBounds());
+                case exports.CollisionType.Point: return intersectionPointRect(target, this.getBounds());
                 default: return false;
             }
         }
@@ -2317,10 +2353,10 @@ var Exo = (function (exports) {
                 return this.getBounds().collidesWith(target);
             }
             switch (target.collisionType) {
-                case 6 /* CollisionType.SceneNode */: return getCollisionSat(this, target);
-                case 2 /* CollisionType.Rectangle */: return getCollisionSat(this, target);
-                case 5 /* CollisionType.Polygon */: return getCollisionSat(this, target);
-                case 3 /* CollisionType.Circle */: return getCollisionSat(this, target);
+                case exports.CollisionType.SceneNode: return getCollisionSat(this, target);
+                case exports.CollisionType.Rectangle: return getCollisionSat(this, target);
+                case exports.CollisionType.Polygon: return getCollisionSat(this, target);
+                case exports.CollisionType.Circle: return getCollisionSat(this, target);
                 default: return null;
             }
         }
@@ -2351,6 +2387,7 @@ var Exo = (function (exports) {
     }
 
     class ObservableSize extends Size {
+        _callback;
         constructor(callback, width = 0, height = 0) {
             super(width, height);
             this._callback = callback;
@@ -2415,30 +2452,34 @@ var Exo = (function (exports) {
         ViewFlags[ViewFlags["VertexTint"] = 128] = "VertexTint";
     })(exports.ViewFlags || (exports.ViewFlags = {}));
     class View {
+        _center;
+        _size;
+        _viewport = new Rectangle(0, 0, 1, 1);
+        _transform = new Matrix();
+        _inverseTransform = new Matrix();
+        _bounds = new Bounds();
+        _flags = new Flags();
+        _rotation = 0;
+        _sin = 0;
+        _cos = 1;
+        _zoomLevel = 1;
+        _zoomBaseWidth;
+        _zoomBaseHeight;
+        _followTarget = null;
+        _followLerp = 1;
+        _followOffsetX = 0;
+        _followOffsetY = 0;
+        _boundsConstraint = null;
+        _shakeIntensity = 0;
+        _shakeDurationMs = 0;
+        _shakeElapsedMs = 0;
+        _shakeFrequency = 16;
+        _shakeDecay = true;
+        _shakePhase = 0;
+        _shakeOffsetX = 0;
+        _shakeOffsetY = 0;
+        _updateId = 0;
         constructor(centerX, centerY, width, height) {
-            this._viewport = new Rectangle(0, 0, 1, 1);
-            this._transform = new Matrix();
-            this._inverseTransform = new Matrix();
-            this._bounds = new Bounds();
-            this._flags = new Flags();
-            this._rotation = 0;
-            this._sin = 0;
-            this._cos = 1;
-            this._zoomLevel = 1;
-            this._followTarget = null;
-            this._followLerp = 1;
-            this._followOffsetX = 0;
-            this._followOffsetY = 0;
-            this._boundsConstraint = null;
-            this._shakeIntensity = 0;
-            this._shakeDurationMs = 0;
-            this._shakeElapsedMs = 0;
-            this._shakeFrequency = 16;
-            this._shakeDecay = true;
-            this._shakePhase = 0;
-            this._shakeOffsetX = 0;
-            this._shakeOffsetY = 0;
-            this._updateId = 0;
             this._center = new ObservableVector(this._setPositionDirty.bind(this), centerX, centerY);
             this._size = new ObservableSize(this._setScalingDirty.bind(this), width, height);
             this._zoomBaseWidth = width;
@@ -2753,9 +2794,11 @@ var Exo = (function (exports) {
 
     let temp$4 = null;
     class Vector extends AbstractVector {
+        collisionType = exports.CollisionType.Point;
+        x;
+        y;
         constructor(x = 0, y = 0) {
             super();
-            this.collisionType = 0 /* CollisionType.Point */;
             this.x = x;
             this.y = y;
         }
@@ -2769,13 +2812,13 @@ var Exo = (function (exports) {
         }
         intersectsWith(target) {
             switch (target.collisionType) {
-                case 6 /* CollisionType.SceneNode */: return intersectionPointRect(this, target.getBounds());
-                case 2 /* CollisionType.Rectangle */: return intersectionPointRect(this, target);
-                case 5 /* CollisionType.Polygon */: return intersectionPointPoly(this, target);
-                case 3 /* CollisionType.Circle */: return intersectionPointCircle(this, target);
-                case 4 /* CollisionType.Ellipse */: return intersectionPointEllipse(this, target);
-                case 1 /* CollisionType.Line */: return intersectionPointLine(this, target);
-                case 0 /* CollisionType.Point */: return intersectionPointPoint(this, target);
+                case exports.CollisionType.SceneNode: return intersectionPointRect(this, target.getBounds());
+                case exports.CollisionType.Rectangle: return intersectionPointRect(this, target);
+                case exports.CollisionType.Polygon: return intersectionPointPoly(this, target);
+                case exports.CollisionType.Circle: return intersectionPointCircle(this, target);
+                case exports.CollisionType.Ellipse: return intersectionPointEllipse(this, target);
+                case exports.CollisionType.Line: return intersectionPointLine(this, target);
+                case exports.CollisionType.Point: return intersectionPointPoint(this, target);
                 default: return false;
             }
         }
@@ -2805,6 +2848,8 @@ var Exo = (function (exports) {
             }
             return temp$4;
         }
+        static zero = new Vector(0, 0);
+        static one = new Vector(1, 1);
         static add(v1, v2) {
             return new Vector(v1.x + v2.x, v1.y + v2.y);
         }
@@ -2818,14 +2863,16 @@ var Exo = (function (exports) {
             return new Vector(v1.x / v2.x, v1.y / v2.y);
         }
     }
-    Vector.zero = new Vector(0, 0);
-    Vector.one = new Vector(1, 1);
 
     class RenderTarget {
+        _root;
+        _destroyListeners = new Set();
+        _version = 0;
+        _size;
+        _viewport = new Rectangle();
+        _defaultView;
+        _view;
         constructor(width, height, root = false) {
-            this._destroyListeners = new Set();
-            this._version = 0;
-            this._viewport = new Rectangle();
             this._size = new Size(width, height);
             this._root = root;
             this._defaultView = new View(width / 2, height / 2, width, height);
@@ -2920,10 +2967,22 @@ var Exo = (function (exports) {
     }
 
     class RenderTexture extends RenderTarget {
+        static defaultSamplerOptions = {
+            scaleMode: exports.ScaleModes.Linear,
+            wrapMode: exports.WrapModes.ClampToEdge,
+            premultiplyAlpha: true,
+            generateMipMap: false,
+            flipY: true,
+        };
+        _source = null;
+        _textureVersion = 0;
+        _scaleMode;
+        _wrapMode;
+        _premultiplyAlpha;
+        _generateMipMap;
+        _flipY;
         constructor(width, height, options) {
             super(width, height, false);
-            this._source = null;
-            this._textureVersion = 0;
             const { scaleMode, wrapMode, premultiplyAlpha, generateMipMap, flipY } = { ...RenderTexture.defaultSamplerOptions, ...options };
             this._scaleMode = scaleMode;
             this._wrapMode = wrapMode;
@@ -3023,15 +3082,12 @@ var Exo = (function (exports) {
             this._textureVersion++;
         }
     }
-    RenderTexture.defaultSamplerOptions = {
-        scaleMode: exports.ScaleModes.Linear,
-        wrapMode: exports.WrapModes.ClampToEdge,
-        premultiplyAlpha: true,
-        generateMipMap: false,
-        flipY: true,
-    };
 
     class RenderTargetPass {
+        _callback;
+        _target;
+        _view;
+        _clearColor;
         constructor(callback, options = {}) {
             this._callback = callback;
             this._target = options.target ?? null;
@@ -3058,17 +3114,15 @@ var Exo = (function (exports) {
 
     const isDestroyableFilter = (filter) => ('destroy' in filter && typeof filter.destroy === 'function');
     class RenderNode extends SceneNode {
-        constructor() {
-            super(...arguments);
-            this._filters = [];
-            this._cacheBounds = new Rectangle();
-            this._cacheSprite = null;
-            this._captureView = null;
-            this._mask = null;
-            this._cacheAsBitmap = false;
-            this._cacheDirty = true;
-            this._cacheTexture = null;
-        }
+        static _spriteFactory = null;
+        _filters = [];
+        _cacheBounds = new Rectangle();
+        _cacheSprite = null;
+        _captureView = null;
+        _mask = null;
+        _cacheAsBitmap = false;
+        _cacheDirty = true;
+        _cacheTexture = null;
         get filters() {
             return this._filters;
         }
@@ -3282,14 +3336,10 @@ var Exo = (function (exports) {
             return this._cacheSprite;
         }
     }
-    RenderNode._spriteFactory = null;
 
     class Drawable extends RenderNode {
-        constructor() {
-            super(...arguments);
-            this._tint = Color.white.clone();
-            this._blendMode = exports.BlendModes.Normal;
-        }
+        _tint = Color.white.clone();
+        _blendMode = exports.BlendModes.Normal;
         get tint() {
             return this._tint;
         }
@@ -3336,6 +3386,9 @@ var Exo = (function (exports) {
     }
 
     class DrawableShape extends Drawable {
+        geometry;
+        drawMode;
+        color;
         constructor(geometry, color, drawMode = exports.RenderingPrimitives.Triangles) {
             super();
             this.geometry = geometry;
@@ -3349,6 +3402,9 @@ var Exo = (function (exports) {
     }
 
     class Geometry {
+        vertices;
+        indices;
+        points;
         constructor({ vertices = [], indices = [], points = [], } = {}) {
             this.vertices = new Float32Array(vertices);
             this.indices = new Uint16Array(indices);
@@ -3374,47 +3430,15 @@ var Exo = (function (exports) {
     });
     const defaultFadeTransitionDuration = 220;
     class SceneManager {
+        _app;
+        _stack = [];
+        _transitionOverlay = new TransitionOverlayShape(createOverlayGeometry(), Color.black, exports.RenderingPrimitives.TriangleStrip);
+        _transition = null;
+        onChangeScene = new Signal();
+        onStartScene = new Signal();
+        onUpdateScene = new Signal();
+        onStopScene = new Signal();
         constructor(app) {
-            this._stack = [];
-            this._transitionOverlay = new TransitionOverlayShape(createOverlayGeometry(), Color.black, exports.RenderingPrimitives.TriangleStrip);
-            this._transition = null;
-            this.onChangeScene = new Signal();
-            this.onStartScene = new Signal();
-            this.onUpdateScene = new Signal();
-            this.onStopScene = new Signal();
-            this._handleKeyDown = (channel) => {
-                this._dispatchInput({ type: 'keyDown', channel });
-            };
-            this._handleKeyUp = (channel) => {
-                this._dispatchInput({ type: 'keyUp', channel });
-            };
-            this._handlePointerEnter = (pointer) => {
-                this._dispatchInput({ type: 'pointerEnter', pointer });
-            };
-            this._handlePointerLeave = (pointer) => {
-                this._dispatchInput({ type: 'pointerLeave', pointer });
-            };
-            this._handlePointerDown = (pointer) => {
-                this._dispatchInput({ type: 'pointerDown', pointer });
-            };
-            this._handlePointerMove = (pointer) => {
-                this._dispatchInput({ type: 'pointerMove', pointer });
-            };
-            this._handlePointerUp = (pointer) => {
-                this._dispatchInput({ type: 'pointerUp', pointer });
-            };
-            this._handlePointerTap = (pointer) => {
-                this._dispatchInput({ type: 'pointerTap', pointer });
-            };
-            this._handlePointerSwipe = (pointer) => {
-                this._dispatchInput({ type: 'pointerSwipe', pointer });
-            };
-            this._handlePointerCancel = (pointer) => {
-                this._dispatchInput({ type: 'pointerCancel', pointer });
-            };
-            this._handleMouseWheel = (wheel) => {
-                this._dispatchInput({ type: 'mouseWheel', wheel });
-            };
             this._app = app;
             this._subscribeInputRouting();
         }
@@ -3529,7 +3553,7 @@ var Exo = (function (exports) {
                 if (cleanupError) {
                     const initMessage = error instanceof Error ? error.message : String(error);
                     const cleanupMessage = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
-                    throw new Error(`Failed to initialize scene: ${initMessage}. Cleanup also failed: ${cleanupMessage}.`);
+                    throw new Error(`Failed to initialize scene: ${initMessage}. Cleanup also failed: ${cleanupMessage}.`, { cause: error });
                 }
                 throw error;
             }
@@ -3639,6 +3663,39 @@ var Exo = (function (exports) {
                 }
             }
         }
+        _handleKeyDown = (channel) => {
+            this._dispatchInput({ type: 'keyDown', channel });
+        };
+        _handleKeyUp = (channel) => {
+            this._dispatchInput({ type: 'keyUp', channel });
+        };
+        _handlePointerEnter = (pointer) => {
+            this._dispatchInput({ type: 'pointerEnter', pointer });
+        };
+        _handlePointerLeave = (pointer) => {
+            this._dispatchInput({ type: 'pointerLeave', pointer });
+        };
+        _handlePointerDown = (pointer) => {
+            this._dispatchInput({ type: 'pointerDown', pointer });
+        };
+        _handlePointerMove = (pointer) => {
+            this._dispatchInput({ type: 'pointerMove', pointer });
+        };
+        _handlePointerUp = (pointer) => {
+            this._dispatchInput({ type: 'pointerUp', pointer });
+        };
+        _handlePointerTap = (pointer) => {
+            this._dispatchInput({ type: 'pointerTap', pointer });
+        };
+        _handlePointerSwipe = (pointer) => {
+            this._dispatchInput({ type: 'pointerSwipe', pointer });
+        };
+        _handlePointerCancel = (pointer) => {
+            this._dispatchInput({ type: 'pointerCancel', pointer });
+        };
+        _handleMouseWheel = (wheel) => {
+            this._dispatchInput({ type: 'mouseWheel', wheel });
+        };
         async _runWithTransition(action, transition) {
             if (!transition || transition.type !== 'fade') {
                 await action();
@@ -4905,11 +4962,12 @@ var Exo = (function (exports) {
     }();
 
     class WebGl2VertexArrayObject {
+        _attributes = [];
+        _indexBuffer = null;
+        _drawMode;
+        _runtime = null;
+        _version = 0;
         constructor(drawMode = exports.RenderingPrimitives.Triangles) {
-            this._attributes = [];
-            this._indexBuffer = null;
-            this._runtime = null;
-            this._version = 0;
             this._drawMode = drawMode;
         }
         get attributes() {
@@ -4987,10 +5045,8 @@ var Exo = (function (exports) {
      * - flush(): submit any batched draw calls to the GPU
      */
     class AbstractWebGl2Renderer {
-        constructor() {
-            this.backendType = exports.RenderBackendType.WebGl2;
-            this._runtime = null;
-        }
+        backendType = exports.RenderBackendType.WebGl2;
+        _runtime = null;
         connect(runtime) {
             if (this._runtime !== null) {
                 return;
@@ -5030,10 +5086,12 @@ var Exo = (function (exports) {
     }
 
     class Shader {
+        attributes = new Map();
+        uniforms = new Map();
+        _vertexSource;
+        _fragmentSource;
+        _runtime = null;
         constructor(vertexSource, fragmentSource) {
-            this.attributes = new Map();
-            this.uniforms = new Map();
-            this._runtime = null;
             this._vertexSource = vertexSource;
             this._fragmentSource = fragmentSource;
         }
@@ -5144,8 +5202,12 @@ var Exo = (function (exports) {
     };
 
     class ShaderAttribute {
+        index;
+        name;
+        type;
+        size;
+        location = -1;
         constructor(index, name, type) {
-            this.location = -1;
             this.index = index;
             this.name = name;
             this.type = type;
@@ -5157,8 +5219,13 @@ var Exo = (function (exports) {
     }
 
     class ShaderUniform {
+        index;
+        type;
+        size;
+        name;
+        _value;
+        _dirty = true;
         constructor(index, type, size, name, data) {
-            this._dirty = true;
             this.name = name.replace(/\[.*?]/, '');
             this.index = index;
             this.type = type;
@@ -5188,8 +5255,16 @@ var Exo = (function (exports) {
     }
 
     class WebGl2ShaderBlock {
+        index;
+        name;
+        binding;
+        dataSize;
+        _context;
+        _program;
+        _blockData;
+        _uniformBuffer;
+        _uniforms = new Map();
         constructor(gl, program, index) {
-            this._uniforms = new Map();
             this._context = gl;
             this._program = program;
             this.index = index;
@@ -5391,10 +5466,12 @@ var Exo = (function (exports) {
     }
 
     class WebGl2RenderBuffer {
+        _type;
+        _usage;
+        _runtime = null;
+        _data = emptyArrayBuffer;
+        _version = 0;
         constructor(type, data, usage) {
-            this._runtime = null;
-            this._data = emptyArrayBuffer;
-            this._version = 0;
             this._type = type;
             this._usage = usage;
             if (data) {
@@ -5476,17 +5553,24 @@ var Exo = (function (exports) {
     };
 
     class AbstractWebGl2BatchedRenderer extends AbstractWebGl2Renderer {
+        attributeCount;
+        batchSize;
+        indexData;
+        vertexData;
+        float32View;
+        uint32View;
+        shader;
+        batchIndex = 0;
+        currentTexture = null;
+        currentBlendMode = null;
+        currentView = null;
+        currentViewId = -1;
+        vao = null;
+        indexBuffer = null;
+        vertexBuffer = null;
+        connection = null;
         constructor(batchSize, attributeCount, vertexSource, fragmentSource) {
             super();
-            this.batchIndex = 0;
-            this.currentTexture = null;
-            this.currentBlendMode = null;
-            this.currentView = null;
-            this.currentViewId = -1;
-            this.vao = null;
-            this.indexBuffer = null;
-            this.vertexBuffer = null;
-            this.connection = null;
             this.batchSize = batchSize;
             this.attributeCount = attributeCount;
             this.vertexData = new ArrayBuffer(batchSize * attributeCount * 4);
@@ -5828,13 +5912,19 @@ var Exo = (function (exports) {
     const vertexStrideBytes$2 = 12;
     const vertexStrideWords = vertexStrideBytes$2 / 4;
     class WebGl2PrimitiveRenderer extends AbstractWebGl2Renderer {
+        _vertexCapacity;
+        _indexCapacity;
+        _vertexData;
+        _indexData;
+        _float32View;
+        _uint32View;
+        _shader = new Shader(vertexSource, fragmentSource);
+        _connection = null;
+        _currentBlendMode = null;
+        _currentView = null;
+        _viewId = -1;
         constructor(batchSize) {
             super();
-            this._shader = new Shader(vertexSource, fragmentSource);
-            this._connection = null;
-            this._currentBlendMode = null;
-            this._currentView = null;
-            this._viewId = -1;
             this._vertexCapacity = Math.max(minBatchVertexSize, batchSize);
             this._indexCapacity = Math.max(6, this._vertexCapacity * 3);
             this._vertexData = new ArrayBuffer(this._vertexCapacity * vertexStrideBytes$2);
@@ -6038,12 +6128,12 @@ var Exo = (function (exports) {
         SpriteFlags[SpriteFlags["VertexTint"] = 128] = "VertexTint";
     })(exports.SpriteFlags || (exports.SpriteFlags = {}));
     class Sprite extends Drawable {
+        _texture = null;
+        _textureFrame = new Rectangle();
+        _vertices = new Float32Array(8);
+        _texCoords = new Uint32Array(4);
         constructor(texture) {
             super();
-            this._texture = null;
-            this._textureFrame = new Rectangle();
-            this._vertices = new Float32Array(8);
-            this._texCoords = new Uint32Array(4);
             if (texture !== null) {
                 this.setTexture(texture);
             }
@@ -6186,17 +6276,15 @@ var Exo = (function (exports) {
     RenderNode.setInternalSpriteFactory(() => new Sprite(null));
 
     class Particle {
-        constructor() {
-            this._totalLifetime = Time.oneSecond.clone();
-            this._elapsedLifetime = Time.zero.clone();
-            this._position = Vector.zero.clone();
-            this._velocity = Vector.zero.clone();
-            this._scale = Vector.one.clone();
-            this._rotation = 0;
-            this._rotationSpeed = 0;
-            this._textureIndex = 0;
-            this._tint = Color.white.clone();
-        }
+        _totalLifetime = Time.oneSecond.clone();
+        _elapsedLifetime = Time.zero.clone();
+        _position = Vector.zero.clone();
+        _velocity = Vector.zero.clone();
+        _scale = Vector.one.clone();
+        _rotation = 0;
+        _rotationSpeed = 0;
+        _textureIndex = 0;
+        _tint = Color.white.clone();
         get totalLifetime() {
             return this._totalLifetime;
         }
@@ -6287,17 +6375,18 @@ var Exo = (function (exports) {
     }
 
     class ParticleSystem extends Drawable {
+        _emitters = [];
+        _affectors = [];
+        _particles = [];
+        _graveyard = [];
+        _texture;
+        _textureFrame = new Rectangle();
+        _vertices = new Float32Array(4);
+        _texCoords = new Uint32Array(4);
+        _updateTexCoords = true;
+        _updateVertices = true;
         constructor(texture) {
             super();
-            this._emitters = [];
-            this._affectors = [];
-            this._particles = [];
-            this._graveyard = [];
-            this._textureFrame = new Rectangle();
-            this._vertices = new Float32Array(4);
-            this._texCoords = new Uint32Array(4);
-            this._updateTexCoords = true;
-            this._updateVertices = true;
             this._texture = texture;
             this.resetTextureFrame();
         }
@@ -6466,6 +6555,16 @@ var Exo = (function (exports) {
     }
 
     class Texture {
+        static _black = null;
+        static _white = null;
+        static defaultSamplerOptions = {
+            scaleMode: exports.ScaleModes.Linear,
+            wrapMode: exports.WrapModes.ClampToEdge,
+            premultiplyAlpha: true,
+            generateMipMap: true,
+            flipY: false,
+        };
+        static empty = new Texture(null);
         static get black() {
             if (Texture._black === null) {
                 Texture._black = new Texture(createCanvas({ fillStyle: '#000' }));
@@ -6478,14 +6577,16 @@ var Exo = (function (exports) {
             }
             return Texture._white;
         }
+        _version = 0;
+        _source = null;
+        _size = new Size(0, 0);
+        _destroyListeners = new Set();
+        _scaleMode;
+        _wrapMode;
+        _premultiplyAlpha = false;
+        _generateMipMap = false;
+        _flipY = false;
         constructor(source = null, options) {
-            this._version = 0;
-            this._source = null;
-            this._size = new Size(0, 0);
-            this._destroyListeners = new Set();
-            this._premultiplyAlpha = false;
-            this._generateMipMap = false;
-            this._flipY = false;
             const { scaleMode, wrapMode, premultiplyAlpha, generateMipMap, flipY } = { ...Texture.defaultSamplerOptions, ...options };
             this._scaleMode = scaleMode;
             this._wrapMode = wrapMode;
@@ -6617,16 +6718,6 @@ var Exo = (function (exports) {
             this._version++;
         }
     }
-    Texture._black = null;
-    Texture._white = null;
-    Texture.defaultSamplerOptions = {
-        scaleMode: exports.ScaleModes.Linear,
-        wrapMode: exports.WrapModes.ClampToEdge,
-        premultiplyAlpha: true,
-        generateMipMap: true,
-        flipY: false,
-    };
-    Texture.empty = new Texture(null);
 
     /**
      * Instance-based renderer registry.
@@ -6642,10 +6733,8 @@ var Exo = (function (exports) {
      * custom renderer registration.
      */
     class RendererRegistry {
-        constructor() {
-            this._renderers = new Map();
-            this._runtime = null;
-        }
+        _renderers = new Map();
+        _runtime = null;
         /**
          * Register a renderer for a specific drawable type.
          *
@@ -6754,27 +6843,35 @@ var Exo = (function (exports) {
         validateNoneOfTheArgsAreUndefined(functionName, args);
     };
     class WebGl2RenderManager {
+        backendType = exports.RenderBackendType.WebGl2;
+        rendererRegistry = new RendererRegistry();
+        _context;
+        _rootRenderTarget;
+        _onContextLostHandler;
+        _onContextRestoredHandler;
+        _textureStates = new Map();
+        _renderTargetStates = new Map();
+        _textureDestroyHandlers = new Map();
+        _renderTargetDestroyHandlers = new Map();
+        _temporaryRenderTextures = [];
+        _maskStack = [];
+        _maskPixelStack = [];
+        _maskPointA = new Vector();
+        _maskPointB = new Vector();
+        _canvas;
+        _contextLost;
+        _renderTarget;
+        _renderer = null;
+        _shader = null;
+        _blendMode = null;
+        _texture = null;
+        _textureUnit = 0;
+        _vao = null;
+        _clearColor = new Color();
+        _cursor;
+        _boundFramebuffer = null;
+        _stats = createRenderStats();
         constructor(app) {
-            this.backendType = exports.RenderBackendType.WebGl2;
-            this.rendererRegistry = new RendererRegistry();
-            this._textureStates = new Map();
-            this._renderTargetStates = new Map();
-            this._textureDestroyHandlers = new Map();
-            this._renderTargetDestroyHandlers = new Map();
-            this._temporaryRenderTextures = [];
-            this._maskStack = [];
-            this._maskPixelStack = [];
-            this._maskPointA = new Vector();
-            this._maskPointB = new Vector();
-            this._renderer = null;
-            this._shader = null;
-            this._blendMode = null;
-            this._texture = null;
-            this._textureUnit = 0;
-            this._vao = null;
-            this._clearColor = new Color();
-            this._boundFramebuffer = null;
-            this._stats = createRenderStats();
             const { width, height, clearColor, webglAttributes, debug, spriteRendererBatchSize, particleRendererBatchSize, primitiveRendererBatchSize, } = app.options;
             this._canvas = app.canvas;
             const gl = this._createContext(webglAttributes);
@@ -7322,10 +7419,8 @@ var Exo = (function (exports) {
      * - flush(): encode and submit command buffers for all collected draw calls
      */
     class AbstractWebGpuRenderer {
-        constructor() {
-            this.backendType = exports.RenderBackendType.WebGpu;
-            this._runtime = null;
-        }
+        backendType = exports.RenderBackendType.WebGpu;
+        _runtime = null;
         connect(runtime) {
             if (this._runtime !== null) {
                 return;
@@ -7466,27 +7561,24 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     const vertexStrideBytes$1 = 20;
     const wordsPerVertex$1 = vertexStrideBytes$1 / Uint32Array.BYTES_PER_ELEMENT;
     class WebGpuPrimitiveRenderer extends AbstractWebGpuRenderer {
-        constructor() {
-            super(...arguments);
-            this._combinedTransform = new Matrix();
-            this._drawCalls = [];
-            this._drawCallCount = 0;
-            this._pipelines = new Map();
-            this._renderManager = null;
-            this._device = null;
-            this._shaderModule = null;
-            this._pipelineLayout = null;
-            this._vertexBuffer = null;
-            this._indexBuffer = null;
-            this._vertexBufferCapacity = 0;
-            this._indexBufferCapacity = 0;
-            this._vertexData = new ArrayBuffer(0);
-            this._float32View = new Float32Array(this._vertexData);
-            this._uint32View = new Uint32Array(this._vertexData);
-            this._packedIndexData = new Uint16Array(0);
-            this._generatedIndexData = new Uint16Array(0);
-            this._sequentialIndexData = new Uint16Array(0);
-        }
+        _combinedTransform = new Matrix();
+        _drawCalls = [];
+        _drawCallCount = 0;
+        _pipelines = new Map();
+        _renderManager = null;
+        _device = null;
+        _shaderModule = null;
+        _pipelineLayout = null;
+        _vertexBuffer = null;
+        _indexBuffer = null;
+        _vertexBufferCapacity = 0;
+        _indexBufferCapacity = 0;
+        _vertexData = new ArrayBuffer(0);
+        _float32View = new Float32Array(this._vertexData);
+        _uint32View = new Uint32Array(this._vertexData);
+        _packedIndexData = new Uint16Array(0);
+        _generatedIndexData = new Uint16Array(0);
+        _sequentialIndexData = new Uint16Array(0);
         render(shape) {
             const runtime = this._renderManager;
             if (runtime === null) {
@@ -7917,121 +8009,121 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     /// <reference types="@webgpu/types" />
-    const spriteShaderSource = `
-struct ProjectionUniforms {
-    matrix: mat4x4<f32>,
-};
-
-@group(0) @binding(0)
-var<uniform> projection: ProjectionUniforms;
-
-@group(1) @binding(0)
-var spriteTexture0: texture_2d<f32>;
-@group(1) @binding(1)
-var spriteTexture1: texture_2d<f32>;
-@group(1) @binding(2)
-var spriteTexture2: texture_2d<f32>;
-@group(1) @binding(3)
-var spriteTexture3: texture_2d<f32>;
-@group(1) @binding(4)
-var spriteTexture4: texture_2d<f32>;
-@group(1) @binding(5)
-var spriteTexture5: texture_2d<f32>;
-@group(1) @binding(6)
-var spriteTexture6: texture_2d<f32>;
-@group(1) @binding(7)
-var spriteTexture7: texture_2d<f32>;
-
-@group(1) @binding(8)
-var spriteSampler0: sampler;
-@group(1) @binding(9)
-var spriteSampler1: sampler;
-@group(1) @binding(10)
-var spriteSampler2: sampler;
-@group(1) @binding(11)
-var spriteSampler3: sampler;
-@group(1) @binding(12)
-var spriteSampler4: sampler;
-@group(1) @binding(13)
-var spriteSampler5: sampler;
-@group(1) @binding(14)
-var spriteSampler6: sampler;
-@group(1) @binding(15)
-var spriteSampler7: sampler;
-
-struct VertexInput {
-    @location(0) position: vec2<f32>,
-    @location(1) texcoord: vec2<f32>,
-    @location(2) color: vec4<f32>,
-    @location(3) premultiplySample: u32,
-    @location(4) textureSlot: u32,
-};
-
-struct VertexOutput {
-    @builtin(position) position: vec4<f32>,
-    @location(0) texcoord: vec2<f32>,
-    @location(1) color: vec4<f32>,
-    @location(2) @interpolate(flat) premultiplySample: u32,
-    @location(3) @interpolate(flat) textureSlot: u32,
-};
-
-@vertex
-fn vertexMain(input: VertexInput) -> VertexOutput {
-    var output: VertexOutput;
-
-    output.position = projection.matrix * vec4<f32>(input.position, 0.0, 1.0);
-    output.texcoord = input.texcoord;
-    output.color = vec4(input.color.rgb * input.color.a, input.color.a);
-    output.premultiplySample = input.premultiplySample;
-    output.textureSlot = input.textureSlot;
-
-    return output;
-}
-
-fn sampleTexture(slot: u32, uv: vec2<f32>, ddx: vec2<f32>, ddy: vec2<f32>) -> vec4<f32> {
-    switch slot {
-        case 0u: {
-            return textureSampleGrad(spriteTexture0, spriteSampler0, uv, ddx, ddy);
-        }
-        case 1u: {
-            return textureSampleGrad(spriteTexture1, spriteSampler1, uv, ddx, ddy);
-        }
-        case 2u: {
-            return textureSampleGrad(spriteTexture2, spriteSampler2, uv, ddx, ddy);
-        }
-        case 3u: {
-            return textureSampleGrad(spriteTexture3, spriteSampler3, uv, ddx, ddy);
-        }
-        case 4u: {
-            return textureSampleGrad(spriteTexture4, spriteSampler4, uv, ddx, ddy);
-        }
-        case 5u: {
-            return textureSampleGrad(spriteTexture5, spriteSampler5, uv, ddx, ddy);
-        }
-        case 6u: {
-            return textureSampleGrad(spriteTexture6, spriteSampler6, uv, ddx, ddy);
-        }
-        default: {
-            return textureSampleGrad(spriteTexture7, spriteSampler7, uv, ddx, ddy);
-        }
-    }
-}
-
-@fragment
-fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
-    // Compute screen-space derivatives in uniform control flow before the
-    // per-slot switch. WGSL requires textureSample (implicit LOD) to run in
-    // uniform control flow, which multi-texture batching breaks because the
-    // slot varies per fragment. textureSampleGrad takes explicit derivatives
-    // and is valid regardless of control-flow uniformity, while preserving
-    // mipmap-correct LOD when sprites use mipmapped textures.
-    let ddx = dpdx(input.texcoord);
-    let ddy = dpdy(input.texcoord);
-    let sample = sampleTexture(input.textureSlot, input.texcoord, ddx, ddy);
-    let resolvedSample = select(sample, vec4(sample.rgb * sample.a, sample.a), input.premultiplySample == 1u);
-
-    return resolvedSample * input.color;
-}
+    const spriteShaderSource = `
+struct ProjectionUniforms {
+    matrix: mat4x4<f32>,
+};
+
+@group(0) @binding(0)
+var<uniform> projection: ProjectionUniforms;
+
+@group(1) @binding(0)
+var spriteTexture0: texture_2d<f32>;
+@group(1) @binding(1)
+var spriteTexture1: texture_2d<f32>;
+@group(1) @binding(2)
+var spriteTexture2: texture_2d<f32>;
+@group(1) @binding(3)
+var spriteTexture3: texture_2d<f32>;
+@group(1) @binding(4)
+var spriteTexture4: texture_2d<f32>;
+@group(1) @binding(5)
+var spriteTexture5: texture_2d<f32>;
+@group(1) @binding(6)
+var spriteTexture6: texture_2d<f32>;
+@group(1) @binding(7)
+var spriteTexture7: texture_2d<f32>;
+
+@group(1) @binding(8)
+var spriteSampler0: sampler;
+@group(1) @binding(9)
+var spriteSampler1: sampler;
+@group(1) @binding(10)
+var spriteSampler2: sampler;
+@group(1) @binding(11)
+var spriteSampler3: sampler;
+@group(1) @binding(12)
+var spriteSampler4: sampler;
+@group(1) @binding(13)
+var spriteSampler5: sampler;
+@group(1) @binding(14)
+var spriteSampler6: sampler;
+@group(1) @binding(15)
+var spriteSampler7: sampler;
+
+struct VertexInput {
+    @location(0) position: vec2<f32>,
+    @location(1) texcoord: vec2<f32>,
+    @location(2) color: vec4<f32>,
+    @location(3) premultiplySample: u32,
+    @location(4) textureSlot: u32,
+};
+
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) texcoord: vec2<f32>,
+    @location(1) color: vec4<f32>,
+    @location(2) @interpolate(flat) premultiplySample: u32,
+    @location(3) @interpolate(flat) textureSlot: u32,
+};
+
+@vertex
+fn vertexMain(input: VertexInput) -> VertexOutput {
+    var output: VertexOutput;
+
+    output.position = projection.matrix * vec4<f32>(input.position, 0.0, 1.0);
+    output.texcoord = input.texcoord;
+    output.color = vec4(input.color.rgb * input.color.a, input.color.a);
+    output.premultiplySample = input.premultiplySample;
+    output.textureSlot = input.textureSlot;
+
+    return output;
+}
+
+fn sampleTexture(slot: u32, uv: vec2<f32>, ddx: vec2<f32>, ddy: vec2<f32>) -> vec4<f32> {
+    switch slot {
+        case 0u: {
+            return textureSampleGrad(spriteTexture0, spriteSampler0, uv, ddx, ddy);
+        }
+        case 1u: {
+            return textureSampleGrad(spriteTexture1, spriteSampler1, uv, ddx, ddy);
+        }
+        case 2u: {
+            return textureSampleGrad(spriteTexture2, spriteSampler2, uv, ddx, ddy);
+        }
+        case 3u: {
+            return textureSampleGrad(spriteTexture3, spriteSampler3, uv, ddx, ddy);
+        }
+        case 4u: {
+            return textureSampleGrad(spriteTexture4, spriteSampler4, uv, ddx, ddy);
+        }
+        case 5u: {
+            return textureSampleGrad(spriteTexture5, spriteSampler5, uv, ddx, ddy);
+        }
+        case 6u: {
+            return textureSampleGrad(spriteTexture6, spriteSampler6, uv, ddx, ddy);
+        }
+        default: {
+            return textureSampleGrad(spriteTexture7, spriteSampler7, uv, ddx, ddy);
+        }
+    }
+}
+
+@fragment
+fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
+    // Compute screen-space derivatives in uniform control flow before the
+    // per-slot switch. WGSL requires textureSample (implicit LOD) to run in
+    // uniform control flow, which multi-texture batching breaks because the
+    // slot varies per fragment. textureSampleGrad takes explicit derivatives
+    // and is valid regardless of control-flow uniformity, while preserving
+    // mipmap-correct LOD when sprites use mipmapped textures.
+    let ddx = dpdx(input.texcoord);
+    let ddy = dpdy(input.texcoord);
+    let sample = sampleTexture(input.textureSlot, input.texcoord, ddx, ddy);
+    let resolvedSample = select(sample, vec4(sample.rgb * sample.a, sample.a), input.premultiplySample == 1u);
+
+    return resolvedSample * input.color;
+}
 `;
     const vertexStrideBytes = 28;
     const spriteVertexCount = 4;
@@ -8041,27 +8133,24 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     const wordsPerVertex = vertexStrideBytes / Uint32Array.BYTES_PER_ELEMENT;
     const maxBatchTextures = 8;
     class WebGpuSpriteRenderer extends AbstractWebGpuRenderer {
-        constructor() {
-            super(...arguments);
-            this._drawCalls = [];
-            this._drawCallCount = 0;
-            this._projectionData = new Float32Array(projectionByteLength / Float32Array.BYTES_PER_ELEMENT);
-            this._renderManager = null;
-            this._device = null;
-            this._shaderModule = null;
-            this._uniformBindGroupLayout = null;
-            this._textureBindGroupLayout = null;
-            this._pipelineLayout = null;
-            this._uniformBuffer = null;
-            this._uniformBindGroup = null;
-            this._vertexBuffer = null;
-            this._indexBuffer = null;
-            this._vertexCapacity = 0;
-            this._vertexData = new ArrayBuffer(0);
-            this._float32View = new Float32Array(this._vertexData);
-            this._uint32View = new Uint32Array(this._vertexData);
-            this._pipelines = new Map();
-        }
+        _drawCalls = [];
+        _drawCallCount = 0;
+        _projectionData = new Float32Array(projectionByteLength / Float32Array.BYTES_PER_ELEMENT);
+        _renderManager = null;
+        _device = null;
+        _shaderModule = null;
+        _uniformBindGroupLayout = null;
+        _textureBindGroupLayout = null;
+        _pipelineLayout = null;
+        _uniformBuffer = null;
+        _uniformBindGroup = null;
+        _vertexBuffer = null;
+        _indexBuffer = null;
+        _vertexCapacity = 0;
+        _vertexData = new ArrayBuffer(0);
+        _float32View = new Float32Array(this._vertexData);
+        _uint32View = new Uint32Array(this._vertexData);
+        _pipelines = new Map();
         onConnect(runtime) {
             if (!this._renderManager) {
                 this._renderManager = runtime;
@@ -8520,28 +8609,25 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
         0, 2, 3,
     ]);
     class WebGpuParticleRenderer extends AbstractWebGpuRenderer {
-        constructor() {
-            super(...arguments);
-            this._drawCalls = [];
-            this._drawCallCount = 0;
-            this._uniformData = new Float32Array(uniformByteLength / Float32Array.BYTES_PER_ELEMENT);
-            this._renderManager = null;
-            this._device = null;
-            this._shaderModule = null;
-            this._uniformBindGroupLayout = null;
-            this._textureBindGroupLayout = null;
-            this._pipelineLayout = null;
-            this._uniformBuffer = null;
-            this._uniformBindGroup = null;
-            this._staticVertexBuffer = null;
-            this._instanceBuffer = null;
-            this._indexBuffer = null;
-            this._instanceBufferByteLength = 0;
-            this._instanceData = new ArrayBuffer(instanceStrideBytes * initialParticleCapacity);
-            this._float32View = new Float32Array(this._instanceData);
-            this._uint32View = new Uint32Array(this._instanceData);
-            this._pipelines = new Map();
-        }
+        _drawCalls = [];
+        _drawCallCount = 0;
+        _uniformData = new Float32Array(uniformByteLength / Float32Array.BYTES_PER_ELEMENT);
+        _renderManager = null;
+        _device = null;
+        _shaderModule = null;
+        _uniformBindGroupLayout = null;
+        _textureBindGroupLayout = null;
+        _pipelineLayout = null;
+        _uniformBuffer = null;
+        _uniformBindGroup = null;
+        _staticVertexBuffer = null;
+        _instanceBuffer = null;
+        _indexBuffer = null;
+        _instanceBufferByteLength = 0;
+        _instanceData = new ArrayBuffer(instanceStrideBytes * initialParticleCapacity);
+        _float32View = new Float32Array(this._instanceData);
+        _uint32View = new Uint32Array(this._instanceData);
+        _pipelines = new Map();
         render(system) {
             const runtime = this._renderManager;
             const texture = system.texture;
@@ -8883,33 +8969,36 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     /// <reference types="@webgpu/types" />
     const managedTextureFormat = 'rgba8unorm';
     class WebGpuRenderManager {
+        backendType = exports.RenderBackendType.WebGpu;
+        rendererRegistry = new RendererRegistry();
+        _canvas;
+        _rootRenderTarget;
+        _clearColor = new Color();
+        _textureStates = new Map();
+        _textureDestroyHandlers = new Map();
+        _renderTargetDestroyHandlers = new Map();
+        _temporaryRenderTextures = [];
+        _maskStack = [];
+        _maskPixelStack = [];
+        _maskPointA = new Vector();
+        _maskPointB = new Vector();
+        _mipmapShaderModule = null;
+        _mipmapBindGroupLayout = null;
+        _mipmapPipelineLayout = null;
+        _mipmapPipeline = null;
+        _mipmapSampler = null;
+        _context = null;
+        _device = null;
+        _format = null;
+        _initializePromise = null;
+        _renderTarget;
+        _renderer = null;
+        _blendMode = null;
+        _texture = null;
+        _clearRequested = false;
+        _hasPresentedFrame = false;
+        _stats = createRenderStats();
         constructor(app) {
-            this.backendType = exports.RenderBackendType.WebGpu;
-            this.rendererRegistry = new RendererRegistry();
-            this._clearColor = new Color();
-            this._textureStates = new Map();
-            this._textureDestroyHandlers = new Map();
-            this._renderTargetDestroyHandlers = new Map();
-            this._temporaryRenderTextures = [];
-            this._maskStack = [];
-            this._maskPixelStack = [];
-            this._maskPointA = new Vector();
-            this._maskPointB = new Vector();
-            this._mipmapShaderModule = null;
-            this._mipmapBindGroupLayout = null;
-            this._mipmapPipelineLayout = null;
-            this._mipmapPipeline = null;
-            this._mipmapSampler = null;
-            this._context = null;
-            this._device = null;
-            this._format = null;
-            this._initializePromise = null;
-            this._renderer = null;
-            this._blendMode = null;
-            this._texture = null;
-            this._clearRequested = false;
-            this._hasPresentedFrame = false;
-            this._stats = createRenderStats();
             const { width, height, clearColor, } = app.options;
             this._canvas = app.canvas;
             this._rootRenderTarget = new RenderTarget(width, height, true);
@@ -9643,6 +9732,12 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
         ChannelSize[ChannelSize["Category"] = 256] = "Category";
         ChannelSize[ChannelSize["Gamepad"] = 64] = "Gamepad";
     })(exports.ChannelSize || (exports.ChannelSize = {}));
+    exports.ChannelOffset = void 0;
+    (function (ChannelOffset) {
+        ChannelOffset[ChannelOffset["Keyboard"] = 0] = "Keyboard";
+        ChannelOffset[ChannelOffset["Pointers"] = 256] = "Pointers";
+        ChannelOffset[ChannelOffset["Gamepads"] = 512] = "Gamepads";
+    })(exports.ChannelOffset || (exports.ChannelOffset = {}));
     exports.Keyboard = void 0;
     (function (Keyboard) {
         Keyboard[Keyboard["Backspace"] = 8] = "Backspace";
@@ -9747,24 +9842,28 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     })(exports.Keyboard || (exports.Keyboard = {}));
 
     class Gamepad {
+        onConnect = new Signal();
+        onDisconnect = new Signal();
+        onUpdate = new Signal();
+        indexValue;
+        channelsValue;
+        channelOffset;
+        mappingValue;
+        browserGamepad = null;
+        info = {
+            name: 'Generic Gamepad',
+            label: 'Generic Gamepad',
+            vendorId: null,
+            productId: null,
+            productKey: null,
+        };
         constructor(indexOrGamepad, channels, mappingOrDefinition) {
-            this.onConnect = new Signal();
-            this.onDisconnect = new Signal();
-            this.onUpdate = new Signal();
-            this.browserGamepad = null;
-            this.info = {
-                name: 'Generic Gamepad',
-                label: 'Generic Gamepad',
-                vendorId: null,
-                productId: null,
-                productKey: null,
-            };
             const isBrowserGamepad = typeof indexOrGamepad !== 'number';
             const gamepad = isBrowserGamepad ? indexOrGamepad : null;
             const index = isBrowserGamepad ? indexOrGamepad.index : indexOrGamepad;
             this.indexValue = index;
             this.channelsValue = channels;
-            this.channelOffset = 512 /* ChannelOffset.Gamepads */ + (index * exports.ChannelSize.Gamepad);
+            this.channelOffset = exports.ChannelOffset.Gamepads + (index * exports.ChannelSize.Gamepad);
             this.mappingValue = gamepad
                 ? mappingOrDefinition.mapping
                 : mappingOrDefinition;
@@ -9876,10 +9975,10 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
             this.onUpdate.destroy();
         }
         resolveChannelOffset(channel) {
-            return this.channelOffset + (channel ^ 512 /* ChannelOffset.Gamepads */);
+            return this.channelOffset + (channel ^ exports.ChannelOffset.Gamepads);
         }
         static resolveChannelOffset(gamepadIndex, channel) {
-            return 512 /* ChannelOffset.Gamepads */ + (gamepadIndex * exports.ChannelSize.Gamepad) + (channel ^ 512 /* ChannelOffset.Gamepads */);
+            return exports.ChannelOffset.Gamepads + (gamepadIndex * exports.ChannelSize.Gamepad) + (channel ^ exports.ChannelOffset.Gamepads);
         }
         clearMappedChannels() {
             for (const control of this.mappingValue.buttons) {
@@ -9912,10 +10011,19 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
         PointerState[PointerState["Cancelled"] = 6] = "Cancelled";
     })(exports.PointerState || (exports.PointerState = {}));
     class Pointer {
+        id;
+        type;
+        position;
+        startPos = new Vector(-1, -1);
+        size;
+        tilt;
+        stateFlags = new Flags();
+        _canvas;
+        _buttons;
+        _pressure;
+        _rotation;
+        _currentState = exports.PointerState.Unknown;
         constructor(event, canvas) {
-            this.startPos = new Vector(-1, -1);
-            this.stateFlags = new Flags();
-            this._currentState = exports.PointerState.Unknown;
             const { pointerId, pointerType, clientX, clientY, width, height, tiltX, tiltY, buttons, pressure, twist } = event;
             const { left, top } = canvas.getBoundingClientRect();
             this._canvas = canvas;
@@ -10045,6 +10153,11 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     })(exports.GamepadChannel || (exports.GamepadChannel = {}));
 
     class GamepadControl {
+        index;
+        channel;
+        invert;
+        normalize;
+        threshold;
         constructor(index, channel, options = {}) {
             this.index = index;
             this.channel = channel;
@@ -10077,6 +10190,8 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
         GamepadMappingFamily["ArcadeStick"] = "arcadeStick";
     })(exports.GamepadMappingFamily || (exports.GamepadMappingFamily = {}));
     class GamepadMapping {
+        buttons;
+        axes;
         constructor(buttons, axes) {
             this.buttons = buttons;
             this.axes = axes;
@@ -10108,9 +10223,9 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
         [16, exports.GamepadChannel.Guide],
     ];
     class ArcadeStickGamepadMapping extends GamepadMapping {
+        family = exports.GamepadMappingFamily.ArcadeStick;
         constructor() {
             super(GamepadMapping.createControls(arcadeStickButtonDefinitions), []);
-            this.family = exports.GamepadMappingFamily.ArcadeStick;
         }
     }
 
@@ -10156,59 +10271,38 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
         [7, exports.GamepadChannel.AuxiliaryAxis3Positive],
     ];
     class GenericDualAnalogGamepadMapping extends GamepadMapping {
+        family = exports.GamepadMappingFamily.GenericDualAnalog;
         constructor() {
             super(GamepadMapping.createControls(genericDualAnalogButtonDefinitions), GamepadMapping.createControls(genericDualAnalogAxisDefinitions));
-            this.family = exports.GamepadMappingFamily.GenericDualAnalog;
         }
     }
 
     class GameCubeGamepadMapping extends GenericDualAnalogGamepadMapping {
-        constructor() {
-            super(...arguments);
-            this.family = exports.GamepadMappingFamily.GameCube;
-        }
+        family = exports.GamepadMappingFamily.GameCube;
     }
 
     class JoyConLeftGamepadMapping extends GenericDualAnalogGamepadMapping {
-        constructor() {
-            super(...arguments);
-            this.family = exports.GamepadMappingFamily.JoyConLeft;
-        }
+        family = exports.GamepadMappingFamily.JoyConLeft;
     }
 
     class JoyConRightGamepadMapping extends GenericDualAnalogGamepadMapping {
-        constructor() {
-            super(...arguments);
-            this.family = exports.GamepadMappingFamily.JoyConRight;
-        }
+        family = exports.GamepadMappingFamily.JoyConRight;
     }
 
     class PlayStationGamepadMapping extends GenericDualAnalogGamepadMapping {
-        constructor() {
-            super(...arguments);
-            this.family = exports.GamepadMappingFamily.PlayStation;
-        }
+        family = exports.GamepadMappingFamily.PlayStation;
     }
 
     class SteamControllerGamepadMapping extends GenericDualAnalogGamepadMapping {
-        constructor() {
-            super(...arguments);
-            this.family = exports.GamepadMappingFamily.SteamController;
-        }
+        family = exports.GamepadMappingFamily.SteamController;
     }
 
     class SwitchProGamepadMapping extends GenericDualAnalogGamepadMapping {
-        constructor() {
-            super(...arguments);
-            this.family = exports.GamepadMappingFamily.SwitchPro;
-        }
+        family = exports.GamepadMappingFamily.SwitchPro;
     }
 
     class XboxGamepadMapping extends GenericDualAnalogGamepadMapping {
-        constructor() {
-            super(...arguments);
-            this.family = exports.GamepadMappingFamily.Xbox;
-        }
+        family = exports.GamepadMappingFamily.Xbox;
     }
 
     const vendorProductPattern = /vendor[:\s]*([0-9a-f]{4})\s*product[:\s]*([0-9a-f]{4})/i;
@@ -10383,43 +10477,47 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
         InputManagerFlag[InputManagerFlag["PointerUpdate"] = 8] = "PointerUpdate";
     })(InputManagerFlag || (InputManagerFlag = {}));
     class InputManager {
+        canvas;
+        channels = new Float32Array(exports.ChannelSize.Container);
+        inputs = new Set();
+        pointers = {};
+        gamepadsValue = [];
+        gamepadsByIndex = new Map();
+        gamepadSlotsActive = new Uint8Array(exports.ChannelSize.Category / exports.ChannelSize.Gamepad);
+        wheelOffset = new Vector();
+        flags = new Flags();
+        channelsPressed = [];
+        channelsReleased = [];
+        gamepadDefinitions;
+        canvasFocusedValue;
+        pointerDistanceThreshold;
+        keyDownHandler = this.handleKeyDown.bind(this);
+        keyUpHandler = this.handleKeyUp.bind(this);
+        canvasFocusHandler = this.handleCanvasFocus.bind(this);
+        canvasBlurHandler = this.handleCanvasBlur.bind(this);
+        windowBlurHandler = this.handleWindowBlur.bind(this);
+        mouseWheelHandler = this.handleMouseWheel.bind(this);
+        pointerOverHandler = this.handlePointerOver.bind(this);
+        pointerLeaveHandler = this.handlePointerLeave.bind(this);
+        pointerDownHandler = this.handlePointerDown.bind(this);
+        pointerMoveHandler = this.handlePointerMove.bind(this);
+        pointerUpHandler = this.handlePointerUp.bind(this);
+        pointerCancelHandler = this.handlePointerCancel.bind(this);
+        onPointerEnter = new Signal();
+        onPointerLeave = new Signal();
+        onPointerDown = new Signal();
+        onPointerMove = new Signal();
+        onPointerUp = new Signal();
+        onPointerTap = new Signal();
+        onPointerSwipe = new Signal();
+        onPointerCancel = new Signal();
+        onMouseWheel = new Signal();
+        onKeyDown = new Signal();
+        onKeyUp = new Signal();
+        onGamepadConnected = new Signal();
+        onGamepadDisconnected = new Signal();
+        onGamepadUpdated = new Signal();
         constructor(app) {
-            this.channels = new Float32Array(exports.ChannelSize.Container);
-            this.inputs = new Set();
-            this.pointers = {};
-            this.gamepadsValue = [];
-            this.gamepadsByIndex = new Map();
-            this.gamepadSlotsActive = new Uint8Array(exports.ChannelSize.Category / exports.ChannelSize.Gamepad);
-            this.wheelOffset = new Vector();
-            this.flags = new Flags();
-            this.channelsPressed = [];
-            this.channelsReleased = [];
-            this.keyDownHandler = this.handleKeyDown.bind(this);
-            this.keyUpHandler = this.handleKeyUp.bind(this);
-            this.canvasFocusHandler = this.handleCanvasFocus.bind(this);
-            this.canvasBlurHandler = this.handleCanvasBlur.bind(this);
-            this.windowBlurHandler = this.handleWindowBlur.bind(this);
-            this.mouseWheelHandler = this.handleMouseWheel.bind(this);
-            this.pointerOverHandler = this.handlePointerOver.bind(this);
-            this.pointerLeaveHandler = this.handlePointerLeave.bind(this);
-            this.pointerDownHandler = this.handlePointerDown.bind(this);
-            this.pointerMoveHandler = this.handlePointerMove.bind(this);
-            this.pointerUpHandler = this.handlePointerUp.bind(this);
-            this.pointerCancelHandler = this.handlePointerCancel.bind(this);
-            this.onPointerEnter = new Signal();
-            this.onPointerLeave = new Signal();
-            this.onPointerDown = new Signal();
-            this.onPointerMove = new Signal();
-            this.onPointerUp = new Signal();
-            this.onPointerTap = new Signal();
-            this.onPointerSwipe = new Signal();
-            this.onPointerCancel = new Signal();
-            this.onMouseWheel = new Signal();
-            this.onKeyDown = new Signal();
-            this.onKeyUp = new Signal();
-            this.onGamepadConnected = new Signal();
-            this.onGamepadDisconnected = new Signal();
-            this.onGamepadUpdated = new Signal();
             const { gamepadDefinitions = [], pointerDistanceThreshold } = app.options;
             this.canvas = app.canvas;
             this.canvasFocusedValue = document.activeElement === this.canvas;
@@ -10506,13 +10604,13 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
             this.onGamepadUpdated.destroy();
         }
         handleKeyDown(event) {
-            const channel = 0 /* ChannelOffset.Keyboard */ + event.keyCode;
+            const channel = exports.ChannelOffset.Keyboard + event.keyCode;
             this.channels[channel] = 1;
             this.channelsPressed.push(channel);
             this.flags.push(InputManagerFlag.KeyDown);
         }
         handleKeyUp(event) {
-            const channel = 0 /* ChannelOffset.Keyboard */ + event.keyCode;
+            const channel = exports.ChannelOffset.Keyboard + event.keyCode;
             this.channels[channel] = 0;
             this.channelsReleased.push(channel);
             this.flags.push(InputManagerFlag.KeyUp);
@@ -10705,6 +10803,13 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class AbstractMedia {
+        onStart = new Signal();
+        onStop = new Signal();
+        _duration;
+        _volume;
+        _playbackRate;
+        _loop;
+        _muted;
         get duration() {
             return this._duration;
         }
@@ -10755,8 +10860,6 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
             }
         }
         constructor(initialState) {
-            this.onStart = new Signal();
-            this.onStop = new Signal();
             const { duration, volume, playbackRate, loop, muted } = initialState;
             this._duration = duration;
             this._volume = volume;
@@ -10910,9 +11013,10 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     const decodeAudioData = async (arrayBuffer) => getOrCreateOfflineAudioContext().decodeAudioData(arrayBuffer);
 
     class Music extends AbstractMedia {
+        _audioElement;
+        _audioSetup = null;
         constructor(audioElement, options) {
             super(audioElement);
-            this._audioSetup = null;
             this._audioElement = audioElement;
             if (options) {
                 this.applyOptions(options);
@@ -11022,6 +11126,16 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class Sound extends AbstractMedia {
+        _audioBuffer;
+        _pooledSources = [];
+        _queuedPooledPlays = [];
+        _sprites = new Map();
+        _audioSetup = null;
+        _paused = true;
+        _startTime = 0;
+        _currentTime = 0;
+        _sourceNode = null;
+        _poolSize = 1;
         get paused() {
             return this._paused;
         }
@@ -11050,15 +11164,6 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
                 loop: false,
                 muted: false,
             });
-            this._pooledSources = [];
-            this._queuedPooledPlays = [];
-            this._sprites = new Map();
-            this._audioSetup = null;
-            this._paused = true;
-            this._startTime = 0;
-            this._currentTime = 0;
-            this._sourceNode = null;
-            this._poolSize = 1;
             this._audioBuffer = audioBuffer;
             const { poolSize, sprites, ...playbackOptions } = options;
             this._poolSize = Math.max(1, Math.floor(poolSize ?? 1));
@@ -11409,18 +11514,23 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class Video extends Sprite {
+        onStart = new Signal();
+        onStop = new Signal();
+        _videoElement;
+        _duration;
+        _volume = 1;
+        _playbackRate = 1;
+        _loop = false;
+        _muted = false;
+        _audioSetup = null;
+        _textureDirty = true;
+        _lastVideoTime = Number.NaN;
+        _videoFrameCallbackHandle = null;
+        _onMetadataHandler;
+        _onResizeHandler;
+        _onVideoFrameHandler;
         constructor(videoElement, playbackOptions, samplerOptions) {
             super(new Texture(videoElement, samplerOptions));
-            this.onStart = new Signal();
-            this.onStop = new Signal();
-            this._volume = 1;
-            this._playbackRate = 1;
-            this._loop = false;
-            this._muted = false;
-            this._audioSetup = null;
-            this._textureDirty = true;
-            this._lastVideoTime = Number.NaN;
-            this._videoFrameCallbackHandle = null;
             const { duration, volume, playbackRate, loop, muted } = videoElement;
             this._videoElement = videoElement;
             this._duration = duration;
@@ -11719,9 +11829,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class FactoryRegistry {
-        constructor() {
-            this._factories = new Map();
-        }
+        _factories = new Map();
         register(type, factory) {
             this._factories.set(type, factory);
         }
@@ -11761,9 +11869,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class AbstractAssetFactory {
-        constructor() {
-            this._objectUrls = [];
-        }
+        _objectUrls = [];
         createObjectUrl(blob) {
             const objectUrl = URL.createObjectURL(blob);
             this._objectUrls.push(objectUrl);
@@ -11785,11 +11891,8 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class FontFactory extends AbstractAssetFactory {
-        constructor() {
-            super(...arguments);
-            this.storageName = 'font';
-            this._addedFontFaces = [];
-        }
+        storageName = 'font';
+        _addedFontFaces = [];
         async process(response) {
             return await response.arrayBuffer();
         }
@@ -11861,27 +11964,27 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
             mask: [0xFF, 0xFF, 0xFF],
         },
         {
-            mimeType: 'audio/basic',
+            mimeType: '@/audio/basic',
             pattern: [0x2E, 0x73, 0x6E, 0x64],
             mask: [0xFF, 0xFF, 0xFF, 0xFF],
         },
         {
-            mimeType: 'audio/mpeg',
+            mimeType: '@/audio/mpeg',
             pattern: [0x49, 0x44, 0x33],
             mask: [0xFF, 0xFF, 0xFF],
         },
         {
-            mimeType: 'audio/wave',
+            mimeType: '@/audio/wave',
             pattern: [0x52, 0x49, 0x46, 0x46, 0x00, 0x00, 0x00, 0x00, 0x57, 0x41, 0x56, 0x45],
             mask: [0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF],
         },
         {
-            mimeType: 'audio/midi',
+            mimeType: '@/audio/midi',
             pattern: [0x4D, 0x54, 0x68, 0x64, 0x00, 0x00, 0x00, 0x06],
             mask: [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF],
         },
         {
-            mimeType: 'audio/aiff',
+            mimeType: '@/audio/aiff',
             pattern: [0x46, 0x4F, 0x52, 0x4D, 0x00, 0x00, 0x00, 0x00, 0x41, 0x49, 0x46, 0x46],
             mask: [0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF],
         },
@@ -11947,10 +12050,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     };
 
     class ImageFactory extends AbstractAssetFactory {
-        constructor() {
-            super(...arguments);
-            this.storageName = 'image';
-        }
+        storageName = 'image';
         async process(response) {
             return await response.arrayBuffer();
         }
@@ -11980,10 +12080,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class JsonFactory extends AbstractAssetFactory {
-        constructor() {
-            super(...arguments);
-            this.storageName = 'json';
-        }
+        storageName = 'json';
         async process(response) {
             return await response.json();
         }
@@ -11994,11 +12091,8 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
 
     const onceListenerOption$1 = { once: true };
     class MusicFactory extends AbstractAssetFactory {
-        constructor() {
-            super(...arguments);
-            this.storageName = 'music';
-            this._audioElements = [];
-        }
+        storageName = 'music';
+        _audioElements = [];
         async process(response) {
             return await response.arrayBuffer();
         }
@@ -12027,10 +12121,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class SoundFactory extends AbstractAssetFactory {
-        constructor() {
-            super(...arguments);
-            this.storageName = 'sound';
-        }
+        storageName = 'sound';
         async process(response) {
             return await response.arrayBuffer();
         }
@@ -12046,10 +12137,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class TextFactory extends AbstractAssetFactory {
-        constructor() {
-            super(...arguments);
-            this.storageName = 'text';
-        }
+        storageName = 'text';
         async process(response) {
             return await response.text();
         }
@@ -12059,10 +12147,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class TextureFactory extends AbstractAssetFactory {
-        constructor() {
-            super(...arguments);
-            this.storageName = 'texture';
-        }
+        storageName = 'texture';
         async process(response) {
             return await response.arrayBuffer();
         }
@@ -12094,11 +12179,8 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
 
     const onceListenerOption = { once: true };
     class VideoFactory extends AbstractAssetFactory {
-        constructor() {
-            super(...arguments);
-            this.storageName = 'video';
-            this._videoElements = [];
-        }
+        storageName = 'video';
+        _videoElements = [];
         async process(response) {
             return await response.arrayBuffer();
         }
@@ -12130,10 +12212,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class SvgFactory extends AbstractAssetFactory {
-        constructor() {
-            super(...arguments);
-            this.storageName = 'svg';
-        }
+        storageName = 'svg';
         async process(response) {
             return await response.text();
         }
@@ -12163,10 +12242,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class BinaryFactory extends AbstractAssetFactory {
-        constructor() {
-            super(...arguments);
-            this.storageName = 'binary';
-        }
+        storageName = 'binary';
         async process(response) {
             return response.arrayBuffer();
         }
@@ -12176,10 +12252,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class WasmFactory extends AbstractAssetFactory {
-        constructor() {
-            super(...arguments);
-            this.storageName = 'wasm';
-        }
+        storageName = 'wasm';
         async process(response) {
             return response.arrayBuffer();
         }
@@ -12203,10 +12276,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
         return seconds;
     };
     class VttFactory extends AbstractAssetFactory {
-        constructor() {
-            super(...arguments);
-            this.storageName = 'vtt';
-        }
+        storageName = 'vtt';
         async process(response) {
             return response.text();
         }
@@ -12245,6 +12315,8 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class BundleLoadError extends Error {
+        bundle;
+        failures;
         constructor(bundle, failures) {
             super(`Failed to load bundle "${bundle}" (${failures.length} failure${failures.length === 1 ? '' : 's'}).`);
             this.name = 'BundleLoadError';
@@ -12310,24 +12382,28 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     // Loader
     // ---------------------------------------------------------------------------
     class Loader {
+        _registry = new FactoryRegistry();
+        _resources = new Map();
+        _manifest = new Map();
+        _bundles = new Map();
+        _inFlight = new Map();
+        _typeIds = new WeakMap();
+        _preventStoreKeys = new Set();
+        _stores;
+        _resourcePath;
+        _requestOptions;
+        _concurrency;
+        _nextTypeId = 1;
+        _backgroundQueue = [];
+        _backgroundActive = 0;
+        _backgroundTotal = 0;
+        _backgroundLoaded = 0;
+        _backgroundResolve = null;
+        onProgress = new Signal();
+        onBundleProgress = new Signal();
+        onLoaded = new Signal();
+        onError = new Signal();
         constructor(options = {}) {
-            this._registry = new FactoryRegistry();
-            this._resources = new Map();
-            this._manifest = new Map();
-            this._bundles = new Map();
-            this._inFlight = new Map();
-            this._typeIds = new WeakMap();
-            this._preventStoreKeys = new Set();
-            this._nextTypeId = 1;
-            this._backgroundQueue = [];
-            this._backgroundActive = 0;
-            this._backgroundTotal = 0;
-            this._backgroundLoaded = 0;
-            this._backgroundResolve = null;
-            this.onProgress = new Signal();
-            this.onBundleProgress = new Signal();
-            this.onLoaded = new Signal();
-            this.onError = new Signal();
             this._resourcePath = options.resourcePath ?? '';
             this._requestOptions = options.requestOptions ?? {};
             this._concurrency = options.concurrency ?? 6;
@@ -12917,14 +12993,22 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
         backend: defaultBackendConfig,
     };
     class Application {
+        options;
+        canvas;
+        loader;
+        inputManager;
+        sceneManager;
+        onResize = new Signal();
+        _updateHandler;
+        _startupClock = new Clock();
+        _activeClock = new Clock();
+        _frameClock = new Clock();
+        _status = exports.ApplicationStatus.Stopped;
+        _frameCount = 0;
+        _frameRequest = 0;
+        _backendType;
+        _renderManager;
         constructor(appSettings) {
-            this.onResize = new Signal();
-            this._startupClock = new Clock();
-            this._activeClock = new Clock();
-            this._frameClock = new Clock();
-            this._status = exports.ApplicationStatus.Stopped;
-            this._frameCount = 0;
-            this._frameRequest = 0;
             this.options = {
                 canvas: appSettings?.canvas ?? createDefaultCanvas(),
                 ...defaultAppSettings,
@@ -13068,9 +13152,13 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class Quadtree {
+        static maxSceneNodes = 50;
+        static maxLevel = 5;
+        level;
+        _bounds;
+        _quadTrees = new Map();
+        _sceneNodes = new Set();
         constructor(bounds, level = 0) {
-            this._quadTrees = new Map();
-            this._sceneNodes = new Set();
             this._bounds = bounds.clone();
             this.level = level;
         }
@@ -13144,17 +13232,12 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
             }
         }
     }
-    Quadtree.maxSceneNodes = 50;
-    Quadtree.maxLevel = 5;
 
     class Container extends RenderNode {
-        constructor() {
-            super(...arguments);
-            this._children = [];
-            this._sortableChildren = false;
-            this._sortDirty = false;
-            this._nextChildOrder = 0;
-        }
+        _children = [];
+        _sortableChildren = false;
+        _sortDirty = false;
+        _nextChildOrder = 0;
         get children() {
             return this._children;
         }
@@ -13343,15 +13426,14 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class Scene {
+        _app = null;
+        _root = new Container();
+        _stackMode = 'overlay';
+        _inputMode = 'capture';
         static create(definition) {
             return Object.assign(new Scene(), definition);
         }
-        constructor() {
-            this._app = null;
-            this._root = new Container();
-            this._stackMode = 'overlay';
-            this._inputMode = 'capture';
-        }
+        constructor() { }
         get app() {
             return this._app;
         }
@@ -13421,6 +13503,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class Timer extends Clock {
+        _limit;
         constructor(limit, autoStart = false) {
             super();
             this._limit = limit.clone();
@@ -13449,10 +13532,20 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class AudioAnalyser {
+        _media;
+        _fftSize;
+        _minDecibels;
+        _maxDecibels;
+        _smoothingTimeConstant;
+        _frequencyBinCount;
+        _timeDomainData;
+        _frequencyData;
+        _preciseTimeDomainData;
+        _preciseFrequencyData;
+        _analyser = null;
+        _audioContext = null;
+        _analyserTarget = null;
         constructor(media, options = {}) {
-            this._analyser = null;
-            this._audioContext = null;
-            this._analyserTarget = null;
             const { fftSize, minDecibels, maxDecibels, smoothingTimeConstant } = options;
             this._media = media;
             this._fftSize = fftSize ?? 2048;
@@ -13631,6 +13724,25 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
         [exports.GamepadMappingFamily.ArcadeStick, genericLabels],
     ]);
     class GamepadPromptLayouts {
+        static controls = [
+            'DPad',
+            'DPadUp',
+            'DPadDown',
+            'DPadLeft',
+            'DPadRight',
+            'ButtonNorth',
+            'ButtonWest',
+            'ButtonEast',
+            'ButtonSouth',
+            'LeftShoulder',
+            'RightShoulder',
+            'LeftTrigger',
+            'RightTrigger',
+            'Select',
+            'Start',
+            'LeftStick',
+            'RightStick',
+        ];
         static getControlPosition(control) {
             return basePositions.get(control) ?? [0.5, 0.5];
         }
@@ -13641,34 +13753,17 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
             return channelMap;
         }
     }
-    GamepadPromptLayouts.controls = [
-        'DPad',
-        'DPadUp',
-        'DPadDown',
-        'DPadLeft',
-        'DPadRight',
-        'ButtonNorth',
-        'ButtonWest',
-        'ButtonEast',
-        'ButtonSouth',
-        'LeftShoulder',
-        'RightShoulder',
-        'LeftTrigger',
-        'RightTrigger',
-        'Select',
-        'Start',
-        'LeftStick',
-        'RightStick',
-    ];
 
     class Input {
+        static triggerThreshold = 300;
+        channels = new Set();
+        triggerTimer;
+        valueState = 0;
+        onStart = new Signal();
+        onStop = new Signal();
+        onActive = new Signal();
+        onTrigger = new Signal();
         constructor(channels, { onStart, onStop, onActive, onTrigger, context, threshold } = {}) {
-            this.channels = new Set();
-            this.valueState = 0;
-            this.onStart = new Signal();
-            this.onStop = new Signal();
-            this.onActive = new Signal();
-            this.onTrigger = new Signal();
             this.channels = new Set(Array.isArray(channels) ? channels : [channels]);
             this.triggerTimer = new Timer(milliseconds(threshold ?? Input.triggerThreshold));
             if (onStart) {
@@ -13720,704 +13815,638 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
             this.onTrigger.destroy();
         }
     }
-    Input.triggerThreshold = 300;
 
-    function getDefaultExportFromCjs (x) {
-    	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+    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;
     }
 
-    var earcut$1 = {exports: {}};
+    // 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;
 
-    var hasRequiredEarcut;
+            // 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);
 
-    function requireEarcut () {
-    	if (hasRequiredEarcut) return earcut$1.exports;
-    	hasRequiredEarcut = 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);
+                }
 
-    	earcut$1.exports = earcut;
-    	earcut$1.exports.default = earcut;
+                break;
+            }
+        }
+    }
 
-    	function earcut(data, holeIndices, dim) {
+    // check whether a polygon node forms a valid ear with adjacent nodes
+    function isEar(ear) {
+        const a = ear.prev,
+            b = ear,
+            c = ear.next;
 
-    	    dim = dim || 2;
+        if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
 
-    	    var hasHoles = holeIndices && holeIndices.length,
-    	        outerLen = hasHoles ? holeIndices[0] * dim : data.length,
-    	        outerNode = linkedList(data, 0, outerLen, dim, true),
-    	        triangles = [];
+        // 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;
 
-    	    if (!outerNode || outerNode.next === outerNode.prev) return triangles;
+        // 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);
 
-    	    var minX, minY, maxX, maxY, x, y, invSize;
+        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;
+        }
 
-    	    if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+        return true;
+    }
 
-    	    // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
-    	    if (data.length > 80 * dim) {
-    	        minX = maxX = data[0];
-    	        minY = maxY = data[1];
+    function isEarHashed(ear, minX, minY, invSize) {
+        const a = ear.prev,
+            b = ear,
+            c = ear.next;
 
-    	        for (var i = dim; i < outerLen; i += dim) {
-    	            x = data[i];
-    	            y = data[i + 1];
-    	            if (x < minX) minX = x;
-    	            if (y < minY) minY = y;
-    	            if (x > maxX) maxX = x;
-    	            if (y > maxY) maxY = y;
-    	        }
+        if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
 
-    	        // 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;
-    	    }
+        const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
 
-    	    earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
+        // 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);
 
-    	    return triangles;
-    	}
+        // z-order range for the current triangle bbox;
+        const minZ = zOrder(x0, y0, minX, minY, invSize),
+            maxZ = zOrder(x1, y1, minX, minY, invSize);
 
-    	// create a circular doubly linked list from polygon points in the specified winding order
-    	function linkedList(data, start, end, dim, clockwise) {
-    	    var i, last;
+        let p = ear.prevZ,
+            n = ear.nextZ;
 
-    	    if (clockwise === (signedArea(data, start, end, dim) > 0)) {
-    	        for (i = start; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last);
-    	    } else {
-    	        for (i = end - dim; i >= start; i -= dim) last = insertNode(i, data[i], data[i + 1], last);
-    	    }
+        // 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 (last && equals(last, last.next)) {
-    	        removeNode(last);
-    	        last = last.next;
-    	    }
+            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 last;
-    	}
+        // 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;
+        }
 
-    	// eliminate colinear or duplicate points
-    	function filterPoints(start, end) {
-    	    if (!start) return start;
-    	    if (!end) end = start;
+        // 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;
+        }
 
-    	    var p = start,
-    	        again;
-    	    do {
-    	        again = false;
+        return true;
+    }
 
-    	        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;
+    // 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;
 
-    	        } else {
-    	            p = p.next;
-    	        }
-    	    } while (again || p !== end);
+            if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
 
-    	    return end;
-    	}
+                triangles.push(a.i, p.i, b.i);
 
-    	// 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;
+                // remove two nodes involved
+                removeNode(p);
+                removeNode(p.next);
 
-    	    // interlink polygon nodes in z-order
-    	    if (!pass && invSize) indexCurve(ear, minX, minY, invSize);
+                p = start = b;
+            }
+            p = p.next;
+        } while (p !== start);
 
-    	    var stop = ear,
-    	        prev, next;
+        return filterPoints(p);
+    }
 
-    	    // iterate through ears, slicing them one by one
-    	    while (ear.prev !== ear.next) {
-    	        prev = ear.prev;
-    	        next = ear.next;
-
-    	        if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
-    	            // cut off the triangle
-    	            triangles.push(prev.i / dim | 0);
-    	            triangles.push(ear.i / dim | 0);
-    	            triangles.push(next.i / dim | 0);
-
-    	            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, dim);
-    	                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);
-    	            }
-
-    	            break;
-    	        }
-    	    }
-    	}
-
-    	// check whether a polygon node forms a valid ear with adjacent nodes
-    	function isEar(ear) {
-    	    var 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
-    	    var ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
-
-    	    // triangle bbox; min & max are calculated like this for speed
-    	    var x0 = ax < bx ? (ax < cx ? ax : cx) : (bx < cx ? bx : cx),
-    	        y0 = ay < by ? (ay < cy ? ay : cy) : (by < cy ? by : cy),
-    	        x1 = ax > bx ? (ax > cx ? ax : cx) : (bx > cx ? bx : cx),
-    	        y1 = ay > by ? (ay > cy ? ay : cy) : (by > cy ? by : cy);
-
-    	    var p = c.next;
-    	    while (p !== a) {
-    	        if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 &&
-    	            pointInTriangle(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) {
-    	    var a = ear.prev,
-    	        b = ear,
-    	        c = ear.next;
-
-    	    if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
-
-    	    var ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
-
-    	    // triangle bbox; min & max are calculated like this for speed
-    	    var x0 = ax < bx ? (ax < cx ? ax : cx) : (bx < cx ? bx : cx),
-    	        y0 = ay < by ? (ay < cy ? ay : cy) : (by < cy ? by : cy),
-    	        x1 = ax > bx ? (ax > cx ? ax : cx) : (bx > cx ? bx : cx),
-    	        y1 = ay > by ? (ay > cy ? ay : cy) : (by > cy ? by : cy);
-
-    	    // z-order range for the current triangle bbox;
-    	    var minZ = zOrder(x0, y0, minX, minY, invSize),
-    	        maxZ = zOrder(x1, y1, minX, minY, invSize);
-
-    	    var 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 &&
-    	            pointInTriangle(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 &&
-    	            pointInTriangle(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 &&
-    	            pointInTriangle(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 &&
-    	            pointInTriangle(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, dim) {
-    	    var p = start;
-    	    do {
-    	        var 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 / dim | 0);
-    	            triangles.push(p.i / dim | 0);
-    	            triangles.push(b.i / dim | 0);
-
-    	            // remove two nodes involved
-    	            removeNode(p);
-    	            removeNode(p.next);
-
-    	            p = start = b;
-    	        }
-    	        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
-    	    var a = start;
-    	    do {
-    	        var b = a.next.next;
-    	        while (b !== a.prev) {
-    	            if (a.i !== b.i && isValidDiagonal(a, b)) {
-    	                // split the polygon in two by the diagonal
-    	                var 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) {
-    	    var queue = [],
-    	        i, len, start, end, list;
-
-    	    for (i = 0, len = holeIndices.length; i < len; i++) {
-    	        start = holeIndices[i] * dim;
-    	        end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
-    	        list = linkedList(data, start, end, dim, false);
-    	        if (list === list.next) list.steiner = true;
-    	        queue.push(getLeftmost(list));
-    	    }
-
-    	    queue.sort(compareX);
-
-    	    // process holes from left to right
-    	    for (i = 0; i < queue.length; i++) {
-    	        outerNode = eliminateHole(queue[i], outerNode);
-    	    }
-
-    	    return outerNode;
-    	}
-
-    	function compareX(a, b) {
-    	    return a.x - b.x;
-    	}
-
-    	// find a bridge between vertices that connects hole with an outer ring and and link it
-    	function eliminateHole(hole, outerNode) {
-    	    var bridge = findHoleBridge(hole, outerNode);
-    	    if (!bridge) {
-    	        return outerNode;
-    	    }
-
-    	    var bridgeReverse = splitPolygon(bridge, hole);
-
-    	    // filter collinear points around the cuts
-    	    filterPoints(bridgeReverse, bridgeReverse.next);
-    	    return filterPoints(bridge, bridge.next);
-    	}
-
-    	// David Eberly's algorithm for finding a bridge between hole and outer polygon
-    	function findHoleBridge(hole, outerNode) {
-    	    var p = outerNode,
-    	        hx = hole.x,
-    	        hy = hole.y,
-    	        qx = -Infinity,
-    	        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
-    	    do {
-    	        if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
-    	            var 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
-
-    	    var stop = m,
-    	        mx = m.x,
-    	        my = m.y,
-    	        tanMin = Infinity,
-    	        tan;
-
-    	    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)) {
-
-    	            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;
-    	}
-
-    	// 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;
-    	}
-
-    	// interlink polygon nodes in z-order
-    	function indexCurve(start, minX, minY, invSize) {
-    	    var 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);
-    	}
-
-    	// Simon Tatham's linked list merge sort algorithm
-    	// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
-    	function sortLinked(list) {
-    	    var i, p, q, e, tail, numMerges, pSize, qSize,
-    	        inSize = 1;
-
-    	    do {
-    	        p = list;
-    	        list = null;
-    	        tail = null;
-    	        numMerges = 0;
-
-    	        while (p) {
-    	            numMerges++;
-    	            q = p;
-    	            pSize = 0;
-    	            for (i = 0; i < inSize; i++) {
-    	                pSize++;
-    	                q = q.nextZ;
-    	                if (!q) break;
-    	            }
-    	            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;
-    	            }
-
-    	            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) {
-    	    var 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 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) && // dones'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) {
-    	    var o1 = sign(area(p1, q1, p2));
-    	    var o2 = sign(area(p1, q1, q2));
-    	    var o3 = sign(area(p2, q2, p1));
-    	    var 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) {
-    	    var 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) {
-    	    var p = a,
-    	        inside = false,
-    	        px = (a.x + b.x) / 2,
-    	        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) {
-    	    var a2 = new Node(a.i, a.x, a.y),
-    	        b2 = new Node(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) {
-    	    var p = new Node(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;
-    	    }
-    	    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 Node(i, x, y) {
-    	    // vertex index in coordinates array
-    	    this.i = i;
-
-    	    // vertex coordinates
-    	    this.x = x;
-    	    this.y = y;
-
-    	    // previous and next vertex nodes in a polygon ring
-    	    this.prev = null;
-    	    this.next = null;
-
-    	    // z-order curve value
-    	    this.z = 0;
-
-    	    // previous and next nodes in z-order
-    	    this.prevZ = null;
-    	    this.nextZ = null;
-
-    	    // indicates whether this is a steiner point
-    	    this.steiner = false;
-    	}
-
-    	// return a percentage difference between the polygon area and its triangulation area;
-    	// used to verify correctness of triangulation
-    	earcut.deviation = function (data, holeIndices, dim, triangles) {
-    	    var hasHoles = holeIndices && holeIndices.length;
-    	    var outerLen = hasHoles ? holeIndices[0] * dim : data.length;
-
-    	    var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim));
-    	    if (hasHoles) {
-    	        for (var i = 0, len = holeIndices.length; i < len; i++) {
-    	            var start = holeIndices[i] * dim;
-    	            var end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
-    	            polygonArea -= Math.abs(signedArea(data, start, end, dim));
-    	        }
-    	    }
-
-    	    var trianglesArea = 0;
-    	    for (i = 0; i < triangles.length; i += 3) {
-    	        var a = triangles[i] * dim;
-    	        var b = triangles[i + 1] * dim;
-    	        var c = triangles[i + 2] * dim;
-    	        trianglesArea += Math.abs(
-    	            (data[a] - data[c]) * (data[b + 1] - data[a + 1]) -
-    	            (data[a] - data[b]) * (data[c + 1] - data[a + 1]));
-    	    }
-
-    	    return polygonArea === 0 && trianglesArea === 0 ? 0 :
-    	        Math.abs((trianglesArea - polygonArea) / polygonArea);
-    	};
-
-    	function signedArea(data, start, end, dim) {
-    	    var sum = 0;
-    	    for (var i = start, j = end - dim; i < end; i += dim) {
-    	        sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
-    	        j = i;
-    	    }
-    	    return sum;
-    	}
-
-    	// turn a polygon in a multi-dimensional array form (e.g. as in GeoJSON) into a form Earcut accepts
-    	earcut.flatten = function (data) {
-    	    var dim = data[0][0].length,
-    	        result = {vertices: [], holes: [], dimensions: dim},
-    	        holeIndex = 0;
-
-    	    for (var i = 0; i < data.length; i++) {
-    	        for (var j = 0; j < data[i].length; j++) {
-    	            for (var d = 0; d < dim; d++) result.vertices.push(data[i][j][d]);
-    	        }
-    	        if (i > 0) {
-    	            holeIndex += data[i - 1].length;
-    	            result.holes.push(holeIndex);
-    	        }
-    	    }
-    	    return result;
-    	};
-    	return earcut$1.exports;
+    // 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);
     }
 
-    var earcutExports = requireEarcut();
-    var earcut = /*@__PURE__*/getDefaultExportFromCjs(earcutExports);
+    // 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;
+            }
+        }
+        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);
+    }
+
+    // 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;
+    }
+
+    // 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;
+    }
+
+    // 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);
+    }
+
+    // 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;
+                }
+
+                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;
+        }
+        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;
+    }
 
     const buildLine = (startX, startY, endX, endY, width, vertices = [], indices = []) => {
         const points = [startX, startY, endX, endY];
@@ -14609,8 +14638,10 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
 
     let temp$3 = null;
     class Line {
+        collisionType = exports.CollisionType.Line;
+        _fromPosition;
+        _toPosition;
         constructor(x1 = 0, y1 = 0, x2 = 0, y2 = 0) {
-            this.collisionType = 1 /* CollisionType.Line */;
             this._fromPosition = new Vector(x1, y1);
             this._toPosition = new Vector(x2, y2);
         }
@@ -14677,13 +14708,13 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
         }
         intersectsWith(target) {
             switch (target.collisionType) {
-                case 6 /* CollisionType.SceneNode */: return intersectionLineRect(this, target.getBounds());
-                case 2 /* CollisionType.Rectangle */: return intersectionLineRect(this, target);
-                case 5 /* CollisionType.Polygon */: return intersectionLinePoly(this, target);
-                case 3 /* CollisionType.Circle */: return intersectionLineCircle(this, target);
-                case 4 /* CollisionType.Ellipse */: return intersectionLineEllipse(this, target);
-                case 1 /* CollisionType.Line */: return intersectionLineLine(this, target);
-                case 0 /* CollisionType.Point */: return intersectionPointLine(target, this);
+                case exports.CollisionType.SceneNode: return intersectionLineRect(this, target.getBounds());
+                case exports.CollisionType.Rectangle: return intersectionLineRect(this, target);
+                case exports.CollisionType.Polygon: return intersectionLinePoly(this, target);
+                case exports.CollisionType.Circle: return intersectionLineCircle(this, target);
+                case exports.CollisionType.Ellipse: return intersectionLineEllipse(this, target);
+                case exports.CollisionType.Line: return intersectionLineLine(this, target);
+                case exports.CollisionType.Point: return intersectionPointLine(target, this);
                 default: return false;
             }
         }
@@ -14713,9 +14744,12 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
 
     let temp$2 = null;
     class Circle {
+        static collisionSegments = 32;
+        collisionType = exports.CollisionType.Circle;
+        _position;
+        _collisionVertices = null;
+        _radius;
         constructor(x = 0, y = 0, radius = 0) {
-            this.collisionType = 3 /* CollisionType.Circle */;
-            this._collisionVertices = null;
             this._position = new Vector(x, y);
             this._radius = radius;
         }
@@ -14789,22 +14823,22 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
         }
         intersectsWith(target) {
             switch (target.collisionType) {
-                case 6 /* CollisionType.SceneNode */: return intersectionRectCircle(target.getBounds(), this);
-                case 2 /* CollisionType.Rectangle */: return intersectionRectCircle(target, this);
-                case 5 /* CollisionType.Polygon */: return intersectionCirclePoly(this, target);
-                case 3 /* CollisionType.Circle */: return intersectionCircleCircle(this, target);
-                case 4 /* CollisionType.Ellipse */: return intersectionCircleEllipse(this, target);
-                case 1 /* CollisionType.Line */: return intersectionLineCircle(target, this);
-                case 0 /* CollisionType.Point */: return intersectionPointCircle(target, this);
+                case exports.CollisionType.SceneNode: return intersectionRectCircle(target.getBounds(), this);
+                case exports.CollisionType.Rectangle: return intersectionRectCircle(target, this);
+                case exports.CollisionType.Polygon: return intersectionCirclePoly(this, target);
+                case exports.CollisionType.Circle: return intersectionCircleCircle(this, target);
+                case exports.CollisionType.Ellipse: return intersectionCircleEllipse(this, target);
+                case exports.CollisionType.Line: return intersectionLineCircle(target, this);
+                case exports.CollisionType.Point: return intersectionPointCircle(target, this);
                 default: return false;
             }
         }
         collidesWith(target) {
             switch (target.collisionType) {
-                case 6 /* CollisionType.SceneNode */: return getCollisionCircleRectangle(this, target.getBounds());
-                case 2 /* CollisionType.Rectangle */: return getCollisionCircleRectangle(this, target);
-                case 5 /* CollisionType.Polygon */: return getCollisionPolygonCircle(target, this, true);
-                case 3 /* CollisionType.Circle */: return getCollisionCircleCircle(this, target);
+                case exports.CollisionType.SceneNode: return getCollisionCircleRectangle(this, target.getBounds());
+                case exports.CollisionType.Rectangle: return getCollisionCircleRectangle(this, target);
+                case exports.CollisionType.Polygon: return getCollisionPolygonCircle(target, this, true);
+                case exports.CollisionType.Circle: return getCollisionCircleCircle(this, target);
                 // case CollisionType.Ellipse: return intersectionCircleEllipse(this, target as Ellipse);
                 // case CollisionType.Line: return intersectionLineCircle(target as Line, this);
                 // case CollisionType.Point: return intersectionPointCircle(target as Vector, this);
@@ -14836,11 +14870,12 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
             return temp$2;
         }
     }
-    Circle.collisionSegments = 32;
 
     class Ellipse {
+        collisionType = exports.CollisionType.Ellipse;
+        _position;
+        _radius;
         constructor(x = 0, y = 0, halfWidth = 0, halfHeight = halfWidth) {
-            this.collisionType = 4 /* CollisionType.Ellipse */;
             this._position = new Vector(x, y);
             this._radius = new Vector(halfWidth, halfHeight);
         }
@@ -14912,13 +14947,13 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
         }
         intersectsWith(target) {
             switch (target.collisionType) {
-                case 6 /* CollisionType.SceneNode */: return intersectionRectEllipse(target.getBounds(), this);
-                case 2 /* CollisionType.Rectangle */: return intersectionRectEllipse(target, this);
-                case 5 /* CollisionType.Polygon */: return intersectionEllipsePoly(this, target);
-                case 3 /* CollisionType.Circle */: return intersectionCircleEllipse(target, this);
-                case 4 /* CollisionType.Ellipse */: return intersectionEllipseEllipse(this, target);
-                case 1 /* CollisionType.Line */: return intersectionLineEllipse(target, this);
-                case 0 /* CollisionType.Point */: return intersectionPointEllipse(target, this);
+                case exports.CollisionType.SceneNode: return intersectionRectEllipse(target.getBounds(), this);
+                case exports.CollisionType.Rectangle: return intersectionRectEllipse(target, this);
+                case exports.CollisionType.Polygon: return intersectionEllipsePoly(this, target);
+                case exports.CollisionType.Circle: return intersectionCircleEllipse(target, this);
+                case exports.CollisionType.Ellipse: return intersectionEllipseEllipse(this, target);
+                case exports.CollisionType.Line: return intersectionLineEllipse(target, this);
+                case exports.CollisionType.Point: return intersectionPointEllipse(target, this);
                 default: return false;
             }
         }
@@ -14942,11 +14977,12 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
 
     let temp$1 = null;
     class Polygon {
+        collisionType = exports.CollisionType.Polygon;
+        _position;
+        _points = [];
+        _edges = [];
+        _normals = [];
         constructor(points = [], x = 0, y = 0) {
-            this.collisionType = 5 /* CollisionType.Polygon */;
-            this._points = [];
-            this._edges = [];
-            this._normals = [];
             this._position = new Vector(x, y);
             this.setPoints(points);
         }
@@ -15057,22 +15093,22 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
         }
         intersectsWith(target) {
             switch (target.collisionType) {
-                case 6 /* CollisionType.SceneNode */: return intersectionRectPoly(target.getBounds(), this);
-                case 2 /* CollisionType.Rectangle */: return intersectionRectPoly(target, this);
-                case 5 /* CollisionType.Polygon */: return intersectionPolyPoly(this, target);
-                case 3 /* CollisionType.Circle */: return intersectionCirclePoly(target, this);
-                case 4 /* CollisionType.Ellipse */: return intersectionEllipsePoly(target, this);
-                case 1 /* CollisionType.Line */: return intersectionLinePoly(target, this);
-                case 0 /* CollisionType.Point */: return intersectionPointPoly(target, this);
+                case exports.CollisionType.SceneNode: return intersectionRectPoly(target.getBounds(), this);
+                case exports.CollisionType.Rectangle: return intersectionRectPoly(target, this);
+                case exports.CollisionType.Polygon: return intersectionPolyPoly(this, target);
+                case exports.CollisionType.Circle: return intersectionCirclePoly(target, this);
+                case exports.CollisionType.Ellipse: return intersectionEllipsePoly(target, this);
+                case exports.CollisionType.Line: return intersectionLinePoly(target, this);
+                case exports.CollisionType.Point: return intersectionPointPoly(target, this);
                 default: return false;
             }
         }
         collidesWith(target) {
             switch (target.collisionType) {
-                case 6 /* CollisionType.SceneNode */: return getCollisionSat(this, target);
-                case 2 /* CollisionType.Rectangle */: return getCollisionSat(this, target);
-                case 5 /* CollisionType.Polygon */: return getCollisionSat(this, target);
-                case 3 /* CollisionType.Circle */: return getCollisionPolygonCircle(this, target);
+                case exports.CollisionType.SceneNode: return getCollisionSat(this, target);
+                case exports.CollisionType.Rectangle: return getCollisionSat(this, target);
+                case exports.CollisionType.Polygon: return getCollisionSat(this, target);
+                case exports.CollisionType.Circle: return getCollisionPolygonCircle(this, target);
                 // case CollisionType.Ellipse: return intersectionEllipsePoly(target as Ellipse, this);
                 // case CollisionType.Line: return intersectionLinePoly(target as Line, this);
                 // case CollisionType.Point: return intersectionPointPoly(target as Vector, this);
@@ -15096,6 +15132,8 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
 
     let temp = null;
     class Segment {
+        _startPoint;
+        _endPoint;
         constructor(startX = 0, startY = 0, endX = 0, endY = 0) {
             this._startPoint = new Vector(startX, startY);
             this._endPoint = new Vector(endX, endY);
@@ -15168,6 +15206,8 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class PolarVector {
+        radius;
+        phi;
         constructor(radius = 0, angle = 0) {
             this.radius = radius;
             this.phi = angle;
@@ -15181,6 +15221,8 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class ColorAffector {
+        _fromColor;
+        _toColor;
         constructor(fromColor, toColor) {
             this._fromColor = fromColor.clone();
             this._toColor = toColor.clone();
@@ -15219,6 +15261,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class ForceAffector {
+        _acceleration;
         constructor(accelerationX, accelerationY) {
             this._acceleration = new Vector(accelerationX, accelerationY);
         }
@@ -15242,6 +15285,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class ScaleAffector {
+        _scaleFactor;
         constructor(factorX, factorY) {
             this._scaleFactor = new Vector(factorX, factorY);
         }
@@ -15265,6 +15309,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class TorqueAffector {
+        _angularAcceleration;
         constructor(angularAcceleration) {
             this._angularAcceleration = angularAcceleration;
         }
@@ -15288,6 +15333,15 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class ParticleOptions {
+        _totalLifetime;
+        _elapsedLifetime;
+        _position;
+        _velocity;
+        _scale;
+        _tint;
+        _rotation;
+        _rotationSpeed;
+        _textureIndex;
         constructor(options = {}) {
             const { totalLifetime, elapsedLifetime, position, velocity, scale, rotation, rotationSpeed, textureIndex, tint, } = options;
             this._totalLifetime = (totalLifetime ?? Time.oneSecond).clone();
@@ -15376,8 +15430,10 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class UniversalEmitter {
+        _emissionRate;
+        _particleOptions;
+        _emissionDelta = 0;
         constructor(emissionRate, particleOptions) {
-            this._emissionDelta = 0;
             this._emissionRate = emissionRate;
             this._particleOptions = particleOptions ?? new ParticleOptions();
         }
@@ -15432,13 +15488,10 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class Graphics extends Container {
-        constructor() {
-            super(...arguments);
-            this._lineWidth = 0;
-            this._lineColor = new Color();
-            this._fillColor = new Color();
-            this._currentPoint = new Vector(0, 0);
-        }
+        _lineWidth = 0;
+        _lineColor = new Color();
+        _fillColor = new Color();
+        _currentPoint = new Vector(0, 0);
         get lineWidth() {
             return this._lineWidth;
         }
@@ -15632,10 +15685,11 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class Spritesheet {
+        texture;
+        frames = new Map();
+        sprites = new Map();
+        animations = new Map();
         constructor(texture, data) {
-            this.frames = new Map();
-            this.sprites = new Map();
-            this.animations = new Map();
             this.texture = texture;
             this.parse(data);
         }
@@ -15715,16 +15769,16 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
 
     const defaultClipFps = 12;
     class AnimatedSprite extends Sprite {
+        _clips = new Map();
+        _currentClipName = null;
+        _currentFrameIndex = 0;
+        _playing = false;
+        _loopOverride = null;
+        _elapsedFrameTimeMs = 0;
+        onComplete = new Signal();
+        onFrame = new Signal();
         constructor(texture, clips) {
             super(texture);
-            this._clips = new Map();
-            this._currentClipName = null;
-            this._currentFrameIndex = 0;
-            this._playing = false;
-            this._loopOverride = null;
-            this._elapsedFrameTimeMs = 0;
-            this.onComplete = new Signal();
-            this.onFrame = new Signal();
             if (clips) {
                 this.setClips(clips);
             }
@@ -15886,8 +15940,21 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class TextStyle {
+        _align;
+        _fill;
+        _stroke;
+        _strokeThickness;
+        _fontSize;
+        _fontWeight;
+        _fontFamily;
+        _wordWrap;
+        _wordWrapWidth;
+        _baseline;
+        _lineJoin;
+        _miterLimit;
+        _padding;
+        _dirty = true;
         constructor(options = {}) {
-            this._dirty = true;
             this._align = options.align ?? 'left';
             this._fill = options.fill ?? 'black';
             this._stroke = options.stroke ?? 'black';
@@ -16064,9 +16131,13 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
 
     const newLinePattern = /(?:\r\n|\r|\n)/;
     class Text extends Sprite {
+        _text;
+        _style;
+        _canvas;
+        _context;
+        _dirty = true;
         constructor(text, style, samplerOptions, canvas = document.createElement('canvas')) {
             super(new Texture(canvas, samplerOptions));
-            this._dirty = true;
             this._text = text;
             this._style = (style && style instanceof TextStyle) ? style : new TextStyle(style);
             this._canvas = canvas;
@@ -16181,6 +16252,13 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class Sampler {
+        _context;
+        _sampler;
+        _scaleMode;
+        _wrapMode;
+        _premultiplyAlpha;
+        _generateMipMap;
+        _flipY;
         constructor(gl, options) {
             const { scaleMode, wrapMode, premultiplyAlpha, generateMipMap, flipY } = options;
             this._context = gl;
@@ -16248,6 +16326,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class CallbackRenderPass {
+        _callback;
         constructor(callback) {
             this._callback = callback;
         }
@@ -16260,12 +16339,12 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class BlurFilter extends Filter {
+        _sprite = new Sprite(null);
+        _sampleTint = Color.white.clone();
+        _radius = 2;
+        _quality = 1;
         constructor(options = {}) {
             super();
-            this._sprite = new Sprite(null);
-            this._sampleTint = Color.white.clone();
-            this._radius = 2;
-            this._quality = 1;
             this._radius = Math.max(0, options.radius ?? 2);
             this._quality = Math.max(1, Math.floor(options.quality ?? 1));
         }
@@ -16320,9 +16399,10 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class ColorFilter extends Filter {
+        _color;
+        _sprite = new Sprite(null);
         constructor(color = Color.white) {
             super();
-            this._sprite = new Sprite(null);
             this._color = color.clone();
         }
         get color() {
@@ -16399,13 +16479,17 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
         'text', 'svg', 'json', 'binary', 'wasm', 'vtt',
     ];
     class IndexedDbDatabase {
+        name;
+        version;
+        _storeNames;
+        _migrations;
+        _onCloseHandler = this.disconnect.bind(this);
+        _connected = false;
+        _database = null;
         get connected() {
             return this._connected;
         }
         constructor(name, version = 1, storeNames = defaultStoreNames, migrations) {
-            this._onCloseHandler = this.disconnect.bind(this);
-            this._connected = false;
-            this._database = null;
             if (!supportsIndexedDb) {
                 throw new Error('This browser does not support indexedDB!');
             }
@@ -16530,6 +16614,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     }
 
     class IndexedDbStore {
+        _db;
         constructor(nameOrOptions) {
             const options = typeof nameOrOptions === 'string'
                 ? { name: nameOrOptions }
@@ -16675,6 +16760,14 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
         toPackedCollisionGroups(options.collisionFilter);
     };
     class RapierPhysicsBinding {
+        _world;
+        _body;
+        _collider;
+        _syncMode;
+        node;
+        bodyType;
+        shape;
+        trigger;
         constructor(world, node, body, collider, options) {
             this._world = world;
             this.node = node;
@@ -16740,14 +16833,17 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
         }
     }
     class RapierPhysicsWorld {
+        onCollisionEnter = new Signal();
+        onCollisionExit = new Signal();
+        onTriggerEnter = new Signal();
+        onTriggerExit = new Signal();
+        _rapier;
+        _world;
+        _eventQueue;
+        _bindings = new Set();
+        _nodeBindings = new Map();
+        _colliderBindings = new Map();
         constructor(rapier, world, eventQueue) {
-            this.onCollisionEnter = new Signal();
-            this.onCollisionExit = new Signal();
-            this.onTriggerEnter = new Signal();
-            this.onTriggerExit = new Signal();
-            this._bindings = new Set();
-            this._nodeBindings = new Map();
-            this._colliderBindings = new Map();
             this._rapier = rapier;
             this._world = world;
             this._eventQueue = eventQueue;
@@ -16760,7 +16856,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
-                throw new Error(`Rapier physics module is unavailable. Install "${rapierModuleName}" or provide a custom module loader. Original error: ${message}`);
+                throw new Error(`Rapier physics module is unavailable. Install "${rapierModuleName}" or provide a custom module loader. Original error: ${message}`, { cause: error });
             }
             const rapier = resolveRapierModule(loadedModule);
             if (typeof rapier.init === 'function') {
@@ -17212,7 +17308,7 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
     exports.resolveDefinition = resolveDefinition;
     exports.resolveGamepadDefinition = resolveGamepadDefinition;
     exports.seconds = seconds;
-    exports.sign = sign;
+    exports.sign = sign$1;
     exports.stopEvent = stopEvent;
     exports.supportsCodec = supportsCodec;
     exports.supportsEventOptions = supportsEventOptions;