holostaff-widget 3.0.0-alpha.8 → 3.0.0

package/dist/{RenderTargetSystem-CzB0gbGa.js → RenderTargetSystem-BCBByEgg.js}

@@ -1,6 +1,1012 @@
-import { W as Ve, K as oe, M as m, G as Ne, b as je, a as $e, X as le, i as l, p as W, Y as w, Z as qe, _ as z, $ as T, R as V, a0 as de, a1 as Ke, T as f, c as g, I as D, a2 as ue, w as ce, a3 as ee, a4 as he, a5 as pe, a6 as fe, a7 as me, t as P, a8 as Ye, C as E, D as N, J as y, a9 as B, aa as Je, P as Xe, ab as Ze, z as Qe, q as te, ac as re, ad as p, e as et, o as O, ae as tt, af as rt, ag as st, ah as nt } from "./index-X9A71QD8.js";
-import { F as at } from "./Filter-CD8NI4d3.js";
-var it = `in vec2 vMaskCoord;
+import { a as ze, i as T, G as He, w as te, c as u, t as Ct, M, e as re, l as V, x as St, B as se, y as G, F as Ve, S as kt, T as S, d as Q, z as xe, H as Fe, J as Le, K as We, L as Oe, C as F, N as wt, k as Y, D as ne, g as I, R as L, O as Mt, P as Bt, b as ge, Q as _e, f as X, p as Rt, W as Pt, X as At } from "./index-C1ZbqCjI.js";
+import { f as Ut, e as Gt, a as be, b as z, G as $e, h as je, U as ie, d as It, F as Dt, S as Et, R as ae, B as zt } from "./Geometry-Bdq2tsB3.js";
+class ve {
+  constructor(e) {
+    typeof e == "number" ? this.rawBinaryData = new ArrayBuffer(e) : e instanceof Uint8Array ? this.rawBinaryData = e.buffer : this.rawBinaryData = e, this.uint32View = new Uint32Array(this.rawBinaryData), this.float32View = new Float32Array(this.rawBinaryData), this.size = this.rawBinaryData.byteLength;
+  }
+  /** View on the raw binary data as a `Int8Array`. */
+  get int8View() {
+    return this._int8View || (this._int8View = new Int8Array(this.rawBinaryData)), this._int8View;
+  }
+  /** View on the raw binary data as a `Uint8Array`. */
+  get uint8View() {
+    return this._uint8View || (this._uint8View = new Uint8Array(this.rawBinaryData)), this._uint8View;
+  }
+  /**  View on the raw binary data as a `Int16Array`. */
+  get int16View() {
+    return this._int16View || (this._int16View = new Int16Array(this.rawBinaryData)), this._int16View;
+  }
+  /** View on the raw binary data as a `Int32Array`. */
+  get int32View() {
+    return this._int32View || (this._int32View = new Int32Array(this.rawBinaryData)), this._int32View;
+  }
+  /** View on the raw binary data as a `Float64Array`. */
+  get float64View() {
+    return this._float64Array || (this._float64Array = new Float64Array(this.rawBinaryData)), this._float64Array;
+  }
+  /** View on the raw binary data as a `BigUint64Array`. */
+  get bigUint64View() {
+    return this._bigUint64Array || (this._bigUint64Array = new BigUint64Array(this.rawBinaryData)), this._bigUint64Array;
+  }
+  /**
+   * Returns the view of the given type.
+   * @param type - One of `int8`, `uint8`, `int16`,
+   *    `uint16`, `int32`, `uint32`, and `float32`.
+   * @returns - typed array of given type
+   */
+  view(e) {
+    return this[`${e}View`];
+  }
+  /** Destroys all buffer references. Do not use after calling this. */
+  destroy() {
+    this.rawBinaryData = null, this.uint32View = null, this.float32View = null, this.uint16View = null, this._int8View = null, this._uint8View = null, this._int16View = null, this._int32View = null, this._float64Array = null, this._bigUint64Array = null;
+  }
+  /**
+   * Returns the size of the given type in bytes.
+   * @param type - One of `int8`, `uint8`, `int16`,
+   *   `uint16`, `int32`, `uint32`, and `float32`.
+   * @returns - size of the type in bytes
+   */
+  static sizeOf(e) {
+    switch (e) {
+      case "int8":
+      case "uint8":
+        return 1;
+      case "int16":
+      case "uint16":
+        return 2;
+      case "int32":
+      case "uint32":
+      case "float32":
+        return 4;
+      default:
+        throw new Error(`${e} isn't a valid view type`);
+    }
+  }
+}
+function ye(n, e, t, r) {
+  if (t ?? (t = 0), r ?? (r = Math.min(n.byteLength - t, e.byteLength)), !(t & 7) && !(r & 7)) {
+    const s = r / 8;
+    new Float64Array(e, 0, s).set(new Float64Array(n, t, s));
+  } else if (!(t & 3) && !(r & 3)) {
+    const s = r / 4;
+    new Float32Array(e, 0, s).set(new Float32Array(n, t, s));
+  } else
+    new Uint8Array(e).set(new Uint8Array(n, t, r));
+}
+const Ht = {
+  normal: "normal-npm",
+  add: "add-npm",
+  screen: "screen-npm"
+};
+var k = /* @__PURE__ */ ((n) => (n[n.DISABLED = 0] = "DISABLED", n[n.RENDERING_MASK_ADD = 1] = "RENDERING_MASK_ADD", n[n.MASK_ACTIVE = 2] = "MASK_ACTIVE", n[n.INVERSE_MASK_ACTIVE = 3] = "INVERSE_MASK_ACTIVE", n[n.RENDERING_MASK_REMOVE = 4] = "RENDERING_MASK_REMOVE", n[n.NONE = 5] = "NONE", n))(k || {});
+function Te(n, e) {
+  return e.alphaMode === "no-premultiply-alpha" && Ht[n] || n;
+}
+const Vt = [
+  "precision mediump float;",
+  "void main(void){",
+  "float test = 0.1;",
+  "%forloop%",
+  "gl_FragColor = vec4(0.0);",
+  "}"
+].join(`
+`);
+function Ft(n) {
+  let e = "";
+  for (let t = 0; t < n; ++t)
+    t > 0 && (e += `
+else `), t < n - 1 && (e += `if(test == ${t}.0){}`);
+  return e;
+}
+function Lt(n, e) {
+  if (n === 0)
+    throw new Error("Invalid value of `0` passed to `checkMaxIfStatementsInShader`");
+  const t = e.createShader(e.FRAGMENT_SHADER);
+  try {
+    for (; ; ) {
+      const r = Vt.replace(/%forloop%/gi, Ft(n));
+      if (e.shaderSource(t, r), e.compileShader(t), !e.getShaderParameter(t, e.COMPILE_STATUS))
+        n = n / 2 | 0;
+      else
+        break;
+    }
+  } finally {
+    e.deleteShader(t);
+  }
+  return n;
+}
+let R = null;
+function Wt() {
+  var e;
+  if (R) return R;
+  const n = Ut();
+  return R = n.getParameter(n.MAX_TEXTURE_IMAGE_UNITS), R = Lt(
+    R,
+    n
+  ), (e = n.getExtension("WEBGL_lose_context")) == null || e.loseContext(), R;
+}
+class Ot {
+  constructor() {
+    this.ids = /* @__PURE__ */ Object.create(null), this.textures = [], this.count = 0;
+  }
+  /** Clear the textures and their locations. */
+  clear() {
+    for (let e = 0; e < this.count; e++) {
+      const t = this.textures[e];
+      this.textures[e] = null, this.ids[t.uid] = null;
+    }
+    this.count = 0;
+  }
+}
+class $t {
+  constructor() {
+    this.renderPipeId = "batch", this.action = "startBatch", this.start = 0, this.size = 0, this.textures = new Ot(), this.blendMode = "normal", this.topology = "triangle-strip", this.canBundle = !0;
+  }
+  destroy() {
+    this.textures = null, this.gpuBindGroup = null, this.bindGroup = null, this.batcher = null, this.elements = null;
+  }
+}
+const D = [];
+let W = 0;
+He.register({
+  clear: () => {
+    if (D.length > 0)
+      for (const n of D)
+        n && n.destroy();
+    D.length = 0, W = 0;
+  }
+});
+function Ce() {
+  return W > 0 ? D[--W] : new $t();
+}
+function Se(n) {
+  n.elements = null, D[W++] = n;
+}
+let A = 0;
+const Ne = class Ke {
+  constructor(e) {
+    this.uid = ze("batcher"), this.dirty = !0, this.batchIndex = 0, this.batches = [], this._elements = [], e = { ...Ke.defaultOptions, ...e }, e.maxTextures || (T("v8.8.0", "maxTextures is a required option for Batcher now, please pass it in the options"), e.maxTextures = Wt());
+    const { maxTextures: t, attributesInitialSize: r, indicesInitialSize: s } = e;
+    this.attributeBuffer = new ve(r * 4), this.indexBuffer = new Uint16Array(s), this.maxTextures = t;
+  }
+  begin() {
+    this.elementSize = 0, this.elementStart = 0, this.indexSize = 0, this.attributeSize = 0;
+    for (let e = 0; e < this.batchIndex; e++)
+      Se(this.batches[e]);
+    this.batchIndex = 0, this._batchIndexStart = 0, this._batchIndexSize = 0, this.dirty = !0;
+  }
+  add(e) {
+    this._elements[this.elementSize++] = e, e._indexStart = this.indexSize, e._attributeStart = this.attributeSize, e._batcher = this, this.indexSize += e.indexSize, this.attributeSize += e.attributeSize * this.vertexSize;
+  }
+  checkAndUpdateTexture(e, t) {
+    const r = e._batch.textures.ids[t._source.uid];
+    return !r && r !== 0 ? !1 : (e._textureId = r, e.texture = t, !0);
+  }
+  updateElement(e) {
+    this.dirty = !0;
+    const t = this.attributeBuffer;
+    e.packAsQuad ? this.packQuadAttributes(
+      e,
+      t.float32View,
+      t.uint32View,
+      e._attributeStart,
+      e._textureId
+    ) : this.packAttributes(
+      e,
+      t.float32View,
+      t.uint32View,
+      e._attributeStart,
+      e._textureId
+    );
+  }
+  /**
+   * breaks the batcher. This happens when a batch gets too big,
+   * or we need to switch to a different type of rendering (a filter for example)
+   * @param instructionSet
+   */
+  break(e) {
+    const t = this._elements;
+    if (!t[this.elementStart]) return;
+    let r = Ce(), s = r.textures;
+    s.clear();
+    const i = t[this.elementStart];
+    let a = Te(i.blendMode, i.texture._source), o = i.topology;
+    this.attributeSize * 4 > this.attributeBuffer.size && this._resizeAttributeBuffer(this.attributeSize * 4), this.indexSize > this.indexBuffer.length && this._resizeIndexBuffer(this.indexSize);
+    const l = this.attributeBuffer.float32View, d = this.attributeBuffer.uint32View, f = this.indexBuffer;
+    let c = this._batchIndexSize, x = this._batchIndexStart, g = "startBatch", m = [];
+    const v = this.maxTextures;
+    for (let _ = this.elementStart; _ < this.elementSize; ++_) {
+      const h = t[_];
+      t[_] = null;
+      const p = h.texture._source, y = Te(h.blendMode, p), b = a !== y || o !== h.topology;
+      if (p._batchTick === A && !b) {
+        h._textureId = p._textureBindLocation, c += h.indexSize, h.packAsQuad ? (this.packQuadAttributes(
+          h,
+          l,
+          d,
+          h._attributeStart,
+          h._textureId
+        ), this.packQuadIndex(
+          f,
+          h._indexStart,
+          h._attributeStart / this.vertexSize
+        )) : (this.packAttributes(
+          h,
+          l,
+          d,
+          h._attributeStart,
+          h._textureId
+        ), this.packIndex(
+          h,
+          f,
+          h._indexStart,
+          h._attributeStart / this.vertexSize
+        )), h._batch = r, m.push(h);
+        continue;
+      }
+      p._batchTick = A, (s.count >= v || b) && (this._finishBatch(
+        r,
+        x,
+        c - x,
+        s,
+        a,
+        o,
+        e,
+        g,
+        m
+      ), g = "renderBatch", x = c, a = y, o = h.topology, r = Ce(), s = r.textures, s.clear(), m = [], ++A), h._textureId = p._textureBindLocation = s.count, s.ids[p.uid] = s.count, s.textures[s.count++] = p, h._batch = r, m.push(h), c += h.indexSize, h.packAsQuad ? (this.packQuadAttributes(
+        h,
+        l,
+        d,
+        h._attributeStart,
+        h._textureId
+      ), this.packQuadIndex(
+        f,
+        h._indexStart,
+        h._attributeStart / this.vertexSize
+      )) : (this.packAttributes(
+        h,
+        l,
+        d,
+        h._attributeStart,
+        h._textureId
+      ), this.packIndex(
+        h,
+        f,
+        h._indexStart,
+        h._attributeStart / this.vertexSize
+      ));
+    }
+    s.count > 0 && (this._finishBatch(
+      r,
+      x,
+      c - x,
+      s,
+      a,
+      o,
+      e,
+      g,
+      m
+    ), x = c, ++A), this.elementStart = this.elementSize, this._batchIndexStart = x, this._batchIndexSize = c;
+  }
+  _finishBatch(e, t, r, s, i, a, o, l, d) {
+    e.gpuBindGroup = null, e.bindGroup = null, e.action = l, e.batcher = this, e.textures = s, e.blendMode = i, e.topology = a, e.start = t, e.size = r, e.elements = d, ++A, this.batches[this.batchIndex++] = e, o.add(e);
+  }
+  finish(e) {
+    this.break(e);
+  }
+  /**
+   * Resizes the attribute buffer to the given size (1 = 1 float32)
+   * @param size - the size in vertices to ensure (not bytes!)
+   */
+  ensureAttributeBuffer(e) {
+    e * 4 <= this.attributeBuffer.size || this._resizeAttributeBuffer(e * 4);
+  }
+  /**
+   * Resizes the index buffer to the given size (1 = 1 float32)
+   * @param size - the size in vertices to ensure (not bytes!)
+   */
+  ensureIndexBuffer(e) {
+    e <= this.indexBuffer.length || this._resizeIndexBuffer(e);
+  }
+  _resizeAttributeBuffer(e) {
+    const t = Math.max(e, this.attributeBuffer.size * 2), r = new ve(t);
+    ye(this.attributeBuffer.rawBinaryData, r.rawBinaryData), this.attributeBuffer = r;
+  }
+  _resizeIndexBuffer(e) {
+    const t = this.indexBuffer;
+    let r = Math.max(e, t.length * 1.5);
+    r += r % 2;
+    const s = r > 65535 ? new Uint32Array(r) : new Uint16Array(r);
+    if (s.BYTES_PER_ELEMENT !== t.BYTES_PER_ELEMENT)
+      for (let i = 0; i < t.length; i++)
+        s[i] = t[i];
+    else
+      ye(t.buffer, s.buffer);
+    this.indexBuffer = s;
+  }
+  packQuadIndex(e, t, r) {
+    e[t] = r + 0, e[t + 1] = r + 1, e[t + 2] = r + 2, e[t + 3] = r + 0, e[t + 4] = r + 2, e[t + 5] = r + 3;
+  }
+  packIndex(e, t, r, s) {
+    const i = e.indices, a = e.indexSize, o = e.indexOffset, l = e.attributeOffset;
+    for (let d = 0; d < a; d++)
+      t[r++] = s + i[d + o] - l;
+  }
+  /**
+   * Destroys the batch and its resources.
+   * @param options - destruction options
+   * @param options.shader - whether to destroy the associated shader
+   */
+  destroy(e = {}) {
+    var t;
+    if (this.batches !== null) {
+      for (let r = 0; r < this.batchIndex; r++)
+        Se(this.batches[r]);
+      this.batches = null, this.geometry.destroy(!0), this.geometry = null, e.shader && ((t = this.shader) == null || t.destroy(), this.shader = null);
+      for (let r = 0; r < this._elements.length; r++)
+        this._elements[r] && (this._elements[r]._batch = null);
+      this._elements = null, this.indexBuffer = null, this.attributeBuffer.destroy(), this.attributeBuffer = null;
+    }
+  }
+};
+Ne.defaultOptions = {
+  maxTextures: null,
+  attributesInitialSize: 4,
+  indicesInitialSize: 6
+};
+let jt = Ne;
+const Nt = new Float32Array(1), Kt = new Uint32Array(1);
+class qt extends Gt {
+  constructor() {
+    const t = new be({
+      data: Nt,
+      label: "attribute-batch-buffer",
+      usage: z.VERTEX | z.COPY_DST,
+      shrinkToFit: !1
+    }), r = new be({
+      data: Kt,
+      label: "index-batch-buffer",
+      usage: z.INDEX | z.COPY_DST,
+      // | BufferUsage.STATIC,
+      shrinkToFit: !1
+    }), s = 24;
+    super({
+      attributes: {
+        aPosition: {
+          buffer: t,
+          format: "float32x2",
+          stride: s,
+          offset: 0
+        },
+        aUV: {
+          buffer: t,
+          format: "float32x2",
+          stride: s,
+          offset: 8
+        },
+        aColor: {
+          buffer: t,
+          format: "unorm8x4",
+          stride: s,
+          offset: 16
+        },
+        aTextureIdAndRound: {
+          buffer: t,
+          format: "uint16x2",
+          stride: s,
+          offset: 20
+        }
+      },
+      indexBuffer: r
+    });
+  }
+}
+function ke(n, e, t) {
+  if (n)
+    for (const r in n) {
+      const s = r.toLocaleLowerCase(), i = e[s];
+      if (i) {
+        let a = n[r];
+        r === "header" && (a = a.replace(/@in\s+[^;]+;\s*/g, "").replace(/@out\s+[^;]+;\s*/g, "")), t && i.push(`//----${t}----//`), i.push(a);
+      } else
+        te(`${r} placement hook does not exist in shader`);
+    }
+}
+const Qt = /\{\{(.*?)\}\}/g;
+function we(n) {
+  var r;
+  const e = {};
+  return (((r = n.match(Qt)) == null ? void 0 : r.map((s) => s.replace(/[{()}]/g, ""))) ?? []).forEach((s) => {
+    e[s] = [];
+  }), e;
+}
+function Me(n, e) {
+  let t;
+  const r = /@in\s+([^;]+);/g;
+  for (; (t = r.exec(n)) !== null; )
+    e.push(t[1]);
+}
+function Be(n, e, t = !1) {
+  const r = [];
+  Me(e, r), n.forEach((o) => {
+    o.header && Me(o.header, r);
+  });
+  const s = r;
+  t && s.sort();
+  const i = s.map((o, l) => `       @location(${l}) ${o},`).join(`
+`);
+  let a = e.replace(/@in\s+[^;]+;\s*/g, "");
+  return a = a.replace("{{in}}", `
+${i}
+`), a;
+}
+function Re(n, e) {
+  let t;
+  const r = /@out\s+([^;]+);/g;
+  for (; (t = r.exec(n)) !== null; )
+    e.push(t[1]);
+}
+function Yt(n) {
+  const t = /\b(\w+)\s*:/g.exec(n);
+  return t ? t[1] : "";
+}
+function Xt(n) {
+  const e = /@.*?\s+/g;
+  return n.replace(e, "");
+}
+function Jt(n, e) {
+  const t = [];
+  Re(e, t), n.forEach((l) => {
+    l.header && Re(l.header, t);
+  });
+  let r = 0;
+  const s = t.sort().map((l) => l.indexOf("builtin") > -1 ? l : `@location(${r++}) ${l}`).join(`,
+`), i = t.sort().map((l) => `       var ${Xt(l)};`).join(`
+`), a = `return VSOutput(
+            ${t.sort().map((l) => ` ${Yt(l)}`).join(`,
+`)});`;
+  let o = e.replace(/@out\s+[^;]+;\s*/g, "");
+  return o = o.replace("{{struct}}", `
+${s}
+`), o = o.replace("{{start}}", `
+${i}
+`), o = o.replace("{{return}}", `
+${a}
+`), o;
+}
+function Pe(n, e) {
+  let t = n;
+  for (const r in e) {
+    const s = e[r];
+    s.join(`
+`).length ? t = t.replace(`{{${r}}}`, `//-----${r} START-----//
+${s.join(`
+`)}
+//----${r} FINISH----//`) : t = t.replace(`{{${r}}}`, "");
+  }
+  return t;
+}
+const w = /* @__PURE__ */ Object.create(null), j = /* @__PURE__ */ new Map();
+let Zt = 0;
+function er({
+  template: n,
+  bits: e
+}) {
+  const t = qe(n, e);
+  if (w[t]) return w[t];
+  const { vertex: r, fragment: s } = rr(n, e);
+  return w[t] = Qe(r, s, e), w[t];
+}
+function tr({
+  template: n,
+  bits: e
+}) {
+  const t = qe(n, e);
+  return w[t] || (w[t] = Qe(n.vertex, n.fragment, e)), w[t];
+}
+function rr(n, e) {
+  const t = e.map((a) => a.vertex).filter((a) => !!a), r = e.map((a) => a.fragment).filter((a) => !!a);
+  let s = Be(t, n.vertex, !0);
+  s = Jt(t, s);
+  const i = Be(r, n.fragment, !0);
+  return {
+    vertex: s,
+    fragment: i
+  };
+}
+function qe(n, e) {
+  return e.map((t) => (j.has(t) || j.set(t, Zt++), j.get(t))).sort((t, r) => t - r).join("-") + n.vertex + n.fragment;
+}
+function Qe(n, e, t) {
+  const r = we(n), s = we(e);
+  return t.forEach((i) => {
+    ke(i.vertex, r, i.name), ke(i.fragment, s, i.name);
+  }), {
+    vertex: Pe(n, r),
+    fragment: Pe(e, s)
+  };
+}
+const sr = (
+  /* wgsl */
+  `
+    @in aPosition: vec2<f32>;
+    @in aUV: vec2<f32>;
+
+    @out @builtin(position) vPosition: vec4<f32>;
+    @out vUV : vec2<f32>;
+    @out vColor : vec4<f32>;
+
+    {{header}}
+
+    struct VSOutput {
+        {{struct}}
+    };
+
+    @vertex
+    fn main( {{in}} ) -> VSOutput {
+
+        var worldTransformMatrix = globalUniforms.uWorldTransformMatrix;
+        var modelMatrix = mat3x3<f32>(
+            1.0, 0.0, 0.0,
+            0.0, 1.0, 0.0,
+            0.0, 0.0, 1.0
+          );
+        var position = aPosition;
+        var uv = aUV;
+
+        {{start}}
+
+        vColor = vec4<f32>(1., 1., 1., 1.);
+
+        {{main}}
+
+        vUV = uv;
+
+        var modelViewProjectionMatrix = globalUniforms.uProjectionMatrix * worldTransformMatrix * modelMatrix;
+
+        vPosition =  vec4<f32>((modelViewProjectionMatrix *  vec3<f32>(position, 1.0)).xy, 0.0, 1.0);
+
+        vColor *= globalUniforms.uWorldColorAlpha;
+
+        {{end}}
+
+        {{return}}
+    };
+`
+), nr = (
+  /* wgsl */
+  `
+    @in vUV : vec2<f32>;
+    @in vColor : vec4<f32>;
+
+    {{header}}
+
+    @fragment
+    fn main(
+        {{in}}
+      ) -> @location(0) vec4<f32> {
+
+        {{start}}
+
+        var outColor:vec4<f32>;
+
+        {{main}}
+
+        var finalColor:vec4<f32> = outColor * vColor;
+
+        {{end}}
+
+        return finalColor;
+      };
+`
+), ir = (
+  /* glsl */
+  `
+    in vec2 aPosition;
+    in vec2 aUV;
+
+    out vec4 vColor;
+    out vec2 vUV;
+
+    {{header}}
+
+    void main(void){
+
+        mat3 worldTransformMatrix = uWorldTransformMatrix;
+        mat3 modelMatrix = mat3(
+            1.0, 0.0, 0.0,
+            0.0, 1.0, 0.0,
+            0.0, 0.0, 1.0
+          );
+        vec2 position = aPosition;
+        vec2 uv = aUV;
+
+        {{start}}
+
+        vColor = vec4(1.);
+
+        {{main}}
+
+        vUV = uv;
+
+        mat3 modelViewProjectionMatrix = uProjectionMatrix * worldTransformMatrix * modelMatrix;
+
+        gl_Position = vec4((modelViewProjectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);
+
+        vColor *= uWorldColorAlpha;
+
+        {{end}}
+    }
+`
+), ar = (
+  /* glsl */
+  `
+
+    in vec4 vColor;
+    in vec2 vUV;
+
+    out vec4 finalColor;
+
+    {{header}}
+
+    void main(void) {
+
+        {{start}}
+
+        vec4 outColor;
+
+        {{main}}
+
+        finalColor = outColor * vColor;
+
+        {{end}}
+    }
+`
+), or = {
+  name: "global-uniforms-bit",
+  vertex: {
+    header: (
+      /* wgsl */
+      `
+        struct GlobalUniforms {
+            uProjectionMatrix:mat3x3<f32>,
+            uWorldTransformMatrix:mat3x3<f32>,
+            uWorldColorAlpha: vec4<f32>,
+            uResolution: vec2<f32>,
+        }
+
+        @group(0) @binding(0) var<uniform> globalUniforms : GlobalUniforms;
+        `
+    )
+  }
+}, lr = {
+  name: "global-uniforms-bit",
+  vertex: {
+    header: (
+      /* glsl */
+      `
+          uniform mat3 uProjectionMatrix;
+          uniform mat3 uWorldTransformMatrix;
+          uniform vec4 uWorldColorAlpha;
+          uniform vec2 uResolution;
+        `
+    )
+  }
+};
+function ur({ bits: n, name: e }) {
+  const t = er({
+    template: {
+      fragment: nr,
+      vertex: sr
+    },
+    bits: [
+      or,
+      ...n
+    ]
+  });
+  return je.from({
+    name: e,
+    vertex: {
+      source: t.vertex,
+      entryPoint: "main"
+    },
+    fragment: {
+      source: t.fragment,
+      entryPoint: "main"
+    }
+  });
+}
+function cr({ bits: n, name: e }) {
+  return new $e({
+    name: e,
+    ...tr({
+      template: {
+        vertex: ir,
+        fragment: ar
+      },
+      bits: [
+        lr,
+        ...n
+      ]
+    })
+  });
+}
+const dr = {
+  name: "color-bit",
+  vertex: {
+    header: (
+      /* wgsl */
+      `
+            @in aColor: vec4<f32>;
+        `
+    ),
+    main: (
+      /* wgsl */
+      `
+            vColor *= vec4<f32>(aColor.rgb * aColor.a, aColor.a);
+        `
+    )
+  }
+}, hr = {
+  name: "color-bit",
+  vertex: {
+    header: (
+      /* glsl */
+      `
+            in vec4 aColor;
+        `
+    ),
+    main: (
+      /* glsl */
+      `
+            vColor *= vec4(aColor.rgb * aColor.a, aColor.a);
+        `
+    )
+  }
+}, N = {};
+function fr(n) {
+  const e = [];
+  if (n === 1)
+    e.push("@group(1) @binding(0) var textureSource1: texture_2d<f32>;"), e.push("@group(1) @binding(1) var textureSampler1: sampler;");
+  else {
+    let t = 0;
+    for (let r = 0; r < n; r++)
+      e.push(`@group(1) @binding(${t++}) var textureSource${r + 1}: texture_2d<f32>;`), e.push(`@group(1) @binding(${t++}) var textureSampler${r + 1}: sampler;`);
+  }
+  return e.join(`
+`);
+}
+function pr(n) {
+  const e = [];
+  if (n === 1)
+    e.push("outColor = textureSampleGrad(textureSource1, textureSampler1, vUV, uvDx, uvDy);");
+  else {
+    e.push("switch vTextureId {");
+    for (let t = 0; t < n; t++)
+      t === n - 1 ? e.push("  default:{") : e.push(`  case ${t}:{`), e.push(`      outColor = textureSampleGrad(textureSource${t + 1}, textureSampler${t + 1}, vUV, uvDx, uvDy);`), e.push("      break;}");
+    e.push("}");
+  }
+  return e.join(`
+`);
+}
+function mr(n) {
+  return N[n] || (N[n] = {
+    name: "texture-batch-bit",
+    vertex: {
+      header: `
+                @in aTextureIdAndRound: vec2<u32>;
+                @out @interpolate(flat) vTextureId : u32;
+            `,
+      main: `
+                vTextureId = aTextureIdAndRound.y;
+            `,
+      end: `
+                if(aTextureIdAndRound.x == 1)
+                {
+                    vPosition = vec4<f32>(roundPixels(vPosition.xy, globalUniforms.uResolution), vPosition.zw);
+                }
+            `
+    },
+    fragment: {
+      header: `
+                @in @interpolate(flat) vTextureId: u32;
+
+                ${fr(n)}
+            `,
+      main: `
+                var uvDx = dpdx(vUV);
+                var uvDy = dpdy(vUV);
+
+                ${pr(n)}
+            `
+    }
+  }), N[n];
+}
+const K = {};
+function xr(n) {
+  const e = [];
+  for (let t = 0; t < n; t++)
+    t > 0 && e.push("else"), t < n - 1 && e.push(`if(vTextureId < ${t}.5)`), e.push("{"), e.push(`	outColor = texture(uTextures[${t}], vUV);`), e.push("}");
+  return e.join(`
+`);
+}
+function gr(n) {
+  return K[n] || (K[n] = {
+    name: "texture-batch-bit",
+    vertex: {
+      header: `
+                in vec2 aTextureIdAndRound;
+                out float vTextureId;
+
+            `,
+      main: `
+                vTextureId = aTextureIdAndRound.y;
+            `,
+      end: `
+                if(aTextureIdAndRound.x == 1.)
+                {
+                    gl_Position.xy = roundPixels(gl_Position.xy, uResolution);
+                }
+            `
+    },
+    fragment: {
+      header: `
+                in float vTextureId;
+
+                uniform sampler2D uTextures[${n}];
+
+            `,
+      main: `
+
+                ${xr(n)}
+            `
+    }
+  }), K[n];
+}
+const _r = {
+  name: "round-pixels-bit",
+  vertex: {
+    header: (
+      /* wgsl */
+      `
+            fn roundPixels(position: vec2<f32>, targetSize: vec2<f32>) -> vec2<f32>
+            {
+                return (floor(((position * 0.5 + 0.5) * targetSize) + 0.5) / targetSize) * 2.0 - 1.0;
+            }
+        `
+    )
+  }
+}, br = {
+  name: "round-pixels-bit",
+  vertex: {
+    header: (
+      /* glsl */
+      `
+            vec2 roundPixels(vec2 position, vec2 targetSize)
+            {
+                return (floor(((position * 0.5 + 0.5) * targetSize) + 0.5) / targetSize) * 2.0 - 1.0;
+            }
+        `
+    )
+  }
+}, Ae = {};
+function vr(n) {
+  let e = Ae[n];
+  if (e) return e;
+  const t = new Int32Array(n);
+  for (let r = 0; r < n; r++)
+    t[r] = r;
+  return e = Ae[n] = new ie({
+    uTextures: { value: t, type: "i32", size: n }
+  }, { isStatic: !0 }), e;
+}
+class Ue extends It {
+  constructor(e) {
+    const t = cr({
+      name: "batch",
+      bits: [
+        hr,
+        gr(e),
+        br
+      ]
+    }), r = ur({
+      name: "batch",
+      bits: [
+        dr,
+        mr(e),
+        _r
+      ]
+    });
+    super({
+      glProgram: t,
+      gpuProgram: r,
+      resources: {
+        batchSamplers: vr(e)
+      }
+    }), this.maxTextures = e;
+  }
+}
+let U = null;
+const Ye = class Xe extends jt {
+  constructor(e) {
+    super(e), this.geometry = new qt(), this.name = Xe.extension.name, this.vertexSize = 6, U ?? (U = new Ue(e.maxTextures)), this.shader = U;
+  }
+  /**
+   * Packs the attributes of a DefaultBatchableMeshElement into the provided views.
+   * @param element - The DefaultBatchableMeshElement to pack.
+   * @param float32View - The Float32Array view to pack into.
+   * @param uint32View - The Uint32Array view to pack into.
+   * @param index - The starting index in the views.
+   * @param textureId - The texture ID to use.
+   */
+  packAttributes(e, t, r, s, i) {
+    const a = i << 16 | e.roundPixels & 65535, o = e.transform, l = o.a, d = o.b, f = o.c, c = o.d, x = o.tx, g = o.ty, { positions: m, uvs: v } = e, _ = e.color, h = e.attributeOffset, C = h + e.attributeSize;
+    for (let p = h; p < C; p++) {
+      const y = p * 2, b = m[y], B = m[y + 1];
+      t[s++] = l * b + f * B + x, t[s++] = c * B + d * b + g, t[s++] = v[y], t[s++] = v[y + 1], r[s++] = _, r[s++] = a;
+    }
+  }
+  /**
+   * Packs the attributes of a DefaultBatchableQuadElement into the provided views.
+   * @param element - The DefaultBatchableQuadElement to pack.
+   * @param float32View - The Float32Array view to pack into.
+   * @param uint32View - The Uint32Array view to pack into.
+   * @param index - The starting index in the views.
+   * @param textureId - The texture ID to use.
+   */
+  packQuadAttributes(e, t, r, s, i) {
+    const a = e.texture, o = e.transform, l = o.a, d = o.b, f = o.c, c = o.d, x = o.tx, g = o.ty, m = e.bounds, v = m.maxX, _ = m.minX, h = m.maxY, C = m.minY, p = a.uvs, y = e.color, b = i << 16 | e.roundPixels & 65535;
+    t[s + 0] = l * _ + f * C + x, t[s + 1] = c * C + d * _ + g, t[s + 2] = p.x0, t[s + 3] = p.y0, r[s + 4] = y, r[s + 5] = b, t[s + 6] = l * v + f * C + x, t[s + 7] = c * C + d * v + g, t[s + 8] = p.x1, t[s + 9] = p.y1, r[s + 10] = y, r[s + 11] = b, t[s + 12] = l * v + f * h + x, t[s + 13] = c * h + d * v + g, t[s + 14] = p.x2, t[s + 15] = p.y2, r[s + 16] = y, r[s + 17] = b, t[s + 18] = l * _ + f * h + x, t[s + 19] = c * h + d * _ + g, t[s + 20] = p.x3, t[s + 21] = p.y3, r[s + 22] = y, r[s + 23] = b;
+  }
+  /**
+   * Updates the maximum number of textures that can be used in the shader.
+   * @param maxTextures - The maximum number of textures that can be used in the shader.
+   * @internal
+   */
+  _updateMaxTextures(e) {
+    this.shader.maxTextures !== e && (U = new Ue(e), this.shader = U);
+  }
+  destroy() {
+    this.shader = null, super.destroy();
+  }
+};
+Ye.extension = {
+  type: [
+    u.Batcher
+  ],
+  name: "default"
+};
+let Je = Ye;
+class qr {
+  constructor(e) {
+    this.items = /* @__PURE__ */ Object.create(null);
+    const { renderer: t, type: r, onUnload: s, priority: i, name: a } = e;
+    this._renderer = t, t.gc.addResourceHash(this, "items", r, i ?? 0), this._onUnload = s, this.name = a;
+  }
+  /**
+   * Add an item to the hash. No-op if already added.
+   * @param item
+   * @returns true if the item was added, false if it was already in the hash
+   */
+  add(e) {
+    return this.items[e.uid] ? !1 : (this.items[e.uid] = e, e.once("unload", this.remove, this), e._gcLastUsed = this._renderer.gc.now, !0);
+  }
+  remove(e, ...t) {
+    var s;
+    if (!this.items[e.uid]) return;
+    const r = e._gpuData[this._renderer.uid];
+    r && ((s = this._onUnload) == null || s.call(this, e, ...t), r.destroy(), e._gpuData[this._renderer.uid] = null, this.items[e.uid] = null);
+  }
+  removeAll(...e) {
+    Object.values(this.items).forEach((t) => t && this.remove(t, ...e));
+  }
+  destroy(...e) {
+    this.removeAll(...e), this.items = /* @__PURE__ */ Object.create(null), this._renderer = null, this._onUnload = null;
+  }
+}
+var yr = `in vec2 vMaskCoord;
 in vec2 vTextureCoord;
 
 uniform sampler2D uTexture;
@@ -34,7 +1040,7 @@ void main(void)
 
     finalColor = original * a;
 }
-`, ot = `in vec2 aPosition;
+`, Tr = `in vec2 aPosition;
 
 out vec2 vTextureCoord;
 out vec2 vMaskCoord;
@@ -71,7 +1077,7 @@ void main(void)
     vTextureCoord = filterTextureCoord(aPosition);
     vMaskCoord = getFilterCoord(aPosition);
 }
-`, se = `struct GlobalFilterUniforms {
+`, Ge = `struct GlobalFilterUniforms {
   uInputSize:vec4<f32>,
   uInputPixel:vec4<f32>,
   uInputClamp:vec4<f32>,
@@ -170,34 +1176,34 @@ fn mainFragment(
     return source * a;
 }
 `;
-class lt extends at {
+class Cr extends Dt {
   constructor(e) {
-    const { sprite: t, ...r } = e, s = new Ve(t.texture), n = new oe({
-      uFilterMatrix: { value: new m(), type: "mat3x3<f32>" },
+    const { sprite: t, ...r } = e, s = new Ct(t.texture), i = new ie({
+      uFilterMatrix: { value: new M(), type: "mat3x3<f32>" },
       uMaskClamp: { value: s.uClampFrame, type: "vec4<f32>" },
       uAlpha: { value: 1, type: "f32" },
       uInverse: { value: e.inverse ? 1 : 0, type: "f32" }
-    }), i = Ne.from({
+    }), a = je.from({
       vertex: {
-        source: se,
+        source: Ge,
         entryPoint: "mainVertex"
       },
       fragment: {
-        source: se,
+        source: Ge,
         entryPoint: "mainFragment"
       }
-    }), o = je.from({
-      vertex: ot,
-      fragment: it,
+    }), o = $e.from({
+      vertex: Tr,
+      fragment: yr,
       name: "mask-filter"
     });
     super({
       ...r,
-      gpuProgram: i,
+      gpuProgram: a,
       glProgram: o,
       clipToViewport: !1,
       resources: {
-        filterUniforms: n,
+        filterUniforms: i,
         uMaskTexture: t.texture.source
       }
     }), this.sprite = t, this._textureMatrix = s;
@@ -215,17 +1221,38 @@ class lt extends at {
     ).prepend(this._textureMatrix.mapCoord), this.resources.uMaskTexture = this.sprite.texture.source, e.applyFilter(this, t, r, s);
   }
 }
-const j = class ge {
+function Sr(n, e, t) {
+  const r = (n >> 24 & 255) / 255;
+  e[t++] = (n & 255) / 255 * r, e[t++] = (n >> 8 & 255) / 255 * r, e[t++] = (n >> 16 & 255) / 255 * r, e[t++] = r;
+}
+class Ze {
+  constructor() {
+    this.batcherName = "default", this.topology = "triangle-list", this.attributeSize = 4, this.indexSize = 6, this.packAsQuad = !0, this.roundPixels = 0, this._attributeStart = 0, this._batcher = null, this._batch = null;
+  }
+  get blendMode() {
+    return this.renderable.groupBlendMode;
+  }
+  get color() {
+    return this.renderable.groupColorAlpha;
+  }
+  reset() {
+    this.renderable = null, this.texture = null, this._batcher = null, this._batch = null, this.bounds = null;
+  }
+  destroy() {
+    this.reset();
+  }
+}
+const oe = class et {
   constructor(e, t) {
     var r, s;
-    this.state = $e.for2d(), this._batchersByInstructionSet = /* @__PURE__ */ Object.create(null), this._activeBatches = /* @__PURE__ */ Object.create(null), this.renderer = e, this._adaptor = t, (s = (r = this._adaptor).init) == null || s.call(r, this);
+    this.state = Et.for2d(), this._batchersByInstructionSet = /* @__PURE__ */ Object.create(null), this._activeBatches = /* @__PURE__ */ Object.create(null), this.renderer = e, this._adaptor = t, (s = (r = this._adaptor).init) == null || s.call(r, this);
   }
   static getBatcher(e) {
     return new this._availableBatchers[e]();
   }
   buildStart(e) {
     let t = this._batchersByInstructionSet[e.uid];
-    t || (t = this._batchersByInstructionSet[e.uid] = /* @__PURE__ */ Object.create(null), t.default || (t.default = new le({
+    t || (t = this._batchersByInstructionSet[e.uid] = /* @__PURE__ */ Object.create(null), t.default || (t.default = new Je({
       maxTextures: this.renderer.limits.maxBatchableTextures
     }))), this._activeBatches = t, this._activeBatch = this._activeBatches.default;
     for (const r in this._activeBatches)
@@ -235,7 +1262,7 @@ const j = class ge {
     if (this._activeBatch.name !== e.batcherName) {
       this._activeBatch.break(t);
       let r = this._activeBatches[e.batcherName];
-      r || (r = this._activeBatches[e.batcherName] = ge.getBatcher(e.batcherName), r.begin()), this._activeBatch = r;
+      r || (r = this._activeBatches[e.batcherName] = et.getBatcher(e.batcherName), r.begin()), this._activeBatch = r;
     }
     this._activeBatch.add(e);
   }
@@ -246,15 +1273,15 @@ const j = class ge {
     this._activeBatch.break(e);
     const t = this._activeBatches;
     for (const r in t) {
-      const s = t[r], n = s.geometry;
-      n.indexBuffer.setDataWithSize(s.indexBuffer, s.indexSize, !0), n.buffers[0].setDataWithSize(s.attributeBuffer.float32View, s.attributeSize, !1);
+      const s = t[r], i = s.geometry;
+      i.indexBuffer.setDataWithSize(s.indexBuffer, s.indexSize, !0), i.buffers[0].setDataWithSize(s.attributeBuffer.float32View, s.attributeSize, !1);
     }
   }
   upload(e) {
     const t = this._batchersByInstructionSet[e.uid];
     for (const r in t) {
-      const s = t[r], n = s.geometry;
-      s.dirty && (s.dirty = !1, n.buffers[0].update(s.attributeSize * 4));
+      const s = t[r], i = s.geometry;
+      s.dirty && (s.dirty = !1, i.buffers[0].update(s.attributeSize * 4));
     }
   }
   execute(e) {
@@ -271,23 +1298,23 @@ const j = class ge {
     this._activeBatches = null;
   }
 };
-j.extension = {
+oe.extension = {
   type: [
-    l.WebGLPipes,
-    l.WebGPUPipes,
-    l.CanvasPipes
+    u.WebGLPipes,
+    u.WebGPUPipes,
+    u.CanvasPipes
   ],
   name: "batch"
 };
-j._availableBatchers = /* @__PURE__ */ Object.create(null);
-let _e = j;
-W.handleByMap(l.Batcher, _e._availableBatchers);
-W.add(le);
-const dt = new z();
-class ut extends de {
+oe._availableBatchers = /* @__PURE__ */ Object.create(null);
+let tt = oe;
+re.handleByMap(u.Batcher, tt._availableBatchers);
+re.add(Je);
+const kr = new se();
+class wr extends Ve {
   constructor() {
-    super(), this.filters = [new lt({
-      sprite: new Ke(f.EMPTY),
+    super(), this.filters = [new Cr({
+      sprite: new kt(S.EMPTY),
       inverse: !1,
       resolution: "inherit",
       antialias: "inherit"
@@ -306,7 +1333,7 @@ class ut extends de {
     this.filters[0].inverse = e;
   }
 }
-class xe {
+class rt {
   constructor(e) {
     this._activeMaskStage = [], this._renderer = e;
   }
@@ -320,12 +1347,12 @@ class xe {
       canBundle: !1,
       maskedContainer: t
     }), e.inverse = t._maskOptions.inverse, e.renderMaskToTexture) {
-      const n = e.mask;
-      n.includeInBuild = !0, n.collectRenderables(
+      const i = e.mask;
+      i.includeInBuild = !0, i.collectRenderables(
         r,
         s,
         null
-      ), n.includeInBuild = !1;
+      ), i.includeInBuild = !1;
     }
     s.renderPipes.batch.break(r), r.add({
       renderPipeId: "alphaMask",
@@ -348,23 +1375,23 @@ class xe {
   execute(e) {
     const t = this._renderer, r = e.mask.renderMaskToTexture;
     if (e.action === "pushMaskBegin") {
-      const s = w.get(ut);
+      const s = V.get(wr);
       if (s.inverse = e.inverse, r) {
         e.mask.mask.measurable = !0;
-        const n = qe(e.mask.mask, !0, dt);
-        e.mask.mask.measurable = !1, n.ceil();
-        const i = t.renderTarget.renderTarget.colorTexture.source, o = T.getOptimalTexture(
-          n.width,
-          n.height,
-          i._resolution,
-          i.antialias
+        const i = St(e.mask.mask, !0, kr);
+        e.mask.mask.measurable = !1, i.ceil();
+        const a = t.renderTarget.renderTarget.colorTexture.source, o = G.getOptimalTexture(
+          i.width,
+          i.height,
+          a._resolution,
+          a.antialias
         );
         t.renderTarget.push(o, !0), t.globalUniforms.push({
-          offset: n,
+          offset: i,
           worldColor: 4294967295
         });
-        const d = s.sprite;
-        d.texture = o, d.worldTransform.tx = n.minX, d.worldTransform.ty = n.minY, this._activeMaskStage.push({
+        const l = s.sprite;
+        l.texture = o, l.worldTransform.tx = i.minX, l.worldTransform.ty = i.minY, this._activeMaskStage.push({
           filterEffect: s,
           maskedContainer: e.maskedContainer,
           filterTexture: o
@@ -376,7 +1403,7 @@ class xe {
         });
     } else if (e.action === "pushMaskEnd") {
       const s = this._activeMaskStage[this._activeMaskStage.length - 1];
-      r && (t.type === V.WEBGL && t.renderTarget.finishRenderPass(), t.renderTarget.pop(), t.globalUniforms.pop()), t.filter.push({
+      r && (t.type === ae.WEBGL && t.renderTarget.finishRenderPass(), t.renderTarget.pop(), t.globalUniforms.pop()), t.filter.push({
         renderPipeId: "filter",
         action: "pushFilter",
         container: s.maskedContainer,
@@ -386,22 +1413,22 @@ class xe {
     } else if (e.action === "popMaskEnd") {
       t.filter.pop();
       const s = this._activeMaskStage.pop();
-      r && T.returnTexture(s.filterTexture), w.return(s.filterEffect);
+      r && G.returnTexture(s.filterTexture), V.return(s.filterEffect);
     }
   }
   destroy() {
     this._renderer = null, this._activeMaskStage = null;
   }
 }
-xe.extension = {
+rt.extension = {
   type: [
-    l.WebGLPipes,
-    l.WebGPUPipes,
-    l.CanvasPipes
+    u.WebGLPipes,
+    u.WebGPUPipes,
+    u.CanvasPipes
   ],
   name: "alphaMask"
 };
-class be {
+class st {
   constructor(e) {
     this._colorStack = [], this._colorStackIndex = 0, this._currentColor = 0, this._renderer = e;
   }
@@ -410,23 +1437,23 @@ class be {
   }
   push(e, t, r) {
     this._renderer.renderPipes.batch.break(r);
-    const n = this._colorStack;
-    n[this._colorStackIndex] = n[this._colorStackIndex - 1] & e.mask;
-    const i = this._colorStack[this._colorStackIndex];
-    i !== this._currentColor && (this._currentColor = i, r.add({
+    const i = this._colorStack;
+    i[this._colorStackIndex] = i[this._colorStackIndex - 1] & e.mask;
+    const a = this._colorStack[this._colorStackIndex];
+    a !== this._currentColor && (this._currentColor = a, r.add({
       renderPipeId: "colorMask",
-      colorMask: i,
+      colorMask: a,
       canBundle: !1
     })), this._colorStackIndex++;
   }
   pop(e, t, r) {
     this._renderer.renderPipes.batch.break(r);
-    const n = this._colorStack;
+    const i = this._colorStack;
     this._colorStackIndex--;
-    const i = n[this._colorStackIndex - 1];
-    i !== this._currentColor && (this._currentColor = i, r.add({
+    const a = i[this._colorStackIndex - 1];
+    a !== this._currentColor && (this._currentColor = a, r.add({
       renderPipeId: "colorMask",
-      colorMask: i,
+      colorMask: a,
       canBundle: !1
     }));
   }
@@ -437,60 +1464,60 @@ class be {
     this._renderer = null, this._colorStack = null;
   }
 }
-be.extension = {
+st.extension = {
   type: [
-    l.WebGLPipes,
-    l.WebGPUPipes
+    u.WebGLPipes,
+    u.WebGPUPipes
   ],
   name: "colorMask"
 };
-class Te {
+class nt {
   constructor(e) {
     this._maskStackHash = {}, this._maskHash = /* @__PURE__ */ new WeakMap(), this._renderer = e;
   }
   push(e, t, r) {
     var s;
-    const n = e, i = this._renderer;
-    i.renderPipes.batch.break(r), i.renderPipes.blendMode.setBlendMode(n.mask, "none", r), r.add({
+    const i = e, a = this._renderer;
+    a.renderPipes.batch.break(r), a.renderPipes.blendMode.setBlendMode(i.mask, "none", r), r.add({
       renderPipeId: "stencilMask",
       action: "pushMaskBegin",
       mask: e,
       inverse: t._maskOptions.inverse,
       canBundle: !1
     });
-    const o = n.mask;
-    o.includeInBuild = !0, this._maskHash.has(n) || this._maskHash.set(n, {
+    const o = i.mask;
+    o.includeInBuild = !0, this._maskHash.has(i) || this._maskHash.set(i, {
       instructionsStart: 0,
       instructionsLength: 0
     });
-    const d = this._maskHash.get(n);
-    d.instructionsStart = r.instructionSize, o.collectRenderables(
+    const l = this._maskHash.get(i);
+    l.instructionsStart = r.instructionSize, o.collectRenderables(
       r,
-      i,
+      a,
       null
-    ), o.includeInBuild = !1, i.renderPipes.batch.break(r), r.add({
+    ), o.includeInBuild = !1, a.renderPipes.batch.break(r), r.add({
       renderPipeId: "stencilMask",
       action: "pushMaskEnd",
       mask: e,
       inverse: t._maskOptions.inverse,
       canBundle: !1
     });
-    const c = r.instructionSize - d.instructionsStart - 1;
-    d.instructionsLength = c;
-    const h = i.renderTarget.renderTarget.uid;
-    (s = this._maskStackHash)[h] ?? (s[h] = 0);
+    const d = r.instructionSize - l.instructionsStart - 1;
+    l.instructionsLength = d;
+    const f = a.renderTarget.renderTarget.uid;
+    (s = this._maskStackHash)[f] ?? (s[f] = 0);
   }
   pop(e, t, r) {
-    const s = e, n = this._renderer;
-    n.renderPipes.batch.break(r), n.renderPipes.blendMode.setBlendMode(s.mask, "none", r), r.add({
+    const s = e, i = this._renderer;
+    i.renderPipes.batch.break(r), i.renderPipes.blendMode.setBlendMode(s.mask, "none", r), r.add({
       renderPipeId: "stencilMask",
       action: "popMaskBegin",
       inverse: t._maskOptions.inverse,
       canBundle: !1
     });
-    const i = this._maskHash.get(e);
-    for (let o = 0; o < i.instructionsLength; o++)
-      r.instructions[r.instructionSize++] = r.instructions[i.instructionsStart++];
+    const a = this._maskHash.get(e);
+    for (let o = 0; o < a.instructionsLength; o++)
+      r.instructions[r.instructionSize++] = r.instructions[a.instructionsStart++];
     r.add({
       renderPipeId: "stencilMask",
       action: "popMaskEnd",
@@ -499,22 +1526,22 @@ class Te {
   }
   execute(e) {
     var t;
-    const r = this._renderer, s = r, n = r.renderTarget.renderTarget.uid;
-    let i = (t = this._maskStackHash)[n] ?? (t[n] = 0);
-    e.action === "pushMaskBegin" ? (s.renderTarget.ensureDepthStencil(), s.stencil.setStencilMode(g.RENDERING_MASK_ADD, i), i++, s.colorMask.setMask(0)) : e.action === "pushMaskEnd" ? (e.inverse ? s.stencil.setStencilMode(g.INVERSE_MASK_ACTIVE, i) : s.stencil.setStencilMode(g.MASK_ACTIVE, i), s.colorMask.setMask(15)) : e.action === "popMaskBegin" ? (s.colorMask.setMask(0), i !== 0 ? s.stencil.setStencilMode(g.RENDERING_MASK_REMOVE, i) : (s.renderTarget.clear(null, D.STENCIL), s.stencil.setStencilMode(g.DISABLED, i)), i--) : e.action === "popMaskEnd" && (e.inverse ? s.stencil.setStencilMode(g.INVERSE_MASK_ACTIVE, i) : s.stencil.setStencilMode(g.MASK_ACTIVE, i), s.colorMask.setMask(15)), this._maskStackHash[n] = i;
+    const r = this._renderer, s = r, i = r.renderTarget.renderTarget.uid;
+    let a = (t = this._maskStackHash)[i] ?? (t[i] = 0);
+    e.action === "pushMaskBegin" ? (s.renderTarget.ensureDepthStencil(), s.stencil.setStencilMode(k.RENDERING_MASK_ADD, a), a++, s.colorMask.setMask(0)) : e.action === "pushMaskEnd" ? (e.inverse ? s.stencil.setStencilMode(k.INVERSE_MASK_ACTIVE, a) : s.stencil.setStencilMode(k.MASK_ACTIVE, a), s.colorMask.setMask(15)) : e.action === "popMaskBegin" ? (s.colorMask.setMask(0), a !== 0 ? s.stencil.setStencilMode(k.RENDERING_MASK_REMOVE, a) : (s.renderTarget.clear(null, Q.STENCIL), s.stencil.setStencilMode(k.DISABLED, a)), a--) : e.action === "popMaskEnd" && (e.inverse ? s.stencil.setStencilMode(k.INVERSE_MASK_ACTIVE, a) : s.stencil.setStencilMode(k.MASK_ACTIVE, a), s.colorMask.setMask(15)), this._maskStackHash[i] = a;
   }
   destroy() {
     this._renderer = null, this._maskStackHash = null, this._maskHash = null;
   }
 }
-Te.extension = {
+nt.extension = {
   type: [
-    l.WebGLPipes,
-    l.WebGPUPipes
+    u.WebGLPipes,
+    u.WebGPUPipes
   ],
   name: "stencilMask"
 };
-class ye {
+class it {
   constructor(e) {
     this._renderer = e;
   }
@@ -535,22 +1562,22 @@ class ye {
     this._renderer = null;
   }
 }
-ye.extension = {
+it.extension = {
   type: [
-    l.WebGLPipes,
-    l.WebGPUPipes,
-    l.CanvasPipes
+    u.WebGLPipes,
+    u.WebGPUPipes,
+    u.CanvasPipes
   ],
   name: "customRender"
 };
-function L(a, e) {
-  const t = a.instructionSet, r = t.instructions;
+function J(n, e) {
+  const t = n.instructionSet, r = t.instructions;
   for (let s = 0; s < t.instructionSize; s++) {
-    const n = r[s];
-    e[n.renderPipeId].execute(n);
+    const i = r[s];
+    e[i.renderPipeId].execute(i);
   }
 }
-class ve {
+class at {
   constructor(e) {
     this._renderer = e;
   }
@@ -564,16 +1591,16 @@ class ve {
     this._renderer = null;
   }
   _addRenderableDirect(e, t) {
-    this._renderer.renderPipes.batch.break(t), e._batchableRenderGroup && (w.return(e._batchableRenderGroup), e._batchableRenderGroup = null), t.add(e);
+    this._renderer.renderPipes.batch.break(t), e._batchableRenderGroup && (V.return(e._batchableRenderGroup), e._batchableRenderGroup = null), t.add(e);
   }
   _addRenderableCacheAsTexture(e, t) {
-    const r = e._batchableRenderGroup ?? (e._batchableRenderGroup = w.get(ue));
+    const r = e._batchableRenderGroup ?? (e._batchableRenderGroup = V.get(Ze));
     r.renderable = e.root, r.transform = e.root.relativeGroupTransform, r.texture = e.texture, r.bounds = e._textureBounds, t.add(e), this._renderer.renderPipes.blendMode.pushBlendMode(e, e.root.groupBlendMode, t), this._renderer.renderPipes.batch.addToBatch(r, t), this._renderer.renderPipes.blendMode.popBlendMode(t);
   }
   _executeCacheAsTexture(e) {
     if (e.textureNeedsUpdate) {
       e.textureNeedsUpdate = !1;
-      const t = new m().translate(
+      const t = new M().translate(
         -e._textureBounds.x,
         -e._textureBounds.y
       );
@@ -581,7 +1608,7 @@ class ve {
         worldTransformMatrix: t,
         worldColor: 4294967295,
         offset: { x: 0, y: 0 }
-      }), L(e, this._renderer.renderPipes), this._renderer.renderTarget.finishRenderPass(), this._renderer.renderTarget.pop(), this._renderer.globalUniforms.pop();
+      }), J(e, this._renderer.renderPipes), this._renderer.renderTarget.finishRenderPass(), this._renderer.renderTarget.pop(), this._renderer.globalUniforms.pop();
     }
     e._batchableRenderGroup._batcher.updateElement(e._batchableRenderGroup), e._batchableRenderGroup._batcher.geometry.buffers[0].update();
   }
@@ -589,18 +1616,18 @@ class ve {
     this._renderer.globalUniforms.push({
       worldTransformMatrix: e.inverseParentTextureTransform,
       worldColor: e.worldColorAlpha
-    }), L(e, this._renderer.renderPipes), this._renderer.globalUniforms.pop();
+    }), J(e, this._renderer.renderPipes), this._renderer.globalUniforms.pop();
   }
 }
-ve.extension = {
+at.extension = {
   type: [
-    l.WebGLPipes,
-    l.WebGPUPipes,
-    l.CanvasPipes
+    u.WebGLPipes,
+    u.WebGPUPipes,
+    u.CanvasPipes
   ],
   name: "renderGroup"
 };
-class Ce {
+class ot {
   constructor(e) {
     this._renderer = e;
   }
@@ -626,30 +1653,30 @@ class Ce {
     return e._gpuData[this._renderer.uid] || this._initGPUSprite(e);
   }
   _initGPUSprite(e) {
-    const t = new ue();
+    const t = new Ze();
     return t.renderable = e, t.transform = e.groupTransform, t.texture = e._texture, t.bounds = e.visualBounds, t.roundPixels = this._renderer._roundPixels | e._roundPixels, e._gpuData[this._renderer.uid] = t, t;
   }
   destroy() {
     this._renderer = null;
   }
 }
-Ce.extension = {
+ot.extension = {
   type: [
-    l.WebGLPipes,
-    l.WebGPUPipes,
-    l.CanvasPipes
+    u.WebGLPipes,
+    u.WebGPUPipes,
+    u.CanvasPipes
   ],
   name: "sprite"
 };
-const v = {};
-W.handle(l.BlendMode, (a) => {
-  if (!a.name)
+const E = {};
+re.handle(u.BlendMode, (n) => {
+  if (!n.name)
     throw new Error("BlendMode extension must have a name property");
-  v[a.name] = a.ref;
-}, (a) => {
-  delete v[a.name];
+  E[n.name] = n.ref;
+}, (n) => {
+  delete E[n.name];
 });
-class ke {
+class lt {
   constructor(e) {
     this._blendModeStack = [], this._isAdvanced = !1, this._filterHash = /* @__PURE__ */ Object.create(null), this._renderer = e, this._renderer.runners.prerender.add(this);
   }
@@ -683,34 +1710,34 @@ class ke {
    * @param instructionSet - The instruction set being built.
    */
   setBlendMode(e, t, r) {
-    var n;
-    const s = e instanceof ee;
+    var i;
+    const s = e instanceof xe;
     if (this._activeBlendMode === t) {
-      this._isAdvanced && e && !s && ((n = this._renderableList) == null || n.push(e));
+      this._isAdvanced && e && !s && ((i = this._renderableList) == null || i.push(e));
       return;
     }
-    this._isAdvanced && this._endAdvancedBlendMode(r), this._activeBlendMode = t, e && (this._isAdvanced = !!v[t], this._isAdvanced && this._beginAdvancedBlendMode(e, r));
+    this._isAdvanced && this._endAdvancedBlendMode(r), this._activeBlendMode = t, e && (this._isAdvanced = !!E[t], this._isAdvanced && this._beginAdvancedBlendMode(e, r));
   }
   _beginAdvancedBlendMode(e, t) {
     this._renderer.renderPipes.batch.break(t);
     const r = this._activeBlendMode;
-    if (!v[r]) {
-      ce(`Unable to assign BlendMode: '${r}'. You may want to include: import 'pixi.js/advanced-blend-modes'`);
+    if (!E[r]) {
+      te(`Unable to assign BlendMode: '${r}'. You may want to include: import 'pixi.js/advanced-blend-modes'`);
       return;
     }
-    const s = this._ensureFilterEffect(r), n = e instanceof ee, i = {
+    const s = this._ensureFilterEffect(r), i = e instanceof xe, a = {
       renderPipeId: "filter",
       action: "pushFilter",
       filterEffect: s,
-      renderables: n ? null : [e],
-      container: n ? e.root : null,
+      renderables: i ? null : [e],
+      container: i ? e.root : null,
       canBundle: !1
     };
-    this._renderableList = i.renderables, t.add(i);
+    this._renderableList = a.renderables, t.add(a);
   }
   _ensureFilterEffect(e) {
     let t = this._filterHash[e];
-    return t || (t = this._filterHash[e] = new de(), t.filters = [new v[e]()]), t;
+    return t || (t = this._filterHash[e] = new Ve(), t.filters = [new E[e]()]), t;
   }
   _endAdvancedBlendMode(e) {
     this._isAdvanced = !1, this._renderableList = null, this._renderer.renderPipes.batch.break(e), e.add({
@@ -743,104 +1770,104 @@ class ke {
     this._filterHash = null;
   }
 }
-ke.extension = {
+lt.extension = {
   type: [
-    l.WebGLPipes,
-    l.WebGPUPipes,
-    l.CanvasPipes
+    u.WebGLPipes,
+    u.WebGPUPipes,
+    u.CanvasPipes
   ],
   name: "blendMode"
 };
-function F(a, e) {
+function Z(n, e) {
   e || (e = 0);
-  for (let t = e; t < a.length && a[t]; t++)
-    a[t] = null;
+  for (let t = e; t < n.length && n[t]; t++)
+    n[t] = null;
 }
-const ct = new P(), ne = pe | fe | me;
-function Me(a, e = !1) {
-  ht(a);
-  const t = a.childrenToUpdate, r = a.updateTick++;
+const Mr = new F(), Ie = Le | We | Oe;
+function ut(n, e = !1) {
+  Br(n);
+  const t = n.childrenToUpdate, r = n.updateTick++;
   for (const s in t) {
-    const n = Number(s), i = t[s], o = i.list, d = i.index;
-    for (let c = 0; c < d; c++) {
-      const h = o[c];
-      h.parentRenderGroup === a && h.relativeRenderGroupDepth === n && Re(h, r, 0);
+    const i = Number(s), a = t[s], o = a.list, l = a.index;
+    for (let d = 0; d < l; d++) {
+      const f = o[d];
+      f.parentRenderGroup === n && f.relativeRenderGroupDepth === i && ct(f, r, 0);
     }
-    F(o, d), i.index = 0;
+    Z(o, l), a.index = 0;
   }
   if (e)
-    for (let s = 0; s < a.renderGroupChildren.length; s++)
-      Me(a.renderGroupChildren[s], e);
+    for (let s = 0; s < n.renderGroupChildren.length; s++)
+      ut(n.renderGroupChildren[s], e);
 }
-function ht(a) {
-  const e = a.root;
+function Br(n) {
+  const e = n.root;
   let t;
-  if (a.renderGroupParent) {
-    const r = a.renderGroupParent;
-    a.worldTransform.appendFrom(
+  if (n.renderGroupParent) {
+    const r = n.renderGroupParent;
+    n.worldTransform.appendFrom(
       e.relativeGroupTransform,
       r.worldTransform
-    ), a.worldColor = he(
+    ), n.worldColor = Fe(
       e.groupColor,
       r.worldColor
     ), t = e.groupAlpha * r.worldAlpha;
   } else
-    a.worldTransform.copyFrom(e.localTransform), a.worldColor = e.localColor, t = e.localAlpha;
-  t = t < 0 ? 0 : t > 1 ? 1 : t, a.worldAlpha = t, a.worldColorAlpha = a.worldColor + ((t * 255 | 0) << 24);
-}
-function Re(a, e, t) {
-  if (e === a.updateTick) return;
-  a.updateTick = e, a.didChange = !1;
-  const r = a.localTransform;
-  a.updateLocalTransform();
-  const s = a.parent;
-  if (s && !s.renderGroup ? (t |= a._updateFlags, a.relativeGroupTransform.appendFrom(
+    n.worldTransform.copyFrom(e.localTransform), n.worldColor = e.localColor, t = e.localAlpha;
+  t = t < 0 ? 0 : t > 1 ? 1 : t, n.worldAlpha = t, n.worldColorAlpha = n.worldColor + ((t * 255 | 0) << 24);
+}
+function ct(n, e, t) {
+  if (e === n.updateTick) return;
+  n.updateTick = e, n.didChange = !1;
+  const r = n.localTransform;
+  n.updateLocalTransform();
+  const s = n.parent;
+  if (s && !s.renderGroup ? (t |= n._updateFlags, n.relativeGroupTransform.appendFrom(
     r,
     s.relativeGroupTransform
-  ), t & ne && ae(a, s, t)) : (t = a._updateFlags, a.relativeGroupTransform.copyFrom(r), t & ne && ae(a, ct, t)), !a.renderGroup) {
-    const n = a.children, i = n.length;
-    for (let c = 0; c < i; c++)
-      Re(n[c], e, t);
-    const o = a.parentRenderGroup, d = a;
-    d.renderPipeId && !o.structureDidChange && o.updateRenderable(d);
-  }
-}
-function ae(a, e, t) {
-  if (t & fe) {
-    a.groupColor = he(
-      a.localColor,
+  ), t & Ie && De(n, s, t)) : (t = n._updateFlags, n.relativeGroupTransform.copyFrom(r), t & Ie && De(n, Mr, t)), !n.renderGroup) {
+    const i = n.children, a = i.length;
+    for (let d = 0; d < a; d++)
+      ct(i[d], e, t);
+    const o = n.parentRenderGroup, l = n;
+    l.renderPipeId && !o.structureDidChange && o.updateRenderable(l);
+  }
+}
+function De(n, e, t) {
+  if (t & We) {
+    n.groupColor = Fe(
+      n.localColor,
       e.groupColor
     );
-    let r = a.localAlpha * e.groupAlpha;
-    r = r < 0 ? 0 : r > 1 ? 1 : r, a.groupAlpha = r, a.groupColorAlpha = a.groupColor + ((r * 255 | 0) << 24);
+    let r = n.localAlpha * e.groupAlpha;
+    r = r < 0 ? 0 : r > 1 ? 1 : r, n.groupAlpha = r, n.groupColorAlpha = n.groupColor + ((r * 255 | 0) << 24);
   }
-  t & me && (a.groupBlendMode = a.localBlendMode === "inherit" ? e.groupBlendMode : a.localBlendMode), t & pe && (a.globalDisplayStatus = a.localDisplayStatus & e.globalDisplayStatus), a._updateFlags = 0;
+  t & Oe && (n.groupBlendMode = n.localBlendMode === "inherit" ? e.groupBlendMode : n.localBlendMode), t & Le && (n.globalDisplayStatus = n.localDisplayStatus & e.globalDisplayStatus), n._updateFlags = 0;
 }
-function pt(a, e) {
-  const { list: t } = a.childrenRenderablesToUpdate;
+function Rr(n, e) {
+  const { list: t } = n.childrenRenderablesToUpdate;
   let r = !1;
-  for (let s = 0; s < a.childrenRenderablesToUpdate.index; s++) {
-    const n = t[s];
-    if (r = e[n.renderPipeId].validateRenderable(n), r)
+  for (let s = 0; s < n.childrenRenderablesToUpdate.index; s++) {
+    const i = t[s];
+    if (r = e[i.renderPipeId].validateRenderable(i), r)
       break;
   }
-  return a.structureDidChange = r, r;
+  return n.structureDidChange = r, r;
 }
-const ft = new m();
-class Se {
+const Pr = new M();
+class dt {
   constructor(e) {
     this._renderer = e;
   }
   render({ container: e, transform: t }) {
     const r = e.parent, s = e.renderGroup.renderGroupParent;
     e.parent = null, e.renderGroup.renderGroupParent = null;
-    const n = this._renderer, i = ft;
-    t && (i.copyFrom(e.renderGroup.localTransform), e.renderGroup.localTransform.copyFrom(t));
-    const o = n.renderPipes;
-    this._updateCachedRenderGroups(e.renderGroup, null), this._updateRenderGroups(e.renderGroup), n.globalUniforms.start({
+    const i = this._renderer, a = Pr;
+    t && (a.copyFrom(e.renderGroup.localTransform), e.renderGroup.localTransform.copyFrom(t));
+    const o = i.renderPipes;
+    this._updateCachedRenderGroups(e.renderGroup, null), this._updateRenderGroups(e.renderGroup), i.globalUniforms.start({
       worldTransformMatrix: t ? e.renderGroup.localTransform : e.renderGroup.worldTransform,
       worldColor: e.renderGroup.worldColorAlpha
-    }), L(e.renderGroup, o), o.uniformBatch && o.uniformBatch.renderEnd(), t && e.renderGroup.localTransform.copyFrom(i), e.parent = r, e.renderGroup.renderGroupParent = s;
+    }), J(e.renderGroup, o), o.uniformBatch && o.uniformBatch.renderEnd(), t && e.renderGroup.localTransform.copyFrom(a), e.parent = r, e.renderGroup.renderGroupParent = s;
   }
   destroy() {
     this._renderer = null;
@@ -854,64 +1881,64 @@ class Se {
       this._updateCachedRenderGroups(e.renderGroupChildren[r], t);
     if (e.invalidateMatrices(), e.isCachedAsTexture) {
       if (e.textureNeedsUpdate) {
-        const r = e.root.getLocalBounds(), s = this._renderer, n = e.textureOptions.resolution || s.view.resolution, i = e.textureOptions.antialias ?? s.view.antialias, o = e.textureOptions.scaleMode ?? "linear", d = e.texture;
-        r.ceil(), e.texture && T.returnTexture(e.texture, !0);
-        const c = T.getOptimalTexture(
+        const r = e.root.getLocalBounds(), s = this._renderer, i = e.textureOptions.resolution || s.view.resolution, a = e.textureOptions.antialias ?? s.view.antialias, o = e.textureOptions.scaleMode ?? "linear", l = e.texture;
+        r.ceil(), e.texture && G.returnTexture(e.texture, !0);
+        const d = G.getOptimalTexture(
           r.width,
           r.height,
-          n,
-          i
+          i,
+          a
         );
-        c._source.style = new Ye({ scaleMode: o }), e.texture = c, e._textureBounds || (e._textureBounds = new z()), e._textureBounds.copyFrom(r), d !== e.texture && e.renderGroupParent && (e.renderGroupParent.structureDidChange = !0);
+        d._source.style = new wt({ scaleMode: o }), e.texture = d, e._textureBounds || (e._textureBounds = new se()), e._textureBounds.copyFrom(r), l !== e.texture && e.renderGroupParent && (e.renderGroupParent.structureDidChange = !0);
       }
-    } else e.texture && (T.returnTexture(e.texture, !0), e.texture = null);
+    } else e.texture && (G.returnTexture(e.texture, !0), e.texture = null);
   }
   _updateRenderGroups(e) {
     const t = this._renderer, r = t.renderPipes;
-    if (e.runOnRender(t), e.instructionSet.renderPipes = r, e.structureDidChange ? F(e.childrenRenderablesToUpdate.list, 0) : pt(e, r), Me(e), e.structureDidChange ? (e.structureDidChange = !1, this._buildInstructions(e, t)) : this._updateRenderables(e), e.childrenRenderablesToUpdate.index = 0, t.renderPipes.batch.upload(e.instructionSet), !(e.isCachedAsTexture && !e.textureNeedsUpdate))
+    if (e.runOnRender(t), e.instructionSet.renderPipes = r, e.structureDidChange ? Z(e.childrenRenderablesToUpdate.list, 0) : Rr(e, r), ut(e), e.structureDidChange ? (e.structureDidChange = !1, this._buildInstructions(e, t)) : this._updateRenderables(e), e.childrenRenderablesToUpdate.index = 0, t.renderPipes.batch.upload(e.instructionSet), !(e.isCachedAsTexture && !e.textureNeedsUpdate))
       for (let s = 0; s < e.renderGroupChildren.length; s++)
         this._updateRenderGroups(e.renderGroupChildren[s]);
   }
   _updateRenderables(e) {
     const { list: t, index: r } = e.childrenRenderablesToUpdate;
     for (let s = 0; s < r; s++) {
-      const n = t[s];
-      n.didViewUpdate && e.updateRenderable(n);
+      const i = t[s];
+      i.didViewUpdate && e.updateRenderable(i);
     }
-    F(t, r);
+    Z(t, r);
   }
   _buildInstructions(e, t) {
     const r = e.root, s = e.instructionSet;
     s.reset();
-    const n = t.renderPipes ? t : t.batch.renderer, i = n.renderPipes;
-    i.batch.buildStart(s), i.blendMode.buildStart(), i.colorMask.buildStart(), r.sortableChildren && r.sortChildren(), r.collectRenderablesWithEffects(s, n, null), i.batch.buildEnd(s), i.blendMode.buildEnd(s);
+    const i = t.renderPipes ? t : t.batch.renderer, a = i.renderPipes;
+    a.batch.buildStart(s), a.blendMode.buildStart(), a.colorMask.buildStart(), r.sortableChildren && r.sortChildren(), r.collectRenderablesWithEffects(s, i, null), a.batch.buildEnd(s), a.blendMode.buildEnd(s);
   }
 }
-Se.extension = {
+dt.extension = {
   type: [
-    l.WebGLSystem,
-    l.WebGPUSystem,
-    l.CanvasSystem
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
   ],
   name: "renderGroup"
 };
-const $ = class we {
+const le = class ht {
   constructor() {
-    this.clearBeforeRender = !0, this._backgroundColor = new E(0), this.color = this._backgroundColor, this.alpha = 1;
+    this.clearBeforeRender = !0, this._backgroundColor = new Y(0), this.color = this._backgroundColor, this.alpha = 1;
   }
   /**
    * initiates the background system
    * @param options - the options for the background colors
    */
   init(e) {
-    e = { ...we.defaultOptions, ...e }, this.clearBeforeRender = e.clearBeforeRender, this.color = e.background || e.backgroundColor || this._backgroundColor, this.alpha = e.backgroundAlpha, this._backgroundColor.setAlpha(e.backgroundAlpha);
+    e = { ...ht.defaultOptions, ...e }, this.clearBeforeRender = e.clearBeforeRender, this.color = e.background || e.backgroundColor || this._backgroundColor, this.alpha = e.backgroundAlpha, this._backgroundColor.setAlpha(e.backgroundAlpha);
   }
   /** The background color to fill if not transparent */
   get color() {
     return this._backgroundColor;
   }
   set color(e) {
-    E.shared.setValue(e).alpha < 1 && this._backgroundColor.alpha === 1 && ce(
+    Y.shared.setValue(e).alpha < 1 && this._backgroundColor.alpha === 1 && te(
       "Cannot set a transparent background on an opaque canvas. To enable transparency, set backgroundAlpha < 1 when initializing your Application."
     ), this._backgroundColor.setValue(e);
   }
@@ -933,16 +1960,16 @@ const $ = class we {
   destroy() {
   }
 };
-$.extension = {
+le.extension = {
   type: [
-    l.WebGLSystem,
-    l.WebGPUSystem,
-    l.CanvasSystem
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
   ],
   name: "background",
   priority: 0
 };
-$.defaultOptions = {
+le.defaultOptions = {
   /**
    * {@link WebGLOptions.backgroundAlpha}
    * @default 1
@@ -959,18 +1986,18 @@ $.defaultOptions = {
    */
   clearBeforeRender: !0
 };
-let mt = $;
-const I = {
+let Ar = le;
+const q = {
   png: "image/png",
   jpg: "image/jpeg",
   webp: "image/webp"
-}, q = class Pe {
+}, ue = class ft {
   /** @param renderer - The renderer this System works for. */
   constructor(e) {
     this._renderer = e;
   }
   _normalizeOptions(e, t = {}) {
-    return e instanceof P || e instanceof f ? {
+    return e instanceof F || e instanceof S ? {
       target: e,
       ...t
     } : {
@@ -1011,7 +2038,7 @@ const I = {
    * @category rendering
    */
   async image(e) {
-    const t = N.get().createImage();
+    const t = ne.get().createImage();
     return t.src = await this.base64(e), t;
   }
   /**
@@ -1049,27 +2076,27 @@ const I = {
   async base64(e) {
     e = this._normalizeOptions(
       e,
-      Pe.defaultImageOptions
+      ft.defaultImageOptions
     );
     const { format: t, quality: r } = e, s = this.canvas(e);
     if (s.toBlob !== void 0)
-      return new Promise((n, i) => {
+      return new Promise((i, a) => {
         s.toBlob((o) => {
           if (!o) {
-            i(new Error("ICanvas.toBlob failed!"));
+            a(new Error("ICanvas.toBlob failed!"));
             return;
           }
-          const d = new FileReader();
-          d.onload = () => n(d.result), d.onerror = i, d.readAsDataURL(o);
-        }, I[t], r);
+          const l = new FileReader();
+          l.onload = () => i(l.result), l.onerror = a, l.readAsDataURL(o);
+        }, q[t], r);
       });
     if (s.toDataURL !== void 0)
-      return s.toDataURL(I[t], r);
+      return s.toDataURL(q[t], r);
     if (s.convertToBlob !== void 0) {
-      const n = await s.convertToBlob({ type: I[t], quality: r });
-      return new Promise((i, o) => {
-        const d = new FileReader();
-        d.onload = () => i(d.result), d.onerror = o, d.readAsDataURL(n);
+      const i = await s.convertToBlob({ type: q[t], quality: r });
+      return new Promise((a, o) => {
+        const l = new FileReader();
+        l.onload = () => a(l.result), l.onerror = o, l.readAsDataURL(i);
       });
     }
     throw new Error("Extract.base64() requires ICanvas.toDataURL, ICanvas.toBlob, or ICanvas.convertToBlob to be implemented");
@@ -1117,10 +2144,10 @@ const I = {
   canvas(e) {
     e = this._normalizeOptions(e);
     const t = e.target, r = this._renderer;
-    if (t instanceof f)
+    if (t instanceof S)
       return r.texture.generateCanvas(t);
-    const s = r.textureGenerator.generateTexture(e), n = r.texture.generateCanvas(s);
-    return s.destroy(!0), n;
+    const s = r.textureGenerator.generateTexture(e), i = r.texture.generateCanvas(s);
+    return s.destroy(!0), i;
   }
   /**
    * Returns a one-dimensional array containing the pixel data of the entire texture in RGBA order,
@@ -1154,8 +2181,8 @@ const I = {
    */
   pixels(e) {
     e = this._normalizeOptions(e);
-    const t = e.target, r = this._renderer, s = t instanceof f ? t : r.textureGenerator.generateTexture(e), n = r.texture.getPixels(s);
-    return t instanceof P && s.destroy(!0), n;
+    const t = e.target, r = this._renderer, s = t instanceof S ? t : r.textureGenerator.generateTexture(e), i = r.texture.getPixels(s);
+    return t instanceof F && s.destroy(!0), i;
   }
   /**
    * Creates a texture from a display object or existing texture.
@@ -1201,7 +2228,7 @@ const I = {
    * @category rendering
    */
   texture(e) {
-    return e = this._normalizeOptions(e), e.target instanceof f ? e.target : this._renderer.textureGenerator.generateTexture(e);
+    return e = this._normalizeOptions(e), e.target instanceof S ? e.target : this._renderer.textureGenerator.generateTexture(e);
   }
   /**
    * Extracts and downloads content from the renderer as an image file.
@@ -1273,32 +2300,32 @@ const I = {
     e = this._normalizeOptions(e);
     const r = this.canvas(e), s = r.toDataURL();
     console.log(`[Pixi Texture] ${r.width}px ${r.height}px`);
-    const n = [
+    const i = [
       "font-size: 1px;",
       `padding: ${t}px 300px;`,
       `background: url(${s}) no-repeat;`,
       "background-size: contain;"
     ].join(" ");
-    console.log("%c ", n);
+    console.log("%c ", i);
   }
   destroy() {
     this._renderer = null;
   }
 };
-q.extension = {
+ue.extension = {
   type: [
-    l.WebGLSystem,
-    l.WebGPUSystem,
-    l.CanvasSystem
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
   ],
   name: "extract"
 };
-q.defaultImageOptions = {
+ue.defaultImageOptions = {
   format: "png",
   quality: 1
 };
-let gt = q;
-class K extends f {
+let Ur = ue;
+class ce extends S {
   /**
    * Creates a RenderTexture. Pass `dynamic: true` in options to allow resizing after creation.
    * @param options - Options for the RenderTexture, including width, height, and dynamic.
@@ -1309,8 +2336,8 @@ class K extends f {
    */
   static create(e) {
     const { dynamic: t, ...r } = e;
-    return new K({
-      source: new y(r),
+    return new ce({
+      source: new I(r),
       dynamic: t ?? !1
     });
   }
@@ -1325,8 +2352,8 @@ class K extends f {
     return this.source.resize(e, t, r), this;
   }
 }
-const _t = new B(), xt = new z(), bt = [0, 0, 0, 0];
-class Be {
+const Gr = new L(), Ir = new se(), Dr = [0, 0, 0, 0];
+class pt {
   constructor(e) {
     this._renderer = e;
   }
@@ -1367,66 +2394,66 @@ class Be {
    * @category rendering
    */
   generateTexture(e) {
-    var c;
-    e instanceof P && (e = {
+    var d;
+    e instanceof F && (e = {
       target: e,
       frame: void 0,
       textureSourceOptions: {},
       resolution: void 0
     });
     const t = e.resolution || this._renderer.resolution, r = e.antialias || this._renderer.view.antialias, s = e.target;
-    let n = e.clearColor;
-    n ? n = Array.isArray(n) && n.length === 4 ? n : E.shared.setValue(n).toArray() : n = bt;
-    const i = ((c = e.frame) == null ? void 0 : c.copyTo(_t)) || Je(s, xt).rectangle;
-    i.width = Math.max(i.width, 1 / t) | 0, i.height = Math.max(i.height, 1 / t) | 0;
-    const o = K.create({
+    let i = e.clearColor;
+    i ? i = Array.isArray(i) && i.length === 4 ? i : Y.shared.setValue(i).toArray() : i = Dr;
+    const a = ((d = e.frame) == null ? void 0 : d.copyTo(Gr)) || Mt(s, Ir).rectangle;
+    a.width = Math.max(a.width, 1 / t) | 0, a.height = Math.max(a.height, 1 / t) | 0;
+    const o = ce.create({
       ...e.textureSourceOptions,
-      width: i.width,
-      height: i.height,
+      width: a.width,
+      height: a.height,
       resolution: t,
       antialias: r
-    }), d = m.shared.translate(-i.x, -i.y);
+    }), l = M.shared.translate(-a.x, -a.y);
     return this._renderer.render({
       container: s,
-      transform: d,
+      transform: l,
       target: o,
-      clearColor: n
+      clearColor: i
     }), o.source.updateMipmaps(), o;
   }
   destroy() {
     this._renderer = null;
   }
 }
-Be.extension = {
+pt.extension = {
   type: [
-    l.WebGLSystem,
-    l.WebGPUSystem,
-    l.CanvasSystem
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
   ],
   name: "textureGenerator"
 };
-function Tt(a) {
+function Er(n) {
   let e = !1;
-  for (const r in a)
-    if (a[r] == null) {
+  for (const r in n)
+    if (n[r] == null) {
       e = !0;
       break;
     }
-  if (!e) return a;
+  if (!e) return n;
   const t = /* @__PURE__ */ Object.create(null);
-  for (const r in a) {
-    const s = a[r];
+  for (const r in n) {
+    const s = n[r];
     s && (t[r] = s);
   }
   return t;
 }
-function yt(a) {
+function zr(n) {
   let e = 0;
-  for (let t = 0; t < a.length; t++)
-    a[t] == null ? e++ : a[t - e] = a[t];
-  return a.length -= e, a;
+  for (let t = 0; t < n.length; t++)
+    n[t] == null ? e++ : n[t - e] = n[t];
+  return n.length -= e, n;
 }
-const Y = class Ge {
+const de = class mt {
   /**
    * Creates a new GCSystem instance.
    * @param renderer - The renderer this garbage collection system works for
@@ -1439,7 +2466,7 @@ const Y = class Ge {
    * @param options - Configuration options
    */
   init(e) {
-    e = { ...Ge.defaultOptions, ...e }, this.maxUnusedTime = e.gcMaxUnusedTime, this._frequency = e.gcFrequency, this.enabled = e.gcActive, this.now = performance.now();
+    e = { ...mt.defaultOptions, ...e }, this.maxUnusedTime = e.gcMaxUnusedTime, this._frequency = e.gcFrequency, this.enabled = e.gcActive, this.now = performance.now();
   }
   /**
    * Gets whether the garbage collection system is currently enabled.
@@ -1463,8 +2490,8 @@ const Y = class Ge {
     ), this._collectionsHandler = this._renderer.scheduler.repeat(
       () => {
         for (const t of this._managedCollections) {
-          const { context: r, collection: s, type: n } = t;
-          n === "hash" ? r[s] = Tt(r[s]) : r[s] = yt(r[s]);
+          const { context: r, collection: s, type: i } = t;
+          i === "hash" ? r[s] = Er(r[s]) : r[s] = zr(r[s]);
         }
       },
       this._frequency
@@ -1511,7 +2538,7 @@ const Y = class Ge {
    * @param type - The type of resource to track
    */
   addResource(e, t) {
-    var s, n;
+    var s, i;
     if (e._gcLastUsed !== -1) {
       e._gcLastUsed = this.now, (s = e._onTouch) == null || s.call(e, this.now);
       return;
@@ -1520,7 +2547,7 @@ const Y = class Ge {
     e._gcData = {
       index: r,
       type: t
-    }, e._gcLastUsed = this.now, (n = e._onTouch) == null || n.call(e, this.now), e.once("unload", this.removeResource, this), this._managedResources.push(e);
+    }, e._gcLastUsed = this.now, (i = e._onTouch) == null || i.call(e, this.now), e.once("unload", this.removeResource, this), this._managedResources.push(e);
   }
   /**
    * Removes a resource from garbage collection tracking.
@@ -1532,8 +2559,8 @@ const Y = class Ge {
     if (!t) return;
     const r = t.index, s = this._managedResources.length - 1;
     if (r !== s) {
-      const n = this._managedResources[s];
-      this._managedResources[r] = n, n._gcData.index = r;
+      const i = this._managedResources[s];
+      this._managedResources[r] = i, i._gcData.index = r;
     }
     this._managedResources.length--, e._gcData = null, e._gcLastUsed = -1;
   }
@@ -1551,7 +2578,7 @@ const Y = class Ge {
       hash: t,
       type: r,
       priority: s
-    }), this._managedResourceHashes.sort((n, i) => n.priority - i.priority);
+    }), this._managedResourceHashes.sort((i, a) => i.priority - a.priority);
   }
   /**
    * Performs garbage collection by cleaning up unused resources.
@@ -1563,15 +2590,15 @@ const Y = class Ge {
       this.runOnHash(s, e);
     let r = 0;
     for (let s = 0; s < this._managedResources.length; s++) {
-      const n = this._managedResources[s];
-      r = this.runOnResource(n, e, r);
+      const i = this._managedResources[s];
+      r = this.runOnResource(i, e, r);
     }
     this._managedResources.length = r;
   }
   updateRenderableGCTick(e, t) {
-    var n, i;
-    const r = e.renderGroup ?? e.parentRenderGroup, s = ((n = r == null ? void 0 : r.instructionSet) == null ? void 0 : n.gcTick) ?? -1;
-    ((r == null ? void 0 : r.gcTick) ?? 0) === s && (e._gcLastUsed = t, (i = e._onTouch) == null || i.call(e, t));
+    var i, a;
+    const r = e.renderGroup ?? e.parentRenderGroup, s = ((i = r == null ? void 0 : r.instructionSet) == null ? void 0 : i.gcTick) ?? -1;
+    ((r == null ? void 0 : r.gcTick) ?? 0) === s && (e._gcLastUsed = t, (a = e._onTouch) == null || a.call(e, t));
   }
   runOnResource(e, t, r) {
     const s = e._gcData;
@@ -1592,26 +2619,26 @@ const Y = class Ge {
     return r;
   }
   runOnHash(e, t) {
-    var c;
-    const { context: r, hash: s, type: n } = e, i = r[s];
-    let o = null, d = 0;
-    for (const h in i) {
-      const u = i[h];
-      if (u === null) {
-        d++, d === 1e4 && !o && (o = this._createHashClone(i, h));
+    var d;
+    const { context: r, hash: s, type: i } = e, a = r[s];
+    let o = null, l = 0;
+    for (const f in a) {
+      const c = a[f];
+      if (c === null) {
+        l++, l === 1e4 && !o && (o = this._createHashClone(a, f));
         continue;
       }
-      if (u._gcLastUsed === -1) {
-        u._gcLastUsed = t, (c = u._onTouch) == null || c.call(u, t), o && (o[h] = u);
+      if (c._gcLastUsed === -1) {
+        c._gcLastUsed = t, (d = c._onTouch) == null || d.call(c, t), o && (o[f] = c);
         continue;
       }
-      if (n === "renderable" && this.updateRenderableGCTick(u, t), !(t - u._gcLastUsed < this.maxUnusedTime) && u.autoGarbageCollect) {
-        if (o || (d + 1 !== 1e4 ? (i[h] = null, d++) : o = this._createHashClone(i, h)), n === "renderable") {
-          const _ = u, x = _.renderGroup ?? _.parentRenderGroup;
-          x && (x.structureDidChange = !0);
+      if (i === "renderable" && this.updateRenderableGCTick(c, t), !(t - c._gcLastUsed < this.maxUnusedTime) && c.autoGarbageCollect) {
+        if (o || (l + 1 !== 1e4 ? (a[f] = null, l++) : o = this._createHashClone(a, f)), i === "renderable") {
+          const g = c, m = g.renderGroup ?? g.parentRenderGroup;
+          m && (m.structureDidChange = !0);
         }
-        u.unload(), u._gcData = null, u._gcLastUsed = -1;
-      } else o && (o[h] = u);
+        c.unload(), c._gcData = null, c._gcLastUsed = -1;
+      } else o && (o[f] = c);
     }
     o && (r[s] = o);
   }
@@ -1622,16 +2649,16 @@ const Y = class Ge {
     }), this._managedResources.length = 0, this._managedResourceHashes.length = 0, this._managedCollections.length = 0, this._renderer = null;
   }
 };
-Y.extension = {
+de.extension = {
   type: [
-    l.WebGLSystem,
-    l.WebGPUSystem,
-    l.CanvasSystem
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
   ],
   name: "gc",
   priority: 0
 };
-Y.defaultOptions = {
+de.defaultOptions = {
   /** Enable/disable the garbage collector */
   gcActive: !0,
   /** Time in ms before an unused resource is collected (default 1 minute) */
@@ -1639,8 +2666,8 @@ Y.defaultOptions = {
   /** How often to run garbage collection in ms (default 30 seconds) */
   gcFrequency: 3e4
 };
-let vt = Y;
-class Ue {
+let Hr = de;
+class xt {
   constructor(e) {
     this._stackIndex = 0, this._globalUniformDataStack = [], this._uniformsPool = [], this._activeUniforms = [], this._bindGroupPool = [], this._activeBindGroups = [], this._renderer = e;
   }
@@ -1660,35 +2687,35 @@ class Ue {
     projectionMatrix: t,
     worldTransformMatrix: r,
     worldColor: s,
-    offset: n
+    offset: i
   }) {
-    const i = this._renderer.renderTarget.renderTarget, o = this._stackIndex ? this._globalUniformDataStack[this._stackIndex - 1] : {
-      worldTransformMatrix: new m(),
+    const a = this._renderer.renderTarget.renderTarget, o = this._stackIndex ? this._globalUniformDataStack[this._stackIndex - 1] : {
+      worldTransformMatrix: new M(),
       worldColor: 4294967295,
-      offset: new Xe()
-    }, d = {
+      offset: new Bt()
+    }, l = {
       projectionMatrix: t || this._renderer.renderTarget.projectionMatrix,
-      resolution: e || i.size,
+      resolution: e || a.size,
       worldTransformMatrix: r || o.worldTransformMatrix,
       worldColor: s || o.worldColor,
-      offset: n || o.offset,
+      offset: i || o.offset,
       bindGroup: null
-    }, c = this._uniformsPool.pop() || this._createUniforms();
-    this._activeUniforms.push(c);
-    const h = c.uniforms;
-    h.uProjectionMatrix = d.projectionMatrix, h.uResolution = d.resolution, h.uWorldTransformMatrix.copyFrom(d.worldTransformMatrix), h.uWorldTransformMatrix.tx -= d.offset.x, h.uWorldTransformMatrix.ty -= d.offset.y, Ze(
-      d.worldColor,
-      h.uWorldColorAlpha,
+    }, d = this._uniformsPool.pop() || this._createUniforms();
+    this._activeUniforms.push(d);
+    const f = d.uniforms;
+    f.uProjectionMatrix = l.projectionMatrix, f.uResolution = l.resolution, f.uWorldTransformMatrix.copyFrom(l.worldTransformMatrix), f.uWorldTransformMatrix.tx -= l.offset.x, f.uWorldTransformMatrix.ty -= l.offset.y, Sr(
+      l.worldColor,
+      f.uWorldColorAlpha,
       0
-    ), c.update();
-    let u;
-    this._renderer.renderPipes.uniformBatch ? u = this._renderer.renderPipes.uniformBatch.getUniformBindGroup(c, !1) : (u = this._bindGroupPool.pop() || new Qe(), this._activeBindGroups.push(u), u.setResource(c, 0)), d.bindGroup = u, this._currentGlobalUniformData = d;
+    ), d.update();
+    let c;
+    this._renderer.renderPipes.uniformBatch ? c = this._renderer.renderPipes.uniformBatch.getUniformBindGroup(d, !1) : (c = this._bindGroupPool.pop() || new zt(), this._activeBindGroups.push(c), c.setResource(d, 0)), l.bindGroup = c, this._currentGlobalUniformData = l;
   }
   push(e) {
     this.bind(e), this._globalUniformDataStack[this._stackIndex++] = this._currentGlobalUniformData;
   }
   pop() {
-    this._currentGlobalUniformData = this._globalUniformDataStack[--this._stackIndex - 1], this._renderer.type === V.WEBGL && this._currentGlobalUniformData.bindGroup.resources[0].update();
+    this._currentGlobalUniformData = this._globalUniformDataStack[--this._stackIndex - 1], this._renderer.type === ae.WEBGL && this._currentGlobalUniformData.bindGroup.resources[0].update();
   }
   get bindGroup() {
     return this._currentGlobalUniformData.bindGroup;
@@ -1700,9 +2727,9 @@ class Ue {
     return this._currentGlobalUniformData.bindGroup.resources[0];
   }
   _createUniforms() {
-    return new oe({
-      uProjectionMatrix: { value: new m(), type: "mat3x3<f32>" },
-      uWorldTransformMatrix: { value: new m(), type: "mat3x3<f32>" },
+    return new ie({
+      uProjectionMatrix: { value: new M(), type: "mat3x3<f32>" },
+      uWorldTransformMatrix: { value: new M(), type: "mat3x3<f32>" },
       // TODO - someone smart - set this to be a unorm8x4 rather than a vec4<f32>
       uWorldColorAlpha: { value: new Float32Array(4), type: "vec4<f32>" },
       uResolution: { value: [0, 0], type: "vec2<f32>" }
@@ -1714,22 +2741,22 @@ class Ue {
     this._renderer = null, this._globalUniformDataStack.length = 0, this._uniformsPool.length = 0, this._activeUniforms.length = 0, this._bindGroupPool.length = 0, this._activeBindGroups.length = 0, this._currentGlobalUniformData = null;
   }
 }
-Ue.extension = {
+xt.extension = {
   type: [
-    l.WebGLSystem,
-    l.WebGPUSystem,
-    l.CanvasSystem
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
   ],
   name: "globalUniforms"
 };
-let Ct = 1;
-class Ae {
+let Vr = 1;
+class gt {
   constructor() {
     this._tasks = [], this._offset = 0;
   }
   /** Initializes the scheduler system and starts the ticker. */
   init() {
-    te.system.add(this._update, this);
+    ge.system.add(this._update, this);
   }
   /**
    * Schedules a repeating task.
@@ -1739,13 +2766,13 @@ class Ae {
    * @returns The unique identifier for the scheduled task.
    */
   repeat(e, t, r = !0) {
-    const s = Ct++;
-    let n = 0;
-    return r && (this._offset += 1e3, n = this._offset), this._tasks.push({
+    const s = Vr++;
+    let i = 0;
+    return r && (this._offset += 1e3, i = this._offset), this._tasks.push({
       func: e,
       duration: t,
       start: performance.now(),
-      offset: n,
+      offset: i,
       last: performance.now(),
       repeat: !0,
       id: s
@@ -1781,24 +2808,24 @@ class Ae {
    * @internal
    */
   destroy() {
-    te.system.remove(this._update, this), this._tasks.length = 0;
+    ge.system.remove(this._update, this), this._tasks.length = 0;
   }
 }
-Ae.extension = {
+gt.extension = {
   type: [
-    l.WebGLSystem,
-    l.WebGPUSystem,
-    l.CanvasSystem
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
   ],
   name: "scheduler",
   priority: 0
 };
-let ie = !1;
-function kt(a) {
-  if (!ie) {
-    if (N.get().getNavigator().userAgent.toLowerCase().indexOf("chrome") > -1) {
+let Ee = !1;
+function Fr(n) {
+  if (!Ee) {
+    if (ne.get().getNavigator().userAgent.toLowerCase().indexOf("chrome") > -1) {
       const e = [
-        `%c  %c  %c  %c  %c PixiJS %c v${re} (${a}) http://www.pixijs.com/
+        `%c  %c  %c  %c  %c PixiJS %c v${_e} (${n}) http://www.pixijs.com/
 
 `,
         "background: #E72264; padding:5px 0;",
@@ -1809,11 +2836,11 @@ function kt(a) {
         "color: #E72264; background: #FFFFFF; padding:5px 0;"
       ];
       globalThis.console.log(...e);
-    } else globalThis.console && globalThis.console.log(`PixiJS ${re} - ${a} - http://www.pixijs.com/`);
-    ie = !0;
+    } else globalThis.console && globalThis.console.log(`PixiJS ${_e} - ${n} - http://www.pixijs.com/`);
+    Ee = !0;
   }
 }
-class J {
+class he {
   constructor(e) {
     this._renderer = e;
   }
@@ -1824,24 +2851,24 @@ class J {
   init(e) {
     if (e.hello) {
       let t = this._renderer.name;
-      this._renderer.type === V.WEBGL && (t += ` ${this._renderer.context.webGLVersion}`), kt(t);
+      this._renderer.type === ae.WEBGL && (t += ` ${this._renderer.context.webGLVersion}`), Fr(t);
     }
   }
 }
-J.extension = {
+he.extension = {
   type: [
-    l.WebGLSystem,
-    l.WebGPUSystem,
-    l.CanvasSystem
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
   ],
   name: "hello",
   priority: -2
 };
-J.defaultOptions = {
+he.defaultOptions = {
   /** {@link WebGLOptions.hello} */
   hello: !1
 };
-const X = class Ie {
+const fe = class _t {
   /**
    * Creates a new RenderableGCSystem instance.
    * @param renderer - The renderer this garbage collection system works for
@@ -1854,14 +2881,14 @@ const X = class Ie {
    * @param options - Configuration options for the renderer
    */
   init(e) {
-    e = { ...Ie.defaultOptions, ...e }, this.maxUnusedTime = e.renderableGCMaxUnusedTime;
+    e = { ..._t.defaultOptions, ...e }, this.maxUnusedTime = e.renderableGCMaxUnusedTime;
   }
   /**
    * Gets whether the garbage collection system is currently enabled.
    * @returns True if GC is enabled, false otherwise
    */
   get enabled() {
-    return p("8.15.0", "RenderableGCSystem.enabled is deprecated, please use the GCSystem.enabled instead."), this._renderer.gc.enabled;
+    return T("8.15.0", "RenderableGCSystem.enabled is deprecated, please use the GCSystem.enabled instead."), this._renderer.gc.enabled;
   }
   /**
    * Enables or disables the garbage collection system.
@@ -1869,7 +2896,7 @@ const X = class Ie {
    * When disabled, cancels all scheduled cleanups.
    */
   set enabled(e) {
-    p("8.15.0", "RenderableGCSystem.enabled is deprecated, please use the GCSystem.enabled instead."), this._renderer.gc.enabled = e;
+    T("8.15.0", "RenderableGCSystem.enabled is deprecated, please use the GCSystem.enabled instead."), this._renderer.gc.enabled = e;
   }
   /**
    * Adds a hash table to be managed by the garbage collector.
@@ -1877,7 +2904,7 @@ const X = class Ie {
    * @param hash - The property name of the hash table
    */
   addManagedHash(e, t) {
-    p("8.15.0", "RenderableGCSystem.addManagedHash is deprecated, please use the GCSystem.addCollection instead."), this._renderer.gc.addCollection(e, t, "hash");
+    T("8.15.0", "RenderableGCSystem.addManagedHash is deprecated, please use the GCSystem.addCollection instead."), this._renderer.gc.addCollection(e, t, "hash");
   }
   /**
    * Adds an array to be managed by the garbage collector.
@@ -1885,7 +2912,7 @@ const X = class Ie {
    * @param hash - The property name of the array
    */
   addManagedArray(e, t) {
-    p("8.15.0", "RenderableGCSystem.addManagedArray is deprecated, please use the GCSystem.addCollection instead."), this._renderer.gc.addCollection(e, t, "array");
+    T("8.15.0", "RenderableGCSystem.addManagedArray is deprecated, please use the GCSystem.addCollection instead."), this._renderer.gc.addCollection(e, t, "array");
   }
   /**
    * Starts tracking a renderable for garbage collection.
@@ -1893,30 +2920,30 @@ const X = class Ie {
    * @deprecated since 8.15.0
    */
   addRenderable(e) {
-    p("8.15.0", "RenderableGCSystem.addRenderable is deprecated, please use the GCSystem instead."), this._renderer.gc.addResource(e, "renderable");
+    T("8.15.0", "RenderableGCSystem.addRenderable is deprecated, please use the GCSystem instead."), this._renderer.gc.addResource(e, "renderable");
   }
   /**
    * Performs garbage collection by cleaning up unused renderables.
    * Removes renderables that haven't been used for longer than maxUnusedTime.
    */
   run() {
-    p("8.15.0", "RenderableGCSystem.run is deprecated, please use the GCSystem instead."), this._renderer.gc.run();
+    T("8.15.0", "RenderableGCSystem.run is deprecated, please use the GCSystem instead."), this._renderer.gc.run();
   }
   /** Cleans up the garbage collection system. Disables GC and removes all tracked resources. */
   destroy() {
     this._renderer = null;
   }
 };
-X.extension = {
+fe.extension = {
   type: [
-    l.WebGLSystem,
-    l.WebGPUSystem,
-    l.CanvasSystem
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
   ],
   name: "renderableGC",
   priority: 0
 };
-X.defaultOptions = {
+fe.defaultOptions = {
   /** Enable/disable the garbage collector */
   renderableGCActive: !0,
   /** Time in ms before an unused resource is collected (default 1 minute) */
@@ -1924,8 +2951,8 @@ X.defaultOptions = {
   /** How often to run garbage collection in ms (default 30 seconds) */
   renderableGCFrequency: 3e4
 };
-let Mt = X;
-const Z = class S {
+let Lr = fe;
+const pe = class H {
   /**
    * Frame count since started.
    * @readonly
@@ -1943,7 +2970,7 @@ const Z = class S {
     return this._checkCount;
   }
   set checkCount(e) {
-    p("8.15.0", "TextureGCSystem.run is deprecated, please use the GCSystem instead."), this._checkCount = e;
+    T("8.15.0", "TextureGCSystem.run is deprecated, please use the GCSystem instead."), this._checkCount = e;
   }
   /**
    * Maximum idle frames before a texture is destroyed by garbage collection.
@@ -1954,7 +2981,7 @@ const Z = class S {
     return this._renderer.gc.maxUnusedTime / 1e3 * 60;
   }
   set maxIdle(e) {
-    p("8.15.0", "TextureGCSystem.run is deprecated, please use the GCSystem instead."), this._renderer.gc.maxUnusedTime = e / 60 * 1e3;
+    T("8.15.0", "TextureGCSystem.run is deprecated, please use the GCSystem instead."), this._renderer.gc.maxUnusedTime = e / 60 * 1e3;
   }
   /**
    * Frames between two garbage collections.
@@ -1966,7 +2993,7 @@ const Z = class S {
     return Math.floor(this._renderer.gc._frequency / 1e3);
   }
   set checkCountMax(e) {
-    p("8.15.0", "TextureGCSystem.run is deprecated, please use the GCSystem instead.");
+    T("8.15.0", "TextureGCSystem.run is deprecated, please use the GCSystem instead.");
   }
   /**
    * Current garbage collection mode.
@@ -1977,14 +3004,14 @@ const Z = class S {
     return this._renderer.gc.enabled;
   }
   set active(e) {
-    p("8.15.0", "TextureGCSystem.run is deprecated, please use the GCSystem instead."), this._renderer.gc.enabled = e;
+    T("8.15.0", "TextureGCSystem.run is deprecated, please use the GCSystem instead."), this._renderer.gc.enabled = e;
   }
   /** @param renderer - The renderer this System works for. */
   constructor(e) {
     this._renderer = e, this._checkCount = 0;
   }
   init(e) {
-    e.textureGCActive !== S.defaultOptions.textureGCActive && (this.active = e.textureGCActive), e.textureGCMaxIdle !== S.defaultOptions.textureGCMaxIdle && (this.maxIdle = e.textureGCMaxIdle), e.textureGCCheckCountMax !== S.defaultOptions.textureGCCheckCountMax && (this.checkCountMax = e.textureGCCheckCountMax);
+    e.textureGCActive !== H.defaultOptions.textureGCActive && (this.active = e.textureGCActive), e.textureGCMaxIdle !== H.defaultOptions.textureGCMaxIdle && (this.maxIdle = e.textureGCMaxIdle), e.textureGCCheckCountMax !== H.defaultOptions.textureGCCheckCountMax && (this.checkCountMax = e.textureGCCheckCountMax);
   }
   /**
    * Checks to see when the last time a texture was used.
@@ -1992,20 +3019,20 @@ const Z = class S {
    * @deprecated since 8.15.0
    */
   run() {
-    p("8.15.0", "TextureGCSystem.run is deprecated, please use the GCSystem instead."), this._renderer.gc.run();
+    T("8.15.0", "TextureGCSystem.run is deprecated, please use the GCSystem instead."), this._renderer.gc.run();
   }
   destroy() {
     this._renderer = null;
   }
 };
-Z.extension = {
+pe.extension = {
   type: [
-    l.WebGLSystem,
-    l.WebGPUSystem
+    u.WebGLSystem,
+    u.WebGPUSystem
   ],
   name: "textureGC"
 };
-Z.defaultOptions = {
+pe.defaultOptions = {
   /**
    * If set to true, this will enable the garbage collector on the GPU.
    * @default true
@@ -2027,17 +3054,17 @@ Z.defaultOptions = {
    */
   textureGCCheckCountMax: 600
 };
-let Rt = Z;
-const De = class Ee {
+let Wr = pe;
+const bt = class vt {
   /**
    * @param [descriptor] - Options for creating a render target.
    */
   constructor(e = {}) {
-    if (this.uid = et("renderTarget"), this.colorTextures = [], this.dirtyId = 0, this.isRoot = !1, this._size = new Float32Array(2), this._managedColorTextures = !1, e = { ...Ee.defaultOptions, ...e }, this.stencil = e.stencil, this.depth = e.depth, this.isRoot = e.isRoot, typeof e.colorTextures == "number") {
+    if (this.uid = ze("renderTarget"), this.colorTextures = [], this.dirtyId = 0, this.isRoot = !1, this._size = new Float32Array(2), this._managedColorTextures = !1, e = { ...vt.defaultOptions, ...e }, this.stencil = e.stencil, this.depth = e.depth, this.isRoot = e.isRoot, typeof e.colorTextures == "number") {
       this._managedColorTextures = !0;
       for (let t = 0; t < e.colorTextures; t++)
         this.colorTextures.push(
-          new y({
+          new I({
             width: e.width,
             height: e.height,
             resolution: e.resolution,
@@ -2049,7 +3076,7 @@ const De = class Ee {
       const t = this.colorTexture.source;
       this.resize(t.width, t.height, t._resolution);
     }
-    this.colorTexture.source.on("resize", this.onSourceResize, this), (e.depthStencilTexture || this.stencil) && (e.depthStencilTexture instanceof f || e.depthStencilTexture instanceof y ? this.depthStencilTexture = e.depthStencilTexture.source : this.ensureDepthStencilTexture());
+    this.colorTexture.source.on("resize", this.onSourceResize, this), (e.depthStencilTexture || this.stencil) && (e.depthStencilTexture instanceof S || e.depthStencilTexture instanceof I ? this.depthStencilTexture = e.depthStencilTexture.source : this.ensureDepthStencilTexture());
   }
   get size() {
     const e = this._size;
@@ -2082,7 +3109,7 @@ const De = class Ee {
    * @internal
    */
   ensureDepthStencilTexture() {
-    this.depthStencilTexture || (this.depthStencilTexture = new y({
+    this.depthStencilTexture || (this.depthStencilTexture = new I({
       width: this.width,
       height: this.height,
       resolution: this.resolution,
@@ -2094,8 +3121,8 @@ const De = class Ee {
     }));
   }
   resize(e, t, r = this.resolution, s = !1) {
-    this.dirtyId++, this.colorTextures.forEach((n, i) => {
-      s && i === 0 || n.source.resize(e, t, r);
+    this.dirtyId++, this.colorTextures.forEach((i, a) => {
+      s && a === 0 || i.source.resize(e, t, r);
     }), this.depthStencilTexture && this.depthStencilTexture.source.resize(e, t, r);
   }
   destroy() {
@@ -2104,7 +3131,7 @@ const De = class Ee {
     }), this.depthStencilTexture && (this.depthStencilTexture.destroy(), delete this.depthStencilTexture);
   }
 };
-De.defaultOptions = {
+bt.defaultOptions = {
   /** the width of the RenderTarget */
   width: 0,
   /** the height of the RenderTarget */
@@ -2123,24 +3150,24 @@ De.defaultOptions = {
   /** is this a root element, true if this is gl context owners render target */
   isRoot: !1
 };
-let H = De;
-const b = /* @__PURE__ */ new Map();
-tt.register(b);
-function Oe(a, e) {
-  if (!b.has(a)) {
-    const t = new f({
-      source: new O({
-        resource: a,
+let ee = bt;
+const P = /* @__PURE__ */ new Map();
+He.register(P);
+function yt(n, e) {
+  if (!P.has(n)) {
+    const t = new S({
+      source: new X({
+        resource: n,
         ...e
       })
     }), r = () => {
-      b.get(a) === t && b.delete(a);
+      P.get(n) === t && P.delete(n);
     };
-    t.once("destroy", r), t.source.once("destroy", r), b.set(a, t);
+    t.once("destroy", r), t.source.once("destroy", r), P.set(n, t);
   }
-  return b.get(a);
+  return P.get(n);
 }
-const Q = class Le {
+const me = class Tt {
   /**
    * Whether CSS dimensions of canvas view should be resized to screen dimensions automatically.
    * This is only supported for HTMLCanvasElement and will be ignored if the canvas is an OffscreenCanvas.
@@ -2169,9 +3196,9 @@ const Q = class Le {
    */
   init(e) {
     e = {
-      ...Le.defaultOptions,
+      ...Tt.defaultOptions,
       ...e
-    }, e.view && (p(rt, "ViewSystem.view has been renamed to ViewSystem.canvas"), e.canvas = e.view), this.screen = new B(0, 0, e.width, e.height), this.canvas = e.canvas || N.get().createCanvas(), this.antialias = !!e.antialias, this.texture = Oe(this.canvas, e), this.renderTarget = new H({
+    }, e.view && (T(Rt, "ViewSystem.view has been renamed to ViewSystem.canvas"), e.canvas = e.view), this.screen = new L(0, 0, e.width, e.height), this.canvas = e.canvas || ne.get().createCanvas(), this.antialias = !!e.antialias, this.texture = yt(this.canvas, e), this.renderTarget = new ee({
       colorTextures: [this.texture],
       depth: !!e.depth,
       isRoot: !0
@@ -2198,16 +3225,16 @@ const Q = class Le {
     (typeof e == "boolean" ? e : !!(e != null && e.removeView)) && this.canvas.parentNode && this.canvas.parentNode.removeChild(this.canvas), this.texture.destroy();
   }
 };
-Q.extension = {
+me.extension = {
   type: [
-    l.WebGLSystem,
-    l.WebGPUSystem,
-    l.CanvasSystem
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
   ],
   name: "view",
   priority: 0
 };
-Q.defaultOptions = {
+me.defaultOptions = {
   /**
    * {@link WebGLOptions.width}
    * @default 800
@@ -2229,41 +3256,41 @@ Q.defaultOptions = {
    */
   antialias: !1
 };
-let St = Q;
-const Ut = [
-  mt,
-  Ue,
-  J,
-  St,
-  Se,
-  vt,
-  Rt,
-  Be,
-  gt,
+let Or = me;
+const Qr = [
+  Ar,
+  xt,
+  he,
+  Or,
+  dt,
+  Hr,
+  Wr,
+  pt,
+  Ur,
+  Pt,
+  Lr,
+  gt
+], Yr = [
+  lt,
+  tt,
+  ot,
+  at,
+  rt,
+  nt,
   st,
-  Mt,
-  Ae
-], At = [
-  ke,
-  _e,
-  Ce,
-  ve,
-  xe,
-  Te,
-  be,
-  ye
+  it
 ];
-function wt(a, e, t, r, s, n) {
-  const i = n ? 1 : -1;
-  return a.identity(), a.a = 1 / r * 2, a.d = i * (1 / s * 2), a.tx = -1 - e * a.a, a.ty = -i - t * a.d, a;
+function $r(n, e, t, r, s, i) {
+  const a = i ? 1 : -1;
+  return n.identity(), n.a = 1 / r * 2, n.d = a * (1 / s * 2), n.tx = -1 - e * n.a, n.ty = -a - t * n.d, n;
 }
-function Pt(a) {
-  const e = a.colorTexture.source.resource;
+function jr(n) {
+  const e = n.colorTexture.source.resource;
   return globalThis.HTMLCanvasElement && e instanceof HTMLCanvasElement && document.body.contains(e);
 }
-class It {
+class Xr {
   constructor(e) {
-    this.rootViewPort = new B(), this.viewport = new B(), this.mipLevel = 0, this.layer = 0, this.onRenderTargetChange = new nt("onRenderTargetChange"), this.projectionMatrix = new m(), this.defaultClearColor = [0, 0, 0, 0], this._renderSurfaceToRenderTargetHash = /* @__PURE__ */ new Map(), this._gpuRenderTargetHash = /* @__PURE__ */ Object.create(null), this._renderTargetStack = [], this._renderer = e, e.gc.addCollection(this, "_gpuRenderTargetHash", "hash");
+    this.rootViewPort = new L(), this.viewport = new L(), this.mipLevel = 0, this.layer = 0, this.onRenderTargetChange = new At("onRenderTargetChange"), this.projectionMatrix = new M(), this.defaultClearColor = [0, 0, 0, 0], this._renderSurfaceToRenderTargetHash = /* @__PURE__ */ new Map(), this._gpuRenderTargetHash = /* @__PURE__ */ Object.create(null), this._renderTargetStack = [], this._renderer = e, e.gc.addCollection(this, "_gpuRenderTargetHash", "hash");
   }
   /** called when dev wants to finish a render pass */
   finishRenderPass() {
@@ -2285,18 +3312,18 @@ class It {
     clear: t,
     clearColor: r,
     frame: s,
-    mipLevel: n,
-    layer: i
+    mipLevel: i,
+    layer: a
   }) {
-    var o, d;
+    var o, l;
     this._renderTargetStack.length = 0, this.push(
       e,
       t,
       r,
       s,
-      n ?? 0,
-      i ?? 0
-    ), this.rootViewPort.copyFrom(this.viewport), this.rootRenderTarget = this.renderTarget, this.renderingToScreen = Pt(this.rootRenderTarget), (d = (o = this.adaptor).prerender) == null || d.call(o, this.rootRenderTarget);
+      i ?? 0,
+      a ?? 0
+    ), this.rootViewPort.copyFrom(this.viewport), this.rootRenderTarget = this.renderTarget, this.renderingToScreen = jr(this.rootRenderTarget), (l = (o = this.adaptor).prerender) == null || l.call(o, this.rootRenderTarget);
   }
   postrender() {
     var e, t;
@@ -2327,39 +3354,39 @@ class It {
    * Ignored for surfaces that do not support layers.
    * @returns the render target that was bound
    */
-  bind(e, t = !0, r, s, n = 0, i = 0) {
-    const o = this.getRenderTarget(e), d = this.renderTarget !== o;
+  bind(e, t = !0, r, s, i = 0, a = 0) {
+    const o = this.getRenderTarget(e), l = this.renderTarget !== o;
     this.renderTarget = o, this.renderSurface = e;
-    const c = this.getGpuRenderTarget(o);
-    (o.pixelWidth !== c.width || o.pixelHeight !== c.height) && (this.adaptor.resizeGpuRenderTarget(o), c.width = o.pixelWidth, c.height = o.pixelHeight);
-    const h = o.colorTexture, u = this.viewport, G = h.arrayLayerCount || 1;
-    if ((i | 0) !== i && (i |= 0), i < 0 || i >= G)
-      throw new Error(`[RenderTargetSystem] layer ${i} is out of bounds (arrayLayerCount=${G}).`);
-    this.mipLevel = n | 0, this.layer = i | 0;
-    const _ = Math.max(h.pixelWidth >> n, 1), x = Math.max(h.pixelHeight >> n, 1);
-    if (!s && e instanceof f && (s = e.frame), s) {
-      const C = h._resolution, k = 1 << Math.max(n | 0, 0), Fe = s.x * C + 0.5 | 0, He = s.y * C + 0.5 | 0, We = s.width * C + 0.5 | 0, ze = s.height * C + 0.5 | 0;
-      let M = Math.floor(Fe / k), R = Math.floor(He / k), U = Math.ceil(We / k), A = Math.ceil(ze / k);
-      M = Math.min(Math.max(M, 0), _ - 1), R = Math.min(Math.max(R, 0), x - 1), U = Math.min(Math.max(U, 1), _ - M), A = Math.min(Math.max(A, 1), x - R), u.x = M, u.y = R, u.width = U, u.height = A;
+    const d = this.getGpuRenderTarget(o);
+    (o.pixelWidth !== d.width || o.pixelHeight !== d.height) && (this.adaptor.resizeGpuRenderTarget(o), d.width = o.pixelWidth, d.height = o.pixelHeight);
+    const f = o.colorTexture, c = this.viewport, x = f.arrayLayerCount || 1;
+    if ((a | 0) !== a && (a |= 0), a < 0 || a >= x)
+      throw new Error(`[RenderTargetSystem] layer ${a} is out of bounds (arrayLayerCount=${x}).`);
+    this.mipLevel = i | 0, this.layer = a | 0;
+    const g = Math.max(f.pixelWidth >> i, 1), m = Math.max(f.pixelHeight >> i, 1);
+    if (!s && e instanceof S && (s = e.frame), s) {
+      const v = f._resolution, _ = 1 << Math.max(i | 0, 0), h = s.x * v + 0.5 | 0, C = s.y * v + 0.5 | 0, p = s.width * v + 0.5 | 0, y = s.height * v + 0.5 | 0;
+      let b = Math.floor(h / _), B = Math.floor(C / _), O = Math.ceil(p / _), $ = Math.ceil(y / _);
+      b = Math.min(Math.max(b, 0), g - 1), B = Math.min(Math.max(B, 0), m - 1), O = Math.min(Math.max(O, 1), g - b), $ = Math.min(Math.max($, 1), m - B), c.x = b, c.y = B, c.width = O, c.height = $;
     } else
-      u.x = 0, u.y = 0, u.width = _, u.height = x;
-    return wt(
+      c.x = 0, c.y = 0, c.width = g, c.height = m;
+    return $r(
       this.projectionMatrix,
       0,
       0,
-      u.width / h.resolution,
-      u.height / h.resolution,
+      c.width / f.resolution,
+      c.height / f.resolution,
       !o.isRoot
-    ), this.adaptor.startRenderPass(o, t, r, u, n, i), d && this.onRenderTargetChange.emit(o), o;
+    ), this.adaptor.startRenderPass(o, t, r, c, i, a), l && this.onRenderTargetChange.emit(o), o;
   }
-  clear(e, t = D.ALL, r, s = this.mipLevel, n = this.layer) {
+  clear(e, t = Q.ALL, r, s = this.mipLevel, i = this.layer) {
     t && (e && (e = this.getRenderTarget(e)), this.adaptor.clear(
       e || this.renderTarget,
       t,
       r,
       this.viewport,
       s,
-      n
+      i
     ));
   }
   contextChange() {
@@ -2375,13 +3402,13 @@ class It {
    * @param layer - The layer of the render surface to render to. For array textures or cube maps, this specifies
    * which layer or face to target. Defaults to 0 (the first layer).
    */
-  push(e, t = D.ALL, r, s, n = 0, i = 0) {
-    const o = this.bind(e, t, r, s, n, i);
+  push(e, t = Q.ALL, r, s, i = 0, a = 0) {
+    const o = this.bind(e, t, r, s, i, a);
     return this._renderTargetStack.push({
       renderTarget: o,
       frame: s,
-      mipLevel: n,
-      layer: i
+      mipLevel: i,
+      layer: a
     }), o;
   }
   /** Pops the current render target from the renderer and restores the previous render target. */
@@ -2446,15 +3473,15 @@ class It {
    * @param {number} originDest.x - the x origin of the paste
    * @param {number} originDest.y - the y origin of the paste
    */
-  copyToTexture(e, t, r, s, n) {
-    r.x < 0 && (s.width += r.x, n.x -= r.x, r.x = 0), r.y < 0 && (s.height += r.y, n.y -= r.y, r.y = 0);
-    const { pixelWidth: i, pixelHeight: o } = e;
-    return s.width = Math.min(s.width, i - r.x), s.height = Math.min(s.height, o - r.y), this.adaptor.copyToTexture(
+  copyToTexture(e, t, r, s, i) {
+    r.x < 0 && (s.width += r.x, i.x -= r.x, r.x = 0), r.y < 0 && (s.height += r.y, i.y -= r.y, r.y = 0);
+    const { pixelWidth: a, pixelHeight: o } = e;
+    return s.width = Math.min(s.width, a - r.x), s.height = Math.min(s.height, o - r.y), this.adaptor.copyToTexture(
       e,
       t,
       r,
       s,
-      n
+      i
     );
   }
   /**
@@ -2472,9 +3499,9 @@ class It {
   }
   _initRenderTarget(e) {
     let t = null;
-    return O.test(e) && (e = Oe(e).source), e instanceof H ? t = e : e instanceof y && (t = new H({
+    return X.test(e) && (e = yt(e).source), e instanceof ee ? t = e : e instanceof I && (t = new ee({
       colorTextures: [e]
-    }), e.source instanceof O && (t.isRoot = !0), e.once("destroy", () => {
+    }), e.source instanceof X && (t.isRoot = !0), e.once("destroy", () => {
       t.destroy(), this._renderSurfaceToRenderTargetHash.delete(e);
       const r = this._gpuRenderTargetHash[t.uid];
       r && (this._gpuRenderTargetHash[t.uid] = null, this.adaptor.destroyGpuRenderTarget(r));
@@ -2488,14 +3515,29 @@ class It {
   }
 }
 export {
-  xe as A,
-  ke as B,
-  ye as C,
-  It as R,
-  Ut as S,
-  _e as a,
-  Ce as b,
-  ve as c,
-  At as d
+  rt as A,
+  lt as B,
+  it as C,
+  Je as D,
+  qr as G,
+  Xr as R,
+  k as S,
+  dr as a,
+  Qr as b,
+  ur as c,
+  Yr as d,
+  Lt as e,
+  ye as f,
+  mr as g,
+  cr as h,
+  hr as i,
+  br as j,
+  gr as k,
+  vr as l,
+  Sr as m,
+  tt as n,
+  ot as o,
+  at as p,
+  _r as r
 };
-//# sourceMappingURL=RenderTargetSystem-CzB0gbGa.js.map
+//# sourceMappingURL=RenderTargetSystem-BCBByEgg.js.map