rapid-render 0.1.21 → 1.0.0

package/dist/rapid-render.js

@@ -0,0 +1,3258 @@
+var N = /* @__PURE__ */ ((s) => (s[s.Float32 = 0] = "Float32", s[s.Uint32 = 1] = "Uint32", s[s.Uint16 = 2] = "Uint16", s))(N || {});
+class W {
+  /** The number of elements currently used in the buffer. */
+  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:
+        return Float32Array;
+      case 1:
+        return Uint32Array;
+      case 2:
+        return Uint16Array;
+      default:
+        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:
+        this.typedArray = this.float32;
+        break;
+      case 1:
+        this.typedArray = this.uint32;
+        break;
+      case 2:
+        this.typedArray = this.uint16;
+        break;
+    }
+  }
+  /**
+   * Resets the element usage count to zero. The underlying memory capacity is preserved.
+   */
+  clear() {
+    this.usedElemNum = 0;
+  }
+  /**
+   * 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; )
+        this.maxElemNum *= 2;
+      return this.setMaxSize(this.maxElemNum), !0;
+    }
+    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 j extends W {
+  /** The actual WebGLBuffer object maintained by this instance. */
+  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, i = t.ARRAY_BUFFER, r = t.DYNAMIC_DRAW) {
+    super(e), this.gl = t, this.buffer = t.createBuffer(), this.type = i, this.usage = r;
+  }
+  /**
+   * 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;
+      this.maxElemNum > this.webglBufferSize && (t.bufferData(this.type, this.maxElemNum * this.bytePerElem, this.usage), this.webglBufferSize = this.maxElemNum), t.bufferSubData(this.type, 0, this.getArray(0, this.usedElemNum)), this.dirty = !1;
+    }
+  }
+}
+class d {
+  _r;
+  _g;
+  _b;
+  _a;
+  uint32;
+  premultipliedUint32;
+  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, i, r = 255) {
+    this._r = t, this._g = e, this._b = i, this._a = r, 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 = d.clampByte(this._a), e = d.clampByte(this._r * t / 255), i = d.clampByte(this._g * t / 255), r = d.clampByte(this._b * t / 255);
+    this.premultipliedUint32 = (t << 24 | r << 16 | i << 8 | e) >>> 0;
+  }
+  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, i, r) {
+    this.r = t, this.g = e, this.b = i, this.a = r, this.updateUint();
+  }
+  setHSL(t, e, i) {
+    t = (t % 360 + 360) % 360, e = Math.max(0, Math.min(100, e)) / 100, i = Math.max(0, Math.min(100, i)) / 100;
+    const r = (1 - Math.abs(2 * i - 1)) * e, n = r * (1 - Math.abs(t / 60 % 2 - 1)), a = i - r / 2;
+    let o = 0, h = 0, u = 0;
+    return t < 60 ? [o, h, u] = [r, n, 0] : t < 120 ? [o, h, u] = [n, r, 0] : t < 180 ? [o, h, u] = [0, r, n] : t < 240 ? [o, h, u] = [0, n, r] : t < 300 ? [o, h, u] = [n, 0, r] : [o, h, u] = [r, 0, n], this.setRGBA((o + a) * 255, (h + a) * 255, (u + 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)}`;
+  }
+  /**
+   * 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 d(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"), i = this.g.toString(16).padStart(2, "0"), r = this.b.toString(16).padStart(2, "0"), n = this.a.toString(16).padStart(2, "0");
+    return `#${e}${i}${r}${t ? n : ""}`;
+  }
+  /**
+   * 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) {
+    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, i) {
+    return new d(0, 0, 0).setHSL(t, e, i);
+  }
+  static FromRGB(t, e, i) {
+    return new d(t, e, i);
+  }
+  static fromNorm(t, e, i, r = 1) {
+    return new d(
+      Math.round(t * 255),
+      Math.round(e * 255),
+      Math.round(i * 255),
+      Math.round(r * 255)
+    );
+  }
+  /**
+   * 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.
+   */
+  static fromHex(t) {
+    t.startsWith("#") && (t = t.slice(1));
+    const e = parseInt(t.slice(0, 2), 16), i = parseInt(t.slice(2, 4), 16), r = parseInt(t.slice(4, 6), 16);
+    let n = 255;
+    return t.length >= 8 && (n = parseInt(t.slice(6, 8), 16)), new d(e, i, r, n);
+  }
+  /**
+   * 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 d(
+      Math.min(this.r + t.r, 255),
+      Math.min(this.g + t.g, 255),
+      Math.min(this.b + t.b, 255),
+      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 d(
+      Math.max(0, this.r - t.r),
+      // Clamp to 0
+      Math.max(0, this.g - t.g),
+      // Clamp to 0
+      Math.max(0, this.b - t.b),
+      // Clamp to 0
+      Math.max(0, this.a - t.a)
+      // Clamp to 0
+    );
+  }
+  divide(t) {
+    return t instanceof d ? new d(
+      this.r / t.r,
+      this.g / t.g,
+      this.b / t.b,
+      this.a / t.a
+    ) : new d(
+      this.r / t,
+      this.g / t,
+      this.b / t,
+      this.a / t
+    );
+  }
+  multiply(t) {
+    return t instanceof d ? new d(
+      this.r * t.r,
+      this.g * t.g,
+      this.b * t.b,
+      this.a * t.a
+    ) : new d(
+      this.r * t,
+      this.g * t,
+      this.b * t,
+      this.a * t
+    );
+  }
+  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));
+  }
+  static Red = new d(255, 0, 0, 255);
+  static Green = new d(0, 255, 0, 255);
+  static Blue = new d(0, 0, 255, 255);
+  static Yellow = new d(255, 255, 0, 255);
+  static Purple = new d(128, 0, 128, 255);
+  static Orange = new d(255, 165, 0, 255);
+  static Pink = new d(255, 192, 203, 255);
+  static Gray = new d(128, 128, 128, 255);
+  static Brown = new d(139, 69, 19, 255);
+  static Cyan = new d(0, 255, 255, 255);
+  static Magenta = new d(255, 0, 255, 255);
+  static Lime = new d(192, 255, 0, 255);
+  static White = new d(255, 255, 255, 255);
+  static Black = new d(0, 0, 0, 255);
+  static Transparent = new d(0, 0, 0, 0);
+  static TRANSPARENT = new d(0, 0, 0, 0);
+}
+const p = 6;
+class pt {
+  /** Total number of matrices currently allocated in the store. */
+  matrixCount = 0;
+  /** The dynamic buffer used to hold matrix data. */
+  buffer;
+  /** The raw floating-point data of all matrices. */
+  data;
+  /**
+   * Creates a new MatrixStore.
+   * @param capacity - The initial capacity of the matrix store (default is 10).
+   */
+  constructor(t = 10) {
+    this.buffer = new W(N.Float32), this.buffer.resize(t * p), this.data = this.buffer.getArray();
+  }
+  /**
+   * 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(p) && (this.data = this.buffer.getArray()), this.buffer.usedElemNum += p, this.matrixCount++;
+  }
+  /**
+   * Resets the store, clearing all allocated matrices.
+   */
+  reset() {
+    this.matrixCount = 0, this.buffer.usedElemNum = 0;
+  }
+  /**
+   * 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 * p, i = this.data;
+    i[e] = 1, i[e + 1] = 0, i[e + 2] = 0, i[e + 3] = 1, i[e + 4] = 0, i[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, i) {
+    const r = t * p, n = this.data;
+    n[r + 4] = n[r] * e + n[r + 2] * i + n[r + 4], n[r + 5] = n[r + 1] * e + n[r + 3] * i + n[r + 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, i) {
+    const r = t * p, n = this.data;
+    n[r] *= e, n[r + 1] *= e, n[r + 2] *= i, n[r + 3] *= i;
+  }
+  /**
+   * 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 i = t * p, r = this.data, n = Math.cos(e), a = Math.sin(e), o = r[i], h = r[i + 1], u = r[i + 2], c = r[i + 3];
+    r[i] = o * n + u * a, r[i + 1] = h * n + c * a, r[i + 2] = o * -a + u * n, r[i + 3] = h * -a + c * n;
+  }
+  /**
+   * 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.
+   */
+  rotateWithOffset(t, e, i, r) {
+    this.translate(t, i, r), this.rotate(t, e), this.translate(t, -i, -r);
+  }
+  /**
+   * 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 i = t * p, r = e * p, n = this.data;
+    n[i] = n[r], n[i + 1] = n[r + 1], n[i + 2] = n[r + 2], n[i + 3] = n[r + 3], n[i + 4] = n[r + 4], n[i + 5] = n[r + 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, i) {
+    const r = t * p, n = e * p, a = i * p, o = this.data, h = o[n], u = o[n + 1], c = o[n + 2], m = o[n + 3], f = o[n + 4], v = o[n + 5], x = o[a], T = o[a + 1], E = o[a + 2], R = o[a + 3], _ = o[a + 4], A = o[a + 5];
+    o[r] = h * x + c * T, o[r + 1] = u * x + m * T, o[r + 2] = h * E + c * R, o[r + 3] = u * E + m * R, o[r + 4] = h * _ + c * A + f, o[r + 5] = u * _ + m * A + v;
+  }
+  /**
+   * 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 * p, i = this.data, r = i[e], n = i[e + 1], a = i[e + 2], o = i[e + 3], h = i[e + 4], u = i[e + 5];
+    let c = r * o - n * a;
+    if (!c) {
+      this.identity(t);
+      return;
+    }
+    c = 1 / c, i[e] = o * c, i[e + 1] = -n * c, i[e + 2] = -a * c, i[e + 3] = r * c, i[e + 4] = (a * u - o * h) * c, i[e + 5] = (n * h - r * u) * c;
+  }
+  /**
+   * 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}.
+   */
+  transformPoint(t, e, i) {
+    const r = t * p, n = this.data;
+    return {
+      x: e * n[r] + i * n[r + 2] + n[r + 4],
+      y: e * n[r + 1] + i * n[r + 3] + n[r + 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, i) {
+    const r = this.allocDirty();
+    this.copy(r, t), this.invert(r);
+    const n = this.transformPoint(r, e, i);
+    return this.matrixCount--, this.buffer.usedElemNum -= p, n;
+  }
+  /**
+   * 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.
+   */
+  localToWorld(t, e, i) {
+    return this.transformPoint(t, e, i);
+  }
+  /**
+   * 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 * p, i = this.data;
+    return { x: i[e + 4], y: i[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 * p, i = this.data, r = Math.sqrt(i[e] * i[e] + i[e + 1] * i[e + 1]), n = Math.sqrt(i[e + 2] * i[e + 2] + i[e + 3] * i[e + 3]);
+    return { x: r, y: n };
+  }
+  /**
+   * 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 * p, i = this.data;
+    return Math.atan2(i[e + 1], i[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, i = 1) {
+    const r = t * p, n = this.data;
+    return `matrix(${n[r] * e}, ${n[r + 1] * i}, ${n[r + 2] * e}, ${n[r + 3] * i}, ${n[r + 4] * e}, ${n[r + 5] * i})`;
+  }
+  /**
+   * 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 * p;
+    return this.data.slice(e, e + p);
+  }
+  /**
+   * 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.
+   */
+  getMatrixRef(t) {
+    const e = t * p;
+    return this.data.subarray(e, e + p);
+  }
+  /**
+   * 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.
+   */
+  setMatrix(t, e) {
+    const i = t * p, r = this.data;
+    r[i] = e[0], r[i + 1] = e[1], r[i + 2] = e[2], r[i + 3] = e[3], r[i + 4] = e[4], r[i + 5] = e[5];
+  }
+}
+class gt {
+  /** The underlying store for matrices. */
+  matrix = new pt();
+  /** The current step or depth in the transformation hierarchy. */
+  step = 0;
+  /** Internal stack maintaining structural information. */
+  stack = new W(N.Uint32);
+  /** Records the world matrices generated at each step. */
+  stepWorldM = new W(N.Uint32);
+  /** Records actions (push/pop) taken during the traversal. */
+  stepAction = new W(N.Uint32);
+  /** Records the parent world matrix for each step (used by updateMatrix). */
+  stepParentM = new W(N.Uint32);
+  /** Buffer used during hierarchy traversal updates. */
+  parentStack = new W(N.Uint32);
+  /** The index of the current local matrix in the matrix store. */
+  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.step++, this.curLocalM = this.matrix.alloc(), this.curWorldM = this.matrix.allocDirty(), this.stepWorldM.push(this.curWorldM), this.stepParentM.push(t), this.matrix.copy(this.curWorldM, t), this.stepAction.push(1), { 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.stepAction.push(0));
+  }
+  /**
+   * Evaluates and updates matrices from the given step. Used primarily for deferred transformation.
+   * @param step - The initial step to update matrices from.
+   */
+  updateMatrix(t) {
+    const e = (typeof t == "number" ? t : t.step) - 1, i = this.stepParentM.get(e);
+    let r = 0, n = e;
+    const a = this.parentStack;
+    for (a.reset(), a.push(i); n < this.stepAction.length; ) {
+      if (this.stepAction.get(n) === 1) {
+        const h = this.stepWorldM.get(n), u = h - 1, c = a.top();
+        this.matrix.multiplyOut(h, c, u), a.push(h), r++;
+      } else if (a.pop(), r--, r === 0)
+        break;
+      n++;
+    }
+  }
+  /**
+   * 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, i) {
+    this.matrix.rotateWithOffset(this.curLocalM, t, e, i), this.matrix.rotateWithOffset(this.curWorldM, t, e, i);
+  }
+  /**
+   * 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.
+   */
+  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 * p;
+    return this.matrix.data.slice(t, t + p);
+  }
+  /**
+   * Directly overwrites the current world matrix with the given 6-element 2D transform.
+   */
+  setTransform(t) {
+    const e = this.curWorldM * p, i = this.matrix.data;
+    i[e] = t[0], i[e + 1] = t[1], i[e + 2] = t[2], i[e + 3] = t[3], i[e + 4] = t[4], i[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 (saveTransform defaults to true).
+   */
+  applyTransform(t, e = 0, i = 0) {
+    (t.saveTransform ?? !0) && this.save(), t.afterSave?.();
+    const r = t.x ?? 0, n = t.y ?? 0;
+    (r || n) && this.translate(r, n), t.position && this.translate(t.position.x, t.position.y), t.rotation && this.rotate(t.rotation);
+    const a = t.scale, o = typeof a == "number";
+    a && this.scale(
+      o ? a : a.x,
+      o ? a : a.y
+    );
+    let h = t.offsetX ?? 0, u = t.offsetY ?? 0;
+    t.offset && (h += t.offset.x, u += t.offset.y);
+    const c = t.origin;
+    c !== void 0 && (typeof c == "number" ? (h -= c * e, u -= c * i) : (h -= c.x * e, u -= c.y * i)), this.translate(h, u);
+  }
+}
+var H = /* @__PURE__ */ ((s) => (s[s.REPEAT = 0] = "REPEAT", s[s.CLAMP = 1] = "CLAMP", s[s.MIRRORED_REPEAT = 2] = "MIRRORED_REPEAT", s))(H || {});
+class vt {
+  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 i = this.cache.get(t);
+    if (i)
+      return new C(i);
+    try {
+      const r = await this._fetchImage(t);
+      return i = D.fromSource(this.render, r, e), i.uid = t, this.cache.set(t, i), new C(i);
+    } catch (r) {
+      throw console.error(`[TextureManager] Failed to load: ${t}`, r), r;
+    }
+  }
+  /**
+   * 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 C(this.cache.get(e.key));
+    const i = D.fromSource(this.render, t, e);
+    return e?.key && (i.uid = e.key, this.cache.set(e.key, i)), new C(i);
+  }
+  /**
+   * 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 Tt(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 Et(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.
+   */
+  destroy(t, e = !1) {
+    let i, r;
+    typeof t == "string" ? (r = t, i = this.cache.get(r)) : t instanceof C ? (i = t.base, r = i?.uid, t.destroy()) : (i = t, r = i.uid), i && (i.refCount <= 0 || e) && (i.destroy(this.render.gl), r && this.cache.delete(r));
+  }
+  /**
+   * Destroys all cached textures and clears the cache, ignoring reference counts.
+   */
+  destroyAll() {
+    for (const t of this.cache.values())
+      t.destroy(this.render.gl);
+    this.cache.clear();
+  }
+  _fetchImage(t) {
+    return new Promise((e, i) => {
+      const r = new Image();
+      r.crossOrigin = "anonymous", r.onload = () => e(r), r.onerror = () => i(new Error(`Failed to load image resource: ${t}`)), r.src = t;
+    });
+  }
+}
+class D {
+  glTexture = null;
+  width;
+  height;
+  uid;
+  refCount = 0;
+  constructor(t, e, i) {
+    this.glTexture = t, this.width = e, this.height = i;
+  }
+  /**
+   * 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, i = {}) {
+    const r = X(t, e, i);
+    return new D(r, 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.
+   */
+  updateSource(t, e, i = {}) {
+    this.glTexture && (t.bindTexture(t.TEXTURE_2D, this.glTexture), i.textureFilter !== void 0 && Z(t, i.textureFilter), i.wrap !== void 0 && q(t, i.wrap), t.pixelStorei(t.UNPACK_FLIP_Y_WEBGL, 1), t.pixelStorei(t.UNPACK_ALIGNMENT, 1), i.premultipliedAlpha !== void 0 && t.pixelStorei(t.UNPACK_PREMULTIPLY_ALPHA_WEBGL, i.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), i.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), Z(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), q(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);
+  }
+}
+class C {
+  base;
+  uvX = 0;
+  uvY = 0;
+  uvW = 1;
+  uvH = 1;
+  rawWidth = 0;
+  rawHeight = 0;
+  offsetX = 0;
+  offsetY = 0;
+  scale = 1;
+  isAtlas = !1;
+  flipY = !1;
+  isRotated = !1;
+  glTexture = null;
+  get width() {
+    return (this.isRotated ? this.rawHeight : this.rawWidth) * this.scale;
+  }
+  get height() {
+    return (this.isRotated ? this.rawWidth : this.rawHeight) * this.scale;
+  }
+  // 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, i, r) {
+    return this.base ? (this._px = t, this._py = e, this._pw = i, this._ph = r, this.isAtlas = t !== 0 || e !== 0 || i !== this.base.width || r !== this.base.height, this.uvX = t / this.base.width, this.uvY = e / this.base.height, this.uvW = this.uvX + i / this.base.width, this.uvH = this.uvY + r / this.base.height, this.rawWidth = i, this.rawHeight = r, 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.
+   */
+  getSubTexture(t, e, i, r) {
+    if (!this.base) return new C();
+    const n = this.clone(), a = this._px, o = this._py;
+    return n.setRegion(a + t, o + e, i, r), n;
+  }
+  /**
+   * Creates a shallow copy of this Texture, sharing the same BaseTexture.
+   * @returns A new Texture instance.
+   */
+  clone(t) {
+    const e = t ?? new C(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.
+   */
+  splitGrid(t, e, i, r, n = 0) {
+    if (!this.base) return [];
+    const a = [], o = this.rawWidth, h = this.rawHeight, u = Math.max(0, n), c = t + u, m = e + u, f = i ?? Math.floor((o + u) / c), v = r ?? Math.floor((h + u) / m);
+    for (let x = 0; x < v; x++)
+      for (let T = 0; T < f; T++)
+        a.push(this.getSubTexture(T * c, x * m, 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, i = {}) {
+    const r = X(t, e, i);
+    return new C(new D(r, 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 Tt extends C {
+  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 ?? d.Black;
+    const i = Math.max(Math.round(e.width), 1), r = Math.max(Math.round(e.height), 1), a = X(t, { width: i, height: r }, { ...e, onlySize: !0 });
+    if (this.setBase(new D(a, i, r)), 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(i, r, !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, i = !1) {
+    t = Math.max(Math.round(t), 1), e = Math.max(Math.round(e), 1);
+    const r = this.rawWidth === t && this.rawHeight === e;
+    if (!i && r) return;
+    const n = this.gl;
+    (i || 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, n.bindTexture(n.TEXTURE_2D, this.base.glTexture), n.texImage2D(n.TEXTURE_2D, 0, n.RGBA, this._allocW, this._allocH, 0, n.RGBA, n.UNSIGNED_BYTE, null), n.bindRenderbuffer(n.RENDERBUFFER, this.renderbuffer), n.renderbufferStorage(n.RENDERBUFFER, n.STENCIL_INDEX8, this._allocW, this._allocH), n.bindFramebuffer(n.FRAMEBUFFER, this.framebuffer), n.framebufferTexture2D(n.FRAMEBUFFER, n.COLOR_ATTACHMENT0, n.TEXTURE_2D, this.base.glTexture, 0), n.framebufferRenderbuffer(n.FRAMEBUFFER, n.STENCIL_ATTACHMENT, n.RENDERBUFFER, this.renderbuffer), n.bindFramebuffer(n.FRAMEBUFFER, null), n.bindRenderbuffer(n.RENDERBUFFER, null), n.bindTexture(n.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;
+    e.bindFramebuffer(e.FRAMEBUFFER, this.framebuffer), e.viewport(0, 0, this.rawWidth, this.rawHeight), t && this.clear();
+  }
+  clear(t) {
+    if (!this.framebuffer) return;
+    const e = this.gl, i = t ?? this.clearColor;
+    i && (i.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, i = this.rawWidth, r = this.rawHeight) {
+    if (!this.framebuffer) return new Uint8Array(0);
+    const n = Math.floor(t), a = Math.floor(e), o = Math.floor(i), h = Math.floor(r);
+    if (o <= 0 || h <= 0) return new Uint8Array(0);
+    if (n < 0 || a < 0 || n >= this.rawWidth || a >= this.rawHeight)
+      return new Uint8Array(0);
+    const u = Math.min(o, this.rawWidth - n), c = Math.min(h, this.rawHeight - a), m = this.rawHeight - a - c, f = this.gl, v = f.getParameter(f.FRAMEBUFFER_BINDING);
+    f.bindFramebuffer(f.FRAMEBUFFER, this.framebuffer);
+    const x = new Uint8Array(u * c * 4);
+    return f.readPixels(n, m, u, c, f.RGBA, f.UNSIGNED_BYTE, x), f.bindFramebuffer(f.FRAMEBUFFER, v), x;
+  }
+  /**
+   * 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 i = this.GetPixels(t, e, 1, 1);
+    return i.length < 4 ? new d(0, 0, 0, 0) : new d(i[0], i[1], i[2], i[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 yt = {
+  fontFamily: "Arial",
+  fontSize: 24,
+  fontWeight: "normal",
+  fill: "#000000",
+  strokeThickness: 1,
+  align: "left",
+  baseline: "top"
+};
+class Et extends C {
+  canvas;
+  ctx;
+  render;
+  _text;
+  _style;
+  options;
+  flipY = !0;
+  constructor(t, e) {
+    super(), this.render = t, this._style = { ...yt, ...e }, this._text = e?.text ?? "", this.options = { premultipliedAlpha: t.premultipliedAlpha, ...e }, this.scale = 1 / t.dpr, this.canvas = document.createElement("canvas");
+    const i = this.canvas.getContext("2d", { willReadFrequently: !0 });
+    if (!i) throw new Error("Failed to get 2d context for TextTexture");
+    this.ctx = i, this.canvas.width = 1, this.canvas.height = 1;
+    const r = X(t, this.canvas, this.options);
+    this.setBase(new D(r, 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();
+  }
+  updateOffset(t, e) {
+    switch (this._style.align) {
+      case "center":
+        this.offsetX = -t / 2;
+        break;
+      case "right":
+        this.offsetX = -t;
+        break;
+      default:
+        this.offsetX = 0;
+        break;
+    }
+    switch (this._style.baseline) {
+      case "middle":
+        this.offsetY = -e / 2;
+        break;
+      case "bottom":
+        this.offsetY = -e;
+        break;
+      default:
+        this.offsetY = 0;
+        break;
+    }
+  }
+  /**
+   * Updates the internal canvas and uploads it to WebGL
+   */
+  update() {
+    const t = this.ctx, e = this._style.fontSize, i = this._style.fontWeight, r = this._style.fontFamily, n = `${i} ${e}px ${r}`, a = this.render.dpr;
+    t.font = n;
+    const o = this._text.split(`
+`);
+    let h = 0, u = 0;
+    t.textBaseline = "alphabetic";
+    const c = t.measureText(o[0]), m = c.fontBoundingBoxAscent, f = c.fontBoundingBoxDescent;
+    for (const A of o) {
+      const g = t.measureText(A);
+      g.width > h && (h = g.width), u += m + f;
+    }
+    u -= f;
+    const v = (this._style.strokeThickness || 0) * 2, x = Math.ceil(h + v) || 1, T = Math.ceil(u + v) || 1, E = x * a, R = T * a;
+    (this.canvas.width !== E || this.canvas.height !== R) && (this.canvas.width = E, this.canvas.height = R), t.setTransform(a, 0, 0, a, 0, 0), t.clearRect(0, 0, x, T), t.font = n, t.textBaseline = "top", t.textAlign = "left", this.updateOffset(x, T);
+    let _ = v / 2;
+    for (const A of o) {
+      let g = v / 2;
+      this._style.stroke && this._style.strokeThickness > 0 && (t.lineWidth = this._style.strokeThickness, t.strokeStyle = this._style.stroke, t.strokeText(A, g, _)), this._style.fill && (t.fillStyle = this._style.fill, t.fillText(A, g, _)), _ += m + f;
+    }
+    this.base?.updateSource(this.render.gl, this.canvas, this.options), this.setRegion(0, 0, this.canvas.width, this.canvas.height);
+  }
+}
+const Rt = (s, t = !1, e = !0) => {
+  const i = s.getContext("webgl2", { stencil: !0, antialias: t, premultipliedAlpha: e });
+  if (!i)
+    throw new Error("WebGL2 is not supported in this browser.");
+  return i;
+}, et = (s, t, e) => {
+  const i = s.createShader(e);
+  if (!i)
+    throw new Error("Unable to create webgl shader");
+  if (s.shaderSource(i, t), s.compileShader(i), !s.getShaderParameter(i, s.COMPILE_STATUS)) {
+    const n = s.getShaderInfoLog(i);
+    throw console.error("Shader compilation failed:", n), new Error("Unable to compile shader: " + n + t);
+  }
+  return i;
+}, Mt = (s, t, e) => {
+  var i = s.createProgram(), r = et(s, t, 35633), n = et(s, e, 35632);
+  if (!i)
+    throw new Error("Unable to create program shader");
+  if (s.attachShader(i, r), s.attachShader(i, n), s.linkProgram(i), !s.getProgramParameter(i, s.LINK_STATUS)) {
+    const o = s.getProgramInfoLog(i);
+    throw new Error("Unable to link shader program: " + o);
+  }
+  return i;
+};
+function q(s, t) {
+  const e = {
+    [H.CLAMP]: s.CLAMP_TO_EDGE,
+    [H.REPEAT]: s.REPEAT,
+    [H.MIRRORED_REPEAT]: s.MIRRORED_REPEAT
+  }[t] || s.CLAMP_TO_EDGE;
+  s.texParameteri(s.TEXTURE_2D, s.TEXTURE_WRAP_S, e), s.texParameteri(s.TEXTURE_2D, s.TEXTURE_WRAP_T, e);
+}
+function Z(s, t) {
+  const e = {
+    [Q.LINEAR]: s.LINEAR,
+    [Q.NEAREST]: s.NEAREST
+  }[t] ?? s.NEAREST;
+  s.texParameteri(s.TEXTURE_2D, s.TEXTURE_MIN_FILTER, e), s.texParameteri(s.TEXTURE_2D, s.TEXTURE_MAG_FILTER, e);
+}
+function X(s, t, e) {
+  const i = s.gl, r = i.createTexture();
+  if (!r)
+    throw new Error("Unable to create WebGL texture");
+  if (i.bindTexture(i.TEXTURE_2D, r), i.pixelStorei(i.UNPACK_FLIP_Y_WEBGL, 0), i.pixelStorei(i.UNPACK_ALIGNMENT, 1), q(i, e.wrap ?? H.CLAMP), Z(i, e.textureFilter ?? s.textureFilter), e.onlySize) {
+    const n = t;
+    i.texImage2D(i.TEXTURE_2D, 0, i.RGBA, n.width, n.height, 0, i.RGBA, i.UNSIGNED_BYTE, null);
+  } else {
+    const n = e.premultipliedAlpha ?? s.premultipliedAlpha;
+    n && i.pixelStorei(i.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !0), i.texImage2D(i.TEXTURE_2D, 0, i.RGBA, i.RGBA, i.UNSIGNED_BYTE, t), n && i.pixelStorei(i.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !1);
+  }
+  return i.bindTexture(i.TEXTURE_2D, null), r;
+}
+function F(s, t) {
+  if (s.includes("%TEXTURE_NUM%") && (s = s.replace("%TEXTURE_NUM%", t.toString())), s.includes("%GET_COLOR%")) {
+    let e = "";
+    for (let i = 0; i < t; i++)
+      i == 0 ? e += `if(vTextureId == ${i})` : i == t - 1 ? e += "else" : e += `else if(vTextureId == ${i})`, e += `{return texture(uTextures[${i}], uv) * vColor;}`;
+    s = s.replace("%GET_COLOR%", e);
+  }
+  return s;
+}
+const wt = 5126, it = 5121;
+function bt(s, t, e) {
+  s.vertexAttribDivisor(t, e);
+}
+function At(s, t, e, i, r) {
+  s.drawArraysInstanced(t, e, i, r);
+}
+let St = 0;
+class ct {
+  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 = St++;
+  // for debug
+  vao;
+  constructor(t, e, i, r) {
+    this.gl = t, this.program = Mt(t, e, i), this.parseShader(e), this.parseShader(i), this.vao = t.createVertexArray(), r && this.setAttributes(r);
+  }
+  /** 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 i = this.uniformLoc[t];
+    if (i === void 0) return;
+    const r = this.uniformType[t], n = this.uniformIsArray[t];
+    Ut(this.gl, i, r, e, n);
+  }
+  /**
+   * Batch-set uniforms via a plain value map.
+   * @example
+   *   shader.setUniforms({
+   *     uTime:       1.5,
+   *     uResolution: [800, 600],
+   *     uMVP:        mat4,
+   *   });
+   */
+  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;
+    const i = this.gl;
+    i.vertexAttribPointer(
+      e,
+      t.size,
+      t.type ?? wt,
+      t.normalized ?? !1,
+      t.stride,
+      t.offset ?? 0
+    ), i.enableVertexAttribArray(e), bt(i, 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, i = t.match(/(?:in|attribute)\s+\w+\s+\w+/g);
+    if (i)
+      for (const n of i) {
+        const o = n.split(/\s+/)[2], h = e.getAttribLocation(this.program, o);
+        h !== -1 && (this.attributeLoc[o] = h);
+      }
+    const r = t.match(/uniform\s+\w+\s+\w+(?:\[\d+\])?/g);
+    if (r)
+      for (const n of r) {
+        const a = n.split(/\s+/), o = a[1], h = a[2].replace(/\[\d+\]$/, ""), u = e.getUniformLocation(this.program, h);
+        u !== null && (this.uniformLoc[h] = u, this.uniformType[h] = o, this.uniformIsArray[h] = /\[\d+\]$/.test(a[2]));
+      }
+  }
+}
+function Ut(s, t, e, i, r = !1) {
+  switch (e) {
+    // scalars
+    case "float":
+      return s.uniform1f(t, i);
+    case "int":
+    case "bool":
+    case "sampler2D":
+    case "samplerCube":
+      return r ? s.uniform1iv(t, i) : s.uniform1i(t, i);
+    // float vectors
+    case "vec2":
+      return s.uniform2fv(t, i);
+    case "vec3":
+      return s.uniform3fv(t, i);
+    case "vec4":
+      return s.uniform4fv(t, i);
+    // int / bool vectors
+    case "ivec2":
+    case "bvec2":
+      return s.uniform2iv(t, i);
+    case "ivec3":
+    case "bvec3":
+      return s.uniform3iv(t, i);
+    case "ivec4":
+    case "bvec4":
+      return s.uniform4iv(t, i);
+    // matrices (column-major, transpose = false)
+    case "mat2":
+      return s.uniformMatrix2fv(t, !1, i);
+    case "mat3":
+      return s.uniformMatrix3fv(t, !1, i);
+    case "mat4":
+      return s.uniformMatrix4fv(t, !1, i);
+    // fallback: guess by value shape
+    default:
+      return _t(s, t, i);
+  }
+}
+function _t(s, t, e) {
+  if (typeof e == "number")
+    return s.uniform1f(t, e);
+  const i = e;
+  switch (i.length) {
+    case 2:
+      return s.uniform2fv(t, i);
+    case 3:
+      return s.uniform3fv(t, i);
+    case 4:
+      return s.uniform4fv(t, i);
+    case 9:
+      return s.uniformMatrix3fv(t, !1, i);
+    case 16:
+      return s.uniformMatrix4fv(t, !1, i);
+    default:
+      return s.uniform1fv(t, i);
+  }
+}
+class rt {
+  /** Custom vertex shader code */
+  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, i, r = 0, n) {
+    this.vs = e, this.fs = i, this.rapid = t, this.uniforms = n ?? {}, this.usedTextureUnitNum = r;
+  }
+  /**
+   * 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 = {}, i = {};
+    for (const [r, n] of Object.entries(t))
+      n instanceof WebGLTexture ? i[r] = n : e[r] = n;
+    Object.assign(this.uniforms, e), Object.assign(this.uniformTextures, i);
+    for (const r of this.glshader.keys())
+      this.uniformDirty.add(r);
+  }
+  /**
+   * 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 i = this.glshader.get(t);
+    i && (Object.keys(e).length > 0 && i.setUniforms(e), this.uniformDirty.has(t) && (i.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, i, r) {
+    if (this.glshader.has(e))
+      return this.glshader.get(e);
+    if (r == null || i == null)
+      return console.warn("CustomGlShader: missing base shader for " + e), null;
+    i = i.replace("// CUSTOM_CODE_CALL", "vertex(position, vRegion);"), r = r.replace("// CUSTOM_CODE_CALL", "fragment(fragColor);"), i = i.replace("// CUSTOM_CODE", this.vs), r = r.replace("// CUSTOM_CODE", this.fs);
+    const n = t.createShader(i, r);
+    return n.isCustom = !0, n.padding = this.padding, this.glshader.set(e, n), this.uniformDirty.add(e), n;
+  }
+}
+class lt {
+  constructor(t) {
+    this.rapid = t, this.gl = t.gl, this.maxTextureUnits = t.maxTextureUnits, this.matrixStore = t.matrix;
+  }
+  defaultShader;
+  currentShader;
+  customShader = null;
+  customShaderUsedTextureNum = 0;
+  gl;
+  maxTextureUnits;
+  matrixStore;
+  isDefaultShader = !0;
+  KEY = "default";
+  vs = "";
+  fs = "";
+  usedTextures = [];
+  usedTexturePadding = [];
+  createBuffer() {
+  }
+  createDefaultShader() {
+  }
+  get freeTextureUnitNum() {
+    return this.maxTextureUnits - this.usedTextures.length - this.customShaderUsedTextureNum;
+  }
+  getTextureUnitList() {
+    return Array.from(
+      { length: this.maxTextureUnits },
+      (t, e) => e
+    );
+  }
+  findTextureUnit(t, e = 0, i = 0) {
+    for (let r = 0; r < this.usedTextures.length; r++) {
+      const n = r * 2;
+      if (this.usedTextures[r] === t && this.usedTexturePadding[n] === e && this.usedTexturePadding[n + 1] === i)
+        return r;
+    }
+    return -1;
+  }
+  useTexture(t, e = 0, i = 0) {
+    const r = this.findTextureUnit(t, e, i);
+    return r == -1 ? (this.usedTextures.push(t), this.usedTexturePadding.push(e), this.usedTexturePadding.push(i), this.usedTextures.length - 1) : r;
+  }
+  createShader(t, e) {
+    return new ct(this.gl, t, e);
+  }
+  createCustomShader(t) {
+    return t.getGLShader(this, this.KEY, this.vs, this.fs);
+  }
+  getCustomShader(t) {
+    if (!t)
+      return this.defaultShader;
+    if (t instanceof rt) {
+      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 rt ? (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);
+  }
+  flush() {
+    this.render(), this.resetRender();
+  }
+  render() {
+    const t = this.currentShader;
+    if (t.use(), this.customShader) {
+      const i = this.customShader, r = {};
+      for (const n in i.uniformTextures)
+        r[n] = this.useTexture(i.uniformTextures[n]);
+      this.customShader.applyUniform(this.KEY, r);
+    }
+    const e = this.gl;
+    for (let i = 0; i < this.usedTextures.length; i++)
+      e.activeTexture(e.TEXTURE0 + i), e.bindTexture(e.TEXTURE_2D, this.usedTextures[i]);
+    t.setUniform("uTextures", Int32Array.from(
+      { length: this.usedTextures.length },
+      (i, r) => r
+    )), t.setUniform("uPadding", Float32Array.from(
+      { length: this.usedTexturePadding.length },
+      (i, r) => this.usedTexturePadding[r]
+    ));
+  }
+  resetRender() {
+    this.usedTextures.length = 0, this.usedTexturePadding.length = 0;
+  }
+  hasPendingContent() {
+    return !1;
+  }
+}
+const z = `#version 300 es\r
+precision mediump float;\r
+\r
+// per-vertex\r
+in vec2 aVertex;\r
+\r
+// per-instance：2x3 仿射矩阵，拆成两个 vec3\r
+in vec3 aMatrixRow0; // [a, c, tx]\r
+in vec3 aMatrixRow1; // [b, d, ty]\r
+\r
+// per-instance：UV 区域 (u0, v0, u1, v1)\r
+in vec4 aUVRect;\r
+\r
+// per-instance：tint color\r
+in vec4 aColor;\r
+\r
+// per-instance：纹理索引\r
+in float aTextureId;\r
+\r
+uniform mat4 u_projection;\r
+uniform vec2 uPadding[%TEXTURE_NUM%];\r
+\r
+out vec2 vRegion;\r
+flat out int vTextureId;\r
+out vec4 vColor;\r
+\r
+out vec4 vUVRect;\r
+out vec2 vPadding;\r
+// CUSTOM_CODE\r
+\r
+void main(void) {\r
+    vPadding = uPadding[int(aTextureId)];\r
+    vUVRect = aUVRect;\r
+    vRegion = mix(aUVRect.xy - vPadding, aUVRect.zw + vPadding, aVertex.xy);\r
+\r
+    vTextureId = int(aTextureId);\r
+    vColor = aColor;\r
+\r
+    vec4 position = vec4(\r
+        dot(aMatrixRow0.xyz, vec3(aVertex.xy, 1.0)), \r
+        dot(aMatrixRow1.xyz, vec3(aVertex.xy, 1.0)), \r
+        0.0, \r
+        1.0\r
+    );\r
+    // CUSTOM_CODE_CALL\r
+\r
+    gl_Position = u_projection * position;\r
+}\r
+`, st = `#version 300 es\r
+precision mediump float;\r
+\r
+uniform sampler2D uTextures[%TEXTURE_NUM%];\r
+\r
+in vec2 vRegion;\r
+flat in int vTextureId;\r
+in vec4 vColor;\r
+\r
+in vec4 vUVRect;\r
+\r
+out vec4 fragColor;\r
+in vec2 vPadding;\r
+\r
+bool clampUV(vec2 uv) {\r
+    return uv.x < vUVRect.x || uv.x > vUVRect.z || uv.y < vUVRect.y || uv.y > vUVRect.w;\r
+}\r
+\r
+vec4 sampleTexture(vec2 uv) {\r
+    %GET_COLOR%\r
+}\r
+\r
+vec4 sampleClampTexture(vec2 uv) {\r
+    if (clampUV(uv)) {\r
+        return vec4(0.0, 0.0, 0.0, 0.0);\r
+    }\r
+    return sampleTexture(uv);\r
+}\r
+\r
+vec4 sampleTextureLocal(vec2 uv){\r
+    vec2 gUV = mix(vUVRect.xy, vUVRect.zw, uv);\r
+    if (clampUV(gUV)) {\r
+        return vec4(0.0, 0.0, 0.0, 0.0);\r
+    }\r
+    return sampleTexture(gUV);\r
+}\r
+\r
+// CUSTOM_CODE\r
+\r
+void main(void) {\r
+    fragColor = sampleTexture(vRegion);\r
+    // if (vPadding.x != 0.0) {\r
+    //     if (clampUV(vRegion)) {\r
+    //         fragColor = vec4(0.0, 0.0, 0.0, 0.0);\r
+    //     }\r
+    // }\r
+\r
+    // CUSTOM_CODE_CALL\r
+}\r
+`, k = 48, Ct = new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]);
+class dt extends lt {
+  instanceBuffer;
+  quadBuffer;
+  instanceCount = 0;
+  localSpriteMatrix = new Float32Array(6);
+  worldSpriteMatrix = new Float32Array(6);
+  KEY = "Sprite";
+  constructor(t) {
+    super(t), this.createBuffer(), this.createDefaultShader();
+  }
+  createBuffer() {
+    const t = this.gl;
+    this.quadBuffer = new j(t, N.Float32, t.ARRAY_BUFFER, t.STATIC_DRAW), this.quadBuffer.bindBuffer();
+    for (const e of Ct) this.quadBuffer.pushFloat32(e);
+    this.quadBuffer.makeDirty(), this.quadBuffer.bufferData(), this.instanceBuffer = new j(t, N.Uint32, t.ARRAY_BUFFER, t.DYNAMIC_DRAW);
+  }
+  createDefaultShader() {
+    const t = this.rapid, e = F(st, t.maxTextureUnits), i = F(z, t.maxTextureUnits);
+    return this.vs = i, this.fs = e, this.defaultShader = this.createShader(i, e), this.defaultShader;
+  }
+  createShader(t, e) {
+    const i = super.createShader(t, e);
+    return i.use(), i.bindVAO(), this.instanceBuffer.bindBuffer(), i.setAttributes([
+      { name: "aMatrixRow0", size: 3, stride: k, offset: 0, divisor: 1 },
+      { name: "aMatrixRow1", size: 3, stride: k, offset: 12, divisor: 1 },
+      { name: "aUVRect", size: 4, stride: k, offset: 24, divisor: 1 },
+      { name: "aColor", size: 4, type: it, normalized: !0, stride: k, offset: 40, divisor: 1 },
+      { name: "aTextureId", size: 1, type: it, stride: k, offset: 44, divisor: 1 }
+    ]), this.quadBuffer.bindBuffer(), i.setAttributes([
+      { name: "aVertex", size: 2, stride: 8, offset: 0, divisor: 0 }
+    ]), i.unbindVAO(), this.currentShader && this.currentShader.use(), i;
+  }
+  createCustomShader(t) {
+    const e = F(st, this.rapid.maxTextureUnits - t.usedTextureUnitNum), i = F(z, this.rapid.maxTextureUnits - t.usedTextureUnitNum);
+    return t.getGLShader(this, this.KEY, i, 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, i = 0, r = 0, n = 1, a = 1, o = 4294967295, h = 0, u = 0, c = !1, m = !1, f = !1) {
+    this.freeTextureUnitNum === 0 && this.flush();
+    const v = t.base, x = t.scale || 1, T = t.rawWidth, E = t.rawHeight, R = t.offsetX, _ = t.offsetY, A = this.useTexture(
+      t.glTexture,
+      h / x / v.width,
+      u / x / v.height
+    ), g = e * 6, M = this.matrixStore.data, L = this.instanceBuffer, S = L.usedElemNum;
+    L.resize(12);
+    const U = L.float32, O = L.uint32, B = (f ? E : T) * x, K = (f ? T : E) * x, P = B + 2 * h, I = K + 2 * u, Y = R - h, tt = _ - u, y = this.localSpriteMatrix;
+    f ? (y[0] = 0, y[1] = m ? I : -I, y[2] = c ? -P : P, y[3] = 0, y[4] = Y + (c ? P : 0), y[5] = tt + (m ? 0 : I)) : (y[0] = c ? -P : P, y[1] = 0, y[2] = 0, y[3] = m ? -I : I, y[4] = Y + (c ? P : 0), y[5] = tt + (m ? I : 0));
+    const w = this.worldSpriteMatrix;
+    w[0] = M[g] * y[0] + M[g + 2] * y[1], w[1] = M[g + 1] * y[0] + M[g + 3] * y[1], w[2] = M[g] * y[2] + M[g + 2] * y[3], w[3] = M[g + 1] * y[2] + M[g + 3] * y[3], w[4] = M[g + 4] + M[g] * y[4] + M[g + 2] * y[5], w[5] = M[g + 5] + M[g + 1] * y[4] + M[g + 3] * y[5], U[S + 6] = i, U[S + 7] = r, U[S + 8] = n, U[S + 9] = a, O[S + 10] = o, O[S + 11] = A, this.rapid.roundPixels && (w[4] = Math.round(w[4]), w[5] = Math.round(w[5])), U[S] = w[0], U[S + 1] = w[2], U[S + 2] = w[4], U[S + 3] = w[1], U[S + 4] = w[3], U[S + 5] = w[5], L.usedElemNum += 12, L.makeDirty(), this.instanceCount++;
+  }
+  render() {
+    if (this.instanceCount === 0) return;
+    super.render();
+    const t = this.gl, e = this.currentShader;
+    this.instanceBuffer.bindBuffer(), this.instanceBuffer.bufferData(), e.bindVAO(), At(t, t.TRIANGLE_STRIP, 0, 4, this.instanceCount), this.rapid.drawcallCount++;
+  }
+  resetRender() {
+    super.resetRender(), this.instanceBuffer.clear(), this.instanceCount = 0;
+  }
+  hasPendingContent() {
+    return this.instanceCount > 0;
+  }
+}
+const Nt = `#version 300 es\r
+precision mediump float;\r
+\r
+in vec2 aPosition;\r
+in vec4 aColor;\r
+in vec2 aUV;\r
+\r
+uniform mat4 u_projection;\r
+uniform vec3 uMatrixRow0; // [a, c, tx]\r
+uniform vec3 uMatrixRow1; // [b, d, ty]\r
+uniform vec4 uUVRect;\r
+\r
+out vec4 vColor;\r
+out vec2 vRegion;\r
+out vec4 vUVRect;\r
+\r
+// CUSTOM_CODE\r
+\r
+void main(void) {\r
+    vColor = aColor;\r
+    vUVRect = uUVRect;\r
+    vRegion = mix(uUVRect.xy, uUVRect.zw, aUV);\r
+    vec4 position = vec4(\r
+        dot(uMatrixRow0.xyz, vec3(aPosition.xy, 1.0)), \r
+        dot(uMatrixRow1.xyz, vec3(aPosition.xy, 1.0)), \r
+        0.0, \r
+        1.0\r
+    );\r
+    // CUSTOM_CODE_CALL\r
+    gl_Position = u_projection * position;\r
+}\r
+`, Lt = `#version 300 es\r
+precision mediump float;\r
+\r
+in vec4 vColor;\r
+in vec2 vRegion;\r
+in vec4 vUVRect;\r
+\r
+uniform sampler2D uTexture;\r
+uniform int uUseTexture;\r
+\r
+out vec4 fragColor;\r
+\r
+bool clampUV(vec2 uv) {\r
+    vec2 uvMin = min(vUVRect.xy, vUVRect.zw);\r
+    vec2 uvMax = max(vUVRect.xy, vUVRect.zw);\r
+    return uv.x < uvMin.x || uv.x > uvMax.x || uv.y < uvMin.y || uv.y > uvMax.y;\r
+}\r
+\r
+vec4 sampleTexture(vec2 uv) {\r
+    if (uUseTexture > 0) {\r
+        return texture(uTexture, uv) * vColor;\r
+    }\r
+    return vColor;\r
+}\r
+\r
+vec4 sampleClampTexture(vec2 uv) {\r
+    if (clampUV(uv)) {\r
+        return vec4(0.0, 0.0, 0.0, 0.0);\r
+    }\r
+    return sampleTexture(uv);\r
+}\r
+\r
+vec4 sampleTextureLocal(vec2 uv) {\r
+    vec2 gUV = mix(vUVRect.xy, vUVRect.zw, uv);\r
+    if (clampUV(gUV)) {\r
+        return vec4(0.0, 0.0, 0.0, 0.0);\r
+    }\r
+    return sampleTexture(gUV);\r
+}\r
+\r
+// CUSTOM_CODE\r
+\r
+void main(void) {\r
+    fragColor = sampleTexture(vRegion);\r
+    // CUSTOM_CODE_CALL\r
+}\r
+`, Pt = `#version 300 es\r
+precision mediump float;\r
+\r
+in vec2 aPosition;\r
+in vec2 aUV;\r
+\r
+uniform mat4 u_projection;\r
+uniform vec3 uMatrixRow0; // [a, c, tx]\r
+uniform vec3 uMatrixRow1; // [b, d, ty]\r
+uniform vec4 uUVRect;\r
+\r
+out vec2 vRegion;\r
+\r
+void main(void) {\r
+    vRegion = mix(uUVRect.xy, uUVRect.zw, aUV);\r
+    vec4 position = vec4(\r
+        dot(uMatrixRow0.xyz, vec3(aPosition.xy, 1.0)), \r
+        dot(uMatrixRow1.xyz, vec3(aPosition.xy, 1.0)), \r
+        0.0, \r
+        1.0\r
+    );\r
+    gl_Position = u_projection * position;\r
+}\r
+`, It = `#version 300 es\r
+precision mediump float;\r
+\r
+in vec2 vRegion;\r
+\r
+uniform sampler2D uTexture;\r
+uniform int uUseTexture;\r
+\r
+out vec4 fragColor;\r
+\r
+void main(void) {\r
+    if (uUseTexture > 0) {\r
+        fragColor = texture(uTexture, vRegion);\r
+    } else {\r
+        fragColor = vec4(1.0);\r
+    }\r
+    if(fragColor.a == 0.0) {\r
+        discard;\r
+    }\r
+}\r
+`, G = 20;
+class Ot extends lt {
+  vertexBuffer;
+  vertexCount = 0;
+  matrixIndex = -1;
+  drawMode = this.gl.TRIANGLES;
+  texture;
+  maskShader;
+  KEY = "Graphic";
+  constructor(t) {
+    super(t), this.createBuffer(), this.createDefaultShader();
+  }
+  createBuffer() {
+    const t = this.gl;
+    this.vertexBuffer = new j(t, N.Float32, t.ARRAY_BUFFER, t.DYNAMIC_DRAW), this.maskShader = this.createMaskShader(Pt, It);
+  }
+  createDefaultShader() {
+    return this.vs = Nt, this.fs = Lt, this.defaultShader = this.createShader(this.vs, this.fs), this.defaultShader;
+  }
+  createMaskShader(t, e) {
+    const i = this.gl, r = new ct(i, t, e);
+    return r.use(), r.bindVAO(), this.vertexBuffer.bindBuffer(), r.setAttributes([
+      { name: "aPosition", size: 2, type: i.FLOAT, stride: G - 4, offset: 0, divisor: 0 },
+      { name: "aUV", size: 2, type: i.FLOAT, stride: G - 4, offset: 8, divisor: 0 }
+    ]), r.unbindVAO(), this.currentShader && this.currentShader.use(), r;
+  }
+  createShader(t, e) {
+    const i = this.gl, r = super.createShader(t, e);
+    return r.use(), r.bindVAO(), this.vertexBuffer.bindBuffer(), r.setAttributes([
+      { name: "aPosition", size: 2, type: i.FLOAT, stride: G, offset: 0, divisor: 0 },
+      { name: "aColor", size: 4, type: i.UNSIGNED_BYTE, normalized: !0, stride: G, offset: 8, divisor: 0 },
+      { name: "aUV", size: 2, type: i.FLOAT, stride: G, offset: 12, divisor: 0 }
+    ]), r.unbindVAO(), this.currentShader && this.currentShader.use(), r;
+  }
+  /**
+   * 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, i) {
+    this.vertexBuffer.clear(), this.vertexCount = 0, this.matrixIndex = t, this.drawMode = e, this.texture = i;
+  }
+  /**
+   * 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, i = 0, r = 0, n = 4294967295) {
+    const a = this.vertexBuffer;
+    a.pushFloat32(t), a.pushFloat32(e), this.currentShader != this.maskShader && a.pushUint32(n), a.pushFloat32(i), a.pushFloat32(r), this.vertexCount++, this.vertexBuffer.makeDirty();
+  }
+  /**
+   * Finishes the graphic construction and dispatches the rendering call immediately.
+   */
+  endGraphic() {
+    this.render();
+  }
+  render() {
+    if (this.vertexCount === 0) return;
+    super.render();
+    const t = this.gl, e = this.currentShader, i = this.matrixIndex * 6, r = this.matrixStore.data;
+    let n = r[i + 4], a = r[i + 5];
+    this.rapid.roundPixels && (n = Math.round(n), a = Math.round(a)), e.setUniform("uMatrixRow0", [r[i], r[i + 2], n]), e.setUniform("uMatrixRow1", [r[i + 1], r[i + 3], a]), e.setUniform(
+      "uUVRect",
+      this.texture ? [this.texture.uvX, this.texture.uvY, this.texture.uvW, this.texture.uvH] : [0, 0, 1, 1]
+    ), this.texture?.glTexture ? (t.activeTexture(t.TEXTURE0), t.bindTexture(t.TEXTURE_2D, this.texture.glTexture), e.setUniform("uTexture", 0), e.setUniform("uUseTexture", 1)) : e.setUniform("uUseTexture", 0), this.vertexBuffer.bindBuffer(), this.vertexBuffer.bufferData(), e.bindVAO(), t.drawArrays(this.drawMode, 0, this.vertexCount), this.rapid.drawcallCount++;
+  }
+  hasPendingContent() {
+    return !1;
+  }
+}
+class l {
+  x;
+  y;
+  static ZERO = new l(0, 0);
+  static ONE = new l(1, 1);
+  static UP = new l(0, 1);
+  static DOWN = new l(0, -1);
+  static LEFT = new l(-1, 0);
+  static RIGHT = new l(1, 0);
+  constructor(t, e) {
+    this.x = t !== void 0 ? t : 0, this.y = e !== void 0 ? e : 0;
+  }
+  set(t, e) {
+    return e === void 0 ? (this.x = t, this.y = t) : (this.x = t, this.y = e), this;
+  }
+  add(t) {
+    return new l(this.x + t.x, this.y + t.y);
+  }
+  subtract(t) {
+    return new l(this.x - t.x, this.y - t.y);
+  }
+  sub(t) {
+    return new l(this.x - t.x, this.y - t.y);
+  }
+  multiply(t) {
+    return t instanceof l ? new l(this.x * t.x, this.y * t.y) : new l(this.x * t, this.y * t);
+  }
+  mul(t) {
+    return this.multiply(t);
+  }
+  divide(t) {
+    return t instanceof l ? new l(this.x / t.x, this.y / t.y) : new l(this.x / t, this.y / t);
+  }
+  dot(t) {
+    return this.x * t.x + this.y * t.y;
+  }
+  cross(t) {
+    return this.x * t.y - this.y * t.x;
+  }
+  distanceTo(t) {
+    const e = this.x - t.x, i = this.y - t.y;
+    return Math.sqrt(e * e + i * i);
+  }
+  clone() {
+    return new l(this.x, this.y);
+  }
+  to(t) {
+    this.x = t.x, this.y = t.y;
+  }
+  copy() {
+    return new l(this.x, this.y);
+  }
+  equals(t) {
+    return t.x == this.x && t.y == this.y;
+  }
+  perpendicular() {
+    const t = this.x;
+    return this.x = -this.y, this.y = t, this;
+  }
+  invert() {
+    return this.x = -this.x, this.y = -this.y, this;
+  }
+  inverted() {
+    return new l(this.x * -1, this.y * -1);
+  }
+  length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y);
+  }
+  squaredLength() {
+    return this.x * this.x + this.y * this.y;
+  }
+  normalize() {
+    const t = this.length();
+    return this.x = this.x / t || 0, this.y = this.y / t || 0, this;
+  }
+  normalized() {
+    const t = this.length();
+    return new l(this.x / t || 0, this.y / t || 0);
+  }
+  fix(t = 1e-13) {
+    this.x = Math.abs(this.x) < t ? 0 : this.x, this.y = Math.abs(this.y) < t ? 0 : this.y;
+  }
+  fixed(t = 1e-13) {
+    return new l(
+      Math.abs(this.x) < t ? 0 : this.x,
+      Math.abs(this.y) < t ? 0 : this.y
+    );
+  }
+  angle() {
+    return Math.atan2(this.y, this.x);
+  }
+  abs() {
+    return new l(Math.abs(this.x), Math.abs(this.y));
+  }
+  floor() {
+    return new l(Math.floor(this.x), Math.floor(this.y));
+  }
+  ceil() {
+    return new l(Math.ceil(this.x), Math.ceil(this.y));
+  }
+  stringify() {
+    return `Vec2(${this.x}, ${this.y})`;
+  }
+  clear() {
+    this.x = 0, this.y = 0;
+  }
+  isPrettyMuchZero() {
+    return Math.abs(this.x) < 1e-4 && Math.abs(this.y) < 1e-4;
+  }
+  isZero() {
+    return this.x == 0 && this.y == 0;
+  }
+  isNotZero() {
+    return this.x !== 0 || this.y !== 0;
+  }
+  setToPolar(t, e = 1) {
+    return this.x = Math.cos(t) * e, this.y = Math.sin(t) * e, this;
+  }
+  static FromArray(t) {
+    return t.map((e) => new l(e[0], e[1]));
+  }
+  static fromAngle(t) {
+    return new l(Math.cos(t), Math.sin(t));
+  }
+}
+const $ = 10, nt = (s, t, e, i, r, n) => {
+  const a = [], o = [], h = i ? Math.atan2(t.y, t.x) : Math.atan2(-t.y, -t.x), u = Math.PI, c = new l(t.y, -t.x);
+  for (let m = 0; m < $; m++) {
+    const f = m / $, v = (m + 1) / $, x = h + f * u, T = h + v * u, E = new l(Math.cos(x) * e, Math.sin(x) * e), R = new l(Math.cos(T) * e, Math.sin(T) * e);
+    a.push(s), o.push(new l(r, 0.5)), a.push(s.add(E)), o.push(new l(r + E.dot(c) * n, 0.5 - 0.5 * E.dot(t) / e)), a.push(s.add(R)), o.push(new l(r + R.dot(c) * n, 0.5 - 0.5 * R.dot(t) / e));
+  }
+  return { vertices: a, uv: o };
+}, Ft = (s, t = !1) => {
+  const e = [];
+  if (s.length < 2 || t && s.length < 3) return { normals: e, length: 0 };
+  const i = 4, r = 1e-3, n = s.length;
+  let a = 0;
+  if (t)
+    for (let h = 0; h < n; h++) {
+      const u = s[h], c = s[(h + 1) % n];
+      a += u.distanceTo(c);
+    }
+  else
+    for (let h = 0; h < n - 1; h++)
+      a += s[h].distanceTo(s[h + 1]);
+  const o = (h, u, c) => {
+    const m = u.subtract(h).normalize(), f = u.subtract(c).normalize(), v = f.dot(m);
+    if (v < -1 + r)
+      return { normal: m.perpendicular(), miters: 1 };
+    {
+      let x = f.add(m).normalize();
+      m.cross(f) < 0 && (x = x.multiply(-1));
+      let T = 1 / Math.sqrt((1 - v) / 2);
+      return { normal: x, miters: Math.min(T, i) };
+    }
+  };
+  if (t)
+    for (let h = 0; h < n; h++) {
+      const u = h === 0 ? s[n - 1] : s[h - 1], c = s[h], m = h === n - 1 ? s[0] : s[h + 1];
+      e.push(o(u, c, m));
+    }
+  else
+    for (let h = 0; h < n; h++)
+      if (h === 0) {
+        const u = s[1].subtract(s[0]).normalize();
+        e.push({ normal: u.perpendicular(), miters: 1 });
+      } else if (h === n - 1) {
+        const u = s[h].subtract(s[h - 1]).normalize();
+        e.push({ normal: u.perpendicular(), miters: 1 });
+      } else
+        e.push(o(s[h - 1], s[h], s[h + 1]));
+  return { normals: e, length: a };
+}, Wt = (s) => {
+  const t = s.points;
+  if (t.length < 2) return { vertices: [], uv: [] };
+  const { normals: e, length: i } = Ft(t, s.closed), r = (s.width || 1) / 2, n = [], a = [], o = s.roundCap || !1, h = s.textureMode || 0;
+  let u = 0;
+  const c = s.texture?.rawWidth || 1, m = s.closed ? t.length : t.length - 1;
+  for (let f = 0; f < m; f++) {
+    const v = t[f], x = e[f].normal, T = e[f].miters, E = (f + 1) % t.length, R = t[E], _ = e[E].normal, A = e[E].miters, g = v.add(x.multiply(T * r)), M = v.subtract(x.multiply(T * r)), L = R.add(_.multiply(A * r)), S = R.subtract(_.multiply(A * r)), U = v.distanceTo(R);
+    let O = 0, B = 0;
+    h === 0 ? (O = u / i, B = (u + U) / i) : (O = u / c, B = O + U / c);
+    const K = new l(O, 0), P = new l(O, 1), I = new l(B, 0), Y = new l(B, 1);
+    n.push(g), a.push(K), n.push(M), a.push(P), n.push(L), a.push(I), n.push(L), a.push(I), n.push(S), a.push(Y), n.push(M), a.push(P), u += U;
+  }
+  if (o && !s.closed) {
+    const f = t[0], v = e[0].normal, x = h === 0 ? i > 0 ? 1 / i : 0 : 1 / c, T = nt(f, v, r, !0, 0, x);
+    n.push(...T.vertices), a.push(...T.uv);
+    const E = t[t.length - 1], R = e[t.length - 1].normal, _ = h === 0 ? 1 : u / c, A = h === 0 ? i > 0 ? 1 / i : 0 : 1 / c, g = nt(E, R, r, !1, _, A);
+    n.push(...g.vertices), a.push(...g.uv);
+  }
+  return { vertices: n, uv: a };
+}, Dt = (s) => s.saveTransform !== void 0 || s.afterSave !== void 0 || s.x !== void 0 || s.y !== void 0 || s.position !== void 0 || s.rotation !== void 0 || s.scale !== void 0 || s.offsetX !== void 0 || s.offsetY !== void 0 || s.offset !== void 0 || s.origin !== void 0, V = (s, t, e, i, r) => {
+  if (!Dt(t)) {
+    r();
+    return;
+  }
+  s.matrixStack.applyTransform(t, e, i);
+  try {
+    r();
+  } finally {
+    (t.saveTransform ?? !0) && s.matrixStack.restore();
+  }
+}, J = (s, t) => t ? s.premultipliedAlpha ? t.premultipliedUint32 : t.uint32 : 4294967295, Bt = 2, ft = (s, t) => {
+  const e = t.texture;
+  if (!e?.base || s.inCreateMask)
+    return;
+  const i = e.isAtlas ? s.atlasSpriteRegion : s.spriteRegion;
+  s.enterRegion(i, t.shader);
+  let r = e.uvX, n = e.uvY, a = e.uvW, o = e.uvH;
+  const h = !!t.flipX, u = !!t.flipY != !!e.flipY;
+  let c = t.padding ?? i.currentShader.padding;
+  e.isAtlas && (c += Bt);
+  const m = r <= a ? c : -c, f = n <= o ? c : -c;
+  i.drawSprite(
+    e,
+    t.customMatrix ?? s.matrixStack.curWorldM,
+    r,
+    n,
+    a,
+    o,
+    J(s, t.color),
+    m,
+    f,
+    h,
+    u,
+    e.isRotated
+  );
+}, kt = (s, t) => {
+  V(s, t, t.texture.rawWidth, t.texture.rawHeight, () => {
+    ft(s, t);
+  });
+}, mt = (s, t) => {
+  t.points.length !== 0 && V(s, t, 0, 0, () => {
+    s.startGraphic(
+      t.drawMode ?? s.gl.TRIANGLES,
+      t.texture,
+      t.shader,
+      t.customMatrix
+    );
+    for (let e = 0; e < t.points.length; e++) {
+      const i = t.points[e], r = t.uv?.[e], n = Array.isArray(t.color) ? t.color[e] : t.color;
+      s.addGraphicVertex(
+        i.x,
+        i.y,
+        r?.x ?? 0,
+        r?.y ?? 0,
+        J(s, n)
+      );
+    }
+    s.endGraphic();
+  });
+}, Gt = (s, t) => {
+  if (s.inCreateMask)
+    return;
+  const { vertices: e, uv: i } = Wt(t);
+  mt(s, {
+    ...t,
+    points: e,
+    uv: i,
+    drawMode: s.gl.TRIANGLES
+  });
+}, Ht = (s, t) => {
+  V(s, t, t.texture.rawWidth, t.texture.rawHeight, () => {
+    s.startMaskGraphic(
+      s.gl.TRIANGLE_FAN,
+      t.texture,
+      t.customMatrix
+    ), s.addRectVertex(t.texture.rawWidth, t.texture.rawHeight), s.endGraphic();
+  });
+}, Vt = (s, t) => {
+  V(s, t, t.width, t.height, () => {
+    s.startGraphic(
+      s.gl.TRIANGLE_FAN,
+      t.texture,
+      t.shader,
+      t.customMatrix
+    ), s.addRectVertex(t.width, t.height, t.color), s.endGraphic();
+  });
+}, Yt = (s, t) => {
+  const e = t.segments ?? 32;
+  V(s, t, 0, 0, () => {
+    s.startGraphic(
+      s.gl.TRIANGLE_FAN,
+      void 0,
+      t.shader,
+      t.customMatrix
+    );
+    const i = J(s, t.color);
+    s.addGraphicVertex(0, 0, 0.5, 0.5, i), s.addCircleVertex(t.radius, t.color, e), s.addGraphicVertex(t.radius, 0, 1, 0.5, i), s.endGraphic();
+  });
+}, at = `#version 300 es\r
+precision mediump float;\r
+\r
+uniform sampler2D uTextures[%TEXTURE_NUM%];\r
+\r
+in vec2 vRegion;\r
+flat in int vTextureId;\r
+in vec4 vColor;\r
+\r
+in vec4 vUVRect;\r
+\r
+out vec4 fragColor;\r
+in vec2 vPadding;\r
+\r
+bool clampUV(vec2 uv) {\r
+    return uv.x < vUVRect.x || uv.x > vUVRect.z || uv.y < vUVRect.y || uv.y > vUVRect.w;\r
+}\r
+\r
+vec4 sampleTexture(vec2 uv) {\r
+    %GET_COLOR%\r
+}\r
+\r
+vec4 sampleClampTexture(vec2 uv) {\r
+    if (clampUV(uv)) {\r
+        return vec4(0.0, 0.0, 0.0, 0.0);\r
+    }\r
+    return sampleTexture(uv);\r
+}\r
+\r
+vec4 sampleTextureLocal(vec2 uv){\r
+    vec2 gUV = mix(vUVRect.xy, vUVRect.zw, uv);\r
+    if (clampUV(gUV)) {\r
+        return vec4(0.0, 0.0, 0.0, 0.0);\r
+    }\r
+    return sampleTexture(gUV);\r
+}\r
+\r
+// CUSTOM_CODE\r
+\r
+void main(void) {\r
+    fragColor = sampleClampTexture(vRegion);\r
+    // if (vPadding.x != 0.0) {\r
+    //     if (clampUV(vRegion)) {\r
+    //         fragColor = vec4(0.0, 0.0, 0.0, 0.0);\r
+    //     }\r
+    // }\r
+\r
+    // CUSTOM_CODE_CALL\r
+}\r
+`;
+class zt extends dt {
+  KEY = "AtlasSprite";
+  constructor(t) {
+    super(t);
+  }
+  createCustomShader(t) {
+    const e = F(at, this.rapid.maxTextureUnits - t.usedTextureUnitNum), i = F(z, this.rapid.maxTextureUnits - t.usedTextureUnitNum);
+    return t.getGLShader(this, this.KEY, i, e);
+  }
+  createDefaultShader() {
+    const t = this.rapid, e = F(at, t.maxTextureUnits), i = F(z, t.maxTextureUnits);
+    return this.vs = i, this.fs = e, this.defaultShader = this.createShader(i, e), this.defaultShader;
+  }
+}
+var Xt = /* @__PURE__ */ ((s) => (s[s.EQUAL = 0] = "EQUAL", s[s.NOT_EQUAL = 1] = "NOT_EQUAL", s))(Xt || {}), Kt = /* @__PURE__ */ ((s) => (s[s.NORMAL = 0] = "NORMAL", s[s.ADD = 1] = "ADD", s[s.MULTIPLY = 2] = "MULTIPLY", s[s.SCREEN = 3] = "SCREEN", s[s.ERASE = 4] = "ERASE", s))(Kt || {}), Q = /* @__PURE__ */ ((s) => (s[s.LINEAR = 0] = "LINEAR", s[s.NEAREST = 1] = "NEAREST", s))(Q || {}), $t = /* @__PURE__ */ ((s) => (s[s.CanvasItem = 0] = "CanvasItem", s[s.Viewport = 1] = "Viewport", s))($t || {});
+class Qt {
+  /** The active WebGL context. */
+  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 = d.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 gt(this);
+  /** Direct access to the underlying matrix store. */
+  matrix;
+  /** Region dedicated to fast sprite rendering. */
+  spriteRegion;
+  /** Region dedicated to arbitrary geometry and shapes rendering. */
+  graphicRegion;
+  atlasSpriteRegion;
+  /** 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 C();
+  get height() {
+    return this.logicHeight;
+  }
+  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 = Rt(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 dt(this), this.graphicRegion = new Ot(this), this.atlasSpriteRegion = new zt(this);
+    const i = this.canvas.clientWidth || this.canvas.width, r = this.canvas.clientHeight || this.canvas.height;
+    this.physicsWidth = t.physicsWidth || Math.round(i * this.dpr), this.physicsHeight = t.physicsHeight || Math.round(r * this.dpr), this.logicWidth = t.logicWidth || this.physicsWidth / this.dpr, this.logicHeight = t.logicHeight || this.physicsHeight / this.dpr, this.resize(this.logicWidth, this.logicHeight, this.physicsWidth, this.physicsHeight), this.texture = new vt(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 t ? this.premultipliedAlpha ? t.premultipliedUint32 : t.uint32 : 4294967295;
+  }
+  /**
+   * 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));
+  }
+  drawSprite(t) {
+    kt(this, t);
+  }
+  drawLine(t) {
+    Gt(this, t);
+  }
+  drawGraphic(t) {
+    mt(this, t);
+  }
+  drawRect(t) {
+    Vt(this, t);
+  }
+  drawCircle(t) {
+    Yt(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, i, r) {
+    this.enterRegion(this.graphicRegion, i), this.graphicRegion.startGraphic(r ?? 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, i) {
+    this.startGraphic(t, e, this.graphicRegion.maskShader, i);
+  }
+  /**
+   * 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) {
+    Ht(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.
+   */
+  addRectVertex(t, e, i) {
+    const r = this.getColorUint32(i);
+    this.addGraphicVertex(0, 0, 0, 0, r), this.addGraphicVertex(t, 0, 1, 0, r), this.addGraphicVertex(t, e, 1, 1, r), this.addGraphicVertex(0, e, 0, 1, r);
+  }
+  /**
+   * 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, i = 32) {
+    const r = Math.PI * 2 / i, n = this.getColorUint32(e);
+    for (let a = 0; a < i; a++) {
+      const o = r * a, h = Math.cos(o) * t, u = Math.sin(o) * t, c = 0.5 + Math.cos(o) * 0.5, m = 0.5 + Math.sin(o) * 0.5;
+      this.addGraphicVertex(h, u, c, m, n);
+    }
+  }
+  /**
+   * 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, i = 0, r = 0, n = 4294967295) {
+    this.graphicRegion.addVertex(t, e, i, r, n);
+  }
+  /**
+   * 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, i, r) {
+    this.flush();
+    const n = i ?? this.canvas.clientWidth ?? this.canvas.width, a = r ?? this.canvas.clientHeight ?? this.canvas.height;
+    switch (i !== void 0 && (this.canvas.style.width = n + "px"), r !== void 0 && (this.canvas.style.height = a + "px"), this.physicsWidth = n * this.dpr, this.physicsHeight = a * this.dpr, this.logicWidth = t, this.logicHeight = e, this.scaleMode) {
+      case 1:
+        this.canvas.width = t, this.canvas.height = e, this.canvas.style.imageRendering = "pixelated", this.gl.viewport(0, 0, t, e);
+        break;
+      case 0:
+        this.canvas.width = this.physicsWidth, this.canvas.height = this.physicsHeight, this.canvas.style.imageRendering = "auto", this.gl.viewport(0, 0, this.physicsWidth, this.physicsHeight);
+        break;
+      default:
+        throw new Error("scaleMode can only be CanvasScaleMode.Viewport or CanvasScaleMode.CanvasItem");
+    }
+    this.updateProjection(0, this.logicWidth, this.logicHeight, 0);
+  }
+  /**
+   * Updates the projection matrix using an orthographic mapping.
+   * Automatically sets local flag projectionDirty.
+   */
+  updateProjection(t, e, i, r) {
+    this.updateOrthMatrix(this.projection, t, e, i, r), 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, i, r, n) {
+    t[0] = 2 / (i - e), t[1] = 0, t[2] = 0, t[3] = 0, t[4] = 0, t[5] = 2 / (n - r), t[6] = 0, t[7] = 0, t[8] = 0, t[9] = 0, t[10] = -1, t[11] = 0, t[12] = -(i + e) / (i - e), t[13] = -(n + r) / (n - r), 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 i = Math.max(...e.map((u) => u.padding)), r = i, n = t.rawWidth + i * 2, a = t.rawHeight + i * 2;
+    for (let u = 0; u < 2; u++)
+      this._filterRT[u] ? this._filterRT[u].resize(n, a) : this._filterRT[u] = this.texture.createRenderTexture({ width: n, height: a });
+    let o = t.clone(this._filterInput), h = 0;
+    this.matrixStack.save(), this.matrixStack.identity();
+    for (let u = 0; u < e.length; u++) {
+      const c = this._filterRT[h % 2];
+      c.offsetX = 0, c.offsetY = 0, this.enterRenderTexture(c), this.clearRenderTexture(), this.drawSprite({
+        texture: o,
+        shader: e[u],
+        offsetX: u == 0 ? r : 0,
+        // padding back
+        offsetY: u == 0 ? r : 0,
+        padding: i
+      }), this.leaveRenderTexture(), o = c, h++;
+    }
+    return this.matrixStack.restore(), o.offsetX = -r, o.offsetY = -r, o;
+  }
+  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 d(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, i = new d(0, 0, 0, 0)) {
+    this.enterRenderTexture(t);
+    try {
+      i !== null && this.clearRenderTexture(i), e();
+    } finally {
+      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, i = 0, r = 1) {
+    this.clearMask(), this.startDrawMask(r);
+    try {
+      t();
+    } finally {
+      this.endDrawMask();
+    }
+    this.enterMask(i, r);
+    try {
+      e();
+    } finally {
+      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, i = 0, r = 0) {
+    if (e) {
+      const n = e.saveTransform ?? !0;
+      try {
+        this.matrixStack.applyTransform(e, i, r), t();
+      } finally {
+        n && this.matrixStack.restore();
+      }
+    } else {
+      this.matrixStack.save();
+      try {
+        t();
+      } finally {
+        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, i, r, n) {
+    this.startScissor(t, e, i, r);
+    try {
+      n();
+    } finally {
+      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 {
+      e();
+    } finally {
+      this.setBlendMode(
+        0
+        /* NORMAL */
+      );
+    }
+  }
+  /**
+   * 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 i = this.gl;
+    i.stencilMask(e), i.colorMask(!1, !1, !1, !1), i.stencilFunc(i.ALWAYS, t, e), i.stencilOp(i.KEEP, i.KEEP, i.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, i = 255) {
+    this.flush();
+    const r = this.gl;
+    r.colorMask(!0, !0, !0, !0), r.stencilMask(0), r.stencilFunc(t === 0 ? r.EQUAL : r.NOTEQUAL, e, i), r.stencilOp(r.KEEP, r.KEEP, r.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;
+    switch (t) {
+      case 0:
+        this.premultipliedAlpha ? e.blendFuncSeparate(e.ONE, e.ONE_MINUS_SRC_ALPHA, e.ONE, e.ONE_MINUS_SRC_ALPHA) : e.blendFuncSeparate(e.SRC_ALPHA, e.ONE_MINUS_SRC_ALPHA, e.ONE, e.ONE_MINUS_SRC_ALPHA);
+        break;
+      case 1:
+        e.blendFuncSeparate(e.ONE, e.ONE, e.ONE, e.ONE);
+        break;
+      case 2:
+        e.blendFuncSeparate(e.DST_COLOR, e.ONE_MINUS_SRC_ALPHA, e.ONE, e.ONE_MINUS_SRC_ALPHA);
+        break;
+      case 3:
+        e.blendFuncSeparate(e.ONE, e.ONE_MINUS_SRC_COLOR, e.ONE, e.ONE_MINUS_SRC_ALPHA);
+        break;
+      case 4:
+        e.blendFuncSeparate(e.ZERO, e.ONE_MINUS_SRC_ALPHA, e.ZERO, e.ONE_MINUS_SRC_ALPHA);
+        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, i, r) {
+    this.flush();
+    const n = this.gl, a = this.physicsWidth / this.logicWidth, o = this.physicsHeight / this.logicHeight, h = Math.round(t * a), u = Math.round(this.physicsHeight - (e + r) * o), c = Math.round(i * a), m = Math.round(r * o);
+    n.enable(n.SCISSOR_TEST), n.scissor(h, u, c, m);
+  }
+  /**
+   * Disables scissor clipping, restoring full-canvas rendering.
+   */
+  endScissor() {
+    this.flush(), this.gl.disable(this.gl.SCISSOR_TEST);
+  }
+  renderCamera(t) {
+    this.matrixStack.applyTransform(t);
+    const e = this.matrixStack.curWorldM;
+    this.matrix.invert(e);
+  }
+  logicToPhysics(t) {
+    return t.multiply(new l(
+      this.physicsWidth / this.logicWidth,
+      this.physicsHeight / this.logicHeight
+    ));
+  }
+  physicsToLogic(t) {
+    return t.multiply(new l(
+      this.logicWidth / this.physicsWidth,
+      this.logicHeight / this.physicsHeight
+    ));
+  }
+  cssToDevicePixel(t) {
+    return t.mul(this.dpr);
+  }
+  cssToLogic(t) {
+    const e = this.cssToDevicePixel(t);
+    return this.physicsToLogic(e);
+  }
+  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, i = this.physicsHeight / this.dpr / this.logicHeight;
+    return this.matrix.toCSSMatrix(t ?? this.matrixStack.curWorldM, e, i);
+  }
+}
+function jt(s) {
+  return !(s === null || typeof s != "object" || Array.isArray(s) || s instanceof l || s instanceof d);
+}
+class b {
+  /** 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, i, r) {
+    return new l(b.float(t, e), b.float(i, r));
+  }
+  /** Random Color with each component interpolated between minColor and maxColor. */
+  static randomColor(t, e) {
+    return new d(
+      b.float(t.r, e.r),
+      b.float(t.g, e.g),
+      b.float(t.b, e.b),
+      b.float(t.a, e.a)
+    );
+  }
+  /** Pick a random element from an array with uniform probability. */
+  static pick(t) {
+    return t[b.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;
+    for (const [, r] of t) e += r;
+    let i = Math.random() * e;
+    for (const [r, n] of t)
+      if (i -= n, i <= 0) return r;
+    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)) {
+      const [i, r] = t;
+      if (typeof i == "number")
+        return b.float(i, r);
+      if (i instanceof l)
+        return b.vector(i.x, r.x, i.y, r.y);
+      if (i instanceof d)
+        return b.randomColor(i, r);
+    }
+    return typeof t == "number" ? t : t.clone();
+  }
+}
+var qt = /* @__PURE__ */ ((s) => (s.POINT = "point", s.CIRCLE = "circle", s.RECT = "rect", s))(qt || {});
+const ht = 10, ot = 0, ut = !0;
+class Zt {
+  life = 0;
+  maxLife;
+  texture;
+  options;
+  position;
+  datas;
+  rapid;
+  constructor(t, e) {
+    this.rapid = t, this.options = e, e.texture instanceof C ? this.texture = e.texture : e.texture instanceof Array && e.texture[0] instanceof Array ? this.texture = b.pickWeight(e.texture) : e.texture instanceof Array && (this.texture = b.pick(e.texture)), this.maxLife = b.scalarOrRange(e.life, 1), this.datas = {
+      speed: this.processAttribute(e.animation.speed, 0),
+      rotation: this.processAttribute(e.animation.rotation, 0),
+      scale: this.processAttribute(e.animation.scale, 1),
+      color: this.processAttribute(e.animation.color, d.White.clone()),
+      velocity: this.processAttribute(e.animation.velocity, l.ZERO),
+      acceleration: this.processAttribute(e.animation.acceleration, l.ZERO)
+    }, this.position = l.ZERO, this.initializePosition();
+  }
+  processAttribute(t, e) {
+    if (t == null)
+      return { value: e };
+    if (jt(t)) {
+      const i = t, r = b.scalarOrRange(i.start, e), n = i.end === void 0 ? r : b.scalarOrRange(i.end, e);
+      return {
+        delta: i.delta ?? this.getDelta(r, n, this.maxLife),
+        value: r,
+        damping: i.damping
+      };
+    } else
+      return this.processAttribute({ start: t }, e);
+  }
+  updateNumberAttribute(t, e) {
+    t.damping !== void 0 && (t.value *= Math.pow(t.damping, e)), t.delta !== void 0 && (t.value += t.delta * e);
+  }
+  updateVec2Attribute(t, e) {
+    t.damping !== void 0 && (t.value = t.value.multiply(Math.pow(t.damping, e))), t.delta !== void 0 && (t.value = t.value.add(t.delta.multiply(e)));
+  }
+  updateColorAttribute(t, e) {
+    t.damping !== void 0 && (t.value = t.value.multiply(Math.pow(t.damping, e))), t.delta !== void 0 && (t.value = t.value.add(t.delta.multiply(e))), t.value.clamp();
+  }
+  updateAttributes(t) {
+    const e = this.datas;
+    this.updateNumberAttribute(e.speed, t), this.updateNumberAttribute(e.rotation, t), this.updateNumberAttribute(e.scale, t), this.updateColorAttribute(e.color, t), this.updateVec2Attribute(e.velocity, t), this.updateVec2Attribute(e.acceleration, t), e.velocity.value = e.velocity.value.add(
+      e.acceleration.value.multiply(t)
+    );
+    const r = l.fromAngle(e.rotation.value).multiply(e.speed.value * t);
+    this.position = this.position.add(r).add(e.velocity.value.multiply(t));
+  }
+  getDelta(t, e, i) {
+    return typeof t == "number" && typeof e == "number" ? (e - t) / i : t instanceof l && e instanceof l || t instanceof d && e instanceof d ? e.subtract(t).divide(i) : t;
+  }
+  /**
+   * Updates particle state.
+   * @param deltaTime - Seconds elapsed since last frame
+   * @returns `true` while the particle is alive, `false` when it should be removed
+   */
+  update(t) {
+    return this.life += t, this.life >= this.maxLife ? !1 : (this.updateAttributes(t), !0);
+  }
+  /**
+   * Renders the particle using the Rapid engine's matrixStack + drawSprite.
+   * The emitter is responsible for calling save/restore around a batch of particles.
+   */
+  render() {
+    const t = this.rapid.matrixStack, e = this.datas.scale.value, i = this.datas.rotation.value, r = this.datas.color.value;
+    t.save(), t.translate(this.position.x, this.position.y), i !== 0 && t.rotate(i), e !== 1 && t.scale(e, e);
+    const n = this.options.origin ? this.options.origin.x : 0.5, a = this.options.origin ? this.options.origin.y : 0.5;
+    (n !== 0 || a !== 0) && t.translate(-n * this.texture.rawWidth, -a * this.texture.rawHeight), ft(this.rapid, { texture: this.texture, color: r }), t.restore();
+  }
+  initializePosition() {
+    switch (this.options.emitShape) {
+      case "circle": {
+        const t = Math.random() * Math.PI * 2, e = (this.options.emitRadius ?? 0) * Math.sqrt(Math.random());
+        this.position = new l(Math.cos(t) * e, Math.sin(t) * e);
+        break;
+      }
+      case "rect": {
+        this.position = new l(
+          (Math.random() - 0.5) * (this.options.emitRect?.width ?? 0),
+          (Math.random() - 0.5) * (this.options.emitRect?.height ?? 0)
+        );
+        break;
+      }
+      default:
+        this.position = l.ZERO;
+        break;
+    }
+    !this.options.localSpace && this.options.position && (this.position = this.position.add(this.options.position));
+  }
+}
+class xt {
+  particles = [];
+  options;
+  emitting = !1;
+  emitTimer = 0;
+  emitRate = ht;
+  emitTime = ot;
+  emitTimeCounter = 0;
+  /** Whether spawned particles are positioned in local emitter space (default: true). */
+  localSpace = ut;
+  /** World position of the emitter. Used for both local-space transform and world-space spawn offset. */
+  position = l.ZERO;
+  rapid;
+  gameObject;
+  /**
+   * 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 !== void 0 ? e.emitRate : ht, this.emitTime = e.emitTime !== void 0 ? e.emitTime : ot, this.localSpace = e.localSpace !== void 0 ? e.localSpace : ut, this.position = e.position ?? l.ZERO;
+  }
+  /** 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 xt(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() {
+    this.particles = [], this.emitTimeCounter = 0;
+  }
+  /**
+   * Spawns `count` particles immediately.
+   * Respects `maxParticles` if set.
+   */
+  emit(t) {
+    const e = this.options.maxParticles ?? 1 / 0, i = Math.min(t, e - this.particles.length);
+    for (let r = 0; r < i; r++)
+      this.particles.push(new Zt(this.rapid, { ...this.options }));
+  }
+  /**
+   * 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) {
+        if (this.emitTimeCounter += t, this.emitTimeCounter >= this.emitTime) {
+          const e = Math.floor(this.emitTimeCounter / this.emitTime);
+          this.emit(this.emitRate * e), this.emitTimeCounter -= e * this.emitTime;
+        }
+      } else {
+        this.emitTimer += t;
+        const e = Math.floor(this.emitTimer * this.emitRate);
+        e > 0 && (this.emit(e), this.emitTimer -= e / this.emitRate);
+      }
+    for (let e = this.particles.length - 1; e >= 0; e--)
+      this.particles[e].update(t) || this.particles.splice(e, 1);
+  }
+  /**
+   * Renders all live particles.
+   * In local-space mode the emitter's own transform is applied around the batch.
+   */
+  render() {
+    const t = this.rapid.matrixStack;
+    this.localSpace && (t.save(), t.translate(this.position.x, this.position.y));
+    for (const e of this.particles)
+      e.render();
+    this.localSpace && t.restore();
+  }
+  /** Returns the current number of live particles. */
+  getParticleCount() {
+    return this.particles.length;
+  }
+  /** Returns `true` if the emitter is running or still has live particles. */
+  isActive() {
+    return this.emitting || this.particles.length > 0;
+  }
+  /**
+   * Convenience: emit `emitRate` particles in one shot (fire-and-forget burst).
+   */
+  oneShot() {
+    this.emit(this.emitRate);
+  }
+}
+export {
+  N as ArrayType,
+  D as BaseTexture,
+  Kt as BlendMode,
+  $t as CanvasScaleMode,
+  d as Color,
+  rt as CustomGlShader,
+  W as DynamicArrayBuffer,
+  ct as GLShader,
+  Ot as GraphicRegion,
+  Xt as MaskType,
+  gt as MatrixStack,
+  pt as MatrixStore,
+  Zt as Particle,
+  xt as ParticleEmitter,
+  qt as ParticleShape,
+  Qt as Rapid,
+  lt as Region,
+  Tt as RenderTexture,
+  dt as SpriteRegion,
+  Et as TextTexture,
+  C as Texture,
+  Q as TextureFilterMode,
+  vt as TextureManager,
+  H as TextureWrapMode,
+  l as Vec2,
+  j as WebglBufferArray,
+  Yt as drawCircle,
+  mt as drawGraphic,
+  Gt as drawLine,
+  Ht as drawMaskImage,
+  Vt as drawRect,
+  kt as drawSprite,
+  ft as drawSpriteRaw
+};