rapid-render 1.0.15 → 1.0.16

package/dist/rapid-render.js

@@ -1,34 +1,17 @@
-var A = /* @__PURE__ */ ((n) => (n[n.Float32 = 0] = "Float32", n[n.Uint32 = 1] = "Uint32", n[n.Uint16 = 2] = "Uint16", n))(A || {});
-class b {
-  /** The number of elements currently used in the buffer. */
+var S = /* @__PURE__ */ ((n) => (n[n.Float32 = 0] = "Float32", n[n.Uint32 = 1] = "Uint32", n[n.Uint16 = 2] = "Uint16", n))(S || {});
+class A {
   usedElemNum;
-  /** The main typed array view corresponding to the specified ArrayType. */
   typedArray;
   arrayType;
-  /** The maximum number of elements the buffer can currently hold without resizing. */
   maxElemNum;
-  /** The number of bytes per element based on the `ArrayType`. */
   bytePerElem;
   arraybuffer;
-  /** `Uint32Array` view of the underlying memory buffer. */
   uint32;
-  /** `Float32Array` view of the underlying memory buffer. */
   float32;
-  /** `Uint16Array` view of the underlying memory buffer. */
   uint16;
-  /**
-   * Initializes a new dynamic array buffer.
-   * @param arrayType - The type of elements this buffer will store primarily.
-   */
   constructor(t) {
     this.usedElemNum = 0, this.maxElemNum = 512, this.bytePerElem = this.getArrayType(t).BYTES_PER_ELEMENT, this.arrayType = t, this.arraybuffer = new ArrayBuffer(this.maxElemNum * this.bytePerElem), this.updateTypedArray();
   }
-  /**
-   * Returns the typed array constructor for the corresponding `ArrayType`.
-   * @param arrayType - The type of the array.
-   * @returns The typed array constructor.
-   * @throws Dispatches an error if the specified type is unsupported.
-   */
   getArrayType(t) {
     switch (t) {
       case 0:
@@ -41,9 +24,6 @@ class b {
         throw new Error("Unsupported ArrayType");
     }
   }
-  /**
-   * Updates the typed array views when the internal array buffer gets reallocated.
-   */
   updateTypedArray() {
     switch (this.uint32 = new Uint32Array(this.arraybuffer), this.float32 = new Float32Array(this.arraybuffer), this.uint16 = new Uint16Array(this.arraybuffer), this.arrayType) {
       case 0:
@@ -57,38 +37,30 @@ class b {
         break;
     }
   }
-  /**
-   * Resets the element usage count to zero. The underlying memory capacity is preserved.
-   */
   clear() {
     this.usedElemNum = 0;
   }
   static removeAtIndices(t, e) {
-    const r = Math.max(...e.map((o) => o.usedElemNum)), i = [...new Set(t)].filter(
-      (o) => o >= 0 && o < r
-    ).sort((o, h) => o - h);
+    const r = Math.max(...e.map((h) => h.usedElemNum)), i = [...new Set(t)].filter(
+      (h) => h >= 0 && h < r
+    ).sort((h, o) => h - o);
     if (i.length === 0)
       return 0;
     let s = 0, a = 0;
-    for (let o = 0; o < r; o++) {
-      if (a < i.length && o === i[a]) {
+    for (let h = 0; h < r; h++) {
+      if (a < i.length && h === i[a]) {
         a++;
         continue;
       }
-      if (s !== o)
-        for (const h of e)
-          h.typedArray[s] = h.typedArray[o];
+      if (s !== h)
+        for (const o of e)
+          o.typedArray[s] = o.typedArray[h];
       s++;
     }
-    for (const o of e)
-      o.usedElemNum = s;
+    for (const h of e)
+      h.usedElemNum = s;
     return r - s;
   }
-  /**
-   * Checks if the buffer has enough space for additional elements and resizes the buffer if necessary.
-   * @param size - The number of new elements that need to be accommodated.
-   * @returns `true` if the buffer was resized, `false` otherwise.
-   */
   resize(t = 0) {
     if (t += this.usedElemNum, t > this.maxElemNum) {
       for (; t > this.maxElemNum; )
@@ -97,125 +69,54 @@ class b {
     }
     return !1;
   }
-  /**
-   * Reallocates the underlying array buffer to a new size and copies existing data.
-   * @param size - The new maximum number of elements.
-   */
   setMaxSize(t = this.maxElemNum) {
     const e = this.typedArray;
     this.maxElemNum = t, this.arraybuffer = new ArrayBuffer(t * this.bytePerElem), this.updateTypedArray(), this.typedArray.set(e);
   }
-  /**
-   * Appends a new 32-bit unsigned integer element to the buffer.
-   * @param value - The item to add.
-   */
   pushUint32(t) {
     this.resize(1), this.uint32[this.usedElemNum++] = t;
   }
-  /**
-   * Appends a new 32-bit floating point element to the buffer.
-   * @param value - The item to add.
-   */
   pushFloat32(t) {
     this.resize(1), this.float32[this.usedElemNum++] = t;
   }
-  /**
-   * Appends an element to the buffer, using the primary typed array view.
-   * @param value - The item to add.
-   */
   push(t) {
     this.resize(1), this.typedArray[this.usedElemNum++] = t;
   }
-  /**
-   * Removes and returns the last element in the buffer.
-   * @returns The removed element or undefined if the buffer is empty.
-   */
   pop() {
     return this.typedArray[--this.usedElemNum];
   }
-  /**
-   * Returns the last element pushed to the buffer without removing it.
-   * @returns The last element.
-   */
   top() {
     return this.typedArray[this.usedElemNum - 1];
   }
-  /**
-   * Gets the value of the element at the specified index.
-   * @param index - The index of the element to retrieve.
-   * @returns The requested element.
-   */
   get(t) {
     return this.typedArray[t];
   }
-  /**
-   * Returns a constrained view of the primary typed array up to the specified range.
-   * If `end` is omitted, returns the whole reallocated buffer slice.
-   * @param begin - The starting index (inclusive). Defaults to 0.
-   * @param end - The ending index (exclusive). Optional.
-   * @returns A subarray corresponding to the specified range.
-   */
   getArray(t = 0, e) {
     return e === void 0 ? this.typedArray : this.typedArray.subarray(t, e);
   }
-  /**
-   * The number of elements currently stored in the buffer.
-   */
   get length() {
     return this.usedElemNum;
   }
-  /**
-   * Resets the buffer's used element count, effectively emptying it.
-   * Same behavior as `clear`.
-   */
-  reset() {
-    this.usedElemNum = 0;
-  }
 }
-class tt extends b {
-  /** The actual WebGLBuffer object maintained by this instance. */
+class it extends A {
   buffer;
-  /** The related WebGL rendering context. */
   gl;
-  /** Signifies whether the buffer has been updated and requires resyncing to the GPU. */
   dirty = !0;
-  /** The WebGL buffer type, e.g., gl.ARRAY_BUFFER. */
   type;
-  /** Size of the allocated buffer block on the GPU side, bounded in elements count. */
   webglBufferSize = 0;
-  /** Usage hint for WebGL, e.g., gl.DYNAMIC_DRAW. */
   usage;
-  /**
-   * Initializes a new WebGL dynamic buffer.
-   * @param gl - The active WebGL rendering context state.
-   * @param arrayType - Type of the underlying data elements to bind.
-   * @param type - Determines the type of WebGLBuffer (defaults to gl.ARRAY_BUFFER).
-   * @param usage - Determines the data usage pattern (defaults to gl.DYNAMIC_DRAW).
-   */
   constructor(t, e, r = t.ARRAY_BUFFER, i = t.DYNAMIC_DRAW) {
     super(e), this.gl = t, this.buffer = t.createBuffer(), this.type = r, this.usage = i;
   }
-  /**
-   * Flags the buffer as dirty, marking it for future data synchronization.
-   */
   makeDirty() {
     this.dirty = !0;
   }
-  /**
-   * Clears CPU side data usage and marks buffer as synced to stop needless updates.
-   */
   clear() {
     super.clear(), this.dirty = !1;
   }
-  /**
-   * Binds this buffer object tracking it as the current bound buffer to the GPU.
-   */
   bindBuffer() {
     this.gl.bindBuffer(this.type, this.buffer);
   }
-  /**
-   * Uploads the local buffer data to the GPU memory synchronously.
-   */
   bufferData() {
     if (this.dirty) {
       const t = this.gl;
@@ -233,75 +134,36 @@ class x {
   static clampByte(t) {
     return t <= 0 ? 0 : t >= 255 ? 255 : Math.round(t);
   }
-  /**
-   * Creates an instance of Color.
-   * @param r - The red component (0-255).
-   * @param g - The green component (0-255).
-   * @param b - The blue component (0-255).
-   * @param a - The alpha component (0-255).
-   */
   constructor(t, e, r, i = 255) {
     this._r = t, this._g = e, this._b = r, this._a = i, this.updateUint();
   }
   setClearColor(t) {
     t.clearColor(this.r / 255, this.g / 255, this.b / 255, this.a / 255);
   }
-  /**
-   * Gets the red component.
-   */
   get r() {
     return this._r;
   }
-  /**
-   * Sets the red component and updates the uint32 representation.
-   * @param value - The new red component (0-255).
-   */
   set r(t) {
     this._r = t, this.updateUint();
   }
-  /**
-   * Gets the green component.
-   */
   get g() {
     return this._g;
   }
-  /**
-   * Sets the green component and updates the uint32 representation.
-   * @param value - The new green component (0-255).
-   */
   set g(t) {
     this._g = t, this.updateUint();
   }
-  /**
-   * Gets the blue component.
-   */
   get b() {
     return this._b;
   }
-  /**
-   * Sets the blue component and updates the uint32 representation.
-   * @param value - The new blue component (0-255).
-   */
   set b(t) {
     this._b = t, this.updateUint();
   }
-  /**
-   * Gets the alpha component.
-   */
   get a() {
     return this._a;
   }
-  /**
-   * Sets the alpha component and updates the uint32 representation.
-   * @param value - The new alpha component (0-255).
-   */
   set a(t) {
     this._a = t, this.updateUint();
   }
-  /**
-   * Updates the uint32 representation of the color.
-   * @private
-   */
   updateUint() {
     this.uint32 = (this._a << 24 | this._b << 16 | this._g << 8 | this._r) >>> 0;
     const t = x.clampByte(this._a), e = x.clampByte(this._r * t / 255), r = x.clampByte(this._g * t / 255), i = x.clampByte(this._b * t / 255);
@@ -310,71 +172,28 @@ class x {
   reset() {
     this._r = 0, this._g = 0, this._b = 0, this._a = 255, this.updateUint();
   }
-  /**
-   * Sets the RGBA values of the color and updates the uint32 representation.
-   * @param r - The red component (0-255).
-   * @param g - The green component (0-255).
-   * @param b - The blue component (0-255).
-   * @param a - The alpha component (0-255).
-   */
   setRGBA(t, e, r, i) {
-    this.r = t, this.g = e, this.b = r, this.a = i, this.updateUint();
+    this._r = t, this._g = e, this._b = r, this._a = i, this.updateUint();
   }
   setHSL(t, e, r) {
     t = (t % 360 + 360) % 360, e = Math.max(0, Math.min(100, e)) / 100, r = Math.max(0, Math.min(100, r)) / 100;
     const i = (1 - Math.abs(2 * r - 1)) * e, s = i * (1 - Math.abs(t / 60 % 2 - 1)), a = r - i / 2;
-    let o = 0, h = 0, c = 0;
-    return t < 60 ? [o, h, c] = [i, s, 0] : t < 120 ? [o, h, c] = [s, i, 0] : t < 180 ? [o, h, c] = [0, i, s] : t < 240 ? [o, h, c] = [0, s, i] : t < 300 ? [o, h, c] = [s, 0, i] : [o, h, c] = [i, 0, s], this.setRGBA((o + a) * 255, (h + a) * 255, (c + a) * 255, 255), this;
-  }
-  toHex() {
-    const t = (e) => Math.max(0, Math.min(255, Math.round(e))).toString(16).padStart(2, "0");
-    return `#${t(this._r)}${t(this._g)}${t(this._b)}${t(this._a)}`;
+    let h = 0, o = 0, c = 0;
+    return t < 60 ? [h, o, c] = [i, s, 0] : t < 120 ? [h, o, c] = [s, i, 0] : t < 180 ? [h, o, c] = [0, i, s] : t < 240 ? [h, o, c] = [0, s, i] : t < 300 ? [h, o, c] = [s, 0, i] : [h, o, c] = [i, 0, s], this.setRGBA((h + a) * 255, (o + a) * 255, (c + a) * 255, 255), this;
   }
-  /**
-   * Copies the RGBA values from another color.
-   * @param color - The color to copy from.
-   */
   copy(t) {
     this.setRGBA(t.r, t.g, t.b, t.a);
   }
-  /**
-   * Clone the current color
-   * @returns A new `Color` instance with the same RGBA values.
-   */
   clone() {
     return new x(this._r, this._g, this._b, this._a);
   }
-  /**
-   * Converts the color to a hexadecimal string representation (e.g., '#RRGGBBAA').
-   * @param includeAlpha - Whether to include the alpha channel in the hex string.
-   * @returns The hexadecimal string representation of the color.
-   */
   toHexString(t = !0) {
     const e = this.r.toString(16).padStart(2, "0"), r = this.g.toString(16).padStart(2, "0"), i = this.b.toString(16).padStart(2, "0"), s = this.a.toString(16).padStart(2, "0");
     return `#${e}${r}${i}${t ? s : ""}`;
   }
-  /**
-   * Checks if the current color is equal to another color.
-   * @param color - The color to compare with.
-   * @returns True if the colors are equal, otherwise false.
-   */
-  equal(t) {
+  equals(t) {
     return t.r === this.r && t.g === this.g && t.b === this.b && t.a === this.a;
   }
-  equals(t) {
-    return this.equal(t);
-  }
-  /**
-   * Creates a Color instance from normalized float components (0–1 range).
-   * Use this instead of `new Color()` when working with shader-style 0.0–1.0 values.
-   * @param r - Red channel (0.0–1.0)
-   * @param g - Green channel (0.0–1.0)
-   * @param b - Blue channel (0.0–1.0)
-   * @param a - Alpha channel (0.0–1.0), defaults to 1.0
-   * @returns A new Color instance with components scaled to 0–255.
-   * @example
-   * Color.fromNorm(0.9, 0.87, 0.55, 0.1) // moon glow
-   */
   static FromHSL(t, e, r) {
     return new x(0, 0, 0).setHSL(t, e, r);
   }
@@ -389,29 +208,16 @@ class x {
       Math.round(i * 255)
     );
   }
-  static clampColorByte(t) {
-    return t <= 0 ? 0 : t >= 255 ? 255 : Math.round(t);
-  }
   static packColor(t, e, r, i, s) {
-    const a = x.clampColorByte(i), o = s ? a / 255 : 1, h = x.clampColorByte(t * o), c = x.clampColorByte(e * o), u = x.clampColorByte(r * o);
-    return (a << 24 | u << 16 | c << 8 | h) >>> 0;
-  }
-  /**
-   * Creates a Color instance from a hexadecimal color string.
-   * @param hexString - The hexadecimal color string, e.g., '#RRGGBB' or '#RRGGBBAA'.
-   * @returns A new Color instance.
-   */
+    const a = x.clampByte(i), h = s ? a / 255 : 1, o = x.clampByte(t * h), c = x.clampByte(e * h), u = x.clampByte(r * h);
+    return (a << 24 | u << 16 | c << 8 | o) >>> 0;
+  }
   static fromHex(t) {
     t.startsWith("#") && (t = t.slice(1));
     const e = parseInt(t.slice(0, 2), 16), r = parseInt(t.slice(2, 4), 16), i = parseInt(t.slice(4, 6), 16);
     let s = 255;
     return t.length >= 8 && (s = parseInt(t.slice(6, 8), 16)), new x(e, r, i, s);
   }
-  /**
-   * Adds the components of another color to this color, clamping the result to 255.
-   * @param color - The color to add.
-   * @returns A new Color instance with the result of the addition.
-   */
   add(t) {
     return new x(
       Math.min(this.r + t.r, 255),
@@ -420,11 +226,6 @@ class x {
       Math.min(this.a + t.a, 255)
     );
   }
-  /**
-   * Subtracts the components of another color from this color, clamping the result to 0.
-   * @param color - The color to subtract.
-   * @returns A new Color instance with the result of the subtraction.
-   */
   subtract(t) {
     return new x(
       this.r - t.r,
@@ -460,7 +261,7 @@ class x {
     );
   }
   clamp() {
-    this.r = Math.max(0, Math.min(255, this.r)), this.g = Math.max(0, Math.min(255, this.g)), this.b = Math.max(0, Math.min(255, this.b)), this.a = Math.max(0, Math.min(255, this.a));
+    this._r = Math.max(0, Math.min(255, this._r)), this._g = Math.max(0, Math.min(255, this._g)), this._b = Math.max(0, Math.min(255, this._b)), this._a = Math.max(0, Math.min(255, this._a)), this.updateUint();
   }
   static Red = new x(255, 0, 0, 255);
   static Green = new x(0, 255, 0, 255);
@@ -477,458 +278,254 @@ class x {
   static White = new x(255, 255, 255, 255);
   static Black = new x(0, 0, 0, 255);
   static Transparent = new x(0, 0, 0, 0);
-  static TRANSPARENT = new x(0, 0, 0, 0);
 }
-const E = 6;
-class Rt {
-  /** Total number of matrices currently allocated in the store. */
+const T = 6;
+class At {
   matrixCount = 0;
-  /** The dynamic buffer used to hold matrix data. */
   buffer;
-  /** The raw floating-point data of all matrices. */
   data;
   temporary = -1;
-  /**
-   * Creates a new MatrixStore.
-   * @param capacity - The initial capacity of the matrix store (default is 10).
-   */
   constructor(t = 10) {
-    this.buffer = new b(A.Float32), this.buffer.resize(t * E), this.data = this.buffer.getArray(), this.reset();
+    this.buffer = new A(S.Float32), this.buffer.resize(t * T), this.data = this.buffer.getArray(), this.reset();
   }
-  /**
-   * Allocates a new matrix and initializes it to the identity matrix.
-   * @returns The index of the newly allocated matrix.
-   */
   alloc() {
     const t = this.allocDirty();
     return this.identity(t), t;
   }
-  /**
-   * Allocates a new matrix without initializing its elements.
-   * @returns The index of the newly allocated matrix.
-   */
   allocDirty() {
-    return this.buffer.resize(E) && (this.data = this.buffer.getArray()), this.buffer.usedElemNum += E, this.matrixCount++;
+    return this.buffer.resize(T) && (this.data = this.buffer.getArray()), this.buffer.usedElemNum += T, this.matrixCount++;
   }
-  /**
-   * Resets the store, clearing all allocated matrices.
-   */
   reset() {
     this.matrixCount = 0, this.buffer.usedElemNum = 0, this.temporary = this.alloc();
   }
-  /**
-   * Sets the matrix at the given index to the identity matrix.
-   * @param index - The index of the matrix to modify.
-   */
   identity(t) {
-    const e = t * E, r = this.data;
+    const e = t * T, r = this.data;
     r[e] = 1, r[e + 1] = 0, r[e + 2] = 0, r[e + 3] = 1, r[e + 4] = 0, r[e + 5] = 0;
   }
-  /**
-   * Translates the matrix at the given index by x and y.
-   * @param index - The index of the matrix to modify.
-   * @param x - The x translation.
-   * @param y - The y translation.
-   */
   translate(t, e, r) {
-    const i = t * E, s = this.data;
+    const i = t * T, s = this.data;
     s[i + 4] = s[i] * e + s[i + 2] * r + s[i + 4], s[i + 5] = s[i + 1] * e + s[i + 3] * r + s[i + 5];
   }
-  /**
-   * Scales the matrix at the given index by scaleX and scaleY.
-   * @param index - The index of the matrix to modify.
-   * @param scaleX - The scale factor along the x-axis.
-   * @param scaleY - The scale factor along the y-axis.
-   */
   scale(t, e, r) {
-    const i = t * E, s = this.data;
+    const i = t * T, s = this.data;
     s[i] *= e, s[i + 1] *= e, s[i + 2] *= r, s[i + 3] *= r;
   }
-  /**
-   * Rotates the matrix at the given index by the specified radians.
-   * @param index - The index of the matrix to modify.
-   * @param radians - The rotation angle in radians.
-   */
   rotate(t, e) {
-    const r = t * E, i = this.data, s = Math.cos(e), a = Math.sin(e), o = i[r], h = i[r + 1], c = i[r + 2], u = i[r + 3];
-    i[r] = o * s + c * a, i[r + 1] = h * s + u * a, i[r + 2] = o * -a + c * s, i[r + 3] = h * -a + u * s;
-  }
-  /**
-   * Rotates the matrix at the given index around a local offset point (pivot).
-   *
-   * This is equivalent to:
-   * 1. Translating by `(offsetX, offsetY)` to move the pivot to the origin.
-   * 2. Rotating by `radians`.
-   * 3. Translating back by `(-offsetX, -offsetY)`.
-   *
-   * Useful for rotating a sprite around a point other than its own origin,
-   * e.g. a character's limb rotating around its joint.
-   *
-   * @param index   - The index of the matrix to modify.
-   * @param radians - The rotation angle in radians.
-   * @param offsetX - The x component of the pivot point in local space.
-   * @param offsetY - The y component of the pivot point in local space.
-   */
+    const r = t * T, i = this.data, s = Math.cos(e), a = Math.sin(e), h = i[r], o = i[r + 1], c = i[r + 2], u = i[r + 3];
+    i[r] = h * s + c * a, i[r + 1] = o * s + u * a, i[r + 2] = h * -a + c * s, i[r + 3] = o * -a + u * s;
+  }
   rotateWithOffset(t, e, r, i) {
     this.translate(t, r, i), this.rotate(t, e), this.translate(t, -r, -i);
   }
-  /**
-   * Copies the elements from the source matrix to the destination matrix.
-   * @param dst - The index of the destination matrix.
-   * @param src - The index of the source matrix.
-   */
   copy(t, e) {
-    const r = t * E, i = e * E, s = this.data;
+    const r = t * T, i = e * T, s = this.data;
     s[r] = s[i], s[r + 1] = s[i + 1], s[r + 2] = s[i + 2], s[r + 3] = s[i + 3], s[r + 4] = s[i + 4], s[r + 5] = s[i + 5];
   }
-  /**
-   * Multiplies the destination matrix by the source matrix and stores the result in the destination.
-   * @param dst - The index of the destination matrix.
-   * @param src - The index of the source matrix.
-   */
   multiply(t, e) {
     this.multiplyOut(t, t, e);
   }
-  /**
-   * Multiplies matrix A by matrix B and stores the result in the output matrix.
-   * @param out - The index of the output matrix.
-   * @param aIdx - The index of matrix A.
-   * @param bIdx - The index of matrix B.
-   */
   multiplyOut(t, e, r) {
-    const i = t * E, s = e * E, a = r * E, o = this.data, h = o[s], c = o[s + 1], u = o[s + 2], l = o[s + 3], d = o[s + 4], f = o[s + 5], m = o[a], g = o[a + 1], v = o[a + 2], y = o[a + 3], R = o[a + 4], M = o[a + 5];
-    o[i] = h * m + u * g, o[i + 1] = c * m + l * g, o[i + 2] = h * v + u * y, o[i + 3] = c * v + l * y, o[i + 4] = h * R + u * M + d, o[i + 5] = c * R + l * M + f;
+    const i = t * T, s = e * T, a = r * T, h = this.data, o = h[s], c = h[s + 1], u = h[s + 2], l = h[s + 3], d = h[s + 4], f = h[s + 5], m = h[a], g = h[a + 1], v = h[a + 2], y = h[a + 3], w = h[a + 4], M = h[a + 5];
+    h[i] = o * m + u * g, h[i + 1] = c * m + l * g, h[i + 2] = o * v + u * y, h[i + 3] = c * v + l * y, h[i + 4] = o * w + u * M + d, h[i + 5] = c * w + l * M + f;
   }
-  /**
-   * Inverts the matrix at the given index. If the matrix is not invertible, it defaults to the identity matrix.
-   * @param index - The index of the matrix to invert.
-   */
   invert(t) {
-    const e = t * E, r = this.data, i = r[e], s = r[e + 1], a = r[e + 2], o = r[e + 3], h = r[e + 4], c = r[e + 5];
-    let u = i * o - s * a;
+    const e = t * T, r = this.data, i = r[e], s = r[e + 1], a = r[e + 2], h = r[e + 3], o = r[e + 4], c = r[e + 5];
+    let u = i * h - s * a;
     if (!u) {
       this.identity(t);
       return;
     }
-    u = 1 / u, r[e] = o * u, r[e + 1] = -s * u, r[e + 2] = -a * u, r[e + 3] = i * u, r[e + 4] = (a * c - o * h) * u, r[e + 5] = (s * h - i * c) * u;
-  }
-  /**
-   * Transforms a point by the matrix at the given index.
-   * @param index - The index of the transformation matrix.
-   * @param x - The x coordinate of the point.
-   * @param y - The y coordinate of the point.
-   * @returns The transformed point {x, y}.
-   */
+    u = 1 / u, r[e] = h * u, r[e + 1] = -s * u, r[e + 2] = -a * u, r[e + 3] = i * u, r[e + 4] = (a * c - h * o) * u, r[e + 5] = (s * o - i * c) * u;
+  }
   transformPoint(t, e, r) {
-    const i = t * E, s = this.data;
+    const i = t * T, s = this.data;
     return {
       x: e * s[i] + r * s[i + 2] + s[i + 4],
       y: e * s[i + 1] + r * s[i + 3] + s[i + 5]
     };
   }
-  /**
-   * Transforms a point from world coordinates to local coordinates using the matrix at the specified index.
-   * Useful for hit testing against objects placed in world space.
-   * @param index - The index of the world transformation matrix.
-   * @param x - World x coordinate.
-   * @param y - World y coordinate.
-   * @returns The transformed point in local coordinates.
-   */
   worldToLocal(t, e, r) {
     const i = this.allocDirty();
     this.copy(i, t), this.invert(i);
     const s = this.transformPoint(i, e, r);
-    return this.matrixCount--, this.buffer.usedElemNum -= E, s;
-  }
-  /**
-   * Transforms a point from local coordinates to world coordinates.
-   * @param index - The index of the local transformation matrix.
-   * @param x - Local x coordinate.
-   * @param y - Local y coordinate.
-   * @returns The transformed point in world coordinates.
-   */
+    return this.matrixCount--, this.buffer.usedElemNum -= T, s;
+  }
   localToWorld(t, e, r) {
     return this.transformPoint(t, e, r);
   }
-  /**
-   * Extracts the global position (translation) from the matrix at the given index.
-   * @param index - The index of the matrix.
-   * @returns An object containing `x` and `y` global coordinates.
-   */
   getPosition(t) {
-    const e = t * E, r = this.data;
+    const e = t * T, r = this.data;
     return { x: r[e + 4], y: r[e + 5] };
   }
-  /**
-   * Extracts the global scale from the matrix at the given index.
-   * @param index - The index of the matrix.
-   * @returns An object containing `x` and `y` global scale factors.
-   */
   getScale(t) {
-    const e = t * E, r = this.data, i = Math.sqrt(r[e] * r[e] + r[e + 1] * r[e + 1]), s = Math.sqrt(r[e + 2] * r[e + 2] + r[e + 3] * r[e + 3]);
+    const e = t * T, r = this.data, i = Math.sqrt(r[e] * r[e] + r[e + 1] * r[e + 1]), s = Math.sqrt(r[e + 2] * r[e + 2] + r[e + 3] * r[e + 3]);
     return { x: i, y: s };
   }
-  /**
-   * Extracts the global rotation (in radians) from the matrix at the given index.
-   * @param index - The index of the matrix.
-   * @returns The global rotation in radians.
-   */
   getRotation(t) {
-    const e = t * E, r = this.data;
+    const e = t * T, r = this.data;
     return Math.atan2(r[e + 1], r[e]);
   }
-  /**
-   * Converts the matrix at the given index to a CSS matrix string.
-   * @param index - The index of the matrix.
-   * @param scaleX - Extra scale applied to the a/c/tx components (e.g. to convert logic pixels to CSS pixels).
-   * @param scaleY - Extra scale applied to the b/d/ty components.
-   * @returns A CSS matrix string.
-   */
   toCSSMatrix(t, e = 1, r = 1) {
-    const i = t * E, s = this.data;
+    const i = t * T, s = this.data;
     return `matrix(${s[i] * e}, ${s[i + 1] * r}, ${s[i + 2] * e}, ${s[i + 3] * r}, ${s[i + 4] * e}, ${s[i + 5] * r})`;
   }
-  /**
-   * Retrieves a copy of the 6 elements [a, b, c, d, tx, ty] for the matrix at the specified index.
-   * Note: This uses `slice` to return a new Float32Array instance, ensuring the original data remains safely isolated.
-   * 
-   * @param index - The index of the matrix.
-   * @returns A new Float32Array containing the 6 elements of the matrix.
-   */
   getMatrix(t) {
-    const e = t * E;
-    return this.data.slice(e, e + E);
-  }
-  /**
-   * Retrieves a direct reference (view) to the 6 elements [a, b, c, d, tx, ty] for the matrix at the specified index.
-   * Note: This uses `subarray`. Any modifications made to the returned array will directly affect the underlying MatrixStore data.
-   * 
-   * @param index - The index of the matrix.
-   * @returns A Float32Array view pointing directly to the matrix's data in memory.
-   */
+    const e = t * T;
+    return this.data.slice(e, e + T);
+  }
   getMatrixRef(t) {
-    const e = t * E;
-    return this.data.subarray(e, e + E);
-  }
-  /**
-   * Overwrites the matrix at the specified index with the provided 6 elements [a, b, c, d, tx, ty].
-   * 
-   * @param index - The index of the matrix to modify.
-   * @param f - An array (Float32Array or standard number array) containing the 6 new elements.
-   */
+    const e = t * T;
+    return this.data.subarray(e, e + T);
+  }
   setMatrix(t, e) {
-    const r = t * E, i = this.data;
+    const r = t * T, i = this.data;
     i[r] = e[0], i[r + 1] = e[1], i[r + 2] = e[2], i[r + 3] = e[3], i[r + 4] = e[4], i[r + 5] = e[5];
   }
-  multiplyAffineInPlace(t, e, r, i, s, a, o) {
-    const h = t * 6, c = this.data, u = c[h], l = c[h + 1], d = c[h + 2], f = c[h + 3], m = c[h + 4], g = c[h + 5];
-    c[h] = u * e + d * r, c[h + 1] = l * e + f * r, c[h + 2] = u * i + d * s, c[h + 3] = l * i + f * s, c[h + 4] = u * a + d * o + m, c[h + 5] = l * a + f * o + g;
+  multiplyAffineInPlace(t, e, r, i, s, a, h) {
+    const o = t * 6, c = this.data, u = c[o], l = c[o + 1], d = c[o + 2], f = c[o + 3], m = c[o + 4], g = c[o + 5];
+    c[o] = u * e + d * r, c[o + 1] = l * e + f * r, c[o + 2] = u * i + d * s, c[o + 3] = l * i + f * s, c[o + 4] = u * a + d * h + m, c[o + 5] = l * a + f * h + g;
   }
-  multiplyAffine(t, e, r, i, s, a, o, h) {
+  multiplyAffine(t, e, r, i, s, a, h, o) {
     const c = t * 6, u = e * 6, l = this.data, d = l[c], f = l[c + 1], m = l[c + 2], g = l[c + 3], v = l[c + 4], y = l[c + 5];
-    l[u] = d * r + m * i, l[u + 1] = f * r + g * i, l[u + 2] = d * s + m * a, l[u + 3] = f * s + g * a, l[u + 4] = d * o + m * h + v, l[u + 5] = f * o + g * h + y;
+    l[u] = d * r + m * i, l[u + 1] = f * r + g * i, l[u + 2] = d * s + m * a, l[u + 3] = f * s + g * a, l[u + 4] = d * h + m * o + v, l[u + 5] = f * h + g * o + y;
   }
 }
-class wt {
-  /** The underlying store for matrices. */
-  matrix = new Rt();
-  /** The current step or depth in the transformation hierarchy. */
+class bt {
+  matrix = new At();
   step = 0;
-  /** Internal stack maintaining structural information. */
-  stack = new b(A.Uint32);
-  /** Records the world matrices generated at each step. */
-  stepWorldM = new b(A.Uint32);
-  /** Records actions (push/pop) taken during the traversal. */
-  stepAction = new b(A.Uint32);
-  /** Records the parent world matrix for each step (used by updateMatrixSubtree). */
-  stepParentM = new b(A.Uint32);
-  /** Buffer used during hierarchy traversal updates. */
-  parentStack = new b(A.Uint32);
-  /** The index of the current local matrix in the matrix store. */
+  stack = new A(S.Uint32);
+  stepWorldM = new A(S.Uint32);
+  stepAction = new A(S.Uint32);
+  stepParentM = new A(S.Uint32);
+  stepClose = new A(S.Uint32);
+  stepStack = new A(S.Uint32);
   curLocalM = -1;
-  /** The index of the current world matrix in the matrix store. */
   curWorldM = -1;
   rapid;
-  /**
-   * Creates a new MatrixStack and initializes its state.
-   */
   constructor(t) {
     this.reset(), this.rapid = t;
   }
-  /**
-   * Saves the current matrix state and pushes it onto the stack.
-   * Equivalent to context.save().
-   * @returns The current step counter before saving.
-   */
   save() {
     this.stack.push(this.curWorldM);
     const t = this.curWorldM;
-    return this.curLocalM = this.matrix.alloc(), this.curWorldM = this.matrix.allocDirty(), this.stepWorldM.push(this.curWorldM), this.stepParentM.push(t), this.stepAction.push(1), this.matrix.copy(this.curWorldM, t), { world: this.curWorldM, local: this.curLocalM, step: this.step++ };
+    return this.curLocalM = this.matrix.alloc(), this.curWorldM = this.matrix.allocDirty(), this.stepWorldM.push(this.curWorldM), this.stepParentM.push(t), this.stepAction.push(1), this.stepClose.push(0), this.stepStack.push(this.step), this.matrix.copy(this.curWorldM, t), { world: this.curWorldM, local: this.curLocalM, step: this.step++ };
   }
-  /**
-   * Restores the matrix state from the top of the stack.
-   * Equivalent to context.restore().
-   */
   restore() {
-    this.stack.length != 0 && (this.curWorldM = this.stack.pop(), this.curLocalM = this.curWorldM - 1, this.stepParentM.push(this.stack.get(this.stack.length - 1)), this.stepWorldM.push(this.curWorldM), this.stepAction.push(0), this.step++);
+    this.stack.length == 0 || this.stepStack.length == 0 || (this.curWorldM = this.stack.pop(), this.curLocalM = this.curWorldM - 1, this.stepParentM.push(this.stack.get(this.stack.length - 1)), this.stepWorldM.push(this.curWorldM), this.stepAction.push(0), this.stepClose.push(0), this.stepClose.typedArray[this.stepStack.pop()] = this.step, this.step++);
+  }
+  restoreAll() {
+    for (; this.stack.length > 0 && this.stepStack.length > 0; )
+      this.restore();
+  }
+  getStep(t) {
+    return typeof t == "number" ? t : t.step;
+  }
+  walkSubtree(t, e, r = 1 / 0) {
+    let i = 0, s = t;
+    for (; s < this.step; ) {
+      const a = this.stepAction.get(s);
+      if (a === 1) {
+        if (i++, i > r) {
+          const h = this.stepClose.get(s);
+          if (h > s) {
+            s = h + 1, i--;
+            continue;
+          }
+        }
+      } else
+        i--;
+      if (e(s, a, i) === !1 || a === 0 && i === 0) return;
+      s++;
+    }
+  }
+  getParent(t) {
+    const e = this.getStep(t);
+    return this.stepParentM.get(e);
+  }
+  getChildren(t) {
+    const e = this.getStep(t), r = this.stepClose.get(e), i = [];
+    let s = e + 1;
+    for (; s < r; )
+      this.stepAction.get(s) === 1 ? (i.push(s), s = this.stepClose.get(s) + 1) : s++;
+    return i;
   }
-  /**
-   * Evaluates and updates matrices from the given step. Used primarily for deferred transformation.
-   * @param step - The initial step to update matrices from.
-   */
   updateMatrixSubtree(t) {
-    const e = typeof t == "number" ? t : t.step;
-    let r = 0, i = e;
-    for (; i < this.step; ) {
-      if (this.stepAction.get(i) === 1) {
-        const a = this.stepWorldM.get(i), o = a - 1, h = this.stepParentM.get(i);
-        this.matrix.multiplyOut(a, h, o), r++;
-      } else if (r--, r === 0)
-        break;
-      i++;
-    }
+    const e = this.getStep(t);
+    this.walkSubtree(e, (r, i) => {
+      if (i === 1) {
+        const s = this.stepWorldM.get(r), a = s - 1, h = this.stepParentM.get(r);
+        this.matrix.multiplyOut(s, h, a);
+      }
+    });
   }
-  /**
-   * Translates the current local and world matrices by x and y.
-   * @param x - Translation along the x-axis.
-   * @param y - Translation along the y-axis.
-   */
   translate(t, e) {
     this.matrix.translate(this.curLocalM, t, e), this.matrix.translate(this.curWorldM, t, e);
   }
-  /**
-   * Scales the current local and world matrices by scaleX and scaleY.
-   * @param scaleX - Scaling factor along the x-axis.
-   * @param scaleY - Scaling factor along the y-axis.
-   */
   scale(t, e = t) {
     this.matrix.scale(this.curLocalM, t, e), this.matrix.scale(this.curWorldM, t, e);
   }
-  /**
-   * Rotates the current local and world matrices by the given radians.
-   * @param radians - The rotation angle in radians.
-   */
   rotate(t) {
     this.matrix.rotate(this.curLocalM, t), this.matrix.rotate(this.curWorldM, t);
   }
-  /**
-   * Rotates the current local and world matrices around a pivot point
-   * that is offset from the matrix origin by `(offsetX, offsetY)`.
-   *
-   * This is a convenience wrapper around the common translate → rotate → translate-back
-   * pattern, avoiding manual coordinate juggling at the call site.
-   *
-   * @example
-   * ```ts
-   * // Rotate a 64×64 sprite around its centre
-   * stack.rotateWithOffset(angle, 32, 32);
-   * ```
-   *
-   * @param radians - The rotation angle in radians.
-   * @param offsetX - The x component of the pivot point in local space.
-   * @param offsetY - The y component of the pivot point in local space.
-   */
   rotateWithOffset(t, e, r) {
     this.matrix.rotateWithOffset(this.curLocalM, t, e, r), this.matrix.rotateWithOffset(this.curWorldM, t, e, r);
   }
-  /**
-   * Sets the current local and world matrices to the identity matrix.
-   */
   identity() {
     this.matrix.identity(this.curLocalM), this.matrix.identity(this.curWorldM);
   }
-  /**
-   * Resets the entire stack state context, clearing matrices and step actions.
-   */
   reset() {
-    this.matrix.reset(), this.stack.reset(), this.stepAction.reset(), this.stepWorldM.reset(), this.stepParentM.reset(), this.step = 0, this.curLocalM = this.matrix.alloc(), this.curWorldM = this.matrix.alloc();
-  }
-  /**
-   * Transforms a point from local coordinates to world coordinates.
-   * Uses the current world matrix to apply the transformation.
-   * @param x - Local x coordinate.
-   * @param y - Local y coordinate.
-   * @returns The transformed point in world coordinates.
-   */
+    this.matrix.reset(), this.stack.clear(), this.stepAction.clear(), this.stepWorldM.clear(), this.stepParentM.clear(), this.stepClose.clear(), this.stepStack.clear(), this.step = 0, this.curLocalM = this.matrix.alloc(), this.curWorldM = this.matrix.alloc();
+  }
   localToWorld(t, e) {
     return this.matrix.localToWorld(this.curWorldM, t, e);
   }
-  /**
-   * Transforms a point from world coordinates to local coordinates.
-   * Useful for hit testing against objects placed in world space.
-   * @param x - World x coordinate.
-   * @param y - World y coordinate.
-   * @returns The transformed point in local coordinates.
-   */
   worldToLocal(t, e) {
     return this.matrix.worldToLocal(this.curWorldM, t, e);
   }
-  /**
-   * Extracts the global position (translation) from the current world matrix.
-   * @returns An object containing `x` and `y` global coordinates.
-   */
   getGlobalPosition() {
     return this.matrix.getPosition(this.curWorldM);
   }
-  /**
-   * Extracts the global scale from the current world matrix.
-   * @returns An object containing `x` and `y` global scale factors.
-   */
   getGlobalScale() {
     return this.matrix.getScale(this.curWorldM);
   }
-  /**
-   * Extracts the global rotation (in radians) from the current world matrix.
-   * @returns The global rotation in radians.
-   */
   getGlobalRotation() {
     return this.matrix.getRotation(this.curWorldM);
   }
   toCSSMatrix() {
     return this.matrix.toCSSMatrix(this.curWorldM);
   }
-  /**
-   * Returns the current world matrix as Float32Array [a, b, c, d, tx, ty].
-   */
   getTransform() {
-    const t = this.curWorldM * E;
-    return this.matrix.data.slice(t, t + E);
+    const t = this.curWorldM * T;
+    return this.matrix.data.slice(t, t + T);
   }
-  /**
-   * Directly overwrites the current world matrix with the given 6-element 2D transform.
-   */
   setTransform(t) {
-    const e = this.curWorldM * E, r = this.matrix.data;
+    const e = this.curWorldM * T, r = this.matrix.data;
     r[e] = t[0], r[e + 1] = t[1], r[e + 2] = t[2], r[e + 3] = t[3], r[e + 4] = t[4], r[e + 5] = t[5];
   }
   transformPoint(t, e) {
     return this.matrix.transformPoint(this.curLocalM, t, e);
   }
-  /**
-   * Applies a transform options object to the current matrix state.
-   * Optionally saves the matrix first
-   */
   applyTransform(t, e = 0, r = 0, i = -1) {
     let s = t.x ?? 0, a = t.y ?? 0;
     t.position && (s += t.position.x, a += t.position.y);
-    let o = 1, h = 1;
+    let h = 1, o = 1;
     const c = t.scale;
-    c && (typeof c == "number" ? (o = c, h = c) : (o = c.x, h = c.y));
+    c && (typeof c == "number" ? (h = c, o = c) : (h = c.x, o = c.y));
     const u = t.rotation ?? 0;
     let l = t.offsetX ?? 0, d = t.offsetY ?? 0;
     t.offset && (l += t.offset.x, d += t.offset.y);
     const f = t.origin;
     f !== void 0 && (typeof f == "number" ? (l -= f * e, d -= f * r) : (l -= f.x * e, d -= f.y * r));
-    const m = u ? Math.cos(u) : 1, g = u ? Math.sin(u) : 0, v = m * o, y = g * o, R = -g * h, M = m * h, C = s + v * l + R * d, P = a + y * l + M * d;
+    const m = u ? Math.cos(u) : 1, g = u ? Math.sin(u) : 0, v = m * h, y = g * h, w = -g * o, M = m * o, _ = s + v * l + w * d, P = a + y * l + M * d;
     if (i !== -1) {
       this.matrix.multiplyAffine(
         this.curWorldM,
         i,
         v,
         y,
-        R,
+        w,
         M,
-        C,
+        _,
         P
       );
       return;
@@ -937,89 +534,55 @@ class wt {
       this.curLocalM,
       v,
       y,
-      R,
+      w,
       M,
-      C,
+      _,
       P
     ), this.matrix.multiplyAffineInPlace(
       this.curWorldM,
       v,
       y,
-      R,
+      w,
       M,
-      C,
+      _,
       P
     );
   }
 }
-var K = /* @__PURE__ */ ((n) => (n[n.REPEAT = 0] = "REPEAT", n[n.CLAMP = 1] = "CLAMP", n[n.MIRRORED_REPEAT = 2] = "MIRRORED_REPEAT", n))(K || {});
-class Mt {
+var q = /* @__PURE__ */ ((n) => (n[n.REPEAT = 0] = "REPEAT", n[n.CLAMP = 1] = "CLAMP", n[n.MIRRORED_REPEAT = 2] = "MIRRORED_REPEAT", n))(q || {});
+class Ut {
   render;
   cache = /* @__PURE__ */ new Map();
   constructor(t) {
     this.render = t;
   }
-  /**
-   * Asynchronously loads a texture from a URL.
-   * @param url - The image URL to load.
-   * @param options - Optional configuration for the texture.
-   * @returns A promise that resolves to the loaded Texture.
-   */
   async load(t, e) {
     let r = this.cache.get(t);
     if (r)
       return new N(r);
     try {
       const i = await this._fetchImage(t);
-      return r = Y.fromSource(this.render, i, e), r.uid = t, this.cache.set(t, r), new N(r);
+      return r = V.fromSource(this.render, i, e), r.uid = t, this.cache.set(t, r), new N(r);
     } catch (i) {
       throw console.error(`[TextureManager] Failed to load: ${t}`, i), i;
     }
   }
-  /**
-   * Creates a texture synchronously from an existing HTML element (Image, Canvas, Video).
-   * @param source - The source image element.
-   * @param options - Optional configuration for the texture.
-   * @returns The newly created Texture.
-   */
   create(t, e) {
     if (e?.key && this.cache.has(e.key))
       return new N(this.cache.get(e.key));
-    const r = Y.fromSource(this.render, t, e);
+    const r = V.fromSource(this.render, t, e);
     return e?.key && (r.uid = e.key, this.cache.set(e.key, r)), new N(r);
   }
-  /**
-   * Creates a generic Render Texture (FrameBuffer).
-   * @param width - The width of the render texture.
-   * @param height - The height of the render texture.
-   * @param options - Optional configuration for the texture.
-   * @returns The newly created RenderTexture.
-   */
   createRenderTexture(t) {
-    return new At(this.render, t);
+    return new Ct(this.render, t);
   }
-  /**
-   * Creates a TextTexture for rendering text.
-   * @param options - Optional configuration for the texture.
-   * @returns The newly created TextTexture.
-   */
   createTextTexture(t) {
-    return new bt(this.render, t);
-  }
-  /**
-   * Destroys a texture and potentially removes its BaseTexture from the cache.
-   * If a Texture instance is provided, it decrements the reference count of the BaseTexture.
-   * The BaseTexture will only be destroyed if its reference count drops to 0, or if `force` is true.
-   * @param textureOrUrl - The texture instance, base texture, or cache key (URL) to destroy.
-   * @param force - If true, destroys the underlying BaseTexture immediately regardless of reference count.
-   */
+    return new Pt(this.render, t);
+  }
   destroy(t, e = !1) {
     let r, i;
     typeof t == "string" ? (i = t, r = this.cache.get(i)) : t instanceof N ? (r = t.base, i = r?.uid, t.destroy()) : (r = t, i = r.uid), r && (r.refCount <= 0 || e) && (r.destroy(this.render.gl), i && this.cache.delete(i));
   }
-  /**
-   * Destroys all cached textures and clears the cache, ignoring reference counts.
-   */
   destroyAll() {
     for (const t of this.cache.values())
       t.destroy(this.render.gl);
@@ -1032,7 +595,7 @@ class Mt {
     });
   }
 }
-class Y {
+class V {
   glTexture = null;
   width;
   height;
@@ -1041,42 +604,19 @@ class Y {
   constructor(t, e, r) {
     this.glTexture = t, this.width = e, this.height = r;
   }
-  /**
-   * Creates a BaseTexture from an image source.
-   * @param render - The Rapid renderer instance.
-   * @param source - The image source.
-   * @param options - Optional configuration.
-   * @returns The created BaseTexture.
-   */
   static fromSource(t, e, r = {}) {
-    const i = Z(t, e, r);
-    return new Y(i, e.width, e.height);
-  }
-  /**
-   * Updates the content of the existing texture (e.g. for Video or dynamic Canvas).
-   * Uses texSubImage2D if dimensions haven't changed for better performance.
-   * @param gl - The WebGL rendering context.
-   * @param source - The new image source.
-   */
+    const i = J(t, e, r);
+    return new V(i, e.width, e.height);
+  }
   updateSource(t, e, r = {}) {
-    this.glTexture && (t.bindTexture(t.TEXTURE_2D, this.glTexture), r.textureFilter !== void 0 && rt(t, r.textureFilter), r.wrap !== void 0 && et(t, r.wrap), t.pixelStorei(t.UNPACK_FLIP_Y_WEBGL, 1), t.pixelStorei(t.UNPACK_ALIGNMENT, 1), r.premultipliedAlpha !== void 0 && t.pixelStorei(t.UNPACK_PREMULTIPLY_ALPHA_WEBGL, r.premultipliedAlpha), this.width === e.width && this.height === e.height ? t.texSubImage2D(t.TEXTURE_2D, 0, 0, 0, t.RGBA, t.UNSIGNED_BYTE, e) : (t.texImage2D(t.TEXTURE_2D, 0, t.RGBA, t.RGBA, t.UNSIGNED_BYTE, e), this.width = e.width, this.height = e.height), r.premultipliedAlpha !== void 0 && t.pixelStorei(t.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !1));
+    this.glTexture && (t.bindTexture(t.TEXTURE_2D, this.glTexture), r.textureFilter !== void 0 && nt(t, r.textureFilter), r.wrap !== void 0 && st(t, r.wrap), t.pixelStorei(t.UNPACK_FLIP_Y_WEBGL, 1), t.pixelStorei(t.UNPACK_ALIGNMENT, 1), r.premultipliedAlpha !== void 0 && t.pixelStorei(t.UNPACK_PREMULTIPLY_ALPHA_WEBGL, r.premultipliedAlpha), this.width === e.width && this.height === e.height ? t.texSubImage2D(t.TEXTURE_2D, 0, 0, 0, t.RGBA, t.UNSIGNED_BYTE, e) : (t.texImage2D(t.TEXTURE_2D, 0, t.RGBA, t.RGBA, t.UNSIGNED_BYTE, e), this.width = e.width, this.height = e.height), r.premultipliedAlpha !== void 0 && t.pixelStorei(t.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !1));
   }
-  /**
-   * Dynamically updates the texture filtering mode.
-   */
   setFilterMode(t, e) {
-    this.glTexture && (t.bindTexture(t.TEXTURE_2D, this.glTexture), rt(t, e), t.bindTexture(t.TEXTURE_2D, null));
+    this.glTexture && (t.bindTexture(t.TEXTURE_2D, this.glTexture), nt(t, e), t.bindTexture(t.TEXTURE_2D, null));
   }
-  /**
-   * Dynamically updates the texture wrap mode.
-   */
   setWrapMode(t, e) {
-    this.glTexture && (t.bindTexture(t.TEXTURE_2D, this.glTexture), et(t, e), t.bindTexture(t.TEXTURE_2D, null));
+    this.glTexture && (t.bindTexture(t.TEXTURE_2D, this.glTexture), st(t, e), t.bindTexture(t.TEXTURE_2D, null));
   }
-  /**
-   * Destroys the WebGL texture resource.
-   * @param gl - The WebGL rendering context.
-   */
   destroy(t) {
     this.glTexture && (t.deleteTexture(this.glTexture), this.glTexture = null);
   }
@@ -1105,113 +645,55 @@ class N {
   // Stored pixel-space region (before UV conversion), used by getSubTexture()
   _px = 0;
   _py = 0;
-  _pw = 0;
-  _ph = 0;
   constructor(t) {
     t && this.setBase(t);
   }
-  /**
-   * Sets the base texture and increments its reference count.
-   * @param base - The BaseTexture instance.
-   * @returns The current Texture instance.
-   */
   setBase(t) {
     return this.base === t ? this : (this.base && this.base.refCount--, this.base = t, this.base.refCount++, this.setRegion(0, 0, t.width, t.height), this.glTexture = t.glTexture, this);
   }
-  /**
-   * Sets the visible region (clipping) in pixels relative to the BaseTexture.
-   * @param x - The x coordinate in pixels.
-   * @param y - The y coordinate in pixels.
-   * @param w - The width in pixels.
-   * @param h - The height in pixels.
-   * @returns The current Texture instance.
-   */
   setRegion(t, e, r, i) {
-    return this.base ? (this._px = t, this._py = e, this._pw = r, this._ph = i, this.isAtlas = t !== 0 || e !== 0 || r !== this.base.width || i !== this.base.height, this.uvX = t / this.base.width, this.uvY = e / this.base.height, this.uvW = this.uvX + r / this.base.width, this.uvH = this.uvY + i / this.base.height, this.rawWidth = r * this.scale, this.rawHeight = i * this.scale, this) : this;
-  }
-  /**
-   * Creates a new Texture representing a sub-region of this Texture.
-   * @param x - The x coordinate in pixels, relative to this texture's logical start.
-   * @param y - The y coordinate in pixels, relative to this texture's logical start.
-   * @param width - The width of the sub-texture in pixels.
-   * @param height - The height of the sub-texture in pixels.
-   * @returns A new Texture pointing to the sub-region.
-   */
+    return this.base ? (this._px = t, this._py = e, this.isAtlas = t !== 0 || e !== 0 || r !== this.base.width || i !== this.base.height, this.uvX = t / this.base.width, this.uvY = e / this.base.height, this.uvW = this.uvX + r / this.base.width, this.uvH = this.uvY + i / this.base.height, this.rawWidth = r * this.scale, this.rawHeight = i * this.scale, this) : this;
+  }
   getSubTexture(t, e, r, i) {
     if (!this.base) return new N();
-    const s = this.clone(), a = this._px, o = this._py;
-    return s.setRegion(a + t, o + e, r, i), s;
+    const s = this.clone(), a = this._px, h = this._py;
+    return s.setRegion(a + t, h + e, r, i), s;
   }
-  /**
-   * Creates a shallow copy of this Texture, sharing the same BaseTexture.
-   * @returns A new Texture instance.
-   */
   clone(t) {
     const e = t ?? new N(this.base);
-    return t && this.base && t.setBase(this.base), e.scale = this.scale, e.uvX = this.uvX, e.uvY = this.uvY, e.uvW = this.uvW, e.uvH = this.uvH, e.rawWidth = this.rawWidth, e.rawHeight = this.rawHeight, e.offsetX = this.offsetX, e.offsetY = this.offsetY, e.flipY = this.flipY, e.isRotated = this.isRotated, e.isAtlas = this.isAtlas, e._px = this._px, e._py = this._py, e._pw = this._pw, e._ph = this._ph, e;
-  }
-  /**
-   * Utility to split this texture into a grid of sprite textures.
-   * Sub-textures will respect the current UV offsets.
-   * @param cellWidth - The width of each cell in pixels.
-   * @param cellHeight - The height of each cell in pixels.
-   * @param cols - Optional number of columns. Truncates based on texture width if omitted.
-   * @param rows - Optional number of rows. Truncates based on texture height if omitted.
-   * @param gap - Optional pixel gap between cells.
-   * @returns An array of split Textures.
-   */
+    return t && this.base && t.setBase(this.base), e.scale = this.scale, e.uvX = this.uvX, e.uvY = this.uvY, e.uvW = this.uvW, e.uvH = this.uvH, e.rawWidth = this.rawWidth, e.rawHeight = this.rawHeight, e.offsetX = this.offsetX, e.offsetY = this.offsetY, e.flipY = this.flipY, e.isRotated = this.isRotated, e.isAtlas = this.isAtlas, e._px = this._px, e._py = this._py, e;
+  }
   splitGrid(t, e, r, i, s = 0) {
     if (!this.base) return [];
-    const a = [], o = this.rawWidth, h = this.rawHeight, c = Math.max(0, s), u = t + c, l = e + c, d = r ?? Math.floor((o + c) / u), f = i ?? Math.floor((h + c) / l);
+    const a = [], h = this.rawWidth, o = this.rawHeight, c = Math.max(0, s), u = t + c, l = e + c, d = r ?? Math.floor((h + c) / u), f = i ?? Math.floor((o + c) / l);
     for (let m = 0; m < f; m++)
       for (let g = 0; g < d; g++)
         a.push(this.getSubTexture(g * u, m * l, t, e));
     return a;
   }
-  /**
-   * Creates a Texture directly from an image source, bypassing the TextureManager.
-   * @param source - The image element, canvas, video, or bitmap.
-   * @param options - Optional antialias and wrap mode settings.
-   */
   static fromImageSource(t, e, r = {}) {
-    const i = Z(t, e, r);
-    return new N(new Y(i, e.width, e.height));
+    const i = J(t, e, r);
+    return new N(new V(i, e.width, e.height));
   }
-  /**
-   * Marks this Texture as destroyed, decrementing the BaseTexture reference count.
-   */
   destroy() {
     this.base && (this.base.refCount--, this.base = void 0), this.glTexture = null;
   }
 }
-class At extends N {
+class Ct extends N {
   framebuffer;
   renderbuffer;
   gl;
   flipY = !0;
   clearColor;
-  /** Actual GPU-allocated dimensions — grow-only, never shrink */
   _allocW = 0;
   _allocH = 0;
   constructor(t, e) {
     super(), this.gl = t.gl, this.clearColor = e.clearColor ?? x.Black;
-    const r = Math.max(Math.round(e.width), 1), i = Math.max(Math.round(e.height), 1), a = Z(t, { width: r, height: i }, { ...e, onlySize: !0 });
-    if (this.setBase(new Y(a, r, i)), this.framebuffer = this.gl.createFramebuffer(), this.renderbuffer = this.gl.createRenderbuffer(), !this.framebuffer || !this.renderbuffer)
+    const r = Math.max(Math.round(e.width), 1), i = Math.max(Math.round(e.height), 1), a = J(t, { width: r, height: i }, { ...e, onlySize: !0 });
+    if (this.setBase(new V(a, r, i)), this.framebuffer = this.gl.createFramebuffer(), this.renderbuffer = this.gl.createRenderbuffer(), !this.framebuffer || !this.renderbuffer)
       throw new Error("Failed to create Framebuffer or Renderbuffer");
     this.resize(r, i, !0);
   }
-  /**
-   * Resizes the render texture using a grow-only GPU allocation strategy.
-   *
-   * - GPU memory is only reallocated when the new size **exceeds** the current allocation.
-   * - Shrinking only updates the logical dimensions and UV sub-region — no GPU work.
-   *
-   * This makes it safe to call every frame with varying sizes (e.g. inside applyFilters).
-   *
-   * @param width  - New logical width.
-   * @param height - New logical height.
-   * @param force  - Force full GPU reallocation regardless of current allocation size.
-   */
   resize(t, e, r = !1) {
     t = Math.max(Math.round(t), 1), e = Math.max(Math.round(e), 1);
     const i = this.rawWidth === t && this.rawHeight === e;
@@ -1219,10 +701,6 @@ class At extends N {
     const s = this.gl;
     (r || t > this._allocW || e > this._allocH) && this.base && (this._allocW = Math.max(this._allocW, t), this._allocH = Math.max(this._allocH, e), this.base.width = this._allocW, this.base.height = this._allocH, s.bindTexture(s.TEXTURE_2D, this.base.glTexture), s.texImage2D(s.TEXTURE_2D, 0, s.RGBA, this._allocW, this._allocH, 0, s.RGBA, s.UNSIGNED_BYTE, null), s.bindRenderbuffer(s.RENDERBUFFER, this.renderbuffer), s.renderbufferStorage(s.RENDERBUFFER, s.STENCIL_INDEX8, this._allocW, this._allocH), s.bindFramebuffer(s.FRAMEBUFFER, this.framebuffer), s.framebufferTexture2D(s.FRAMEBUFFER, s.COLOR_ATTACHMENT0, s.TEXTURE_2D, this.base.glTexture, 0), s.framebufferRenderbuffer(s.FRAMEBUFFER, s.STENCIL_ATTACHMENT, s.RENDERBUFFER, this.renderbuffer), s.bindFramebuffer(s.FRAMEBUFFER, null), s.bindRenderbuffer(s.RENDERBUFFER, null), s.bindTexture(s.TEXTURE_2D, null)), this.rawWidth = t, this.rawHeight = e, this.uvX = 0, this.uvW = t / this._allocW, this.uvY = 0, this.uvH = e / this._allocH;
   }
-  /**
-   * Activates this texture as the current render target.
-   * @param clear - Whether to clear the render target after activation.
-   */
   activate(t = !1) {
     if (!this.framebuffer) return;
     const e = this.gl;
@@ -1233,48 +711,30 @@ class At extends N {
     const e = this.gl, r = t ?? this.clearColor;
     r && (r.setClearColor(e), e.clear(e.COLOR_BUFFER_BIT | e.STENCIL_BUFFER_BIT));
   }
-  /**
-   * Deactivates this texture, returning rendering to the default frame buffer.
-   */
   deactivate() {
     const t = this.gl;
     t.bindFramebuffer(t.FRAMEBUFFER, null);
   }
-  /**
-   * Get raw pixels from the render texture.
-   * @param x - X coordinate in logical pixel space (top-left origin).
-   * @param y - Y coordinate in logical pixel space (top-left origin).
-   * @param width - Width of the region to read.
-   * @param height - Height of the region to read.
-   */
   GetPixels(t = 0, e = 0, r = this.rawWidth, i = this.rawHeight) {
     if (!this.framebuffer) return new Uint8Array(0);
-    const s = Math.floor(t), a = Math.floor(e), o = Math.floor(r), h = Math.floor(i);
-    if (o <= 0 || h <= 0) return new Uint8Array(0);
+    const s = Math.floor(t), a = Math.floor(e), h = Math.floor(r), o = Math.floor(i);
+    if (h <= 0 || o <= 0) return new Uint8Array(0);
     if (s < 0 || a < 0 || s >= this.rawWidth || a >= this.rawHeight)
       return new Uint8Array(0);
-    const c = Math.min(o, this.rawWidth - s), u = Math.min(h, this.rawHeight - a), l = this.rawHeight - a - u, d = this.gl, f = d.getParameter(d.FRAMEBUFFER_BINDING);
+    const c = Math.min(h, this.rawWidth - s), u = Math.min(o, this.rawHeight - a), l = this.rawHeight - a - u, d = this.gl, f = d.getParameter(d.FRAMEBUFFER_BINDING);
     d.bindFramebuffer(d.FRAMEBUFFER, this.framebuffer);
     const m = new Uint8Array(c * u * 4);
     return d.readPixels(s, l, c, u, d.RGBA, d.UNSIGNED_BYTE, m), d.bindFramebuffer(d.FRAMEBUFFER, f), m;
   }
-  /**
-   * Get the color at a pixel in the render texture.
-   * @param x - X coordinate in logical pixel space (top-left origin).
-   * @param y - Y coordinate in logical pixel space (top-left origin).
-   */
   GetColorAt(t, e) {
     const r = this.GetPixels(t, e, 1, 1);
     return r.length < 4 ? new x(0, 0, 0, 0) : new x(r[0], r[1], r[2], r[3]);
   }
-  /**
-   * Destroys the framebuffer, renderbuffer, and base texture.
-   */
   destroy() {
     super.destroy(), this.framebuffer && this.gl.deleteFramebuffer(this.framebuffer), this.renderbuffer && this.gl.deleteRenderbuffer(this.renderbuffer), this.base?.destroy(this.gl);
   }
 }
-const St = {
+const _t = {
   fontFamily: "Arial",
   fontSize: 24,
   fontWeight: "normal",
@@ -1283,7 +743,7 @@ const St = {
   align: "left",
   lineHeight: 1
 };
-class bt extends N {
+class Pt extends N {
   canvas;
   ctx;
   render;
@@ -1292,28 +752,22 @@ class bt extends N {
   options;
   flipY = !0;
   constructor(t, e) {
-    super(), this.render = t, this._style = { ...St, ...e }, this._text = e?.text ?? "", this.options = { premultipliedAlpha: t.premultipliedAlpha, ...e }, this.scale = 1 / t.dpr, this.canvas = document.createElement("canvas");
+    super(), this.render = t, this._style = { ..._t, ...e }, this._text = e?.text ?? "", this.options = { premultipliedAlpha: t.premultipliedAlpha, ...e }, this.scale = 1 / t.dpr, this.canvas = document.createElement("canvas");
     const r = this.canvas.getContext("2d", { willReadFrequently: !0 });
     if (!r) throw new Error("Failed to get 2d context for TextTexture");
     this.ctx = r, this.canvas.width = 1, this.canvas.height = 1;
-    const i = Z(t, this.canvas, this.options);
-    this.setBase(new Y(i, 1, 1)), this.update();
+    const i = J(t, this.canvas, this.options);
+    this.setBase(new V(i, 1, 1)), this.update();
   }
   get text() {
     return this._text;
   }
-  /**
-   * Set new text and update the texture
-   */
   set text(t) {
     this._text !== t && (this._text = t, this.update());
   }
   get style() {
     return this._style;
   }
-  /**
-   * Set new style partially and update the texture
-   */
   set style(t) {
     this._style = { ...this._style, ...t }, this.update();
   }
@@ -1327,37 +781,34 @@ class bt extends N {
         return e;
     }
   }
-  /**
-   * Updates the internal canvas and uploads it to WebGL
-   */
   update() {
-    const t = this.ctx, e = this.style, r = e.fontSize, i = e.fontWeight, s = e.fontFamily, a = e.lineHeight, o = `${i} ${r}px ${s}`, h = this.render.dpr;
-    t.font = o, t.textBaseline = "top";
+    const t = this.ctx, e = this.style, r = e.fontSize, i = e.fontWeight, s = e.fontFamily, a = e.lineHeight, h = `${i} ${r}px ${s}`, o = this.render.dpr;
+    t.font = h, t.textBaseline = "top";
     const c = this._text.split(`
 `);
     let u = 0, l = 0;
-    const d = t.measureText(c[0] || "M"), f = (d.fontBoundingBoxAscent || r) + (d.fontBoundingBoxDescent || r * 0.2);
-    for (const O of c) {
-      const _ = t.measureText(O);
-      _.width > u && (u = _.width), l += f * a;
+    const m = t.measureText(c[0] || "M").fontBoundingBoxDescent;
+    for (const b of c) {
+      const R = t.measureText(b);
+      R.width > u && (u = R.width), l += m * a;
     }
-    l -= f * (a - 1);
-    const m = this._style.strokeThickness || 0, g = Math.ceil(u + m * 2) || 1, v = Math.ceil(l + m * 2) || 1, y = Math.ceil(g * h), R = Math.ceil(v * h);
-    (this.canvas.width !== y || this.canvas.height !== R) && (this.canvas.width = y, this.canvas.height = R), t.setTransform(h, 0, 0, h, 0, 0), t.clearRect(0, 0, g, v), t.font = o, t.textBaseline = "top", t.textAlign = this._style.align;
-    const M = this.updateOffset(g, m), C = e.strokeThickness, P = C > 0;
-    P && (t.lineWidth = C, t.strokeStyle = e.stroke, t.lineJoin = "round"), e.fill && (t.fillStyle = e.fill);
-    let I = m;
-    for (const O of c)
-      P && t.strokeText(O, M, I), e.fill && t.fillText(O, M, I), I += f * a;
-    this.base?.updateSource(this.render.gl, this.canvas, this.options), this.setRegion(0, 0, y, R);
+    l -= m * (a - 1);
+    const g = this._style.strokeThickness || 0, v = Math.ceil(u + g * 2) || 1, y = Math.ceil(l + g * 2) || 1, w = Math.ceil(v * o), M = Math.ceil(y * o);
+    (this.canvas.width !== w || this.canvas.height !== M) && (this.canvas.width = w, this.canvas.height = M), t.setTransform(o, 0, 0, o, 0, 0), t.clearRect(0, 0, v, y), t.font = h, t.textBaseline = "top", t.textAlign = this._style.align;
+    const _ = this.updateOffset(v, g), P = e.strokeThickness, O = P > 0;
+    O && (t.lineWidth = P, t.strokeStyle = e.stroke, t.lineJoin = "round"), e.fill && (t.fillStyle = e.fill);
+    let W = g;
+    for (const b of c)
+      O && t.strokeText(b, _, W), e.fill && t.fillText(b, _, W), W += m * a;
+    this.base?.updateSource(this.render.gl, this.canvas, this.options), this.setRegion(0, 0, w, M);
   }
 }
-const Ut = (n, t = !1, e = !0) => {
+const Lt = (n, t = !1, e = !0) => {
   const r = n.getContext("webgl2", { stencil: !0, antialias: t, premultipliedAlpha: e });
   if (!r)
     throw new Error("WebGL2 is not supported in this browser.");
   return r;
-}, at = (n, t, e) => {
+}, ct = (n, t, e) => {
   const r = n.createShader(e);
   if (!r)
     throw new Error("Unable to create webgl shader");
@@ -1366,36 +817,36 @@ const Ut = (n, t = !1, e = !0) => {
     throw console.error("Shader compilation failed:", s), new Error("Unable to compile shader: " + s + t);
   }
   return r;
-}, Ct = (n, t, e) => {
-  var r = n.createProgram(), i = at(n, t, 35633), s = at(n, e, 35632);
+}, Nt = (n, t, e) => {
+  var r = n.createProgram(), i = ct(n, t, 35633), s = ct(n, e, 35632);
   if (!r)
     throw new Error("Unable to create program shader");
   if (n.attachShader(r, i), n.attachShader(r, s), n.linkProgram(r), !n.getProgramParameter(r, n.LINK_STATUS)) {
-    const o = n.getProgramInfoLog(r);
-    throw new Error("Unable to link shader program: " + o);
+    const h = n.getProgramInfoLog(r);
+    throw new Error("Unable to link shader program: " + h);
   }
   return r;
 };
-function et(n, t) {
+function st(n, t) {
   const e = {
-    [K.CLAMP]: n.CLAMP_TO_EDGE,
-    [K.REPEAT]: n.REPEAT,
-    [K.MIRRORED_REPEAT]: n.MIRRORED_REPEAT
+    [q.CLAMP]: n.CLAMP_TO_EDGE,
+    [q.REPEAT]: n.REPEAT,
+    [q.MIRRORED_REPEAT]: n.MIRRORED_REPEAT
   }[t] || n.CLAMP_TO_EDGE;
   n.texParameteri(n.TEXTURE_2D, n.TEXTURE_WRAP_S, e), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_WRAP_T, e);
 }
-function rt(n, t) {
+function nt(n, t) {
   const e = {
-    [st.LINEAR]: n.LINEAR,
-    [st.NEAREST]: n.NEAREST
+    [ht.LINEAR]: n.LINEAR,
+    [ht.NEAREST]: n.NEAREST
   }[t] ?? n.NEAREST;
   n.texParameteri(n.TEXTURE_2D, n.TEXTURE_MIN_FILTER, e), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_MAG_FILTER, e);
 }
-function Z(n, t, e) {
+function J(n, t, e) {
   const r = n.gl, i = r.createTexture();
   if (!i)
     throw new Error("Unable to create WebGL texture");
-  if (r.bindTexture(r.TEXTURE_2D, i), r.pixelStorei(r.UNPACK_FLIP_Y_WEBGL, 0), r.pixelStorei(r.UNPACK_ALIGNMENT, 1), et(r, e.wrap ?? K.CLAMP), rt(r, e.textureFilter ?? n.textureFilter), e.onlySize) {
+  if (r.bindTexture(r.TEXTURE_2D, i), r.pixelStorei(r.UNPACK_FLIP_Y_WEBGL, 0), r.pixelStorei(r.UNPACK_ALIGNMENT, 1), st(r, e.wrap ?? q.CLAMP), nt(r, e.textureFilter ?? n.textureFilter), e.onlySize) {
     const s = t;
     r.texImage2D(r.TEXTURE_2D, 0, r.RGBA, s.width, s.height, 0, r.RGBA, r.UNSIGNED_BYTE, null);
   } else {
@@ -1404,7 +855,7 @@ function Z(n, t, e) {
   }
   return r.bindTexture(r.TEXTURE_2D, null), i;
 }
-function H(n, t) {
+function B(n, t) {
   if (n.includes("%TEXTURE_NUM%") && (n = n.replace("%TEXTURE_NUM%", t.toString())), n.includes("%GET_COLOR%")) {
     let e = "";
     for (let r = 0; r < t; r++)
@@ -1413,76 +864,50 @@ function H(n, t) {
   }
   return n;
 }
-const _t = 5126, it = 5121;
-function Pt(n, t, e) {
+const It = 5126, at = 5121;
+function Ot(n, t, e) {
   n.vertexAttribDivisor(t, e);
 }
-function pt(n, t, e, r, i) {
+function yt(n, t, e, r, i) {
   n.drawArraysInstanced(t, e, r, i);
 }
-let Lt = 0;
-class gt {
+let Wt = 0;
+class Tt {
   program;
   attributeLoc = {};
   uniformLoc = {};
   isCustom = !1;
-  /** Padding in pixels this shader needs beyond the sprite bounds (for outline/glow effects) */
   padding = 0;
-  /** GLSL type for each uniform, parsed from source */
   uniformType = {};
-  /** Whether the uniform is an array (e.g. sampler2D uTextures[8]) */
   uniformIsArray = {};
   gl;
-  shaderId = Lt++;
+  shaderId = Wt++;
   // for debug
   vao;
   constructor(t, e, r, i) {
-    this.gl = t, this.program = Ct(t, e, r), this.parseShader(e), this.parseShader(r), this.vao = t.createVertexArray(), i && this.setAttributes(i);
+    this.gl = t, this.program = Nt(t, e, r), this.parseShader(e), this.parseShader(r), this.vao = t.createVertexArray(), i && this.setAttributes(i);
   }
-  /** Switch GPU to use this shader program */
   use() {
     this.gl.useProgram(this.program);
   }
-  /** Bind this shader's VAO (start recording or replaying attribute state) */
   bindVAO() {
     this.gl.bindVertexArray(this.vao);
   }
-  /** Unbind VAO (finish recording) */
   unbindVAO() {
     this.gl.bindVertexArray(null);
   }
   // ── Uniforms ─────────────────────────────────────────────────────────────
-  /**
-   * Set a single uniform by name. Type is inferred from the parsed GLSL source.
-   * @example
-   *   shader.setUniform("uTime", 1.5);
-   *   shader.setUniform("uColor", [1, 0, 0, 1]);
-   *   shader.setUniform("uMVP", mat4array);
-   */
   setUniform(t, e) {
     const r = this.uniformLoc[t];
     if (r === void 0) return;
     const i = this.uniformType[t], s = this.uniformIsArray[t];
-    Nt(this.gl, r, i, e, s);
-  }
-  /**
-   * Batch-set uniforms via a plain value map.
-   * @example
-   *   shader.setUniforms({
-   *     uTime:       1.5,
-   *     uResolution: [800, 600],
-   *     uMVP:        mat4,
-   *   });
-   */
+    Ft(this.gl, r, i, e, s);
+  }
   setUniforms(t) {
     for (const e in t)
       this.setUniform(e, t[e]);
   }
   // ── Attributes ────────────────────────────────────────────────────────────
-  /**
-   * Bind a single vertex attribute pointer.
-   * The VBO must already be bound before calling this.
-   */
   setAttribute(t) {
     const e = this.attributeLoc[t.name];
     if (e === void 0) return;
@@ -1490,40 +915,37 @@ class gt {
     r.vertexAttribPointer(
       e,
       t.size,
-      t.type ?? _t,
+      t.type ?? It,
       t.normalized ?? !1,
       t.stride,
       t.offset ?? 0
-    ), r.enableVertexAttribArray(e), Pt(r, e, t.divisor ?? 0);
+    ), r.enableVertexAttribArray(e), Ot(r, e, t.divisor ?? 0);
   }
-  /** Bind all vertex attribute pointers at once */
   setAttributes(t) {
     for (const e of t)
       this.setAttribute(e);
   }
   // ── Lifecycle ─────────────────────────────────────────────────────────────
-  /** Free GPU resources */
   destroy() {
     this.gl.deleteProgram(this.program);
   }
-  /** Parse attribute/uniform names and GLSL types from raw shader source */
   parseShader(t) {
     const e = this.gl, r = t.match(/(?:in|attribute)\s+\w+\s+\w+/g);
     if (r)
       for (const s of r) {
-        const o = s.split(/\s+/)[2], h = e.getAttribLocation(this.program, o);
-        h !== -1 && (this.attributeLoc[o] = h);
+        const h = s.split(/\s+/)[2], o = e.getAttribLocation(this.program, h);
+        o !== -1 && (this.attributeLoc[h] = o);
       }
     const i = t.matchAll(
       /uniform\s+(?:(?:lowp|mediump|highp)\s+)?(\w+)\s+(\w+)(\s*\[\s*\d+\s*\])?/g
     );
     for (const s of i) {
-      const a = s[1], o = s[2], h = e.getUniformLocation(this.program, o);
-      h !== null && (this.uniformLoc[o] = h, this.uniformType[o] = a, this.uniformIsArray[o] = s[3] !== void 0);
+      const a = s[1], h = s[2], o = e.getUniformLocation(this.program, h);
+      o !== null && (this.uniformLoc[h] = o, this.uniformType[h] = a, this.uniformIsArray[h] = s[3] !== void 0);
     }
   }
 }
-function Nt(n, t, e, r, i = !1) {
+function Ft(n, t, e, r, i = !1) {
   switch (e) {
     // scalars
     case "float":
@@ -1559,10 +981,10 @@ function Nt(n, t, e, r, i = !1) {
       return n.uniformMatrix4fv(t, !1, r);
     // fallback: guess by value shape
     default:
-      return It(n, t, r);
+      return Bt(n, t, r);
   }
 }
-function It(n, t, e) {
+function Bt(n, t, e) {
   if (typeof e == "number")
     return n.uniform1f(t, e);
   const r = e;
@@ -1581,31 +1003,19 @@ function It(n, t, e) {
       return n.uniform1fv(t, r);
   }
 }
-class ht {
-  /** Custom vertex shader code */
+class ut {
   vs;
-  /** Custom fragment shader code */
   fs;
-  /** Map of compiled GLShader instances per region key */
   glshader = /* @__PURE__ */ new Map();
-  /** Currently stored uniform values */
   uniforms = {};
-  /** Set of region keys that need uniform updates */
   uniformDirty = /* @__PURE__ */ new Set();
-  /** Map of textures to be bound to this shader */
   uniformTextures = {};
-  /** Number of texture units reserved by this custom shader */
   usedTextureUnitNum = 0;
-  /** Padding in pixels this shader needs beyond the sprite bounds (for outline/glow effects) */
   padding = 0;
   rapid;
   constructor(t, e, r, i = 0, s) {
     this.vs = e, this.fs = r, this.rapid = t, this.uniforms = s ?? {}, this.usedTextureUnitNum = i;
   }
-  /**
-   * Updates uniform values or textures for the custom shader.
-   * @param uniforms Map of uniform values or WebGL textures to apply.
-   */
   setUniforms(t) {
     this.rapid.flush();
     const e = {}, r = {};
@@ -1615,34 +1025,16 @@ class ht {
     for (const i of this.glshader.keys())
       this.uniformDirty.add(i);
   }
-  /**
-   * Sets the padding (in pixels) for this shader and propagates to all compiled GLShaders.
-   * Must be called before the first draw call if set after construction.
-   * @param pixels - Number of pixels to expand the quad on each side.
-   */
   setPadding(t) {
     this.padding = t;
     for (const e of this.glshader.values())
       e.padding = t;
     return this;
   }
-  /**
-   * Applies current uniforms and texture unit mappings to the region-specific shader.
-   * @param key The region key.
-   * @param textureUniforms Map of texture uniform names to assigned texture unit indices.
-   */
   applyUniform(t, e) {
     const r = this.glshader.get(t);
     r && (Object.keys(e).length > 0 && r.setUniforms(e), this.uniformDirty.has(t) && (r.setUniforms(this.uniforms), this.uniformDirty.delete(t)));
   }
-  /**
-   * Retrieves or compiles a customized GLShader for a specific region.
-   * @param region The Region requesting the shader.
-   * @param key The region key.
-   * @param baseVS The base vertex shader template.
-   * @param baseFS The base fragment shader template.
-   * @returns The combined and compiled GLShader.
-   */
   getGLShader(t, e, r, i) {
     if (this.glshader.has(e))
       return this.glshader.get(e);
@@ -1656,7 +1048,7 @@ class ht {
     this.glshader.forEach((t) => t.destroy());
   }
 }
-class vt {
+class Et {
   constructor(t) {
     this.rapid = t, this.gl = t.gl, this.maxTextureUnits = t.maxTextureUnits, this.matrixStore = t.matrix;
   }
@@ -1699,7 +1091,7 @@ class vt {
     return i == -1 ? (this.freeTextureUnitNum === 0 && this.flush(), this.usedTextures.push(t), this.usedTexturePadding.push(e), this.usedTexturePadding.push(r), this.usedTextures.length - 1) : i;
   }
   createShader(t, e) {
-    return new gt(this.gl, t, e);
+    return new Tt(this.gl, t, e);
   }
   createCustomShader(t) {
     return t.getGLShader(this, this.KEY, this.vs, this.fs);
@@ -1707,22 +1099,17 @@ class vt {
   getCustomShader(t) {
     if (!t)
       return this.defaultShader;
-    if (t instanceof ht) {
+    if (t instanceof ut) {
       const e = this.createCustomShader(t);
       return e ?? this.defaultShader;
     }
     return t;
   }
-  /**
-   * Checks if the given shader is the same as the currently bound shader.
-   * @param customShader Optional custom shader.
-   * @returns True if already bound, otherwise false.
-   */
   isSameShader(t) {
     return this.isDefaultShader && !t ? !0 : this.getCustomShader(t) == this.currentShader;
   }
   enter(t) {
-    this.resetRender(), this.currentShader = this.getCustomShader(t), t instanceof ht ? (this.customShader = t, this.customShaderUsedTextureNum = t.usedTextureUnitNum) : (this.customShader = null, this.customShaderUsedTextureNum = 0), this.isDefaultShader = this.currentShader == this.defaultShader, this.currentShader.use(), this.currentShader.setUniform("u_projection", this.rapid.projection);
+    this.resetRender(), this.currentShader = this.getCustomShader(t), t instanceof ut ? (this.customShader = t, this.customShaderUsedTextureNum = t.usedTextureUnitNum) : (this.customShader = null, this.customShaderUsedTextureNum = 0), this.isDefaultShader = this.currentShader == this.defaultShader, this.currentShader.use(), this.currentShader.setUniform("u_projection", this.rapid.projection);
   }
   exit() {
     this.hasPendingContent() && this.flush(), this.gl.bindVertexArray(null);
@@ -1759,7 +1146,7 @@ class vt {
     return !1;
   }
 }
-const Q = `#version 300 es\r
+const Z = `#version 300 es\r
 precision highp float;\r
 \r
 // per-vertex\r
@@ -1807,7 +1194,7 @@ void main(void) {\r
 \r
     gl_Position = u_projection * position;\r
 }\r
-`, ot = `#version 300 es\r
+`, lt = `#version 300 es\r
 precision mediump float;\r
 \r
 uniform sampler2D uTextures[%TEXTURE_NUM%];\r
@@ -1856,8 +1243,8 @@ void main(void) {\r
 \r
     // CUSTOM_CODE_CALL\r
 }\r
-`, z = 48, Ot = new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]);
-class nt extends vt {
+`, $ = 48, Dt = new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]);
+class ot extends Et {
   instanceBuffer;
   quadBuffer;
   instanceCount = 0;
@@ -1869,43 +1256,31 @@ class nt extends vt {
   }
   createBuffer() {
     const t = this.gl;
-    this.quadBuffer = new tt(t, A.Float32, t.ARRAY_BUFFER, t.STATIC_DRAW), this.quadBuffer.bindBuffer();
-    for (const e of Ot) this.quadBuffer.pushFloat32(e);
-    this.quadBuffer.makeDirty(), this.quadBuffer.bufferData(), this.instanceBuffer = new tt(t, A.Uint32, t.ARRAY_BUFFER, t.DYNAMIC_DRAW);
+    this.quadBuffer = new it(t, S.Float32, t.ARRAY_BUFFER, t.STATIC_DRAW), this.quadBuffer.bindBuffer();
+    for (const e of Dt) this.quadBuffer.pushFloat32(e);
+    this.quadBuffer.makeDirty(), this.quadBuffer.bufferData(), this.instanceBuffer = new it(t, S.Uint32, t.ARRAY_BUFFER, t.DYNAMIC_DRAW);
   }
   createDefaultShader() {
-    const t = this.rapid, e = H(ot, t.maxTextureUnits), r = H(Q, t.maxTextureUnits);
+    const t = this.rapid, e = B(lt, t.maxTextureUnits), r = B(Z, t.maxTextureUnits);
     return this.vs = r, this.fs = e, this.defaultShader = this.createShader(r, e), this.defaultShader;
   }
   createShader(t, e) {
     const r = super.createShader(t, e);
     return r.use(), r.bindVAO(), this.instanceBuffer.bindBuffer(), r.setAttributes([
-      { name: "aMatrixRow0", size: 3, stride: z, offset: 0, divisor: 1 },
-      { name: "aMatrixRow1", size: 3, stride: z, offset: 12, divisor: 1 },
-      { name: "aUVRect", size: 4, stride: z, offset: 24, divisor: 1 },
-      { name: "aColor", size: 4, type: it, normalized: !0, stride: z, offset: 40, divisor: 1 },
-      { name: "aTextureId", size: 1, type: it, stride: z, offset: 44, divisor: 1 }
+      { name: "aMatrixRow0", size: 3, stride: $, offset: 0, divisor: 1 },
+      { name: "aMatrixRow1", size: 3, stride: $, offset: 12, divisor: 1 },
+      { name: "aUVRect", size: 4, stride: $, offset: 24, divisor: 1 },
+      { name: "aColor", size: 4, type: at, normalized: !0, stride: $, offset: 40, divisor: 1 },
+      { name: "aTextureId", size: 1, type: at, stride: $, offset: 44, divisor: 1 }
     ]), this.quadBuffer.bindBuffer(), r.setAttributes([
       { name: "aVertex", size: 2, stride: 8, offset: 0, divisor: 0 }
     ]), r.unbindVAO(), this.currentShader && this.currentShader.use(), r;
   }
   createCustomShader(t) {
-    const e = H(ot, this.rapid.maxTextureUnits - t.usedTextureUnitNum), r = H(Q, this.rapid.maxTextureUnits - t.usedTextureUnitNum);
+    const e = B(lt, this.rapid.maxTextureUnits - t.usedTextureUnitNum), r = B(Z, this.rapid.maxTextureUnits - t.usedTextureUnitNum);
     return t.getGLShader(this, this.KEY, r, e);
   }
-  /**
-   * Draws a textured sprite via instanced rendering to significantly improve performance.
-   * @param texture The WebGLTexture to map.
-   * @param matrixIndex The index for the transform matrix in MatrixStore.
-   * @param width Render width.
-   * @param height Render height.
-   * @param u0 Left UV mapped coordinate (default 0).
-   * @param v0 Top UV mapped coordinate (default 0).
-   * @param u1 Right UV mapped coordinate (default 1).
-   * @param v1 Bottom UV mapped coordinate (default 1).
-   * @param color The tint color as packed ABGR uniform uint32 (default 0xFFFFFFFF).
-   */
-  drawSprite(t, e, r = 0, i = 0, s = 1, a = 1, o = 4294967295, h = 0, c = 0, u = !1, l = !1, d = !1) {
+  drawSprite(t, e, r = 0, i = 0, s = 1, a = 1, h = 4294967295, o = 0, c = 0, u = !1, l = !1, d = !1) {
     const f = e * 6, m = this.matrixStore.data;
     this.drawSpriteAffine(
       t,
@@ -1919,31 +1294,31 @@ class nt extends vt {
       i,
       s,
       a,
-      o,
       h,
+      o,
       c,
       u,
       l,
       d
     );
   }
-  drawSpriteAffine(t, e, r, i, s, a, o, h = 0, c = 0, u = 1, l = 1, d = 4294967295, f = 0, m = 0, g = !1, v = !1, y = !1) {
-    const R = t.base, M = t.rawWidth, C = t.rawHeight, P = t.offsetX, I = t.offsetY, O = this.useTexture(
+  drawSpriteAffine(t, e, r, i, s, a, h, o = 0, c = 0, u = 1, l = 1, d = 4294967295, f = 0, m = 0, g = !1, v = !1, y = !1) {
+    const w = t.base, M = t.rawWidth, _ = t.rawHeight, P = t.offsetX, O = t.offsetY, W = this.useTexture(
       t.glTexture,
-      f / R.width,
-      m / R.height
-    ), _ = this.instanceBuffer, w = _.usedElemNum;
-    _.resize(12);
-    const U = _.float32, B = _.uint32, D = y ? C : M, G = y ? M : C, F = D + 2 * f, k = G + 2 * m, X = P - f, W = I - m, T = this.localSpriteMatrix;
-    y ? (T[0] = 0, T[1] = v ? k : -k, T[2] = g ? -F : F, T[3] = 0, T[4] = X + (g ? F : 0), T[5] = W + (v ? 0 : k)) : (T[0] = g ? -F : F, T[1] = 0, T[2] = 0, T[3] = v ? -k : k, T[4] = X + (g ? F : 0), T[5] = W + (v ? k : 0));
-    const S = this.worldSpriteMatrix;
-    S[0] = e * T[0] + i * T[1], S[1] = r * T[0] + s * T[1], S[2] = e * T[2] + i * T[3], S[3] = r * T[2] + s * T[3], S[4] = a + e * T[4] + i * T[5], S[5] = o + r * T[4] + s * T[5], U[w + 6] = h, U[w + 7] = c, U[w + 8] = u, U[w + 9] = l, B[w + 10] = d, B[w + 11] = O, this.rapid.roundPixels && (S[4] = Math.round(S[4]), S[5] = Math.round(S[5])), U[w] = S[0], U[w + 1] = S[2], U[w + 2] = S[4], U[w + 3] = S[1], U[w + 4] = S[3], U[w + 5] = S[5], _.usedElemNum += 12, _.makeDirty(), this.instanceCount++;
+      f / w.width,
+      m / w.height
+    ), b = this.instanceBuffer, R = b.usedElemNum;
+    b.resize(12);
+    const C = b.float32, D = b.uint32, k = y ? _ : M, H = y ? M : _, I = k + 2 * f, F = H + 2 * m, Y = P - f, z = O - m, E = this.localSpriteMatrix;
+    y ? (E[0] = 0, E[1] = v ? F : -F, E[2] = g ? -I : I, E[3] = 0, E[4] = Y + (g ? I : 0), E[5] = z + (v ? 0 : F)) : (E[0] = g ? -I : I, E[1] = 0, E[2] = 0, E[3] = v ? -F : F, E[4] = Y + (g ? I : 0), E[5] = z + (v ? F : 0));
+    const U = this.worldSpriteMatrix;
+    U[0] = e * E[0] + i * E[1], U[1] = r * E[0] + s * E[1], U[2] = e * E[2] + i * E[3], U[3] = r * E[2] + s * E[3], U[4] = a + e * E[4] + i * E[5], U[5] = h + r * E[4] + s * E[5], C[R + 6] = o, C[R + 7] = c, C[R + 8] = u, C[R + 9] = l, D[R + 10] = d, D[R + 11] = W, this.rapid.roundPixels && (U[4] = Math.round(U[4]), U[5] = Math.round(U[5])), C[R] = U[0], C[R + 1] = U[2], C[R + 2] = U[4], C[R + 3] = U[1], C[R + 4] = U[3], C[R + 5] = U[5], b.usedElemNum += 12, b.makeDirty(), this.instanceCount++;
   }
   render() {
     if (this.instanceCount === 0) return;
     this.prepareRender();
     const t = this.gl, e = this.currentShader;
-    this.instanceBuffer.bindBuffer(), this.instanceBuffer.bufferData(), e.bindVAO(), pt(t, t.TRIANGLE_STRIP, 0, 4, this.instanceCount), this.rapid.drawcallCount++;
+    this.instanceBuffer.bindBuffer(), this.instanceBuffer.bufferData(), e.bindVAO(), yt(t, t.TRIANGLE_STRIP, 0, 4, this.instanceCount), this.rapid.drawcallCount++;
   }
   resetRender() {
     super.resetRender(), this.instanceBuffer.clear(), this.instanceCount = 0;
@@ -1952,7 +1327,7 @@ class nt extends vt {
     return this.instanceCount > 0;
   }
 }
-const Ft = `#version 300 es\r
+const kt = `#version 300 es\r
 precision highp float;\r
 \r
 in vec2 aPosition;\r
@@ -1983,7 +1358,7 @@ void main(void) {\r
     // CUSTOM_CODE_CALL\r
     gl_Position = u_projection * position;\r
 }\r
-`, Wt = `#version 300 es\r
+`, Ht = `#version 300 es\r
 precision mediump float;\r
 \r
 in vec4 vColor;\r
@@ -2029,7 +1404,7 @@ void main(void) {\r
     fragColor = sampleTexture(vRegion) * vColor;\r
     // CUSTOM_CODE_CALL\r
 }\r
-`, Bt = `#version 300 es\r
+`, Gt = `#version 300 es\r
 precision highp float;\r
 \r
 in vec2 aPosition;\r
@@ -2052,7 +1427,7 @@ void main(void) {\r
     );\r
     gl_Position = u_projection * position;\r
 }\r
-`, Dt = `#version 300 es\r
+`, Vt = `#version 300 es\r
 precision mediump float;\r
 \r
 in vec2 vRegion;\r
@@ -2072,8 +1447,8 @@ void main(void) {\r
         discard;\r
     }\r
 }\r
-`, $ = 20;
-class kt extends vt {
+`, j = 20;
+class Yt extends Et {
   vertexBuffer;
   vertexCount = 0;
   matrixIndex = -1;
@@ -2086,50 +1461,33 @@ class kt extends vt {
   }
   createBuffer() {
     const t = this.gl;
-    this.vertexBuffer = new tt(t, A.Float32, t.ARRAY_BUFFER, t.DYNAMIC_DRAW), this.maskShader = this.createMaskShader(Bt, Dt);
+    this.vertexBuffer = new it(t, S.Float32, t.ARRAY_BUFFER, t.DYNAMIC_DRAW), this.maskShader = this.createMaskShader(Gt, Vt);
   }
   createDefaultShader() {
-    return this.vs = Ft, this.fs = Wt, this.defaultShader = this.createShader(this.vs, this.fs), this.defaultShader;
+    return this.vs = kt, this.fs = Ht, this.defaultShader = this.createShader(this.vs, this.fs), this.defaultShader;
   }
   createMaskShader(t, e) {
-    const r = this.gl, i = new gt(r, t, e);
+    const r = this.gl, i = new Tt(r, t, e);
     return i.use(), i.bindVAO(), this.vertexBuffer.bindBuffer(), i.setAttributes([
-      { name: "aPosition", size: 2, type: r.FLOAT, stride: $ - 4, offset: 0, divisor: 0 },
-      { name: "aUV", size: 2, type: r.FLOAT, stride: $ - 4, offset: 8, divisor: 0 }
+      { name: "aPosition", size: 2, type: r.FLOAT, stride: j - 4, offset: 0, divisor: 0 },
+      { name: "aUV", size: 2, type: r.FLOAT, stride: j - 4, offset: 8, divisor: 0 }
     ]), i.unbindVAO(), this.currentShader && this.currentShader.use(), i;
   }
   createShader(t, e) {
     const r = this.gl, i = super.createShader(t, e);
     return i.use(), i.bindVAO(), this.vertexBuffer.bindBuffer(), i.setAttributes([
-      { name: "aPosition", size: 2, type: r.FLOAT, stride: $, offset: 0, divisor: 0 },
-      { name: "aColor", size: 4, type: r.UNSIGNED_BYTE, normalized: !0, stride: $, offset: 8, divisor: 0 },
-      { name: "aUV", size: 2, type: r.FLOAT, stride: $, offset: 12, divisor: 0 }
+      { name: "aPosition", size: 2, type: r.FLOAT, stride: j, offset: 0, divisor: 0 },
+      { name: "aColor", size: 4, type: r.UNSIGNED_BYTE, normalized: !0, stride: j, offset: 8, divisor: 0 },
+      { name: "aUV", size: 2, type: r.FLOAT, stride: j, offset: 12, divisor: 0 }
     ]), i.unbindVAO(), this.currentShader && this.currentShader.use(), i;
   }
-  /**
-   * Begins a new polygon drawing sequence. Must be followed by addVertex() calls and endGraphic().
-   * @param matrixIndex The index targeting a specific transform matrix in the MatrixStore.
-   * @param drawMode The WebGL drawing primitive mode (e.g., gl.TRIANGLES).
-   * @param texture Optional texture to apply over the polygon.
-   */
   startGraphic(t, e = this.gl.TRIANGLES, r) {
     this.vertexBuffer.clear(), this.vertexCount = 0, this.matrixIndex = t, this.drawMode = e, this.texture = r, this.texture?.glTexture && this.useTexture(this.texture.glTexture, 0, 0);
   }
-  /**
-   * Adds a vertex to the current polygon. Local coordinates and color settings.
-   * @param x Local X coordinate.
-   * @param y Local Y coordinate.
-   * @param u UV mapped X value (0-1, default 0).
-   * @param v UV mapped Y value (0-1, default 0).
-   * @param color Pre-multiplied hex color combined using ABGR byte order (default 0xFFFFFFFF).
-   */
   addVertex(t, e, r = 0, i = 0, s = 4294967295) {
     const a = this.vertexBuffer;
     a.pushFloat32(t), a.pushFloat32(e), this.currentShader != this.maskShader && a.pushUint32(s), a.pushFloat32(r), a.pushFloat32(i), this.vertexCount++, this.vertexBuffer.makeDirty();
   }
-  /**
-   * Finishes the graphic construction and dispatches the rendering call immediately.
-   */
   endGraphic() {
     this.flush();
   }
@@ -2168,15 +1526,9 @@ class p {
   subtract(t) {
     return new p(this.x - t.x, this.y - t.y);
   }
-  sub(t) {
-    return new p(this.x - t.x, this.y - t.y);
-  }
   multiply(t) {
     return t instanceof p ? new p(this.x * t.x, this.y * t.y) : new p(this.x * t, this.y * t);
   }
-  mul(t) {
-    return this.multiply(t);
-  }
   divide(t) {
     return t instanceof p ? new p(this.x / t.x, this.y / t.y) : new p(this.x / t, this.y / t);
   }
@@ -2196,9 +1548,6 @@ class p {
   to(t) {
     this.x = t.x, this.y = t.y;
   }
-  copy() {
-    return new p(this.x, this.y);
-  }
   equals(t) {
     return t.x == this.x && t.y == this.y;
   }
@@ -2272,8 +1621,8 @@ class p {
     return new p(Math.cos(t), Math.sin(t));
   }
 }
-const Ht = (n, t) => {
-  const [e, r, i, s, a, o] = t, h = new Float32Array([
+const Xt = (n, t) => {
+  const [e, r, i, s, a, h] = t, o = new Float32Array([
     e,
     i,
     0,
@@ -2287,12 +1636,12 @@ const Ht = (n, t) => {
     1,
     0,
     a,
-    o,
+    h,
     0,
     1
   ]);
-  return Gt(h, n);
-}, Gt = (n, t) => {
+  return zt(o, n);
+}, zt = (n, t) => {
   const e = new Float32Array(16);
   for (let r = 0; r < 4; r++)
     for (let i = 0; i < 4; i++) {
@@ -2303,29 +1652,29 @@ const Ht = (n, t) => {
     }
   return e;
 };
-var Vt = /* @__PURE__ */ ((n) => (n[n.STRETCH = 0] = "STRETCH", n[n.REPEAT = 1] = "REPEAT", n))(Vt || {});
-const J = 10, ct = (n, t, e, r, i, s) => {
-  const a = [], o = [], h = r ? Math.atan2(t.y, t.x) : Math.atan2(-t.y, -t.x), c = Math.PI, u = new p(t.y, -t.x);
-  for (let l = 0; l < J; l++) {
-    const d = l / J, f = (l + 1) / J, m = h + d * c, g = h + f * c, v = new p(Math.cos(m) * e, Math.sin(m) * e), y = new p(Math.cos(g) * e, Math.sin(g) * e);
-    a.push(n), o.push(new p(i, 0.5)), a.push(n.add(v)), o.push(new p(i + v.dot(u) * s, 0.5 - 0.5 * v.dot(t) / e)), a.push(n.add(y)), o.push(new p(i + y.dot(u) * s, 0.5 - 0.5 * y.dot(t) / e));
-  }
-  return { vertices: a, uv: o };
-}, Yt = (n, t = !1) => {
+var $t = /* @__PURE__ */ ((n) => (n[n.STRETCH = 0] = "STRETCH", n[n.REPEAT = 1] = "REPEAT", n))($t || {});
+const rt = 10, dt = (n, t, e, r, i, s) => {
+  const a = [], h = [], o = r ? Math.atan2(t.y, t.x) : Math.atan2(-t.y, -t.x), c = Math.PI, u = new p(t.y, -t.x);
+  for (let l = 0; l < rt; l++) {
+    const d = l / rt, f = (l + 1) / rt, m = o + d * c, g = o + f * c, v = new p(Math.cos(m) * e, Math.sin(m) * e), y = new p(Math.cos(g) * e, Math.sin(g) * e);
+    a.push(n), h.push(new p(i, 0.5)), a.push(n.add(v)), h.push(new p(i + v.dot(u) * s, 0.5 - 0.5 * v.dot(t) / e)), a.push(n.add(y)), h.push(new p(i + y.dot(u) * s, 0.5 - 0.5 * y.dot(t) / e));
+  }
+  return { vertices: a, uv: h };
+}, jt = (n, t = !1) => {
   const e = [];
   if (n.length < 2 || t && n.length < 3) return { normals: e, length: 0 };
   const r = 4, i = 1e-3, s = n.length;
   let a = 0;
   if (t)
-    for (let h = 0; h < s; h++) {
-      const c = n[h], u = n[(h + 1) % s];
+    for (let o = 0; o < s; o++) {
+      const c = n[o], u = n[(o + 1) % s];
       a += c.distanceTo(u);
     }
   else
-    for (let h = 0; h < s - 1; h++)
-      a += n[h].distanceTo(n[h + 1]);
-  const o = (h, c, u) => {
-    const l = c.subtract(h).normalize(), d = c.subtract(u).normalize(), f = d.dot(l);
+    for (let o = 0; o < s - 1; o++)
+      a += n[o].distanceTo(n[o + 1]);
+  const h = (o, c, u) => {
+    const l = c.subtract(o).normalize(), d = c.subtract(u).normalize(), f = d.dot(l);
     if (f < -1 + i)
       return { normal: l.perpendicular(), miters: 1 };
     {
@@ -2336,42 +1685,42 @@ const J = 10, ct = (n, t, e, r, i, s) => {
     }
   };
   if (t)
-    for (let h = 0; h < s; h++) {
-      const c = h === 0 ? n[s - 1] : n[h - 1], u = n[h], l = h === s - 1 ? n[0] : n[h + 1];
-      e.push(o(c, u, l));
+    for (let o = 0; o < s; o++) {
+      const c = o === 0 ? n[s - 1] : n[o - 1], u = n[o], l = o === s - 1 ? n[0] : n[o + 1];
+      e.push(h(c, u, l));
     }
   else
-    for (let h = 0; h < s; h++)
-      if (h === 0) {
+    for (let o = 0; o < s; o++)
+      if (o === 0) {
         const c = n[1].subtract(n[0]).normalize();
         e.push({ normal: c.perpendicular(), miters: 1 });
-      } else if (h === s - 1) {
-        const c = n[h].subtract(n[h - 1]).normalize();
+      } else if (o === s - 1) {
+        const c = n[o].subtract(n[o - 1]).normalize();
         e.push({ normal: c.perpendicular(), miters: 1 });
       } else
-        e.push(o(n[h - 1], n[h], n[h + 1]));
+        e.push(h(n[o - 1], n[o], n[o + 1]));
   return { normals: e, length: a };
-}, Xt = (n) => {
+}, Kt = (n) => {
   const t = n.points;
   if (t.length < 2) return { vertices: [], uv: [] };
-  const { normals: e, length: r } = Yt(t, n.closed), i = (n.width || 1) / 2, s = [], a = [], o = n.roundCap || !1, h = n.textureMode || 0;
+  const { normals: e, length: r } = jt(t, n.closed), i = (n.width || 1) / 2, s = [], a = [], h = n.roundCap || !1, o = n.textureMode || 0;
   let c = 0;
   const u = n.texture?.rawWidth || 1, l = n.closed ? t.length : t.length - 1;
   for (let d = 0; d < l; d++) {
-    const f = t[d], m = e[d].normal, g = e[d].miters, v = (d + 1) % t.length, y = t[v], R = e[v].normal, M = e[v].miters, C = f.add(m.multiply(g * i)), P = f.subtract(m.multiply(g * i)), I = y.add(R.multiply(M * i)), O = y.subtract(R.multiply(M * i)), _ = f.distanceTo(y);
-    let w = 0, U = 0;
-    h === 0 ? (w = c / r, U = (c + _) / r) : (w = c / u, U = w + _ / u);
-    const B = new p(w, 0), D = new p(w, 1), G = new p(U, 0), F = new p(U, 1);
-    s.push(C), a.push(B), s.push(P), a.push(D), s.push(I), a.push(G), s.push(I), a.push(G), s.push(O), a.push(F), s.push(P), a.push(D), c += _;
-  }
-  if (o && !n.closed) {
-    const d = t[0], f = e[0].normal, m = h === 0 ? r > 0 ? 1 / r : 0 : 1 / u, g = ct(d, f, i, !0, 0, m);
+    const f = t[d], m = e[d].normal, g = e[d].miters, v = (d + 1) % t.length, y = t[v], w = e[v].normal, M = e[v].miters, _ = f.add(m.multiply(g * i)), P = f.subtract(m.multiply(g * i)), O = y.add(w.multiply(M * i)), W = y.subtract(w.multiply(M * i)), b = f.distanceTo(y);
+    let R = 0, C = 0;
+    o === 0 ? (R = c / r, C = (c + b) / r) : (R = c / u, C = R + b / u);
+    const D = new p(R, 0), k = new p(R, 1), H = new p(C, 0), I = new p(C, 1);
+    s.push(_), a.push(D), s.push(P), a.push(k), s.push(O), a.push(H), s.push(O), a.push(H), s.push(W), a.push(I), s.push(P), a.push(k), c += b;
+  }
+  if (h && !n.closed) {
+    const d = t[0], f = e[0].normal, m = o === 0 ? r > 0 ? 1 / r : 0 : 1 / u, g = dt(d, f, i, !0, 0, m);
     s.push(...g.vertices), a.push(...g.uv);
-    const v = t[t.length - 1], y = e[t.length - 1].normal, R = h === 0 ? 1 : c / u, M = h === 0 ? r > 0 ? 1 / r : 0 : 1 / u, C = ct(v, y, i, !1, R, M);
-    s.push(...C.vertices), a.push(...C.uv);
+    const v = t[t.length - 1], y = e[t.length - 1].normal, w = o === 0 ? 1 : c / u, M = o === 0 ? r > 0 ? 1 / r : 0 : 1 / u, _ = dt(v, y, i, !1, w, M);
+    s.push(..._.vertices), a.push(..._.uv);
   }
   return { vertices: s, uv: a };
-}, q = (n, t, e, r) => {
+}, Q = (n, t, e, r) => {
   if (t.customMatrix !== void 0)
     return t.customMatrix;
   if (t.modifyStack) {
@@ -2390,24 +1739,24 @@ const J = 10, ct = (n, t, e, r, i, s) => {
       i
     ), i;
   }
-}, zt = (n, t) => t ? n ? t.premultipliedUint32 : t.uint32 : 4294967295, $t = 2, jt = (n, t) => {
-  const e = q(n, t, t.texture.rawWidth, t.texture.rawHeight), r = t.texture;
+}, qt = (n, t) => t ? n ? t.premultipliedUint32 : t.uint32 : 4294967295, Qt = 2, Zt = (n, t) => {
+  const e = Q(n, t, t.texture.rawWidth, t.texture.rawHeight), r = t.texture;
   if (!r?.base || n.inCreateMask)
     return;
   const i = r.isAtlas ? n.atlasSpriteRegion : n.spriteRegion;
   n.enterRegion(i, t.shader);
-  let s = r.uvX, a = r.uvY, o = r.uvW, h = r.uvH;
+  let s = r.uvX, a = r.uvY, h = r.uvW, o = r.uvH;
   const c = !!t.flipX, u = !!t.flipY != !!r.flipY;
   let l = t.padding ?? i.currentShader.padding;
-  r.isAtlas && (l += $t);
-  const d = s <= o ? l : -l, f = a <= h ? l : -l;
+  r.isAtlas && (l += Qt);
+  const d = s <= h ? l : -l, f = a <= o ? l : -l;
   i.drawSprite(
     r,
     e ?? t.customMatrix ?? n.matrixStack.curWorldM,
     s,
     a,
-    o,
     h,
+    o,
     n.getColorUint32(t.color),
     d,
     f,
@@ -2415,7 +1764,7 @@ const J = 10, ct = (n, t, e, r, i, s) => {
     u,
     r.isRotated
   );
-}, Kt = (n, t) => {
+}, Jt = (n, t) => {
   const e = n.particleRegion;
   n.enterRegion(e, t.shader);
   const r = t.texture, i = t.count ?? t.x.length, s = t.color;
@@ -2441,9 +1790,9 @@ const J = 10, ct = (n, t, e, r, i, s) => {
     t.reverseOrder,
     t.customMatrix
   );
-}, yt = (n, t) => {
+}, Rt = (n, t) => {
   if (t.points.length === 0) return;
-  const e = q(n, t, 0, 0);
+  const e = Q(n, t, 0, 0);
   n.startGraphic(
     t.drawMode ?? n.gl.TRIANGLES,
     t.texture,
@@ -2461,18 +1810,18 @@ const J = 10, ct = (n, t, e, r, i, s) => {
     );
   }
   n.endGraphic();
-}, qt = (n, t) => {
+}, te = (n, t) => {
   if (n.inCreateMask)
     return;
-  const { vertices: e, uv: r } = Xt(t);
-  yt(n, {
+  const { vertices: e, uv: r } = Kt(t);
+  Rt(n, {
     ...t,
     points: e,
     uv: r,
     drawMode: n.gl.TRIANGLES
   });
-}, Qt = (n, t) => {
-  const e = q(
+}, ee = (n, t) => {
+  const e = Q(
     n,
     t,
     t.texture.rawWidth,
@@ -2483,16 +1832,16 @@ const J = 10, ct = (n, t, e, r, i, s) => {
     t.texture,
     e ?? t.customMatrix
   ), n.addRectVertex(t.texture.rawWidth, t.texture.rawHeight), n.endGraphic();
-}, Zt = (n, t) => {
-  const e = q(n, t, t.width, t.height);
+}, re = (n, t) => {
+  const e = Q(n, t, t.width, t.height);
   n.startGraphic(
     n.gl.TRIANGLE_FAN,
     t.texture,
     t.shader,
     e ?? t.customMatrix
   ), n.addRectVertex(t.width, t.height, t.color), n.endGraphic();
-}, Jt = (n, t) => {
-  const e = t.segments ?? 32, r = q(n, t, 0, 0);
+}, ie = (n, t) => {
+  const e = t.segments ?? 32, r = Q(n, t, 0, 0);
   n.startGraphic(
     n.gl.TRIANGLE_FAN,
     void 0,
@@ -2501,7 +1850,7 @@ const J = 10, ct = (n, t, e, r, i, s) => {
   );
   const i = n.getColorUint32(t.color);
   n.addGraphicVertex(0, 0, 0.5, 0.5, i), n.addCircleVertex(t.radius, t.color, e), n.addGraphicVertex(t.radius, 0, 1, 0.5, i), n.endGraphic();
-}, ut = `#version 300 es\r
+}, ft = `#version 300 es\r
 precision mediump float;\r
 \r
 uniform sampler2D uTextures[%TEXTURE_NUM%];\r
@@ -2551,21 +1900,21 @@ void main(void) {\r
     // CUSTOM_CODE_CALL\r
 }\r
 `;
-class te extends nt {
+class se extends ot {
   KEY = "AtlasSprite";
   constructor(t) {
     super(t);
   }
   createCustomShader(t) {
-    const e = H(ut, this.rapid.maxTextureUnits - t.usedTextureUnitNum), r = H(Q, this.rapid.maxTextureUnits - t.usedTextureUnitNum);
+    const e = B(ft, this.rapid.maxTextureUnits - t.usedTextureUnitNum), r = B(Z, this.rapid.maxTextureUnits - t.usedTextureUnitNum);
     return t.getGLShader(this, this.KEY, r, e);
   }
   createDefaultShader() {
-    const t = this.rapid, e = H(ut, t.maxTextureUnits), r = H(Q, t.maxTextureUnits);
+    const t = this.rapid, e = B(ft, t.maxTextureUnits), r = B(Z, t.maxTextureUnits);
     return this.vs = r, this.fs = e, this.defaultShader = this.createShader(r, e), this.defaultShader;
   }
 }
-const lt = `#version 300 es\r
+const mt = `#version 300 es\r
 precision highp float;\r
 \r
 // per-vertex\r
@@ -2606,7 +1955,7 @@ void main(void) {\r
 \r
     gl_Position = u_projection * vec4(v, 0.0, 1.0);\r
 }\r
-`, dt = `#version 300 es\r
+`, xt = `#version 300 es\r
 precision mediump float;\r
 \r
 uniform sampler2D uTexture;\r
@@ -2622,8 +1971,8 @@ void main(void) {\r
 \r
     // CUSTOM_CODE_CALL\r
 }\r
-`, V = 48, ee = V / 4;
-class re extends nt {
+`, G = 48, ne = G / 4;
+class ae extends ot {
   KEY = "ParticleSprite";
   texture;
   customMatrix;
@@ -2632,10 +1981,10 @@ class re extends nt {
     super(t);
   }
   createCustomShader(t) {
-    return t.getGLShader(this, this.KEY, lt, dt);
+    return t.getGLShader(this, this.KEY, mt, xt);
   }
   createDefaultShader() {
-    const t = dt, e = lt;
+    const t = xt, e = mt;
     return this.vs = e, this.fs = t, this.defaultShader = this.createShader(e, t), this.defaultShader;
   }
   enter(t) {
@@ -2644,71 +1993,73 @@ class re extends nt {
   createShader(t, e) {
     const r = super.createShader(t, e);
     return r.use(), r.bindVAO(), this.instanceBuffer.bindBuffer(), r.setAttributes([
-      { name: "aPosition", size: 2, stride: V, offset: 0, divisor: 1 },
-      { name: "aScale", size: 2, stride: V, offset: 8, divisor: 1 },
-      { name: "aRotation", size: 1, stride: V, offset: 16, divisor: 1 },
-      { name: "aUVRect", size: 4, stride: V, offset: 20, divisor: 1 },
-      { name: "aColor", size: 4, type: it, normalized: !0, stride: V, offset: 36, divisor: 1 },
-      { name: "aOrigin", size: 2, stride: V, offset: 40, divisor: 1 }
+      { name: "aPosition", size: 2, stride: G, offset: 0, divisor: 1 },
+      { name: "aScale", size: 2, stride: G, offset: 8, divisor: 1 },
+      { name: "aRotation", size: 1, stride: G, offset: 16, divisor: 1 },
+      { name: "aUVRect", size: 4, stride: G, offset: 20, divisor: 1 },
+      { name: "aColor", size: 4, type: at, normalized: !0, stride: G, offset: 36, divisor: 1 },
+      { name: "aOrigin", size: 2, stride: G, offset: 40, divisor: 1 }
     ]), this.quadBuffer.bindBuffer(), r.setAttributes([
       { name: "aVertex", size: 2, stride: 8, offset: 0, divisor: 0 }
     ]), r.unbindVAO(), this.currentShader && this.currentShader.use(), r;
   }
-  drawParticles(t, e, r, i = 0, s = 4294967295, a, o = 1, h = 1, c = 0, u = 0, l = 1, d = 1, f = !1, m = !1, g = !1, v = 0.5, y = 0.5, R, M = !1, C) {
+  drawParticles(t, e, r, i = 0, s = 4294967295, a, h = 1, o = 1, c = 0, u = 0, l = 1, d = 1, f = !1, m = !1, g = !1, v = 0.5, y = 0.5, w, M = !1, _) {
     if (!t.glTexture || a <= 0) return;
     this.texture && t !== this.texture && this.flush();
-    const P = typeof o == "number", I = typeof h == "number", O = typeof i == "number", _ = typeof s == "number", w = typeof c == "number", U = !_ && typeof s[0] == "number";
-    let B = t.rawWidth * (f ? -1 : 1);
-    P && (B *= o);
-    let D = t.rawHeight * (m ? -1 : 1);
-    I && (D *= h), w && (B *= l - c, D *= d - u);
-    let G = g ? Math.PI / 2 : 0;
-    O && (G += i);
-    const F = s ?? 4294967295, k = this.getParticleLoop(
+    const P = typeof h == "number", O = typeof o == "number", W = typeof i == "number", b = typeof s == "number", R = typeof c == "number", C = !b && typeof s[0] == "number", D = t.uvW - t.uvX, k = t.uvH - t.uvY, H = D === 0 ? 0 : 1 / D, I = k === 0 ? 0 : 1 / k;
+    let F = t.rawWidth * (f ? -1 : 1);
+    P && (F *= h);
+    let Y = t.rawHeight * (m ? -1 : 1);
+    O && (Y *= o), R && (F *= (l - c) * H, Y *= (d - u) * I);
+    let z = g ? Math.PI / 2 : 0;
+    W && (z += i);
+    const E = s ?? 4294967295, U = this.getParticleLoop(
       P,
-      I,
       O,
-      w,
-      _,
-      U,
+      W,
+      R,
+      b,
+      C,
       M,
-      R
+      w
     );
     this.texture || (this.texture = t, this.useTexture(t.glTexture, 0, 0));
-    const X = a, W = this.instanceBuffer;
-    let T = W.usedElemNum;
-    W.resize(X * ee);
-    const S = W.float32, Et = W.uint32;
-    T = k(
+    const tt = a, X = this.instanceBuffer;
+    let et = X.usedElemNum;
+    X.resize(tt * ne);
+    const Mt = X.float32, St = X.uint32;
+    et = U(
       e,
       r,
-      o,
       h,
+      o,
       i,
       c,
       u,
       l,
       d,
       s,
-      S,
-      Et,
-      B,
-      D,
-      G,
+      Mt,
+      St,
       F,
+      Y,
+      H,
+      I,
+      z,
+      E,
       v,
       y,
       a,
-      X,
-      T
-    ), W.usedElemNum = T, W.makeDirty(), this.instanceCount += X, this.customMatrix = C, this.flush();
+      tt,
+      et
+    ), X.usedElemNum = et, X.makeDirty(), this.instanceCount += tt, this.customMatrix = _, this.flush();
   }
-  getParticleLoop(t, e, r, i, s, a, o, h) {
+  getParticleLoop(t, e, r, i, s, a, h, o) {
     const c = [...arguments].join("_");
     if (this.particleLoopCache.has(c))
       return this.particleLoopCache.get(c);
     let u = `
-return function( x, y, scaleX, scaleY, rotation, u0, v0, u1, v1, color, f32, u32, rawWidth, rawHeight, rotationOffset, staticColor, originX, originY, count, batchCount, index ) {
+return function( x, y, scaleX, scaleY, rotation, u0, v0, u1, v1, color, f32, u32, rawWidth, rawHeight, uv2texW, uv2texH, rotationOffset, staticColor, originX, originY, count, batchCount, index ) {
 ${t && i ? "const baseSx = rawWidth;" : ""}
 ${e && i ? "const baseSy = rawHeight;" : ""}
 
@@ -2716,7 +2067,7 @@ const endIdx = index + batchCount * 12;
 let idx = index;
 if (endIdx > f32.length) return index;
 
-${o ? "for (let src = count - 1; idx < endIdx; src--, idx += 12) {" : "for (let src = 0; idx < endIdx; src++, idx += 12) {"}
+${h ? "for (let src = count - 1; idx < endIdx; src--, idx += 12) {" : "for (let src = 0; idx < endIdx; src++, idx += 12) {"}
 f32[idx]     = x[src];
 f32[idx + 1] = y[src];
 
@@ -2730,8 +2081,8 @@ f32[idx + 7] = u1;
 f32[idx + 8] = v1;
 ` : `
 const cu0 = u0[src], cv0 = v0[src], cu1 = u1[src], cv1 = v1[src];
-f32[idx + 2] = (rawWidth * (cu1 - cu0)) ${t ? "" : "* scaleX[src]"};
-f32[idx + 3] = (rawHeight * (cv1 - cv0)) ${e ? "" : "* scaleY[src]"};
+f32[idx + 2] = (rawWidth * (cu1 - cu0) * uv2texW) ${t ? "" : "* scaleX[src]"};
+f32[idx + 3] = (rawHeight * (cv1 - cv0) * uv2texH) ${e ? "" : "* scaleY[src]"};
 f32[idx + 4] = ${r ? "rotationOffset" : "rotation[src] + rotationOffset"};
 f32[idx + 5] = cu0;
 f32[idx + 6] = cv0;
@@ -2739,7 +2090,7 @@ f32[idx + 7] = cu1;
 f32[idx + 8] = cv1;
 `}
 
-u32[idx + 9] = ${s ? "staticColor" : a ? "color[src]" : `color[src].${h ? "premultipliedUint32" : "uint32"}`};
+u32[idx + 9] = ${s ? "staticColor" : a ? "color[src]" : `color[src].${o ? "premultipliedUint32" : "uint32"}`};
 
 f32[idx + 10] = originX;
 f32[idx + 11] = originY;
@@ -2757,61 +2108,38 @@ return idx;
     this.texture && (t.activeTexture(t.TEXTURE0), t.bindTexture(t.TEXTURE_2D, this.texture.glTexture));
     const e = this.currentShader;
     this.instanceBuffer.bindBuffer(), this.instanceBuffer.bufferData(), e.bindVAO();
-    const r = this.rapid.matrixStack, s = this.rapid.matrix.getMatrix(this.customMatrix ?? r.curWorldM), a = Ht(this.rapid.projection, s);
-    this.currentShader.setUniform("u_projection", a), pt(t, t.TRIANGLE_STRIP, 0, 4, this.instanceCount), this.rapid.drawcallCount++, this.texture = void 0, this.customMatrix = void 0;
+    const r = this.rapid.matrixStack, s = this.rapid.matrix.getMatrix(this.customMatrix ?? r.curWorldM), a = Xt(this.rapid.projection, s);
+    this.currentShader.setUniform("u_projection", a), yt(t, t.TRIANGLE_STRIP, 0, 4, this.instanceCount), this.rapid.drawcallCount++, this.texture = void 0, this.customMatrix = void 0;
   }
 }
-var ie = /* @__PURE__ */ ((n) => (n[n.EQUAL = 0] = "EQUAL", n[n.NOT_EQUAL = 1] = "NOT_EQUAL", n))(ie || {}), se = /* @__PURE__ */ ((n) => (n[n.NORMAL = 0] = "NORMAL", n[n.ADD = 1] = "ADD", n[n.MULTIPLY = 2] = "MULTIPLY", n[n.SCREEN = 3] = "SCREEN", n[n.ERASE = 4] = "ERASE", n))(se || {}), st = /* @__PURE__ */ ((n) => (n[n.LINEAR = 0] = "LINEAR", n[n.NEAREST = 1] = "NEAREST", n))(st || {}), ne = /* @__PURE__ */ ((n) => (n[n.CanvasItem = 0] = "CanvasItem", n[n.Viewport = 1] = "Viewport", n))(ne || {});
-class oe {
-  /** The active WebGL context. */
+var he = /* @__PURE__ */ ((n) => (n[n.EQUAL = 0] = "EQUAL", n[n.NOT_EQUAL = 1] = "NOT_EQUAL", n))(he || {}), oe = /* @__PURE__ */ ((n) => (n[n.NORMAL = 0] = "NORMAL", n[n.ADD = 1] = "ADD", n[n.MULTIPLY = 2] = "MULTIPLY", n[n.SCREEN = 3] = "SCREEN", n[n.ERASE = 4] = "ERASE", n))(oe || {}), ht = /* @__PURE__ */ ((n) => (n[n.LINEAR = 0] = "LINEAR", n[n.NEAREST = 1] = "NEAREST", n))(ht || {}), ce = /* @__PURE__ */ ((n) => (n[n.CanvasItem = 0] = "CanvasItem", n[n.Viewport = 1] = "Viewport", n))(ce || {});
+class de {
   gl;
-  /** The target HTMLCanvasElement. */
   canvas;
-  /** The current orthographic projection matrix (16 elements). */
   projection = new Float32Array(16);
-  /** Indicates if the projection matrix has changed and needs to be uploaded to shaders. */
   projectionDirty = !0;
-  /** The current device pixel ratio. */
   dpr;
-  /** Background clear color [r, g, b, a], values range from 0 to 255. */
   backgroundColor = x.Black;
-  /** Logical width in CSS pixels, used for coordinate system and projection matrix. */
   logicWidth = 0;
-  /** Logical height in CSS pixels, used for coordinate system and projection matrix. */
   logicHeight = 0;
-  /** Physical width (canvas actual pixels = logical width * dpr). */
   physicsWidth = 0;
-  /** Physical height (canvas actual pixels = logical height * dpr). */
   physicsHeight = 0;
-  /** The currently active rendering region. */
   currentRegion = null;
-  /** Maximum number of texture units supported by the device. */
   maxTextureUnits = 0;
-  /** Matrix stack for hierarchical transformations. */
-  matrixStack = new wt(this);
-  /** Direct access to the underlying matrix store. */
+  matrixStack = new bt(this);
   matrix;
-  /** Region dedicated to fast sprite rendering. */
   spriteRegion;
-  /** Region dedicated to arbitrary geometry and shapes rendering. */
   graphicRegion;
   atlasSpriteRegion;
   particleRegion;
-  /** Counts the number of WebGL draw calls made in the current frame. */
   drawcallCount = 0;
-  /** Indicates whether we are currently writing to the stencil buffer to create a mask. */
   inCreateMask = !1;
-  /** Manager for creating and organizing textures. */
   texture;
-  /** Whether textures use premultiplied alpha. Set once at construction. */
   premultipliedAlpha;
-  /** Default texture filtering preference and requested canvas MSAA setting. */
   antialias;
   roundPixels;
-  /** Default filtering mode used when sampling textures. */
   textureFilter;
   scaleMode;
-  /** Internal ping-pong RenderTextures for multi-filter chains. */
   _filterRT = [null, null];
   _filterInput = new N();
   get height() {
@@ -2820,123 +2148,66 @@ class oe {
   get width() {
     return this.logicWidth;
   }
-  /**
-   * Creates a new Rapid application instance.
-   * @param options Initialization options including the target canvas.
-   */
   constructor(t) {
     this.canvas = t.canvas, this.dpr = window.devicePixelRatio || 1, this.antialias = t.antialias ?? !1, this.textureFilter = t.textureFilter ?? 1, this.premultipliedAlpha = t.premultipliedAlpha ?? !0, this.roundPixels = t.roundPixels ?? !1, this.scaleMode = t.scaleMode ?? 0;
-    const e = Ut(this.canvas, this.antialias, this.premultipliedAlpha);
-    this.gl = e, this.maxTextureUnits = e.getParameter(e.MAX_TEXTURE_IMAGE_UNITS), this.matrix = this.matrixStack.matrix, this.spriteRegion = new nt(this), this.graphicRegion = new kt(this), this.atlasSpriteRegion = new te(this), this.particleRegion = new re(this);
+    const e = Lt(this.canvas, this.antialias, this.premultipliedAlpha);
+    this.gl = e, this.maxTextureUnits = e.getParameter(e.MAX_TEXTURE_IMAGE_UNITS), this.matrix = this.matrixStack.matrix, this.spriteRegion = new ot(this), this.graphicRegion = new Yt(this), this.atlasSpriteRegion = new se(this), this.particleRegion = new ae(this);
     const r = this.canvas.clientWidth || this.canvas.width, i = this.canvas.clientHeight || this.canvas.height;
-    this.physicsWidth = t.physicsWidth || Math.round(r * this.dpr), this.physicsHeight = t.physicsHeight || Math.round(i * this.dpr), this.logicWidth = t.logicWidth || t.width || this.physicsWidth / this.dpr, this.logicHeight = t.logicHeight || t.height || this.physicsHeight / this.dpr, this.resize(this.logicWidth, this.logicHeight, this.physicsWidth, this.physicsHeight), this.texture = new Mt(this), t.backgroundColor && (this.backgroundColor = t.backgroundColor), e.enable(e.BLEND), this.premultipliedAlpha ? e.blendFunc(e.ONE, e.ONE_MINUS_SRC_ALPHA) : e.blendFunc(e.SRC_ALPHA, e.ONE_MINUS_SRC_ALPHA), e.enable(e.STENCIL_TEST), e.stencilFunc(e.ALWAYS, 1, 255), e.stencilOp(e.KEEP, e.KEEP, e.KEEP);
+    this.physicsWidth = t.physicsWidth || Math.round(r * this.dpr), this.physicsHeight = t.physicsHeight || Math.round(i * this.dpr), this.logicWidth = t.logicWidth || t.width || this.physicsWidth / this.dpr, this.logicHeight = t.logicHeight || t.height || this.physicsHeight / this.dpr, this.resize(this.logicWidth, this.logicHeight, this.physicsWidth, this.physicsHeight), this.texture = new Ut(this), t.backgroundColor && (this.backgroundColor = t.backgroundColor), e.enable(e.BLEND), this.premultipliedAlpha ? e.blendFunc(e.ONE, e.ONE_MINUS_SRC_ALPHA) : e.blendFunc(e.SRC_ALPHA, e.ONE_MINUS_SRC_ALPHA), e.enable(e.STENCIL_TEST), e.stencilFunc(e.ALWAYS, 1, 255), e.stencilOp(e.KEEP, e.KEEP, e.KEEP);
   }
   setTextureFilter(t) {
     this.textureFilter = t;
   }
-  setAntialias(t) {
-    this.antialias = t;
-  }
   getColorUint32(t) {
-    return zt(this.premultipliedAlpha, t);
+    return qt(this.premultipliedAlpha, t);
   }
-  /**
-   * Enters a specific rendering region, flushing the previous one if necessary.
-   * @param region The rendering region to enter.
-   * @param customShader An optional custom shader to use for this region.
-   */
   enterRegion(t, e) {
     this.currentRegion === t && this.currentRegion.isSameShader(e) || (this.flush(), this.currentRegion = t, t.enter(e));
   }
   drawParticles(t) {
-    Kt(this, t);
+    Jt(this, t);
   }
   drawSprite(t) {
-    jt(this, t);
+    Zt(this, t);
   }
   drawLine(t) {
-    qt(this, t);
+    te(this, t);
   }
   drawGraphic(t) {
-    yt(this, t);
+    Rt(this, t);
   }
   drawRect(t) {
-    Zt(this, t);
+    re(this, t);
   }
   drawCircle(t) {
-    Jt(this, t);
+    ie(this, t);
   }
-  /**
-   * Starts rendering arbitrary graphics geometries.
-   * @param drawMode The WebGL drawing mode (e.g., gl.TRIANGLES, gl.TRIANGLE_FAN).
-   * @param texture  An optional texture applied to the graphic vertices.
-   * @param customShader An optional custom shader overriding the region's default shader.
-   */
   startGraphic(t = this.gl.TRIANGLES, e, r, i) {
     this.enterRegion(this.graphicRegion, r), this.graphicRegion.startGraphic(i ?? this.matrixStack.curWorldM, t, e);
   }
-  /**
-   * Starts rendering graphics explicitly for use as a mask, overriding the shader.
-   * @param drawMode The WebGL drawing mode (e.g., gl.TRIANGLES).
-   * @param texture  An optional texture whose alpha channel may dictate masking rules.
-   */
   startMaskGraphic(t = this.gl.TRIANGLES, e, r) {
     this.startGraphic(t, e, this.graphicRegion.maskShader, r);
   }
-  /**
-   * Utility method: Draws an image directly as a mask using a generic rectangle geometry.
-   * @param texture The texture to be used as a mask.
-   */
   drawMaskImage(t) {
-    Qt(this, t);
-  }
-  /**
-   * Pushes vertices for a rectangle geometry. Should be enclosed by startGraphic and endGraphic.
-   * @param w The width of the rectangle.
-   * @param h The height of the rectangle.
-   * @param color An optional tint color.
-   */
+    ee(this, t);
+  }
   addRectVertex(t, e, r) {
     const i = this.getColorUint32(r);
     this.addGraphicVertex(0, 0, 0, 0, i), this.addGraphicVertex(t, 0, 1, 0, i), this.addGraphicVertex(t, e, 1, 1, i), this.addGraphicVertex(0, e, 0, 1, i);
   }
-  /**
-   * Pushes vertices for a circle geometry using TRIANGLES or similar primitives.
-   * @param r The radius of the circle.
-   * @param color An optional tint color.
-   * @param segments The number of segments (polygons) used to approximate the circle.
-   */
   addCircleVertex(t, e, r = 32) {
     const i = Math.PI * 2 / r, s = this.getColorUint32(e);
     for (let a = 0; a < r; a++) {
-      const o = i * a, h = Math.cos(o) * t, c = Math.sin(o) * t, u = 0.5 + Math.cos(o) * 0.5, l = 0.5 + Math.sin(o) * 0.5;
-      this.addGraphicVertex(h, c, u, l, s);
+      const h = i * a, o = Math.cos(h) * t, c = Math.sin(h) * t, u = 0.5 + Math.cos(h) * 0.5, l = 0.5 + Math.sin(h) * 0.5;
+      this.addGraphicVertex(o, c, u, l, s);
     }
   }
-  /**
-   * Adds an individual vertex to the current graphics batch.
-   * @param x The relative X coordinate of the vertex.
-   * @param y The relative Y coordinate of the vertex.
-   * @param u The U texture coordinate (0 to 1).
-   * @param v The V texture coordinate (0 to 1).
-   * @param color The vertex color as a 32-bit unsigned integer.
-   */
   addGraphicVertex(t, e, r = 0, i = 0, s) {
     this.graphicRegion.addVertex(t, e, r, i, typeof s == "number" ? s : this.getColorUint32(s));
   }
-  /**
-   * Ends the current graphics geometry definition, readying it for rendering.
-   */
   endGraphic() {
     this.graphicRegion.endGraphic();
   }
-  /**
-   * Resizes the canvas, updates internal viewport values, and recreates projection boundaries.
-   * @param logicWidth The new logical display width.
-   * @param logicHeight The new logical display height.
-   * @param cssWidth Optional CSS display width.
-   * @param cssHeight Optional CSS display height.
-   */
   resize(t, e, r, i) {
     this.flush();
     const s = r ?? this.canvas.clientWidth ?? this.canvas.width, a = i ?? this.canvas.clientHeight ?? this.canvas.height;
@@ -2952,100 +2223,51 @@ class oe {
     }
     this.updateProjection(0, this.logicWidth, this.logicHeight, 0);
   }
-  /**
-   * Updates the projection matrix using an orthographic mapping.
-   * Automatically sets local flag projectionDirty.
-   */
   updateProjection(t, e, r, i) {
     this.updateOrthMatrix(this.projection, t, e, r, i), this.projectionDirty = !0;
   }
-  /**
-   * Clears the active framebuffer applying the default background color.
-   */
   clear() {
     const t = this.gl;
     this.backgroundColor.setClearColor(t), t.clear(t.COLOR_BUFFER_BIT | t.STENCIL_BUFFER_BIT), this.drawcallCount = 0, this.matrixStack.reset();
   }
-  /**
-   * Populates an orthographic projection matrix in place.
-   * Avoids continuous Float32Array allocations for performance reasons.
-   */
   updateOrthMatrix(t, e, r, i, s) {
     t[0] = 2 / (r - e), t[1] = 0, t[2] = 0, t[3] = 0, t[4] = 0, t[5] = 2 / (s - i), t[6] = 0, t[7] = 0, t[8] = 0, t[9] = 0, t[10] = -1, t[11] = 0, t[12] = -(r + e) / (r - e), t[13] = -(s + i) / (s - i), t[14] = 0, t[15] = 1;
   }
-  /**
-   * Flushes currently buffered rendering operations across all active regions.
-   */
   flush() {
     this.currentRegion && (this.currentRegion.exit(), this.currentRegion = null);
   }
-  /**
-   * Applies a chain of shaders to a texture sequentially using ping-pong RenderTextures.
-   * Each shader receives the output of the previous one as its input.
-   * Two internal RenderTextures are reused across calls (resized as needed).
-   *
-   * @param source   The input texture to start the filter chain from.
-   * @param shaders  An ordered array of CustomGlShader to apply in sequence.
-   * @returns The RenderTexture containing the final filtered result.
-   *          Draw it with `rapid.drawSprite({ texture: result })` to display it on screen.
-   *
-   * @example
-   * const result = rapid.applyFilters(tex, [blurShader, outlineShader]);
-   * rapid.drawSprite({ texture: result });
-   */
   applyFilters(t, e) {
     if (e.length === 0)
       throw new Error("applyFilters: shaders array must not be empty.");
     const r = Math.max(...e.map((c) => c.padding)), i = r, s = t.rawWidth + r * 2, a = t.rawHeight + r * 2;
     for (let c = 0; c < 2; c++)
       this._filterRT[c] ? this._filterRT[c].resize(s, a) : this._filterRT[c] = this.texture.createRenderTexture({ width: s, height: a });
-    let o = t.clone(this._filterInput), h = 0;
+    let h = t.clone(this._filterInput), o = 0;
     this.matrixStack.save(), this.matrixStack.identity();
     for (let c = 0; c < e.length; c++) {
-      const u = this._filterRT[h % 2];
+      const u = this._filterRT[o % 2];
       u.offsetX = 0, u.offsetY = 0, this.enterRenderTexture(u), this.clearRenderTexture(), this.drawSprite({
-        texture: o,
+        texture: h,
         shader: e[c],
         offsetX: c == 0 ? i : 0,
         // padding back
         offsetY: c == 0 ? i : 0,
         padding: r
-      }), this.leaveRenderTexture(), o = u, h++;
+      }), this.leaveRenderTexture(), h = u, o++;
     }
-    return this.matrixStack.restore(), o.offsetX = -i, o.offsetY = -i, o;
+    return this.matrixStack.restore(), h.offsetX = -i, h.offsetY = -i, h;
   }
   enterRenderTexture(t) {
     this.flush(), t.activate(), this.gl.viewport(0, 0, t.rawWidth, t.rawHeight), this.updateProjection(0, t.rawWidth, t.rawHeight, 0);
   }
-  /**
-   * Clears a RenderTexture to a solid color.
-   * Must be called while the RT is the active render target (i.e. inside enterRenderTexture/leaveRenderTexture).
-   * Can also be called standalone — it will bind the RT, clear it, but NOT restore the main framebuffer.
-   * @param rt    The render texture to clear.
-   * @param color Clear color. Defaults to transparent black (0, 0, 0, 0).
-   */
   clearRenderTexture(t = new x(0, 0, 0, 0)) {
     this.flush();
     const e = this.gl;
     t.setClearColor(e), e.clear(e.COLOR_BUFFER_BIT);
   }
-  /**
-   * Completes rendering to an offscreen render texture and reverts rendering back to the main canvas.
-   */
   leaveRenderTexture() {
     this.flush(), this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, null), this.gl.viewport(0, 0, this.physicsWidth, this.physicsHeight), this.updateProjection(0, this.logicWidth, this.logicHeight, 0);
   }
-  /**
-   * Convenience wrapper: enters a RenderTexture, optionally clears it, runs a callback, then leaves.
-   * @param rt    The RenderTexture to render into.
-   * @param cb    The callback containing draw calls to execute inside the RT.
-   * @param color Clear color before rendering. Pass `null` to skip clearing. Defaults to transparent black.
-   *
-   * @example
-   * rapid.drawToRenderTexture(myRT, () => {
-   *     rapid.drawSprite({ texture: mySprite });
-   * });
-   */
   drawToRenderTexture(t, e, r = new x(0, 0, 0, 0)) {
     this.enterRenderTexture(t);
     try {
@@ -3054,19 +2276,6 @@ class oe {
       this.leaveRenderTexture();
     }
   }
-  /**
-   * Convenience wrapper: writes a mask using the stencil buffer, then renders within it, then exits the mask.
-   * @param maskCb   Callback that defines the mask geometry (drawn to stencil, not visible).
-   * @param drawCb   Callback containing the actual draw calls masked by the stencil.
-   * @param type     Mask type: EQUAL (draw inside) or NOT_EQUAL (draw outside). Defaults to EQUAL.
-   * @param ref      Stencil reference value. Defaults to 1.
-   *
-   * @example
-   * rapid.withMask(
-   *     () => rapid.drawRect({ width: 200, height: 200 }),
-   *     () => rapid.drawSprite({ texture: myTexture }),
-   * );
-   */
   withMask(t, e, r = 0, i = 1) {
     this.clearMask(), this.startDrawMask(i);
     try {
@@ -3081,28 +2290,6 @@ class oe {
       this.exitMask();
     }
   }
-  /**
-   * Convenience wrapper: saves the matrix stack, applies an optional transform, runs a callback, then restores.
-   * When `transform` is provided, delegates to `matrixStack.applyTransform()` which handles
-   * position, rotation, scale, offset, and origin automatically.
-   * @param cb        The callback to execute within the saved transform context.
-   * @param transform Optional transform options to apply before running the callback.
-   * @param width     The logical width used to resolve `origin` anchoring. Defaults to 0.
-   * @param height    The logical height used to resolve `origin` anchoring. Defaults to 0.
-   *
-   * @example
-   * // Simple save/restore
-   * rapid.withTransform(() => {
-   *     rapid.matrixStack.translate(100, 100);
-   *     rapid.drawSprite({ texture: myTexture });
-   * });
-   *
-   * @example
-   * // With a transform applied
-   * rapid.withTransform(() => {
-   *     rapid.drawSprite({ texture: myTexture });
-   * }, { x: 100, y: 50, rotation: Math.PI / 4, origin: 0.5 }, myTexture.width, myTexture.height);
-   */
   withTransform(t, e, r = 0, i = 0) {
     this.matrixStack.save();
     try {
@@ -3111,19 +2298,6 @@ class oe {
       this.matrixStack.restore();
     }
   }
-  /**
-   * Convenience wrapper: enables scissor clipping for a region, runs a callback, then disables it.
-   * @param x      Left edge in logical pixels.
-   * @param y      Top edge in logical pixels.
-   * @param width  Width in logical pixels.
-   * @param height Height in logical pixels.
-   * @param cb     The callback to execute within the scissor region.
-   *
-   * @example
-   * rapid.withScissor(50, 50, 300, 200, () => {
-   *     rapid.drawSprite({ texture: myTexture });
-   * });
-   */
   withScissor(t, e, r, i, s) {
     this.startScissor(t, e, r, i);
     try {
@@ -3132,16 +2306,6 @@ class oe {
       this.endScissor();
     }
   }
-  /**
-   * Convenience wrapper: sets a blend mode, runs a callback, then restores NORMAL blend mode.
-   * @param mode The BlendMode to apply for the duration of the callback.
-   * @param cb   The callback to execute under the given blend mode.
-   *
-   * @example
-   * rapid.withBlendMode(BlendMode.ADD, () => {
-   *     rapid.drawSprite({ texture: glowTexture });
-   * });
-   */
   withBlendMode(t, e) {
     this.setBlendMode(t);
     try {
@@ -3153,56 +2317,31 @@ class oe {
       );
     }
   }
-  /**
-   * Starts drawing into the stencil buffer to construct a rendering mask.
-   * @param ref The stencil reference value.
-   * @param mask The stencil bitmask.
-   */
   startDrawMask(t = 1, e = 255) {
     this.flush();
     const r = this.gl;
     r.stencilMask(e), r.colorMask(!1, !1, !1, !1), r.stencilFunc(r.ALWAYS, t, e), r.stencilOp(r.KEEP, r.KEEP, r.REPLACE), this.enterRegion(this.graphicRegion, this.graphicRegion.maskShader), this.inCreateMask = !0;
   }
-  /**
-   * Finishes the mask drawing phase and restores color buffer writing.
-   */
   endDrawMask() {
     this.flush();
     const t = this.gl;
     t.colorMask(!0, !0, !0, !0), t.stencilMask(0), this.inCreateMask = !1;
   }
-  /**
-   * Clears bounds created into the stencil mask.
-   * @param mask The bitmask specifying which stencil layer to clear.
-   */
   clearMask(t = 255) {
     this.flush();
     const e = this.gl;
     e.stencilMask(t), e.clear(e.STENCIL_BUFFER_BIT), this.inCreateMask = !1;
   }
-  /**
-   * Enters a constrained rendering phase masked by the existing stencil buffer values.
-   * @param type Equality check type. Use "equal" to draw inside the mask, or "notEqual" to draw outside.
-   * @param ref The reference value to test against.
-   * @param mask The bitmask specifying which stencil bits to consider.
-   */
   enterMask(t, e = 1, r = 255) {
     this.flush();
     const i = this.gl;
     i.colorMask(!0, !0, !0, !0), i.stencilMask(0), i.stencilFunc(t === 0 ? i.EQUAL : i.NOTEQUAL, e, r), i.stencilOp(i.KEEP, i.KEEP, i.KEEP), this.inCreateMask = !1;
   }
-  /**
-   * Exits the masked rendering phase, restoring default full-screen stencil values tests.
-   */
   exitMask() {
     this.flush();
     const t = this.gl;
     t.colorMask(!0, !0, !0, !0), t.stencilMask(255), t.stencilFunc(t.ALWAYS, 1, 255), t.stencilOp(t.KEEP, t.KEEP, t.KEEP), this.inCreateMask = !1;
   }
-  /**
-   * Configures the global WebGL blending behavior.
-   * @param mode The targeted BlendMode to switch onto.
-   */
   setBlendMode(t) {
     this.flush();
     const e = this.gl;
@@ -3224,23 +2363,11 @@ class oe {
         break;
     }
   }
-  /**
-   * Enables rectangular scissor clipping. Only pixels within the specified
-   * rectangle (in logical coordinates) will be rendered.
-   * Coordinates use the same system as your drawing calls (top-left origin).
-   * @param x Left edge in logical pixels.
-   * @param y Top edge in logical pixels.
-   * @param width Width in logical pixels.
-   * @param height Height in logical pixels.
-   */
   startScissor(t, e, r, i) {
     this.flush();
-    const s = this.gl, a = this.physicsWidth / this.logicWidth, o = this.physicsHeight / this.logicHeight, h = Math.round(t * a), c = Math.round(this.physicsHeight - (e + i) * o), u = Math.round(r * a), l = Math.round(i * o);
-    s.enable(s.SCISSOR_TEST), s.scissor(h, c, u, l);
+    const s = this.gl, a = this.physicsWidth / this.logicWidth, h = this.physicsHeight / this.logicHeight, o = Math.round(t * a), c = Math.round(this.physicsHeight - (e + i) * h), u = Math.round(r * a), l = Math.round(i * h);
+    s.enable(s.SCISSOR_TEST), s.scissor(o, c, u, l);
   }
-  /**
-   * Disables scissor clipping, restoring full-canvas rendering.
-   */
   endScissor() {
     this.flush(), this.gl.disable(this.gl.SCISSOR_TEST);
   }
@@ -3262,7 +2389,7 @@ class oe {
     ));
   }
   cssToDevicePixel(t) {
-    return t.mul(this.dpr);
+    return t.multiply(this.dpr);
   }
   cssToLogic(t) {
     const e = this.cssToDevicePixel(t);
@@ -3271,40 +2398,27 @@ class oe {
   devicePixelToCss(t) {
     return t.divide(this.dpr);
   }
-  /**
-   * Exports a world matrix as a CSS `matrix(...)` string, ready to assign
-   * directly to a DOM element's `style.transform`.
-   * Unlike `matrixStack.toCSSMatrix()`, this bakes in the logic-pixel → CSS-pixel
-   * scale (accounting for dpr and a custom `logicWidth`/`logicHeight`), so the
-   * result lines up with the canvas without any extra `scale(...)` on your end.
-   * @param index - Matrix index to export. Defaults to the current world matrix.
-   */
   toCSSMatrix(t) {
     const e = this.physicsWidth / this.dpr / this.logicWidth, r = this.physicsHeight / this.dpr / this.logicHeight;
     return this.matrix.toCSSMatrix(t ?? this.matrixStack.curWorldM, e, r);
   }
 }
-function ae(n) {
+function ue(n) {
   return !(n === null || typeof n != "object" || Array.isArray(n) || n instanceof p || n instanceof x);
 }
 class L {
-  /** Random float in [min, max). */
   static float(t, e) {
     return Math.random() * (e - t) + t;
   }
-  /** Random integer in [min, max] (inclusive). */
   static int(t, e) {
     return Math.floor(Math.random() * (e - t + 1)) + t;
   }
-  /** Random angle in [0, 2π). */
   static angle() {
     return Math.random() * Math.PI * 2;
   }
-  /** Random Vec2 with components in the supplied per-axis ranges. */
   static vector(t, e, r, i) {
     return new p(L.float(t, e), L.float(r, i));
   }
-  /** Random Color with each component interpolated between minColor and maxColor. */
   static randomColor(t, e) {
     return new x(
       L.float(t.r, e.r),
@@ -3313,14 +2427,9 @@ class L {
       L.float(t.a, e.a)
     );
   }
-  /** Pick a random element from an array with uniform probability. */
   static pick(t) {
     return t[L.int(0, t.length - 1)];
   }
-  /**
-   * Pick a random element using weighted probability.
-   * @param array - Pairs of [item, weight]. Higher weight = more likely.
-   */
   static pickWeight(t) {
     if (!t || t.length === 0) return null;
     let e = 0;
@@ -3330,12 +2439,6 @@ class L {
       if (r -= s, r <= 0) return i;
     return t[t.length - 1][0];
   }
-  /**
-   * Resolves a scalar-or-range value to a concrete T.
-   * - `undefined`  → `defaultValue`
-   * - `T`          → `T` (or a clone for objects)
-   * - `[T, T]`     → random value between the two bounds
-   */
   static scalarOrRange(t, e) {
     if (t == null) return e;
     if (Array.isArray(t)) {
@@ -3350,17 +2453,17 @@ class L {
     return typeof t == "number" ? t : t.clone();
   }
 }
-var he = /* @__PURE__ */ ((n) => (n.POINT = "point", n.CIRCLE = "circle", n.RECT = "rect", n))(he || {});
-const ft = 10, mt = 0, xt = !0;
-class j {
+var le = /* @__PURE__ */ ((n) => (n.POINT = "point", n.CIRCLE = "circle", n.RECT = "rect", n))(le || {});
+const pt = 10, gt = 0, vt = !0;
+class K {
   components;
   constructor(t = 1) {
     if (!Number.isInteger(t) || t <= 0)
       throw new RangeError("ParticleAttributeStore size must be a positive integer");
     this.components = Array.from({ length: t }, () => ({
-      value: new b(A.Float32),
-      delta: new b(A.Float32),
-      damping: new b(A.Float32)
+      value: new A(S.Float32),
+      delta: new A(S.Float32),
+      damping: new A(S.Float32)
     }));
   }
   getArrayBuffer() {
@@ -3399,47 +2502,41 @@ class j {
     ) : this.getComponent(t, e);
   }
   create(t, e, r = 1) {
-    const i = ae(t) ? t : void 0, s = i === void 0 ? t : void 0, a = r > 0 ? r : 1;
-    let o = 0;
-    for (let h = 0; h < this.components.length; h++) {
-      const { value: c, delta: u, damping: l } = this.components[h], d = this.getComponent(e, h), f = s === void 0 ? this.resolveComponent(i?.start, h, d) : this.getComponent(s, h), m = i?.end === void 0 ? f : this.resolveComponent(i.end, h, d);
-      c.push(f), u.push(i?.delta === void 0 ? (m - f) / a : this.getComponent(i.delta, h)), l.push(i?.damping ?? 1), h === 0 && (o = f);
+    const i = ue(t) ? t : void 0, s = i === void 0 ? t : void 0, a = r > 0 ? r : 1;
+    let h = 0;
+    for (let o = 0; o < this.components.length; o++) {
+      const { value: c, delta: u, damping: l } = this.components[o], d = this.getComponent(e, o), f = s === void 0 ? this.resolveComponent(i?.start, o, d) : this.getComponent(s, o), m = i?.end === void 0 ? f : this.resolveComponent(i.end, o, d);
+      c.push(f), u.push(i?.delta === void 0 ? (m - f) / a : this.getComponent(i.delta, o)), l.push(i?.damping ?? 1), o === 0 && (h = f);
     }
-    return o;
+    return h;
   }
 }
-class Tt {
+class wt {
   options;
   emitting = !1;
   emitTimer = 0;
-  emitRate = ft;
-  emitTime = mt;
+  emitRate = pt;
+  emitTime = gt;
   emitTimeCounter = 0;
-  /** Whether spawned particles are positioned in local emitter space (default: true). */
-  localSpace = xt;
+  localSpace = vt;
   rapid;
-  x = new b(A.Float32);
-  y = new b(A.Float32);
-  scaleX = new b(A.Float32);
-  scaleY = new b(A.Float32);
-  rotation = new b(A.Float32);
-  color = new b(A.Uint32);
-  remainingLife = new b(A.Float32);
+  x = new A(S.Float32);
+  y = new A(S.Float32);
+  scaleX = new A(S.Float32);
+  scaleY = new A(S.Float32);
+  rotation = new A(S.Float32);
+  color = new A(S.Uint32);
+  remainingLife = new A(S.Float32);
   animations = {
-    speed: new j(),
-    rotation: new j(),
-    scale: new j(),
-    color: new j(4),
-    velocity: new j(2)
+    speed: new K(),
+    rotation: new K(),
+    scale: new K(),
+    color: new K(4),
+    velocity: new K(2)
   };
   count = 0;
-  /**
-   * Creates a new particle emitter.
-   * @param rapid   - The Rapid renderer instance
-   * @param options - Emitter configuration options
-   */
   constructor(t, e) {
-    this.rapid = t, this.options = e, this.emitRate = e.emitRate ?? ft, this.emitTime = e.emitTime ?? mt, this.localSpace = e.localSpace ?? xt;
+    this.rapid = t, this.options = e, this.emitRate = e.emitRate ?? pt, this.emitTime = e.emitTime ?? gt, this.localSpace = e.localSpace ?? vt;
   }
   getAllArrayBuffer() {
     return [
@@ -3453,43 +2550,29 @@ class Tt {
       ...Object.values(this.animations).flatMap((t) => t.getArrayBuffer())
     ];
   }
-  /** Replaces the emitter's texture at runtime. */
   setTexture(t) {
     this.options.texture = t;
   }
-  /**
-   * Creates a new emitter sharing the same options object.
-   * Particle state is NOT copied.
-   */
   clone() {
-    return new Tt(this.rapid, { ...this.options });
+    return new wt(this.rapid, { ...this.options });
   }
-  /** Sets particles-per-second emission rate (continuous mode). */
   setEmitRate(t) {
     this.emitRate = t;
   }
-  /** Sets the burst interval in seconds (0 = continuous). */
   setEmitTime(t) {
     this.emitTime = t;
   }
-  /** Starts continuous particle emission. */
   start() {
     this.emitting = !0, this.emitTimeCounter = 0;
   }
-  /** Stops new particle emission; existing particles finish their lifecycle. */
   stop() {
     this.emitting = !1;
   }
-  /** Removes all particles and resets timers. */
   clear() {
     for (const t of this.getAllArrayBuffer())
       t.clear();
     this.count = 0, this.emitTimeCounter = 0;
   }
-  /**
-   * Spawns `count` particles immediately.
-   * Respects `maxParticles` if set.
-   */
   emit(t) {
     const e = this.options.maxParticles ?? 1 / 0, r = Math.min(t, e - this.count);
     for (let i = 0; i < r; i++)
@@ -3517,8 +2600,8 @@ class Tt {
       const { x: c, y: u } = i.localToWorld(e, r);
       this.x.push(c), this.y.push(u);
     }
-    const s = this.options.animation, a = this.animations, o = a.scale.create(s.scale, 1, t), h = a.rotation.create(s.rotation, 0, t);
-    a.speed.create(s.speed, 0, t), a.velocity.create(s.velocity, p.ZERO, t), a.color.create(s.color, x.White, t), this.rotation.push(h), this.scaleX.push(o), this.scaleY.push(o), this.color.pushUint32(x.packColor(
+    const s = this.options.animation, a = this.animations, h = a.scale.create(s.scale, 1, t), o = a.rotation.create(s.rotation, 0, t);
+    a.speed.create(s.speed, 0, t), a.velocity.create(s.velocity, p.ZERO, t), a.color.create(s.color, x.White, t), this.rotation.push(o), this.scaleX.push(h), this.scaleY.push(h), this.color.pushUint32(x.packColor(
       a.color.get(this.count, 0),
       a.color.get(this.count, 1),
       a.color.get(this.count, 2),
@@ -3526,10 +2609,6 @@ class Tt {
       this.rapid.premultipliedAlpha
     )), this.count += 1;
   }
-  /**
-   * Updates the emitter and all live particles.
-   * @param deltaTime - Seconds elapsed since last frame
-   */
   update(t) {
     if (this.emitting && this.emitRate > 0)
       if (this.emitTime > 0) {
@@ -3543,7 +2622,7 @@ class Tt {
         r > 0 && (this.emit(r), this.emitTimer -= r / this.emitRate);
       }
     const e = this.updateParticle(t);
-    this.count -= e.length, b.removeAtIndices(e, this.getAllArrayBuffer());
+    this.count -= e.length, A.removeAtIndices(e, this.getAllArrayBuffer());
   }
   updateParticle(t) {
     const e = [], r = this.animations;
@@ -3553,21 +2632,17 @@ class Tt {
         e.push(i);
         continue;
       }
-      const s = r.rotation.get(i), a = r.scale.get(i), o = r.speed.get(i);
+      const s = r.rotation.get(i), a = r.scale.get(i), h = r.speed.get(i);
       this.rotation.typedArray[i] = s, this.scaleX.typedArray[i] = a, this.scaleY.typedArray[i] = a, this.color.uint32[i] = x.packColor(
         r.color.get(i, 0),
         r.color.get(i, 1),
         r.color.get(i, 2),
         r.color.get(i, 3),
         this.rapid.premultipliedAlpha
-      ), this.x.typedArray[i] += (o * Math.cos(s) + r.velocity.get(i, 0)) * t, this.y.typedArray[i] += (o * Math.sin(s) + r.velocity.get(i, 1)) * t;
+      ), this.x.typedArray[i] += (h * Math.cos(s) + r.velocity.get(i, 0)) * t, this.y.typedArray[i] += (h * Math.sin(s) + r.velocity.get(i, 1)) * t;
     }
     return e;
   }
-  /**
-   * Renders all live particles.
-   * In local-space mode the emitter's own transform is applied around the batch.
-   */
   render() {
     const t = this.options, e = this.localSpace ? void 0 : this.rapid.matrix.alloc();
     this.rapid.drawParticles({
@@ -3586,53 +2661,50 @@ class Tt {
       customMatrix: e
     });
   }
-  /** Returns `true` if the emitter is running or still has live particles. */
   isActive() {
     return this.emitting || this.count > 0;
   }
-  /**
-   * Convenience: emit `emitRate` particles in one shot (fire-and-forget burst).
-   */
   oneShot() {
     this.emit(this.emitRate);
   }
 }
 export {
-  A as ArrayType,
-  Y as BaseTexture,
-  se as BlendMode,
-  ne as CanvasScaleMode,
+  S as ArrayType,
+  V as BaseTexture,
+  oe as BlendMode,
+  ce as CanvasScaleMode,
   x as Color,
-  ht as CustomGlShader,
-  b as DynamicArrayBuffer,
-  gt as GLShader,
-  kt as GraphicRegion,
-  Vt as LineTextureMode,
-  ie as MaskType,
-  wt as MatrixStack,
-  Rt as MatrixStore,
-  Tt as ParticleEmitter,
-  he as ParticleShape,
-  Ot as QUAD_VERTICES,
-  oe as Rapid,
-  vt as Region,
-  At as RenderTexture,
-  nt as SpriteRegion,
-  bt as TextTexture,
+  ut as CustomGlShader,
+  A as DynamicArrayBuffer,
+  Tt as GLShader,
+  Yt as GraphicRegion,
+  $t as LineTextureMode,
+  he as MaskType,
+  bt as MatrixStack,
+  At as MatrixStore,
+  wt as ParticleEmitter,
+  ae as ParticleRegion,
+  le as ParticleShape,
+  Dt as QUAD_VERTICES,
+  de as Rapid,
+  Et as Region,
+  Ct as RenderTexture,
+  ot as SpriteRegion,
+  Pt as TextTexture,
   N as Texture,
-  st as TextureFilterMode,
-  Mt as TextureManager,
-  K as TextureWrapMode,
+  ht as TextureFilterMode,
+  Ut as TextureManager,
+  q as TextureWrapMode,
   p as Vec2,
-  tt as WebglBufferArray,
-  Ht as composeProjectionWithAffine,
-  Jt as drawCircle,
-  yt as drawGraphic,
-  qt as drawLine,
-  Qt as drawMaskImage,
-  Kt as drawParticles,
-  Zt as drawRect,
-  jt as drawSprite,
-  zt as getColorUint32,
-  Gt as multiplyMat4
+  it as WebglBufferArray,
+  Xt as composeProjectionWithAffine,
+  ie as drawCircle,
+  Rt as drawGraphic,
+  te as drawLine,
+  ee as drawMaskImage,
+  Jt as drawParticles,
+  re as drawRect,
+  Zt as drawSprite,
+  qt as getColorUint32,
+  zt as multiplyMat4
 };