wuepgg3-track 2.0.4 → 2.0.6

package/dist/{init-kuY9xSth.mjs → init-D-ioxIiP.mjs}

@@ -1,6 +1,6 @@
-import { E as g, U as at, T as ce, a as ot, a0 as w, a1 as M, s as S, aa as he, Y as W, ab as D, N as lt, l as V, ac as ut, ad as fe, Z as we, ae as I, af as C, w as re, k as z, c as Se, F, M as R, a3 as se, R as ie, z as Pe, b as O, B, D as ne, x as X, ag as dt, ah as ae, J as ee, ai as L, q as oe, t as ct, G as ht, m as Ce, p as Fe, a5 as Be, a8 as Ue, n as ft, o as pt, a6 as gt, a7 as mt, a9 as xt, aj as _t, ak as bt, al as N, e as T, am as yt } from "./index-CyClmTrp.mjs";
-import { S as j, c as $, a as vt, b as Tt, B as Me } from "./colorToUniform-zJcCVLeu.mjs";
-class Re {
+import { E as m, U as ct, T as de, b as dt, a2 as w, a3 as U, t as C, ac as he, Z as I, ad as D, O as ht, n as Y, ae as ft, af as fe, _ as Se, ag as W, ah as pt, ai as P, w as X, G as Pe, a as Fe, M as R, m as A, h as Be, F, a5 as ie, R as se, z as Re, d as O, B, D as ne, x as K, aj as gt, ak as ae, J as te, al as V, S as oe, o as Me, s as Ue, a7 as Ge, aa as ze, p as mt, q as xt, a8 as _t, a9 as yt, ab as bt, am as vt, an as Tt, ao as N, e as T, ap as wt } from "./index-qbfgPm_j.mjs";
+import { F as Ct, S as j, c as $, a as St, b as Pt, B as Ae } from "./colorToUniform-CSn0Emyh.mjs";
+class ke {
   /**
    * Initialize the plugin with scope of application instance
    * @private
@@ -30,8 +30,8 @@ class Re {
       if (this._resizeTo === globalThis.window)
         t = globalThis.innerWidth, r = globalThis.innerHeight;
       else {
-        const { clientWidth: s, clientHeight: i } = this._resizeTo;
-        t = s, r = i;
+        const { clientWidth: i, clientHeight: s } = this._resizeTo;
+        t = i, r = s;
       }
       this.renderer.resize(t, r), this.render();
     }, this._resizeId = null, this._resizeTo = null, this.resizeTo = e.resizeTo || null;
@@ -44,8 +44,8 @@ class Re {
     globalThis.removeEventListener("resize", this.queueResize), this._cancelResize(), this._cancelResize = null, this.queueResize = null, this.resizeTo = null, this.resize = null;
   }
 }
-Re.extension = g.Application;
-class Ge {
+ke.extension = m.Application;
+class De {
   /**
    * Initialize the plugin with scope of application instance
    * @private
@@ -60,7 +60,7 @@ class Ge {
       "ticker",
       {
         set(t) {
-          this._ticker && this._ticker.remove(this.render, this), this._ticker = t, t && t.add(this.render, this, at.LOW);
+          this._ticker && this._ticker.remove(this.render, this), this._ticker = t, t && t.add(this.render, this, ct.LOW);
         },
         get() {
           return this._ticker;
@@ -70,7 +70,7 @@ class Ge {
       this._ticker.stop();
     }, this.start = () => {
       this._ticker.start();
-    }, this._ticker = null, this.ticker = e.sharedTicker ? ce.shared : new ce(), e.autoStart && this.start();
+    }, this._ticker = null, this.ticker = e.sharedTicker ? de.shared : new de(), e.autoStart && this.start();
   }
   /**
    * Clean up the ticker, scoped to application.
@@ -83,8 +83,8 @@ class Ge {
     }
   }
 }
-Ge.extension = g.Application;
-class wt extends ot {
+De.extension = m.Application;
+class Ft extends dt {
   constructor() {
     super(...arguments), this.chars = /* @__PURE__ */ Object.create(null), this.lineHeight = 0, this.fontFamily = "", this.fontMetrics = { fontSize: 0, ascent: 0, descent: 0 }, this.baseLineOffset = 0, this.distanceField = { type: "none", range: 0 }, this.pages = [], this.applyFillAsTint = !0, this.baseMeasurementFontSize = 100, this.baseRenderedFontSize = 100;
   }
@@ -93,35 +93,35 @@ class wt extends ot {
    * @deprecated since 8.0.0 Use `fontFamily` instead.
    */
   get font() {
-    return w(M, "BitmapFont.font is deprecated, please use BitmapFont.fontFamily instead."), this.fontFamily;
+    return w(U, "BitmapFont.font is deprecated, please use BitmapFont.fontFamily instead."), this.fontFamily;
   }
   /**
    * The map of base page textures (i.e., sheets of glyphs).
    * @deprecated since 8.0.0 Use `pages` instead.
    */
   get pageTextures() {
-    return w(M, "BitmapFont.pageTextures is deprecated, please use BitmapFont.pages instead."), this.pages;
+    return w(U, "BitmapFont.pageTextures is deprecated, please use BitmapFont.pages instead."), this.pages;
   }
   /**
    * The size of the font face in pixels.
    * @deprecated since 8.0.0 Use `fontMetrics.fontSize` instead.
    */
   get size() {
-    return w(M, "BitmapFont.size is deprecated, please use BitmapFont.fontMetrics.fontSize instead."), this.fontMetrics.fontSize;
+    return w(U, "BitmapFont.size is deprecated, please use BitmapFont.fontMetrics.fontSize instead."), this.fontMetrics.fontSize;
   }
   /**
    * The kind of distance field for this font or "none".
    * @deprecated since 8.0.0 Use `distanceField.type` instead.
    */
   get distanceFieldRange() {
-    return w(M, "BitmapFont.distanceFieldRange is deprecated, please use BitmapFont.distanceField.range instead."), this.distanceField.range;
+    return w(U, "BitmapFont.distanceFieldRange is deprecated, please use BitmapFont.distanceField.range instead."), this.distanceField.range;
   }
   /**
    * The range of the distance field in pixels.
    * @deprecated since 8.0.0 Use `distanceField.range` instead.
    */
   get distanceFieldType() {
-    return w(M, "BitmapFont.distanceFieldType is deprecated, please use BitmapFont.distanceField.type instead."), this.distanceField.type;
+    return w(U, "BitmapFont.distanceFieldType is deprecated, please use BitmapFont.distanceField.type instead."), this.distanceField.type;
   }
   destroy(e = !1) {
     var t;
@@ -131,154 +131,154 @@ class wt extends ot {
     this.chars = null, e && (this.pages.forEach((r) => r.texture.destroy(!0)), this.pages = null);
   }
 }
-const Ae = class ze extends wt {
+const Oe = class Ie extends Ft {
   /**
    * @param options - The options for the dynamic bitmap font.
    */
   constructor(e) {
     super(), this.resolution = 1, this.pages = [], this._padding = 0, this._measureCache = /* @__PURE__ */ Object.create(null), this._currentChars = [], this._currentX = 0, this._currentY = 0, this._currentMaxCharHeight = 0, this._currentPageIndex = -1, this._skipKerning = !1;
-    const t = { ...ze.defaultOptions, ...e };
+    const t = { ...Ie.defaultOptions, ...e };
     this._textureSize = t.textureSize, this._mipmap = t.mipmap;
     const r = t.style.clone();
-    t.overrideFill && (r._fill.color = 16777215, r._fill.alpha = 1, r._fill.texture = S.WHITE, r._fill.fill = null), this.applyFillAsTint = t.overrideFill;
-    const s = r.fontSize;
+    t.overrideFill && (r._fill.color = 16777215, r._fill.alpha = 1, r._fill.texture = C.WHITE, r._fill.fill = null), this.applyFillAsTint = t.overrideFill;
+    const i = r.fontSize;
     r.fontSize = this.baseMeasurementFontSize;
-    const i = he(r);
-    t.overrideSize ? r._stroke && (r._stroke.width *= this.baseRenderedFontSize / s) : r.fontSize = this.baseRenderedFontSize = s, this._style = r, this._skipKerning = t.skipKerning ?? !1, this.resolution = t.resolution ?? 1, this._padding = t.padding ?? 4, t.textureStyle && (this._textureStyle = t.textureStyle instanceof W ? t.textureStyle : new W(t.textureStyle)), this.fontMetrics = D.measureFont(i), this.lineHeight = r.lineHeight || this.fontMetrics.fontSize || r.fontSize;
+    const s = he(r);
+    t.overrideSize ? r._stroke && (r._stroke.width *= this.baseRenderedFontSize / i) : r.fontSize = this.baseRenderedFontSize = i, this._style = r, this._skipKerning = t.skipKerning ?? !1, this.resolution = t.resolution ?? 1, this._padding = t.padding ?? 4, t.textureStyle && (this._textureStyle = t.textureStyle instanceof I ? t.textureStyle : new I(t.textureStyle)), this.fontMetrics = D.measureFont(s), this.lineHeight = r.lineHeight || this.fontMetrics.fontSize || r.fontSize;
   }
   ensureCharacters(e) {
-    var x, p;
-    const t = D.graphemeSegmenter(e).filter((_) => !this._currentChars.includes(_)).filter((_, y, v) => v.indexOf(_) === y);
+    var b, x;
+    const t = D.graphemeSegmenter(e).filter((g) => !this._currentChars.includes(g)).filter((g, p, v) => v.indexOf(g) === p);
     if (!t.length)
       return;
     this._currentChars = [...this._currentChars, ...t];
     let r;
     this._currentPageIndex === -1 ? r = this._nextPage() : r = this.pages[this._currentPageIndex];
-    let { canvas: s, context: i } = r.canvasAndContext, n = r.texture.source;
+    let { canvas: i, context: s } = r.canvasAndContext, n = r.texture.source;
     const a = this._style;
-    let l = this._currentX, u = this._currentY, c = this._currentMaxCharHeight;
-    const d = this.baseRenderedFontSize / this.baseMeasurementFontSize, h = this._padding * d;
+    let u = this._currentX, l = this._currentY, d = this._currentMaxCharHeight;
+    const c = this.baseRenderedFontSize / this.baseMeasurementFontSize, h = this._padding * c;
     let f = !1;
-    const b = s.width / this.resolution, m = s.height / this.resolution;
-    for (let _ = 0; _ < t.length; _++) {
-      const y = t[_], v = D.measureText(y, a, s, !1);
+    const y = i.width / this.resolution, _ = i.height / this.resolution;
+    for (let g = 0; g < t.length; g++) {
+      const p = t[g], v = D.measureText(p, a, i, !1);
       v.lineHeight = v.height;
-      const P = v.width * d, G = Math.ceil((a.fontStyle === "italic" ? 2 : 1) * P), k = v.height * d, U = G + h * 2, E = k + h * 2;
-      if (f = !1, y !== `
-` && y !== "\r" && y !== "	" && y !== " " && (f = !0, c = Math.ceil(Math.max(E, c))), l + U > b && (u += c, c = E, l = 0, u + c > m)) {
+      const S = v.width * c, G = Math.ceil((a.fontStyle === "italic" ? 2 : 1) * S), k = v.height * c, M = G + h * 2, E = k + h * 2;
+      if (f = !1, p !== `
+` && p !== "\r" && p !== "	" && p !== " " && (f = !0, d = Math.ceil(Math.max(E, d))), u + M > y && (l += d, d = E, u = 0, l + d > _)) {
         n.update();
-        const A = this._nextPage();
-        s = A.canvasAndContext.canvas, i = A.canvasAndContext.context, n = A.texture.source, l = 0, u = 0, c = 0;
+        const z = this._nextPage();
+        i = z.canvasAndContext.canvas, s = z.canvasAndContext.context, n = z.texture.source, u = 0, l = 0, d = 0;
       }
-      const it = P / d - (((x = a.dropShadow) == null ? void 0 : x.distance) ?? 0) - (((p = a._stroke) == null ? void 0 : p.width) ?? 0);
-      if (this.chars[y] = {
-        id: y.codePointAt(0),
+      const ut = S / c - (((b = a.dropShadow) == null ? void 0 : b.distance) ?? 0) - (((x = a._stroke) == null ? void 0 : x.width) ?? 0);
+      if (this.chars[p] = {
+        id: p.codePointAt(0),
         xOffset: -this._padding,
         yOffset: -this._padding,
-        xAdvance: it,
+        xAdvance: ut,
         kerning: {}
       }, f) {
         this._drawGlyph(
-          i,
+          s,
           v,
-          l + h,
           u + h,
-          d,
+          l + h,
+          c,
           a
         );
-        const A = n.width * d, de = n.height * d, nt = new lt(
-          l / A * n.width,
-          u / de * n.height,
-          U / A * n.width,
-          E / de * n.height
+        const z = n.width * c, ce = n.height * c, lt = new ht(
+          u / z * n.width,
+          l / ce * n.height,
+          M / z * n.width,
+          E / ce * n.height
         );
-        this.chars[y].texture = new S({
+        this.chars[p].texture = new C({
           source: n,
-          frame: nt
-        }), l += Math.ceil(U);
+          frame: lt
+        }), u += Math.ceil(M);
       }
     }
-    n.update(), this._currentX = l, this._currentY = u, this._currentMaxCharHeight = c, this._skipKerning && this._applyKerning(t, i);
+    n.update(), this._currentX = u, this._currentY = l, this._currentMaxCharHeight = d, this._skipKerning && this._applyKerning(t, s);
   }
   /**
    * @deprecated since 8.0.0
    * The map of base page textures (i.e., sheets of glyphs).
    */
   get pageTextures() {
-    return w(M, "BitmapFont.pageTextures is deprecated, please use BitmapFont.pages instead."), this.pages;
+    return w(U, "BitmapFont.pageTextures is deprecated, please use BitmapFont.pages instead."), this.pages;
   }
   _applyKerning(e, t) {
     const r = this._measureCache;
-    for (let s = 0; s < e.length; s++) {
-      const i = e[s];
+    for (let i = 0; i < e.length; i++) {
+      const s = e[i];
       for (let n = 0; n < this._currentChars.length; n++) {
         const a = this._currentChars[n];
-        let l = r[i];
-        l || (l = r[i] = t.measureText(i).width);
-        let u = r[a];
-        u || (u = r[a] = t.measureText(a).width);
-        let c = t.measureText(i + a).width, d = c - (l + u);
-        d && (this.chars[i].kerning[a] = d), c = t.measureText(i + a).width, d = c - (l + u), d && (this.chars[a].kerning[i] = d);
+        let u = r[s];
+        u || (u = r[s] = t.measureText(s).width);
+        let l = r[a];
+        l || (l = r[a] = t.measureText(a).width);
+        let d = t.measureText(s + a).width, c = d - (u + l);
+        c && (this.chars[s].kerning[a] = c), d = t.measureText(s + a).width, c = d - (u + l), c && (this.chars[a].kerning[s] = c);
       }
     }
   }
   _nextPage() {
     this._currentPageIndex++;
-    const e = this.resolution, t = V.getOptimalCanvasAndContext(
+    const e = this.resolution, t = Y.getOptimalCanvasAndContext(
       this._textureSize,
       this._textureSize,
       e
     );
     this._setupContext(t.context, this._style, e);
-    const r = e * (this.baseRenderedFontSize / this.baseMeasurementFontSize), s = new S({
-      source: new ut({
+    const r = e * (this.baseRenderedFontSize / this.baseMeasurementFontSize), i = new C({
+      source: new ft({
         resource: t.canvas,
         resolution: r,
         alphaMode: "premultiply-alpha-on-upload",
         autoGenerateMipmaps: this._mipmap
       })
     });
-    this._textureStyle && (s.source.style = this._textureStyle);
-    const i = {
+    this._textureStyle && (i.source.style = this._textureStyle);
+    const s = {
       canvasAndContext: t,
-      texture: s
+      texture: i
     };
-    return this.pages[this._currentPageIndex] = i, i;
+    return this.pages[this._currentPageIndex] = s, s;
   }
   // canvas style!
   _setupContext(e, t, r) {
     t.fontSize = this.baseRenderedFontSize, e.scale(r, r), e.font = he(t), t.fontSize = this.baseMeasurementFontSize, e.textBaseline = t.textBaseline;
-    const s = t._stroke, i = (s == null ? void 0 : s.width) ?? 0;
-    if (s && (e.lineWidth = i, e.lineJoin = s.join, e.miterLimit = s.miterLimit, e.strokeStyle = fe(s, e)), t._fill && (e.fillStyle = fe(t._fill, e)), t.dropShadow) {
-      const n = t.dropShadow, a = we.shared.setValue(n.color).toArray(), l = n.blur * r, u = n.distance * r;
-      e.shadowColor = `rgba(${a[0] * 255},${a[1] * 255},${a[2] * 255},${n.alpha})`, e.shadowBlur = l, e.shadowOffsetX = Math.cos(n.angle) * u, e.shadowOffsetY = Math.sin(n.angle) * u;
+    const i = t._stroke, s = (i == null ? void 0 : i.width) ?? 0;
+    if (i && (e.lineWidth = s, e.lineJoin = i.join, e.miterLimit = i.miterLimit, e.strokeStyle = fe(i, e)), t._fill && (e.fillStyle = fe(t._fill, e)), t.dropShadow) {
+      const n = t.dropShadow, a = Se.shared.setValue(n.color).toArray(), u = n.blur * r, l = n.distance * r;
+      e.shadowColor = `rgba(${a[0] * 255},${a[1] * 255},${a[2] * 255},${n.alpha})`, e.shadowBlur = u, e.shadowOffsetX = Math.cos(n.angle) * l, e.shadowOffsetY = Math.sin(n.angle) * l;
     } else
       e.shadowColor = "black", e.shadowBlur = 0, e.shadowOffsetX = 0, e.shadowOffsetY = 0;
   }
-  _drawGlyph(e, t, r, s, i, n) {
-    const a = t.text, l = t.fontProperties, u = n._stroke, c = ((u == null ? void 0 : u.width) ?? 0) * i, d = r + c / 2, h = s - c / 2, f = l.descent * i, b = t.lineHeight * i;
-    let m = !1;
-    n.stroke && c && (m = !0, e.strokeText(a, d, h + b - f));
-    const { shadowBlur: x, shadowOffsetX: p, shadowOffsetY: _ } = e;
-    n._fill && (m && (e.shadowBlur = 0, e.shadowOffsetX = 0, e.shadowOffsetY = 0), e.fillText(a, d, h + b - f)), m && (e.shadowBlur = x, e.shadowOffsetX = p, e.shadowOffsetY = _);
+  _drawGlyph(e, t, r, i, s, n) {
+    const a = t.text, u = t.fontProperties, l = n._stroke, d = ((l == null ? void 0 : l.width) ?? 0) * s, c = r + d / 2, h = i - d / 2, f = u.descent * s, y = t.lineHeight * s;
+    let _ = !1;
+    n.stroke && d && (_ = !0, e.strokeText(a, c, h + y - f));
+    const { shadowBlur: b, shadowOffsetX: x, shadowOffsetY: g } = e;
+    n._fill && (_ && (e.shadowBlur = 0, e.shadowOffsetX = 0, e.shadowOffsetY = 0), e.fillText(a, c, h + y - f)), _ && (e.shadowBlur = b, e.shadowOffsetX = x, e.shadowOffsetY = g);
   }
   destroy() {
     super.destroy();
     for (let e = 0; e < this.pages.length; e++) {
       const { canvasAndContext: t, texture: r } = this.pages[e];
-      V.returnCanvasAndContext(t), r.destroy(!0);
+      Y.returnCanvasAndContext(t), r.destroy(!0);
     }
     this.pages = null;
   }
 };
-Ae.defaultOptions = {
+Oe.defaultOptions = {
   textureSize: 512,
-  style: new I(),
+  style: new W(),
   mipmap: !0
 };
-let pe = Ae;
-function ke(o, e, t, r) {
-  const s = {
+let pe = Oe;
+function We(o, e, t, r) {
+  const i = {
     width: 0,
     height: 0,
     offsetY: 0,
@@ -291,109 +291,109 @@ function ke(o, e, t, r) {
       chars: []
     }]
   };
-  s.offsetY = t.baseLineOffset;
-  let i = s.lines[0], n = null, a = !0;
-  const l = {
+  i.offsetY = t.baseLineOffset;
+  let s = i.lines[0], n = null, a = !0;
+  const u = {
     width: 0,
     start: 0,
     index: 0,
     // use index to not modify the array as we use it a lot!
     positions: [],
     chars: []
-  }, u = t.baseMeasurementFontSize / e.fontSize, c = e.letterSpacing * u, d = e.wordWrapWidth * u, h = e.lineHeight ? e.lineHeight * u : t.lineHeight, f = e.wordWrap && e.breakWords, b = (p) => {
-    const _ = i.width;
-    for (let y = 0; y < l.index; y++) {
-      const v = p.positions[y];
-      i.chars.push(p.chars[y]), i.charPositions.push(v + _);
+  }, l = t.baseMeasurementFontSize / e.fontSize, d = e.letterSpacing * l, c = e.wordWrapWidth * l, h = e.lineHeight ? e.lineHeight * l : t.lineHeight, f = e.wordWrap && e.breakWords, y = (x) => {
+    const g = s.width;
+    for (let p = 0; p < u.index; p++) {
+      const v = x.positions[p];
+      s.chars.push(x.chars[p]), s.charPositions.push(v + g);
     }
-    i.width += p.width, a = !1, l.width = 0, l.index = 0, l.chars.length = 0;
-  }, m = () => {
-    let p = i.chars.length - 1;
+    s.width += x.width, a = !1, u.width = 0, u.index = 0, u.chars.length = 0;
+  }, _ = () => {
+    let x = s.chars.length - 1;
     if (r) {
-      let _ = i.chars[p];
-      for (; _ === " "; )
-        i.width -= t.chars[_].xAdvance, _ = i.chars[--p];
+      let g = s.chars[x];
+      for (; g === " "; )
+        s.width -= t.chars[g].xAdvance, g = s.chars[--x];
     }
-    s.width = Math.max(s.width, i.width), i = {
+    i.width = Math.max(i.width, s.width), s = {
       width: 0,
       charPositions: [],
       chars: [],
       spaceWidth: 0,
       spacesIndex: []
-    }, a = !0, s.lines.push(i), s.height += h;
-  }, x = (p) => p - c > d;
-  for (let p = 0; p < o.length + 1; p++) {
-    let _;
-    const y = p === o.length;
-    y || (_ = o[p]);
-    const v = t.chars[_] || t.chars[" "];
-    if (/(?:\s)/.test(_) || _ === "\r" || _ === `
-` || y) {
-      if (!a && e.wordWrap && x(i.width + l.width) ? (m(), b(l), y || i.charPositions.push(0)) : (l.start = i.width, b(l), y || i.charPositions.push(0)), _ === "\r" || _ === `
+    }, a = !0, i.lines.push(s), i.height += h;
+  }, b = (x) => x - d > c;
+  for (let x = 0; x < o.length + 1; x++) {
+    let g;
+    const p = x === o.length;
+    p || (g = o[x]);
+    const v = t.chars[g] || t.chars[" "];
+    if (/(?:\s)/.test(g) || g === "\r" || g === `
+` || p) {
+      if (!a && e.wordWrap && b(s.width + u.width) ? (_(), y(u), p || s.charPositions.push(0)) : (u.start = s.width, y(u), p || s.charPositions.push(0)), g === "\r" || g === `
 `)
-        i.width !== 0 && m();
-      else if (!y) {
-        const U = v.xAdvance + (v.kerning[n] || 0) + c;
-        i.width += U, i.spaceWidth = U, i.spacesIndex.push(i.charPositions.length), i.chars.push(_);
+        _();
+      else if (!p) {
+        const M = v.xAdvance + (v.kerning[n] || 0) + d;
+        s.width += M, s.spaceWidth = M, s.spacesIndex.push(s.charPositions.length), s.chars.push(g);
       }
     } else {
-      const k = v.kerning[n] || 0, U = v.xAdvance + k + c;
-      f && x(i.width + l.width + U) && (b(l), m()), l.positions[l.index++] = l.width + k, l.chars.push(_), l.width += U;
+      const k = v.kerning[n] || 0, M = v.xAdvance + k + d;
+      f && b(s.width + u.width + M) && (y(u), _()), u.positions[u.index++] = u.width + k, u.chars.push(g), u.width += M;
     }
-    n = _;
+    n = g;
   }
-  return m(), e.align === "center" ? St(s) : e.align === "right" ? Pt(s) : e.align === "justify" && Ct(s), s;
+  return _(), e.align === "center" ? Bt(i) : e.align === "right" ? Rt(i) : e.align === "justify" && Mt(i), i;
 }
-function St(o) {
+function Bt(o) {
   for (let e = 0; e < o.lines.length; e++) {
     const t = o.lines[e], r = o.width / 2 - t.width / 2;
-    for (let s = 0; s < t.charPositions.length; s++)
-      t.charPositions[s] += r;
+    for (let i = 0; i < t.charPositions.length; i++)
+      t.charPositions[i] += r;
   }
 }
-function Pt(o) {
+function Rt(o) {
   for (let e = 0; e < o.lines.length; e++) {
     const t = o.lines[e], r = o.width - t.width;
-    for (let s = 0; s < t.charPositions.length; s++)
-      t.charPositions[s] += r;
+    for (let i = 0; i < t.charPositions.length; i++)
+      t.charPositions[i] += r;
   }
 }
-function Ct(o) {
+function Mt(o) {
   const e = o.width;
   for (let t = 0; t < o.lines.length; t++) {
     const r = o.lines[t];
-    let s = 0, i = r.spacesIndex[s++], n = 0;
-    const a = r.spacesIndex.length, u = (e - r.width) / a;
-    for (let c = 0; c < r.charPositions.length; c++)
-      c === i && (i = r.spacesIndex[s++], n += u), r.charPositions[c] += n;
+    let i = 0, s = r.spacesIndex[i++], n = 0;
+    const a = r.spacesIndex.length, l = (e - r.width) / a;
+    for (let d = 0; d < r.charPositions.length; d++)
+      d === s && (s = r.spacesIndex[i++], n += l), r.charPositions[d] += n;
   }
 }
-function Ft(o) {
+function Ut(o) {
   if (o === "")
     return [];
   typeof o == "string" && (o = [o]);
   const e = [];
   for (let t = 0, r = o.length; t < r; t++) {
-    const s = o[t];
-    if (Array.isArray(s)) {
-      if (s.length !== 2)
-        throw new Error(`[BitmapFont]: Invalid character range length, expecting 2 got ${s.length}.`);
-      if (s[0].length === 0 || s[1].length === 0)
+    const i = o[t];
+    if (Array.isArray(i)) {
+      if (i.length !== 2)
+        throw new Error(`[BitmapFont]: Invalid character range length, expecting 2 got ${i.length}.`);
+      if (i[0].length === 0 || i[1].length === 0)
         throw new Error("[BitmapFont]: Invalid character delimiter.");
-      const i = s[0].charCodeAt(0), n = s[1].charCodeAt(0);
-      if (n < i)
+      const s = i[0].charCodeAt(0), n = i[1].charCodeAt(0);
+      if (n < s)
         throw new Error("[BitmapFont]: Invalid character range.");
-      for (let a = i, l = n; a <= l; a++)
+      for (let a = s, u = n; a <= u; a++)
         e.push(String.fromCharCode(a));
     } else
-      e.push(...Array.from(s));
+      e.push(...Array.from(i));
   }
   if (e.length === 0)
     throw new Error("[BitmapFont]: Empty set when resolving characters.");
   return e;
 }
-let H = 0;
-class Bt {
+let L = 0;
+class Gt {
   constructor() {
     this.ALPHA = [["a", "z"], ["A", "Z"], " "], this.NUMERIC = [["0", "9"]], this.ALPHANUMERIC = [["a", "z"], ["A", "Z"], ["0", "9"], " "], this.ASCII = [[" ", "~"]], this.defaultOptions = {
       chars: this.ALPHANUMERIC,
@@ -401,7 +401,7 @@ class Bt {
       padding: 4,
       skipKerning: !1,
       textureStyle: null
-    };
+    }, this.measureCache = pt(1e3);
   }
   /**
    * Get a font for the specified text and style.
@@ -410,31 +410,25 @@ class Bt {
    */
   getFont(e, t) {
     var n;
-    let r = `${t.fontFamily}-bitmap`, s = !0;
-    if (t._fill.fill && !t._stroke)
-      r += t._fill.fill.styleKey, s = !1;
-    else if (t._stroke || t.dropShadow) {
-      let a = t.styleKey;
-      a = a.substring(0, a.lastIndexOf("-")), r = `${a}-bitmap`, s = !1;
-    }
-    if (!C.has(r)) {
+    let r = `${t.fontFamily}-bitmap`, i = !0;
+    if (t._fill.fill && !t._stroke ? (r += t._fill.fill.styleKey, i = !1) : (t._stroke || t.dropShadow) && (r = `${t.styleKey}-bitmap`, i = !1), !P.has(r)) {
       const a = Object.create(t);
       a.lineHeight = 0;
-      const l = new pe({
+      const u = new pe({
         style: a,
-        overrideFill: s,
+        overrideFill: i,
         overrideSize: !0,
         ...this.defaultOptions
       });
-      H++, H > 50 && re("BitmapText", `You have dynamically created ${H} bitmap fonts, this can be inefficient. Try pre installing your font styles using \`BitmapFont.install({name:"style1", style})\``), l.once("destroy", () => {
-        H--, C.remove(r);
-      }), C.set(
+      L++, L > 50 && X("BitmapText", `You have dynamically created ${L} bitmap fonts, this can be inefficient. Try pre installing your font styles using \`BitmapFont.install({name:"style1", style})\``), u.once("destroy", () => {
+        L--, P.remove(r);
+      }), P.set(
         r,
-        l
+        u
       );
     }
-    const i = C.get(r);
-    return (n = i.ensureCharacters) == null || n.call(i, e), i;
+    const s = P.get(r);
+    return (n = s.ensureCharacters) == null || n.call(s, e), s;
   }
   /**
    * Get the layout of a text for the specified style.
@@ -443,8 +437,11 @@ class Bt {
    * @param trimEnd - Whether to ignore whitespaces at the end of each line
    */
   getLayout(e, t, r = !0) {
-    const s = this.getFont(e, t), i = D.graphemeSegmenter(e);
-    return ke(i, t, s, r);
+    const i = this.getFont(e, t), s = `${e}-${t.styleKey}-${r}`;
+    if (this.measureCache.has(s))
+      return this.measureCache.get(s);
+    const n = D.graphemeSegmenter(e), a = We(n, t, i, r);
+    return this.measureCache.set(s, a), a;
   }
   /**
    * Measure the text using the specified style.
@@ -457,37 +454,37 @@ class Bt {
   }
   // eslint-disable-next-line max-len
   install(...e) {
-    var u, c, d, h;
+    var l, d, c, h;
     let t = e[0];
     typeof t == "string" && (t = {
       name: t,
       style: e[1],
-      chars: (u = e[2]) == null ? void 0 : u.chars,
-      resolution: (c = e[2]) == null ? void 0 : c.resolution,
-      padding: (d = e[2]) == null ? void 0 : d.padding,
+      chars: (l = e[2]) == null ? void 0 : l.chars,
+      resolution: (d = e[2]) == null ? void 0 : d.resolution,
+      padding: (c = e[2]) == null ? void 0 : c.padding,
       skipKerning: (h = e[2]) == null ? void 0 : h.skipKerning
-    }, w(M, "BitmapFontManager.install(name, style, options) is deprecated, use BitmapFontManager.install({name, style, ...options})"));
+    }, w(U, "BitmapFontManager.install(name, style, options) is deprecated, use BitmapFontManager.install({name, style, ...options})"));
     const r = t == null ? void 0 : t.name;
     if (!r)
       throw new Error("[BitmapFontManager] Property `name` is required.");
     t = { ...this.defaultOptions, ...t };
-    const s = t.style, i = s instanceof I ? s : new I(s), n = t.dynamicFill ?? this._canUseTintForStyle(i), a = new pe({
-      style: i,
+    const i = t.style, s = i instanceof W ? i : new W(i), n = t.dynamicFill ?? this._canUseTintForStyle(s), a = new pe({
+      style: s,
       overrideFill: n,
       skipKerning: t.skipKerning,
       padding: t.padding,
       resolution: t.resolution,
       overrideSize: !1,
       textureStyle: t.textureStyle
-    }), l = Ft(t.chars);
-    return a.ensureCharacters(l.join("")), C.set(`${r}-bitmap`, a), a.once("destroy", () => C.remove(`${r}-bitmap`)), a;
+    }), u = Ut(t.chars);
+    return a.ensureCharacters(u.join("")), P.set(`${r}-bitmap`, a), a.once("destroy", () => P.remove(`${r}-bitmap`)), a;
   }
   /**
    * Uninstalls a bitmap font from the cache.
    * @param {string} name - The name of the bitmap font to uninstall.
    */
   uninstall(e) {
-    const t = `${e}-bitmap`, r = C.get(t);
+    const t = `${e}-bitmap`, r = P.get(t);
     r && r.destroy();
   }
   /**
@@ -501,8 +498,108 @@ class Bt {
     return !e._stroke && (!e.dropShadow || e.dropShadow.color === 0) && !e._fill.fill && e._fill.color === 16777215;
   }
 }
-const Ut = new Bt();
-class De {
+const zt = new Gt();
+var At = `in vec2 aPosition;
+out vec2 vTextureCoord;
+
+uniform vec4 uInputSize;
+uniform vec4 uOutputFrame;
+uniform vec4 uOutputTexture;
+
+vec4 filterVertexPosition( void )
+{
+    vec2 position = aPosition * uOutputFrame.zw + uOutputFrame.xy;
+    
+    position.x = position.x * (2.0 / uOutputTexture.x) - 1.0;
+    position.y = position.y * (2.0*uOutputTexture.z / uOutputTexture.y) - uOutputTexture.z;
+
+    return vec4(position, 0.0, 1.0);
+}
+
+vec2 filterTextureCoord( void )
+{
+    return aPosition * (uOutputFrame.zw * uInputSize.zw);
+}
+
+void main(void)
+{
+    gl_Position = filterVertexPosition();
+    vTextureCoord = filterTextureCoord();
+}
+`, kt = `in vec2 vTextureCoord;
+out vec4 finalColor;
+uniform sampler2D uTexture;
+void main() {
+    finalColor = texture(uTexture, vTextureCoord);
+}
+`, ge = `struct GlobalFilterUniforms {
+  uInputSize: vec4<f32>,
+  uInputPixel: vec4<f32>,
+  uInputClamp: vec4<f32>,
+  uOutputFrame: vec4<f32>,
+  uGlobalFrame: vec4<f32>,
+  uOutputTexture: vec4<f32>,
+};
+
+@group(0) @binding(0) var <uniform> gfu: GlobalFilterUniforms;
+@group(0) @binding(1) var uTexture: texture_2d<f32>;
+@group(0) @binding(2) var uSampler: sampler;
+
+struct VSOutput {
+  @builtin(position) position: vec4<f32>,
+  @location(0) uv: vec2<f32>
+};
+
+fn filterVertexPosition(aPosition: vec2<f32>) -> vec4<f32>
+{
+    var position = aPosition * gfu.uOutputFrame.zw + gfu.uOutputFrame.xy;
+
+    position.x = position.x * (2.0 / gfu.uOutputTexture.x) - 1.0;
+    position.y = position.y * (2.0 * gfu.uOutputTexture.z / gfu.uOutputTexture.y) - gfu.uOutputTexture.z;
+
+    return vec4(position, 0.0, 1.0);
+}
+
+fn filterTextureCoord(aPosition: vec2<f32>) -> vec2<f32>
+{
+    return aPosition * (gfu.uOutputFrame.zw * gfu.uInputSize.zw);
+}
+
+@vertex
+fn mainVertex(
+  @location(0) aPosition: vec2<f32>,
+) -> VSOutput {
+  return VSOutput(
+   filterVertexPosition(aPosition),
+   filterTextureCoord(aPosition)
+  );
+}
+
+@fragment
+fn mainFragment(
+  @location(0) uv: vec2<f32>,
+) -> @location(0) vec4<f32> {
+    return textureSample(uTexture, uSampler, uv);
+}
+`;
+class Dt extends Ct {
+  constructor() {
+    const e = Pe.from({
+      vertex: { source: ge, entryPoint: "mainVertex" },
+      fragment: { source: ge, entryPoint: "mainFragment" },
+      name: "passthrough-filter"
+    }), t = Fe.from({
+      vertex: At,
+      fragment: kt,
+      name: "passthrough-filter"
+    });
+    super({
+      gpuProgram: e,
+      glProgram: t
+    });
+  }
+}
+class Ee {
   constructor(e) {
     this._renderer = e;
   }
@@ -529,24 +626,28 @@ class De {
     this._renderer = null;
   }
 }
-De.extension = {
+Ee.extension = {
   type: [
-    g.WebGLPipes,
-    g.WebGPUPipes,
-    g.CanvasPipes
+    m.WebGLPipes,
+    m.WebGPUPipes,
+    m.CanvasPipes
   ],
   name: "filter"
 };
-function Mt(o, e) {
+const me = new R();
+function Ot(o, e) {
   e.clear();
   const t = e.matrix;
   for (let r = 0; r < o.length; r++) {
-    const s = o[r];
-    s.globalDisplayStatus < 7 || (e.matrix = s.worldTransform, e.addBounds(s.bounds));
+    const i = o[r];
+    if (i.globalDisplayStatus < 7)
+      continue;
+    const s = i.renderGroup ?? i.parentRenderGroup;
+    s != null && s.isCachedAsTexture ? e.matrix = me.copyFrom(s.textureOffsetInverseTransform).append(i.worldTransform) : s != null && s._parentCacheAsTextureRenderGroup ? e.matrix = me.copyFrom(s._parentCacheAsTextureRenderGroup.inverseWorldTransform).append(i.groupTransform) : e.matrix = i.worldTransform, e.addBounds(i.bounds);
   }
   return e.matrix = t, e;
 }
-const Rt = new se({
+const It = new ie({
   attributes: {
     aPosition: {
       buffer: new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]),
@@ -557,21 +658,21 @@ const Rt = new se({
   },
   indexBuffer: new Uint32Array([0, 1, 2, 0, 2, 3])
 });
-class Gt {
+class Wt {
   constructor() {
-    this.skip = !1, this.inputTexture = null, this.backTexture = null, this.filters = null, this.bounds = new Pe(), this.container = null, this.blendRequired = !1, this.outputRenderSurface = null, this.globalFrame = { x: 0, y: 0, width: 0, height: 0 };
+    this.skip = !1, this.inputTexture = null, this.backTexture = null, this.filters = null, this.bounds = new Re(), this.container = null, this.blendRequired = !1, this.outputRenderSurface = null, this.globalFrame = { x: 0, y: 0, width: 0, height: 0 }, this.firstEnabledIndex = -1, this.lastEnabledIndex = -1;
   }
 }
-class Oe {
+class Ve {
   constructor(e) {
-    this._filterStackIndex = 0, this._filterStack = [], this._filterGlobalUniforms = new z({
+    this._filterStackIndex = 0, this._filterStack = [], this._filterGlobalUniforms = new A({
       uInputSize: { value: new Float32Array(4), type: "vec4<f32>" },
       uInputPixel: { value: new Float32Array(4), type: "vec4<f32>" },
       uInputClamp: { value: new Float32Array(4), type: "vec4<f32>" },
       uOutputFrame: { value: new Float32Array(4), type: "vec4<f32>" },
       uGlobalFrame: { value: new Float32Array(4), type: "vec4<f32>" },
       uOutputTexture: { value: new Float32Array(4), type: "vec4<f32>" }
-    }), this._globalFilterBindGroup = new Se({}), this.renderer = e;
+    }), this._globalFilterBindGroup = new Be({}), this.renderer = e;
   }
   /**
    * The back texture of the currently active filter. Requires the filter to have `blendRequired` set to true.
@@ -587,26 +688,26 @@ class Oe {
    * @internal
    */
   push(e) {
-    const t = this.renderer, r = e.filterEffect.filters, s = this._pushFilterData();
-    s.skip = !1, s.filters = r, s.container = e.container, s.outputRenderSurface = t.renderTarget.renderSurface;
-    const i = t.renderTarget.renderTarget.colorTexture.source, n = i.resolution, a = i.antialias;
-    if (r.length === 0) {
-      s.skip = !0;
+    const t = this.renderer, r = e.filterEffect.filters, i = this._pushFilterData();
+    i.skip = !1, i.filters = r, i.container = e.container, i.outputRenderSurface = t.renderTarget.renderSurface;
+    const s = t.renderTarget.renderTarget.colorTexture.source, n = s.resolution, a = s.antialias;
+    if (r.every((f) => !f.enabled)) {
+      i.skip = !0;
       return;
     }
-    const l = s.bounds;
-    if (this._calculateFilterArea(e, l), this._calculateFilterBounds(s, t.renderTarget.rootViewPort, a, n, 1), s.skip)
+    const u = i.bounds;
+    if (this._calculateFilterArea(e, u), this._calculateFilterBounds(i, t.renderTarget.rootViewPort, a, n, 1), i.skip)
       return;
-    const u = this._getPreviousFilterData(), c = this._findFilterResolution(n);
-    let d = 0, h = 0;
-    u && (d = u.bounds.minX, h = u.bounds.minY), this._calculateGlobalFrame(
-      s,
-      d,
-      h,
+    const l = this._getPreviousFilterData(), d = this._findFilterResolution(n);
+    let c = 0, h = 0;
+    l && (c = l.bounds.minX, h = l.bounds.minY), this._calculateGlobalFrame(
+      i,
       c,
-      i.width,
-      i.height
-    ), this._setupFilterTextures(s, l, t, u);
+      h,
+      d,
+      s.width,
+      s.height
+    ), this._setupFilterTextures(i, u, t, l);
   }
   /**
    * Applies filters to a texture.
@@ -638,26 +739,26 @@ class Oe {
   generateFilteredTexture({ texture: e, filters: t }) {
     const r = this._pushFilterData();
     this._activeFilterData = r, r.skip = !1, r.filters = t;
-    const s = e.source, i = s.resolution, n = s.antialias;
-    if (t.length === 0)
+    const i = e.source, s = i.resolution, n = i.antialias;
+    if (t.every((f) => !f.enabled))
       return r.skip = !0, e;
     const a = r.bounds;
-    if (a.addRect(e.frame), this._calculateFilterBounds(r, a.rectangle, n, i, 0), r.skip)
+    if (a.addRect(e.frame), this._calculateFilterBounds(r, a.rectangle, n, s, 0), r.skip)
       return e;
-    const l = i;
+    const u = s;
     this._calculateGlobalFrame(
       r,
       0,
       0,
-      l,
-      s.width,
-      s.height
+      u,
+      i.width,
+      i.height
     ), r.outputRenderSurface = F.getOptimalTexture(
       a.width,
       a.height,
       r.resolution,
       r.antialias
-    ), r.backTexture = S.EMPTY, r.inputTexture = e, this.renderer.renderTarget.finishRenderPass(), this._applyFiltersToTexture(r, !0);
+    ), r.backTexture = C.EMPTY, r.inputTexture = e, this.renderer.renderTarget.finishRenderPass(), this._applyFiltersToTexture(r, !0);
     const h = r.outputRenderSurface;
     return h.source.alphaMode = "premultiplied-alpha", h;
   }
@@ -673,22 +774,22 @@ class Oe {
    * @param previousBounds - The previous bounds to use for offsetting the copy.
    */
   getBackTexture(e, t, r) {
-    const s = e.colorTexture.source._resolution, i = F.getOptimalTexture(
+    const i = e.colorTexture.source._resolution, s = F.getOptimalTexture(
       t.width,
       t.height,
-      s,
+      i,
       !1
     );
     let n = t.minX, a = t.minY;
-    r && (n -= r.minX, a -= r.minY), n = Math.floor(n * s), a = Math.floor(a * s);
-    const l = Math.ceil(t.width * s), u = Math.ceil(t.height * s);
+    r && (n -= r.minX, a -= r.minY), n = Math.floor(n * i), a = Math.floor(a * i);
+    const u = Math.ceil(t.width * i), l = Math.ceil(t.height * i);
     return this.renderer.renderTarget.copyToTexture(
       e,
-      i,
+      s,
       { x: n, y: a },
-      { width: l, height: u },
+      { width: u, height: l },
       { x: 0, y: 0 }
-    ), i;
+    ), s;
   }
   /**
    * Applies a filter to a texture.
@@ -697,14 +798,16 @@ class Oe {
    * @param output - The output render surface.
    * @param clear - Whether to clear the output surface before applying the filter.
    */
-  applyFilter(e, t, r, s) {
-    const i = this.renderer, n = this._activeFilterData, l = n.outputRenderSurface === r, u = i.renderTarget.rootRenderTarget.colorTexture.source._resolution, c = this._findFilterResolution(u);
-    let d = 0, h = 0;
-    if (l) {
-      const f = this._findPreviousFilterOffset();
-      d = f.x, h = f.y;
+  applyFilter(e, t, r, i) {
+    const s = this.renderer, n = this._activeFilterData, u = n.outputRenderSurface === r, l = s.renderTarget.rootRenderTarget.colorTexture.source._resolution, d = this._findFilterResolution(l);
+    let c = 0, h = 0;
+    if (u) {
+      const y = this._findPreviousFilterOffset();
+      c = y.x, h = y.y;
     }
-    this._updateFilterUniforms(t, r, n, d, h, c, l, s), this._setupBindGroupsAndRender(e, t, i);
+    this._updateFilterUniforms(t, r, n, c, h, d, u, i);
+    const f = e.enabled ? e : this._getPassthroughFilter();
+    this._setupBindGroupsAndRender(f, t, s);
   }
   /**
    * Multiply _input normalized coordinates_ to this matrix to get _sprite texture normalized coordinates_.
@@ -715,20 +818,25 @@ class Oe {
    * @returns The mapped matrix.
    */
   calculateSpriteMatrix(e, t) {
-    const r = this._activeFilterData, s = e.set(
+    const r = this._activeFilterData, i = e.set(
       r.inputTexture._source.width,
       0,
       0,
       r.inputTexture._source.height,
       r.bounds.minX,
       r.bounds.minY
-    ), i = t.worldTransform.copyTo(R.shared), n = t.renderGroup || t.parentRenderGroup;
-    return n && n.cacheToLocalTransform && i.prepend(n.cacheToLocalTransform), i.invert(), s.prepend(i), s.scale(
+    ), s = t.worldTransform.copyTo(R.shared), n = t.renderGroup || t.parentRenderGroup;
+    return n && n.cacheToLocalTransform && s.prepend(n.cacheToLocalTransform), s.invert(), i.prepend(s), i.scale(
       1 / t.texture.orig.width,
       1 / t.texture.orig.height
-    ), s.translate(t.anchor.x, t.anchor.y), s;
+    ), i.translate(t.anchor.x, t.anchor.y), i;
   }
   destroy() {
+    var e;
+    (e = this._passthroughFilter) == null || e.destroy(!0), this._passthroughFilter = null;
+  }
+  _getPassthroughFilter() {
+    return this._passthroughFilter ?? (this._passthroughFilter = new Dt()), this._passthroughFilter;
   }
   /**
    * Sets up the bind groups and renders the filter.
@@ -738,16 +846,16 @@ class Oe {
    */
   _setupBindGroupsAndRender(e, t, r) {
     if (r.renderPipes.uniformBatch) {
-      const s = r.renderPipes.uniformBatch.getUboResource(this._filterGlobalUniforms);
-      this._globalFilterBindGroup.setResource(s, 0);
+      const i = r.renderPipes.uniformBatch.getUboResource(this._filterGlobalUniforms);
+      this._globalFilterBindGroup.setResource(i, 0);
     } else
       this._globalFilterBindGroup.setResource(this._filterGlobalUniforms, 0);
     this._globalFilterBindGroup.setResource(t.source, 1), this._globalFilterBindGroup.setResource(t.source.style, 2), e.groups[0] = this._globalFilterBindGroup, r.encoder.draw({
-      geometry: Rt,
+      geometry: It,
       shader: e,
       state: e._state,
       topology: "triangle-list"
-    }), r.type === ie.WEBGL && r.renderTarget.finishRenderPass();
+    }), r.type === se.WEBGL && r.renderTarget.finishRenderPass();
   }
   /**
    * Sets up the filter textures including input texture and back texture if needed.
@@ -756,18 +864,18 @@ class Oe {
    * @param renderer - The renderer instance
    * @param previousFilterData - The previous filter data for back texture calculation
    */
-  _setupFilterTextures(e, t, r, s) {
-    if (e.backTexture = S.EMPTY, e.blendRequired) {
-      r.renderTarget.finishRenderPass();
-      const i = r.renderTarget.getRenderTarget(e.outputRenderSurface);
-      e.backTexture = this.getBackTexture(i, t, s == null ? void 0 : s.bounds);
-    }
-    e.inputTexture = F.getOptimalTexture(
+  _setupFilterTextures(e, t, r, i) {
+    if (e.backTexture = C.EMPTY, e.inputTexture = F.getOptimalTexture(
       t.width,
       t.height,
       e.resolution,
       e.antialias
-    ), r.renderTarget.bind(e.inputTexture, !0), r.globalUniforms.push({
+    ), e.blendRequired) {
+      r.renderTarget.finishRenderPass();
+      const s = r.renderTarget.getRenderTarget(e.outputRenderSurface);
+      e.backTexture = this.getBackTexture(s, t, i == null ? void 0 : i.bounds);
+    }
+    r.renderTarget.bind(e.inputTexture, !0), r.globalUniforms.push({
       offset: t
     });
   }
@@ -780,9 +888,9 @@ class Oe {
    * @param sourceWidth - The source texture width
    * @param sourceHeight - The source texture height
    */
-  _calculateGlobalFrame(e, t, r, s, i, n) {
+  _calculateGlobalFrame(e, t, r, i, s, n) {
     const a = e.globalFrame;
-    a.x = t * s, a.y = r * s, a.width = i * s, a.height = n * s;
+    a.x = t * i, a.y = r * i, a.width = s * i, a.height = n * i;
   }
   /**
    * Updates the filter uniforms with the current filter state.
@@ -795,13 +903,13 @@ class Oe {
    * @param isFinalTarget - Whether this is the final render target
    * @param clear - Whether to clear the output surface
    */
-  _updateFilterUniforms(e, t, r, s, i, n, a, l) {
-    const u = this._filterGlobalUniforms.uniforms, c = u.uOutputFrame, d = u.uInputSize, h = u.uInputPixel, f = u.uInputClamp, b = u.uGlobalFrame, m = u.uOutputTexture;
-    a ? (c[0] = r.bounds.minX - s, c[1] = r.bounds.minY - i) : (c[0] = 0, c[1] = 0), c[2] = e.frame.width, c[3] = e.frame.height, d[0] = e.source.width, d[1] = e.source.height, d[2] = 1 / d[0], d[3] = 1 / d[1], h[0] = e.source.pixelWidth, h[1] = e.source.pixelHeight, h[2] = 1 / h[0], h[3] = 1 / h[1], f[0] = 0.5 * h[2], f[1] = 0.5 * h[3], f[2] = e.frame.width * d[2] - 0.5 * h[2], f[3] = e.frame.height * d[3] - 0.5 * h[3];
-    const x = this.renderer.renderTarget.rootRenderTarget.colorTexture;
-    b[0] = s * n, b[1] = i * n, b[2] = x.source.width * n, b[3] = x.source.height * n, t instanceof S && (t.source.resource = null);
-    const p = this.renderer.renderTarget.getRenderTarget(t);
-    this.renderer.renderTarget.bind(t, !!l), t instanceof S ? (m[0] = t.frame.width, m[1] = t.frame.height) : (m[0] = p.width, m[1] = p.height), m[2] = p.isRoot ? -1 : 1, this._filterGlobalUniforms.update();
+  _updateFilterUniforms(e, t, r, i, s, n, a, u) {
+    const l = this._filterGlobalUniforms.uniforms, d = l.uOutputFrame, c = l.uInputSize, h = l.uInputPixel, f = l.uInputClamp, y = l.uGlobalFrame, _ = l.uOutputTexture;
+    a ? (d[0] = r.bounds.minX - i, d[1] = r.bounds.minY - s) : (d[0] = 0, d[1] = 0), d[2] = e.frame.width, d[3] = e.frame.height, c[0] = e.source.width, c[1] = e.source.height, c[2] = 1 / c[0], c[3] = 1 / c[1], h[0] = e.source.pixelWidth, h[1] = e.source.pixelHeight, h[2] = 1 / h[0], h[3] = 1 / h[1], f[0] = 0.5 * h[2], f[1] = 0.5 * h[3], f[2] = e.frame.width * c[2] - 0.5 * h[2], f[3] = e.frame.height * c[3] - 0.5 * h[3];
+    const b = this.renderer.renderTarget.rootRenderTarget.colorTexture;
+    y[0] = i * n, y[1] = s * n, y[2] = b.source.width * n, y[3] = b.source.height * n, t instanceof C && (t.source.resource = null);
+    const x = this.renderer.renderTarget.getRenderTarget(t);
+    this.renderer.renderTarget.bind(t, !!u), t instanceof C ? (_[0] = t.frame.width, _[1] = t.frame.height) : (_[0] = x.width, _[1] = x.height), _[2] = x.isRoot ? -1 : 1, this._filterGlobalUniforms.update();
   }
   /**
    * Finds the correct resolution by looking back through the filter stack.
@@ -822,9 +930,9 @@ class Oe {
     let e = 0, t = 0, r = this._filterStackIndex;
     for (; r > 0; ) {
       r--;
-      const s = this._filterStack[r];
-      if (!s.skip) {
-        e = s.bounds.minX, t = s.bounds.minY;
+      const i = this._filterStack[r];
+      if (!i.skip) {
+        e = i.bounds.minX, t = i.bounds.minY;
         break;
       }
     }
@@ -836,102 +944,107 @@ class Oe {
    * @param bounds - The bounds object to populate
    */
   _calculateFilterArea(e, t) {
-    if (e.renderables ? Mt(e.renderables, t) : e.filterEffect.filterArea ? (t.clear(), t.addRect(e.filterEffect.filterArea), t.applyMatrix(e.container.worldTransform)) : e.container.getFastGlobalBounds(!0, t), e.container) {
-      const s = (e.container.renderGroup || e.container.parentRenderGroup).cacheToLocalTransform;
-      s && t.applyMatrix(s);
+    if (e.renderables ? Ot(e.renderables, t) : e.filterEffect.filterArea ? (t.clear(), t.addRect(e.filterEffect.filterArea), t.applyMatrix(e.container.worldTransform)) : e.container.getFastGlobalBounds(!0, t), e.container) {
+      const i = (e.container.renderGroup || e.container.parentRenderGroup).cacheToLocalTransform;
+      i && t.applyMatrix(i);
     }
   }
   _applyFiltersToTexture(e, t) {
-    const r = e.inputTexture, s = e.bounds, i = e.filters;
-    if (this._globalFilterBindGroup.setResource(r.source.style, 2), this._globalFilterBindGroup.setResource(e.backTexture.source, 3), i.length === 1)
-      i[0].apply(this, r, e.outputRenderSurface, t);
+    const r = e.inputTexture, i = e.bounds, s = e.filters, n = e.firstEnabledIndex, a = e.lastEnabledIndex;
+    if (this._globalFilterBindGroup.setResource(r.source.style, 2), this._globalFilterBindGroup.setResource(e.backTexture.source, 3), n === a)
+      s[n].apply(this, r, e.outputRenderSurface, t);
     else {
-      let n = e.inputTexture;
-      const a = F.getOptimalTexture(
-        s.width,
-        s.height,
-        n.source._resolution,
+      let u = e.inputTexture;
+      const l = F.getOptimalTexture(
+        i.width,
+        i.height,
+        u.source._resolution,
         !1
       );
-      let l = a, u = 0;
-      for (u = 0; u < i.length - 1; ++u) {
-        i[u].apply(this, n, l, !0);
-        const d = n;
-        n = l, l = d;
+      let d = l;
+      for (let c = n; c < a; c++) {
+        const h = s[c];
+        if (!h.enabled)
+          continue;
+        h.apply(this, u, d, !0);
+        const f = u;
+        u = d, d = f;
       }
-      i[u].apply(this, n, e.outputRenderSurface, t), F.returnTexture(a);
+      s[a].apply(this, u, e.outputRenderSurface, t), F.returnTexture(l);
     }
   }
-  _calculateFilterBounds(e, t, r, s, i) {
-    var m;
-    const n = this.renderer, a = e.bounds, l = e.filters;
-    let u = 1 / 0, c = 0, d = !0, h = !1, f = !1, b = !0;
-    for (let x = 0; x < l.length; x++) {
-      const p = l[x];
-      if (u = Math.min(u, p.resolution === "inherit" ? s : p.resolution), c += p.padding, p.antialias === "off" ? d = !1 : p.antialias === "inherit" && d && (d = r), p.clipToViewport || (b = !1), !!!(p.compatibleRenderers & n.type)) {
+  _calculateFilterBounds(e, t, r, i, s) {
+    var x;
+    const n = this.renderer, a = e.bounds, u = e.filters;
+    let l = 1 / 0, d = 0, c = !0, h = !1, f = !1, y = !0, _ = -1, b = -1;
+    for (let g = 0; g < u.length; g++) {
+      const p = u[g];
+      if (!p.enabled)
+        continue;
+      if (_ === -1 && (_ = g), b = g, l = Math.min(l, p.resolution === "inherit" ? i : p.resolution), d += p.padding, p.antialias === "off" ? c = !1 : p.antialias === "inherit" && c && (c = r), p.clipToViewport || (y = !1), !!!(p.compatibleRenderers & n.type)) {
         f = !1;
         break;
       }
-      if (p.blendRequired && !(((m = n.backBuffer) == null ? void 0 : m.useBackBuffer) ?? !0)) {
-        re("Blend filter requires backBuffer on WebGL renderer to be enabled. Set `useBackBuffer: true` in the renderer options."), f = !1;
+      if (p.blendRequired && !(((x = n.backBuffer) == null ? void 0 : x.useBackBuffer) ?? !0)) {
+        X("Blend filter requires backBuffer on WebGL renderer to be enabled. Set `useBackBuffer: true` in the renderer options."), f = !1;
         break;
       }
-      f = p.enabled || f, h || (h = p.blendRequired);
+      f = !0, h || (h = p.blendRequired);
     }
     if (!f) {
       e.skip = !0;
       return;
     }
-    if (b && a.fitBounds(0, t.width / s, 0, t.height / s), a.scale(u).ceil().scale(1 / u).pad((c | 0) * i), !a.isPositive) {
+    if (y && a.fitBounds(0, t.width / i, 0, t.height / i), a.scale(l).ceil().scale(1 / l).pad((d | 0) * s), !a.isPositive) {
       e.skip = !0;
       return;
     }
-    e.antialias = d, e.resolution = u, e.blendRequired = h;
+    e.antialias = c, e.resolution = l, e.blendRequired = h, e.firstEnabledIndex = _, e.lastEnabledIndex = b;
   }
   _popFilterData() {
     return this._filterStackIndex--, this._filterStack[this._filterStackIndex];
   }
   _getPreviousFilterData() {
     let e, t = this._filterStackIndex - 1;
-    for (; t > 1 && (t--, e = this._filterStack[t], !!e.skip); )
+    for (; t > 0 && (t--, e = this._filterStack[t], !!e.skip); )
       ;
     return e;
   }
   _pushFilterData() {
     let e = this._filterStack[this._filterStackIndex];
-    return e || (e = this._filterStack[this._filterStackIndex] = new Gt()), this._filterStackIndex++, e;
+    return e || (e = this._filterStack[this._filterStackIndex] = new Wt()), this._filterStackIndex++, e;
   }
 }
-Oe.extension = {
+Ve.extension = {
   type: [
-    g.WebGLSystem,
-    g.WebGPUSystem
+    m.WebGLSystem,
+    m.WebGPUSystem
   ],
   name: "filter"
 };
-const We = class Ie extends se {
+const Le = class He extends ie {
   constructor(...e) {
     let t = e[0] ?? {};
-    t instanceof Float32Array && (w(M, "use new MeshGeometry({ positions, uvs, indices }) instead"), t = {
+    t instanceof Float32Array && (w(U, "use new MeshGeometry({ positions, uvs, indices }) instead"), t = {
       positions: t,
       uvs: e[1],
       indices: e[2]
-    }), t = { ...Ie.defaultOptions, ...t };
+    }), t = { ...He.defaultOptions, ...t };
     const r = t.positions || new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]);
-    let s = t.uvs;
-    s || (t.positions ? s = new Float32Array(r.length) : s = new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]));
-    const i = t.indices || new Uint32Array([0, 1, 2, 0, 2, 3]), n = t.shrinkBuffersToFit, a = new O({
+    let i = t.uvs;
+    i || (t.positions ? i = new Float32Array(r.length) : i = new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]));
+    const s = t.indices || new Uint32Array([0, 1, 2, 0, 2, 3]), n = t.shrinkBuffersToFit, a = new O({
       data: r,
       label: "attribute-mesh-positions",
       shrinkToFit: n,
       usage: B.VERTEX | B.COPY_DST
-    }), l = new O({
-      data: s,
+    }), u = new O({
+      data: i,
       label: "attribute-mesh-uvs",
       shrinkToFit: n,
       usage: B.VERTEX | B.COPY_DST
-    }), u = new O({
-      data: i,
+    }), l = new O({
+      data: s,
       label: "index-mesh-buffer",
       shrinkToFit: n,
       usage: B.INDEX | B.COPY_DST
@@ -945,13 +1058,13 @@ const We = class Ie extends se {
           offset: 0
         },
         aUV: {
-          buffer: l,
+          buffer: u,
           format: "float32x2",
           stride: 2 * 4,
           offset: 0
         }
       },
-      indexBuffer: u,
+      indexBuffer: l,
       topology: t.topology
     }), this.batchMode = "auto";
   }
@@ -989,43 +1102,46 @@ const We = class Ie extends se {
     this.indexBuffer.data = e;
   }
 };
-We.defaultOptions = {
+Le.defaultOptions = {
   topology: "triangle-list",
   shrinkBuffersToFit: !1
 };
-let le = We;
-const ge = "http://www.w3.org/2000/svg", me = "http://www.w3.org/1999/xhtml";
-class Ee {
+let ue = Le;
+const xe = "http://www.w3.org/2000/svg", _e = "http://www.w3.org/1999/xhtml";
+class Ye {
   constructor() {
-    this.svgRoot = document.createElementNS(ge, "svg"), this.foreignObject = document.createElementNS(ge, "foreignObject"), this.domElement = document.createElementNS(me, "div"), this.styleElement = document.createElementNS(me, "style");
-    const { foreignObject: e, svgRoot: t, styleElement: r, domElement: s } = this;
-    e.setAttribute("width", "10000"), e.setAttribute("height", "10000"), e.style.overflow = "hidden", t.appendChild(e), e.appendChild(r), e.appendChild(s), this.image = ne.get().createImage();
+    this.svgRoot = document.createElementNS(xe, "svg"), this.foreignObject = document.createElementNS(xe, "foreignObject"), this.domElement = document.createElementNS(_e, "div"), this.styleElement = document.createElementNS(_e, "style");
+    const { foreignObject: e, svgRoot: t, styleElement: r, domElement: i } = this;
+    e.setAttribute("width", "10000"), e.setAttribute("height", "10000"), e.style.overflow = "hidden", t.appendChild(e), e.appendChild(r), e.appendChild(i), this.image = ne.get().createImage();
+  }
+  destroy() {
+    this.svgRoot.remove(), this.foreignObject.remove(), this.styleElement.remove(), this.domElement.remove(), this.image.src = "", this.image.remove(), this.svgRoot = null, this.foreignObject = null, this.styleElement = null, this.domElement = null, this.image = null, this.canvasAndContext = null;
   }
 }
-let xe;
-function At(o, e, t, r) {
-  r || (r = xe || (xe = new Ee()));
-  const { domElement: s, styleElement: i, svgRoot: n } = r;
-  s.innerHTML = `<style>${e.cssStyle};</style><div style='padding:0'>${o}</div>`, s.setAttribute("style", "transform-origin: top left; display: inline-block"), t && (i.textContent = t), document.body.appendChild(n);
-  const a = s.getBoundingClientRect();
+let ye;
+function Et(o, e, t, r) {
+  r || (r = ye || (ye = new Ye()));
+  const { domElement: i, styleElement: s, svgRoot: n } = r;
+  i.innerHTML = `<style>${e.cssStyle};</style><div style='padding:0'>${o}</div>`, i.setAttribute("style", "transform-origin: top left; display: inline-block"), t && (s.textContent = t), document.body.appendChild(n);
+  const a = i.getBoundingClientRect();
   n.remove();
-  const l = e.padding * 2;
+  const u = e.padding * 2;
   return {
-    width: a.width - l,
-    height: a.height - l
+    width: a.width - u,
+    height: a.height - u
   };
 }
-class zt {
+class Vt {
   constructor() {
     this.batches = [], this.batched = !1;
   }
   destroy() {
     this.batches.forEach((e) => {
-      X.return(e);
+      K.return(e);
     }), this.batches.length = 0;
   }
 }
-class Le {
+class Xe {
   constructor(e, t) {
     this.state = j.for2d(), this.renderer = e, this._adaptor = t, this.renderer.runners.contextChange.add(this);
   }
@@ -1033,8 +1149,8 @@ class Le {
     this._adaptor.contextChange(this.renderer);
   }
   validateRenderable(e) {
-    const t = e.context, r = !!e._gpuData, s = this.renderer.graphicsContext.updateGpuContext(t);
-    return !!(s.isBatchable || r !== s.isBatchable);
+    const t = e.context, r = !!e._gpuData, i = this.renderer.graphicsContext.updateGpuContext(t);
+    return !!(i.isBatchable || r !== i.isBatchable);
   }
   addRenderable(e, t) {
     const r = this.renderer.graphicsContext.updateGpuContext(e.context);
@@ -1042,9 +1158,9 @@ class Le {
   }
   updateRenderable(e) {
     const r = this._getGpuDataForRenderable(e).batches;
-    for (let s = 0; s < r.length; s++) {
-      const i = r[s];
-      i._batcher.updateElement(i);
+    for (let i = 0; i < r.length; i++) {
+      const s = r[i];
+      s._batcher.updateElement(s);
     }
   }
   execute(e) {
@@ -1053,9 +1169,9 @@ class Le {
     const t = this.renderer, r = e.context;
     if (!t.graphicsContext.getGpuContext(r).batches.length)
       return;
-    const i = r.customShader || this._adaptor.shader;
+    const s = r.customShader || this._adaptor.shader;
     this.state.blendMode = e.groupBlendMode;
-    const n = i.resources.localUniforms.uniforms;
+    const n = s.resources.localUniforms.uniforms;
     n.uTransformMatrix = e.groupTransform, n.uRound = t._roundPixels | e._roundPixels, $(
       e.groupColorAlpha,
       n.uColor,
@@ -1067,9 +1183,9 @@ class Le {
     t.destroy(), r.isBatchable && this._updateBatchesForRenderable(e, t);
   }
   _addToBatcher(e, t) {
-    const r = this.renderer.renderPipes.batch, s = this._getGpuDataForRenderable(e).batches;
-    for (let i = 0; i < s.length; i++) {
-      const n = s[i];
+    const r = this.renderer.renderPipes.batch, i = this._getGpuDataForRenderable(e).batches;
+    for (let s = 0; s < i.length; s++) {
+      const n = i[s];
       r.addToBatch(n, t);
     }
   }
@@ -1077,33 +1193,33 @@ class Le {
     return e._gpuData[this.renderer.uid] || this._initGpuDataForRenderable(e);
   }
   _initGpuDataForRenderable(e) {
-    const t = new zt();
+    const t = new Vt();
     return e._gpuData[this.renderer.uid] = t, t;
   }
   _updateBatchesForRenderable(e, t) {
-    const r = e.context, s = this.renderer.graphicsContext.getGpuContext(r), i = this.renderer._roundPixels | e._roundPixels;
-    t.batches = s.batches.map((n) => {
-      const a = X.get(dt);
-      return n.copyTo(a), a.renderable = e, a.roundPixels = i, a;
+    const r = e.context, i = this.renderer.graphicsContext.getGpuContext(r), s = this.renderer._roundPixels | e._roundPixels;
+    t.batches = i.batches.map((n) => {
+      const a = K.get(gt);
+      return n.copyTo(a), a.renderable = e, a.roundPixels = s, a;
     });
   }
   destroy() {
     this.renderer = null, this._adaptor.destroy(), this._adaptor = null, this.state = null;
   }
 }
-Le.extension = {
+Xe.extension = {
   type: [
-    g.WebGLPipes,
-    g.WebGPUPipes,
-    g.CanvasPipes
+    m.WebGLPipes,
+    m.WebGPUPipes,
+    m.CanvasPipes
   ],
   name: "graphics"
 };
-const He = class Ye extends le {
+const Ke = class je extends ue {
   constructor(...e) {
     super({});
     let t = e[0] ?? {};
-    typeof t == "number" && (w(M, "PlaneGeometry constructor changed please use { width, height, verticesX, verticesY } instead"), t = {
+    typeof t == "number" && (w(U, "PlaneGeometry constructor changed please use { width, height, verticesX, verticesY } instead"), t = {
       width: t,
       height: e[1],
       verticesX: e[2],
@@ -1115,35 +1231,35 @@ const He = class Ye extends le {
    * @param options - Options to be applied to plane geometry
    */
   build(e) {
-    e = { ...Ye.defaultOptions, ...e }, this.verticesX = this.verticesX ?? e.verticesX, this.verticesY = this.verticesY ?? e.verticesY, this.width = this.width ?? e.width, this.height = this.height ?? e.height;
-    const t = this.verticesX * this.verticesY, r = [], s = [], i = [], n = this.verticesX - 1, a = this.verticesY - 1, l = this.width / n, u = this.height / a;
-    for (let d = 0; d < t; d++) {
-      const h = d % this.verticesX, f = d / this.verticesX | 0;
-      r.push(h * l, f * u), s.push(h / n, f / a);
+    e = { ...je.defaultOptions, ...e }, this.verticesX = this.verticesX ?? e.verticesX, this.verticesY = this.verticesY ?? e.verticesY, this.width = this.width ?? e.width, this.height = this.height ?? e.height;
+    const t = this.verticesX * this.verticesY, r = [], i = [], s = [], n = this.verticesX - 1, a = this.verticesY - 1, u = this.width / n, l = this.height / a;
+    for (let c = 0; c < t; c++) {
+      const h = c % this.verticesX, f = c / this.verticesX | 0;
+      r.push(h * u, f * l), i.push(h / n, f / a);
     }
-    const c = n * a;
-    for (let d = 0; d < c; d++) {
-      const h = d % n, f = d / n | 0, b = f * this.verticesX + h, m = f * this.verticesX + h + 1, x = (f + 1) * this.verticesX + h, p = (f + 1) * this.verticesX + h + 1;
-      i.push(
+    const d = n * a;
+    for (let c = 0; c < d; c++) {
+      const h = c % n, f = c / n | 0, y = f * this.verticesX + h, _ = f * this.verticesX + h + 1, b = (f + 1) * this.verticesX + h, x = (f + 1) * this.verticesX + h + 1;
+      s.push(
+        y,
+        _,
         b,
-        m,
+        _,
         x,
-        m,
-        p,
-        x
+        b
       );
     }
-    this.buffers[0].data = new Float32Array(r), this.buffers[1].data = new Float32Array(s), this.indexBuffer.data = new Uint32Array(i), this.buffers[0].update(), this.buffers[1].update(), this.indexBuffer.update();
+    this.buffers[0].data = new Float32Array(r), this.buffers[1].data = new Float32Array(i), this.indexBuffer.data = new Uint32Array(s), this.buffers[0].update(), this.buffers[1].update(), this.indexBuffer.update();
   }
 };
-He.defaultOptions = {
+Ke.defaultOptions = {
   width: 100,
   height: 100,
   verticesX: 10,
   verticesY: 10
 };
-let kt = He;
-class ue {
+let Lt = Ke;
+class le {
   constructor() {
     this.batcherName = "default", this.packAsQuad = !1, this.indexOffset = 0, this.attributeOffset = 0, this.roundPixels = 0, this._batcher = null, this._batch = null, this._textureMatrixUpdateId = -1, this._uvUpdateId = -1;
   }
@@ -1170,9 +1286,9 @@ class ue {
   }
   get uvs() {
     const t = this.geometry.getBuffer("aUV"), r = t.data;
-    let s = r;
-    const i = this.texture.textureMatrix;
-    return i.isSimple || (s = this._transformedUvs, (this._textureMatrixUpdateId !== i._updateID || this._uvUpdateId !== t._updateID) && ((!s || s.length < r.length) && (s = this._transformedUvs = new Float32Array(r.length)), this._textureMatrixUpdateId = i._updateID, this._uvUpdateId = t._updateID, i.multiplyUvs(r, s))), s;
+    let i = r;
+    const s = this.texture.textureMatrix;
+    return s.isSimple || (i = this._transformedUvs, (this._textureMatrixUpdateId !== s._updateID || this._uvUpdateId !== t._updateID) && ((!i || i.length < r.length) && (i = this._transformedUvs = new Float32Array(r.length)), this._textureMatrixUpdateId = s._updateID, this._uvUpdateId = t._updateID, s.multiplyUvs(r, i))), i;
   }
   get positions() {
     return this.geometry.positions;
@@ -1193,28 +1309,28 @@ class ue {
     return this.geometry.indices.length;
   }
 }
-class _e {
+class be {
   destroy() {
   }
 }
-class Ve {
+class $e {
   constructor(e, t) {
-    this.localUniforms = new z({
+    this.localUniforms = new A({
       uTransformMatrix: { value: new R(), type: "mat3x3<f32>" },
       uColor: { value: new Float32Array([1, 1, 1, 1]), type: "vec4<f32>" },
       uRound: { value: 0, type: "f32" }
-    }), this.localUniformsBindGroup = new Se({
+    }), this.localUniformsBindGroup = new Be({
       0: this.localUniforms
     }), this.renderer = e, this._adaptor = t, this._adaptor.init();
   }
   validateRenderable(e) {
-    const t = this._getMeshData(e), r = t.batched, s = e.batched;
-    if (t.batched = s, r !== s)
+    const t = this._getMeshData(e), r = t.batched, i = e.batched;
+    if (t.batched = i, r !== i)
       return !0;
-    if (s) {
-      const i = e._geometry;
-      if (i.indices.length !== t.indexSize || i.positions.length !== t.vertexSize)
-        return t.indexSize = i.indices.length, t.vertexSize = i.positions.length, !0;
+    if (i) {
+      const s = e._geometry;
+      if (s.indices.length !== t.indexSize || s.positions.length !== t.vertexSize)
+        return t.indexSize = s.indices.length, t.vertexSize = s.positions.length, !0;
       const n = this._getBatchableMesh(e);
       return n.texture.uid !== e._texture.uid && (n._textureMatrixUpdateId = -1), !n._batcher.checkAndUpdateTexture(
         n,
@@ -1224,9 +1340,9 @@ class Ve {
     return !1;
   }
   addRenderable(e, t) {
-    var i, n;
-    const r = this.renderer.renderPipes.batch, s = this._getMeshData(e);
-    if (e.didViewUpdate && (s.indexSize = (i = e._geometry.indices) == null ? void 0 : i.length, s.vertexSize = (n = e._geometry.positions) == null ? void 0 : n.length), s.batched) {
+    var s, n;
+    const r = this.renderer.renderPipes.batch, i = this._getMeshData(e);
+    if (e.didViewUpdate && (i.indexSize = (s = e._geometry.indices) == null ? void 0 : s.length, i.vertexSize = (n = e._geometry.positions) == null ? void 0 : n.length), i.batched) {
       const a = this._getBatchableMesh(e);
       a.setTexture(e._texture), a.geometry = e._geometry, r.addToBatch(a, t);
     } else
@@ -1251,7 +1367,7 @@ class Ve {
   }
   _getMeshData(e) {
     var t, r;
-    return (t = e._gpuData)[r = this.renderer.uid] || (t[r] = new _e()), e._gpuData[this.renderer.uid].meshData || this._initMeshData(e);
+    return (t = e._gpuData)[r = this.renderer.uid] || (t[r] = new be()), e._gpuData[this.renderer.uid].meshData || this._initMeshData(e);
   }
   _initMeshData(e) {
     return e._gpuData[this.renderer.uid].meshData = {
@@ -1262,62 +1378,62 @@ class Ve {
   }
   _getBatchableMesh(e) {
     var t, r;
-    return (t = e._gpuData)[r = this.renderer.uid] || (t[r] = new _e()), e._gpuData[this.renderer.uid].batchableMesh || this._initBatchableMesh(e);
+    return (t = e._gpuData)[r = this.renderer.uid] || (t[r] = new be()), e._gpuData[this.renderer.uid].batchableMesh || this._initBatchableMesh(e);
   }
   _initBatchableMesh(e) {
-    const t = new ue();
+    const t = new le();
     return t.renderable = e, t.setTexture(e._texture), t.transform = e.groupTransform, t.roundPixels = this.renderer._roundPixels | e._roundPixels, e._gpuData[this.renderer.uid].batchableMesh = t, t;
   }
   destroy() {
     this.localUniforms = null, this.localUniformsBindGroup = null, this._adaptor.destroy(), this._adaptor = null, this.renderer = null;
   }
 }
-Ve.extension = {
+$e.extension = {
   type: [
-    g.WebGLPipes,
-    g.WebGPUPipes,
-    g.CanvasPipes
+    m.WebGLPipes,
+    m.WebGPUPipes,
+    m.CanvasPipes
   ],
   name: "mesh"
 };
-class Dt {
+class Ht {
   execute(e, t) {
-    const r = e.state, s = e.renderer, i = t.shader || e.defaultShader;
-    i.resources.uTexture = t.texture._source, i.resources.uniforms = e.localUniforms;
-    const n = s.gl, a = e.getBuffers(t);
-    s.shader.bind(i), s.state.set(r), s.geometry.bind(a.geometry, i.glProgram);
-    const u = a.geometry.indexBuffer.data.BYTES_PER_ELEMENT === 2 ? n.UNSIGNED_SHORT : n.UNSIGNED_INT;
-    n.drawElements(n.TRIANGLES, t.particleChildren.length * 6, u, 0);
+    const r = e.state, i = e.renderer, s = t.shader || e.defaultShader;
+    s.resources.uTexture = t.texture._source, s.resources.uniforms = e.localUniforms;
+    const n = i.gl, a = e.getBuffers(t);
+    i.shader.bind(s), i.state.set(r), i.geometry.bind(a.geometry, s.glProgram);
+    const l = a.geometry.indexBuffer.data.BYTES_PER_ELEMENT === 2 ? n.UNSIGNED_SHORT : n.UNSIGNED_INT;
+    n.drawElements(n.TRIANGLES, t.particleChildren.length * 6, l, 0);
   }
 }
-class Ot {
+class Yt {
   execute(e, t) {
-    const r = e.renderer, s = t.shader || e.defaultShader;
-    s.groups[0] = r.renderPipes.uniformBatch.getUniformBindGroup(e.localUniforms, !0), s.groups[1] = r.texture.getTextureBindGroup(t.texture);
-    const i = e.state, n = e.getBuffers(t);
+    const r = e.renderer, i = t.shader || e.defaultShader;
+    i.groups[0] = r.renderPipes.uniformBatch.getUniformBindGroup(e.localUniforms, !0), i.groups[1] = r.texture.getTextureBindGroup(t.texture);
+    const s = e.state, n = e.getBuffers(t);
     r.encoder.draw({
       geometry: n.geometry,
       shader: t.shader || e.defaultShader,
-      state: i,
+      state: s,
       size: t.particleChildren.length * 6
     });
   }
 }
-function be(o, e = null) {
+function ve(o, e = null) {
   const t = o * 6;
   if (t > 65535 ? e || (e = new Uint32Array(t)) : e || (e = new Uint16Array(t)), e.length !== t)
     throw new Error(`Out buffer length is incorrect, got ${e.length} and expected ${t}`);
-  for (let r = 0, s = 0; r < t; r += 6, s += 4)
-    e[r + 0] = s + 0, e[r + 1] = s + 1, e[r + 2] = s + 2, e[r + 3] = s + 0, e[r + 4] = s + 2, e[r + 5] = s + 3;
+  for (let r = 0, i = 0; r < t; r += 6, i += 4)
+    e[r + 0] = i + 0, e[r + 1] = i + 1, e[r + 2] = i + 2, e[r + 3] = i + 0, e[r + 4] = i + 2, e[r + 5] = i + 3;
   return e;
 }
-function Wt(o) {
+function Xt(o) {
   return {
-    dynamicUpdate: ye(o, !0),
-    staticUpdate: ye(o, !1)
+    dynamicUpdate: Te(o, !0),
+    staticUpdate: Te(o, !1)
   };
 }
-function ye(o, e) {
+function Te(o, e) {
   const t = [];
   t.push(`
 
@@ -1329,12 +1445,12 @@ function ye(o, e) {
 
             `);
   let r = 0;
-  for (const i in o) {
-    const n = o[i];
+  for (const s in o) {
+    const n = o[s];
     if (e !== n.dynamic)
       continue;
     t.push(`offset = index + ${r}`), t.push(n.code);
-    const a = ee(n.format);
+    const a = te(n.format);
     r += a.stride / 4;
   }
   t.push(`
@@ -1343,22 +1459,22 @@ function ye(o, e) {
     `), t.unshift(`
         var stride = ${r};
     `);
-  const s = t.join(`
+  const i = t.join(`
 `);
-  return new Function("ps", "f32v", "u32v", s);
+  return new Function("ps", "f32v", "u32v", i);
 }
-class It {
+class Kt {
   constructor(e) {
     this._size = 0, this._generateParticleUpdateCache = {};
     const t = this._size = e.size ?? 1e3, r = e.properties;
-    let s = 0, i = 0;
-    for (const c in r) {
-      const d = r[c], h = ee(d.format);
-      d.dynamic ? i += h.stride : s += h.stride;
+    let i = 0, s = 0;
+    for (const d in r) {
+      const c = r[d], h = te(c.format);
+      c.dynamic ? s += h.stride : i += h.stride;
     }
-    this._dynamicStride = i / 4, this._staticStride = s / 4, this.staticAttributeBuffer = new L(t * 4 * s), this.dynamicAttributeBuffer = new L(t * 4 * i), this.indexBuffer = be(t);
-    const n = new se();
-    let a = 0, l = 0;
+    this._dynamicStride = s / 4, this._staticStride = i / 4, this.staticAttributeBuffer = new V(t * 4 * i), this.dynamicAttributeBuffer = new V(t * 4 * s), this.indexBuffer = ve(t);
+    const n = new ie();
+    let a = 0, u = 0;
     this._staticBuffer = new O({
       data: new Float32Array(1),
       label: "static-particle-buffer",
@@ -1370,33 +1486,33 @@ class It {
       shrinkToFit: !1,
       usage: B.VERTEX | B.COPY_DST
     });
-    for (const c in r) {
-      const d = r[c], h = ee(d.format);
-      d.dynamic ? (n.addAttribute(d.attributeName, {
+    for (const d in r) {
+      const c = r[d], h = te(c.format);
+      c.dynamic ? (n.addAttribute(c.attributeName, {
         buffer: this._dynamicBuffer,
         stride: this._dynamicStride * 4,
         offset: a * 4,
-        format: d.format
-      }), a += h.size) : (n.addAttribute(d.attributeName, {
+        format: c.format
+      }), a += h.size) : (n.addAttribute(c.attributeName, {
         buffer: this._staticBuffer,
         stride: this._staticStride * 4,
-        offset: l * 4,
-        format: d.format
-      }), l += h.size);
+        offset: u * 4,
+        format: c.format
+      }), u += h.size);
     }
     n.addIndex(this.indexBuffer);
-    const u = this.getParticleUpdate(r);
-    this._dynamicUpload = u.dynamicUpdate, this._staticUpload = u.staticUpdate, this.geometry = n;
+    const l = this.getParticleUpdate(r);
+    this._dynamicUpload = l.dynamicUpdate, this._staticUpload = l.staticUpdate, this.geometry = n;
   }
   getParticleUpdate(e) {
-    const t = Et(e);
+    const t = jt(e);
     return this._generateParticleUpdateCache[t] ? this._generateParticleUpdateCache[t] : (this._generateParticleUpdateCache[t] = this.generateParticleUpdate(e), this._generateParticleUpdateCache[t]);
   }
   generateParticleUpdate(e) {
-    return Wt(e);
+    return Xt(e);
   }
   update(e, t) {
-    e.length > this._size && (t = !0, this._size = Math.max(e.length, this._size * 1.5 | 0), this.staticAttributeBuffer = new L(this._size * this._staticStride * 4 * 4), this.dynamicAttributeBuffer = new L(this._size * this._dynamicStride * 4 * 4), this.indexBuffer = be(this._size), this.geometry.indexBuffer.setDataWithSize(
+    e.length > this._size && (t = !0, this._size = Math.max(e.length, this._size * 1.5 | 0), this.staticAttributeBuffer = new V(this._size * this._staticStride * 4 * 4), this.dynamicAttributeBuffer = new V(this._size * this._dynamicStride * 4 * 4), this.indexBuffer = ve(this._size), this.geometry.indexBuffer.setDataWithSize(
       this.indexBuffer,
       this.indexBuffer.byteLength,
       !0
@@ -1407,9 +1523,9 @@ class It {
       e.length * this._dynamicStride * 4,
       !0
     ), t) {
-      const s = this.staticAttributeBuffer;
-      this._staticUpload(e, s.float32View, s.uint32View), this._staticBuffer.setDataWithSize(
-        s.float32View,
+      const i = this.staticAttributeBuffer;
+      this._staticUpload(e, i.float32View, i.uint32View), this._staticBuffer.setDataWithSize(
+        i.float32View,
         e.length * this._staticStride * 4,
         !0
       );
@@ -1419,7 +1535,7 @@ class It {
     this._staticBuffer.destroy(), this._dynamicBuffer.destroy(), this.geometry.destroy();
   }
 }
-function Et(o) {
+function jt(o) {
   const e = [];
   for (const t in o) {
     const r = o[t];
@@ -1427,7 +1543,7 @@ function Et(o) {
   }
   return e.join("_");
 }
-var Lt = `varying vec2 vUV;
+var $t = `varying vec2 vUV;
 varying vec4 vColor;
 
 uniform sampler2D uTexture;
@@ -1435,7 +1551,7 @@ uniform sampler2D uTexture;
 void main(void){
     vec4 color = texture2D(uTexture, vUV) * vColor;
     gl_FragColor = color;
-}`, Ht = `attribute vec2 aVertex;
+}`, Nt = `attribute vec2 aVertex;
 attribute vec2 aUV;
 attribute vec4 aColor;
 
@@ -1474,14 +1590,19 @@ void main(void){
     vUV = aUV;
     vColor = vec4(aColor.rgb * aColor.a, aColor.a) * uColor;
 }
-`, ve = `
+`, we = `
 struct ParticleUniforms {
-  uProjectionMatrix:mat3x3<f32>,
+  uTranslationMatrix:mat3x3<f32>,
   uColor:vec4<f32>,
+  uRound:f32,
   uResolution:vec2<f32>,
-  uRoundPixels:f32,
 };
 
+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;
+}
+
 @group(0) @binding(0) var<uniform> uniforms: ParticleUniforms;
 
 @group(1) @binding(0) var uTexture: texture_2d<f32>;
@@ -1506,7 +1627,11 @@ fn mainVertex(
        aVertex.x * sin(aRotation) + aVertex.y * cos(aRotation)
    ) + aPosition;
 
-   let position = vec4((uniforms.uProjectionMatrix * vec3(v, 1.0)).xy, 0.0, 1.0);
+   var position = vec4((uniforms.uTranslationMatrix * vec3(v, 1.0)).xy, 0.0, 1.0);
+
+   if(uniforms.uRound == 1.0) {
+       position = vec4(roundPixels(position.xy, uniforms.uResolution), position.zw);
+   }
 
     let vColor = vec4(aColor.rgb * aColor.a, aColor.a) * uniforms.uColor;
 
@@ -1528,18 +1653,18 @@ fn mainFragment(
    
     return sample;
 }`;
-class Yt extends oe {
+class qt extends oe {
   constructor() {
-    const e = ct.from({
-      vertex: Ht,
-      fragment: Lt
-    }), t = ht.from({
+    const e = Fe.from({
+      vertex: Nt,
+      fragment: $t
+    }), t = Pe.from({
       fragment: {
-        source: ve,
+        source: we,
         entryPoint: "mainFragment"
       },
       vertex: {
-        source: ve,
+        source: we,
         entryPoint: "mainVertex"
       }
     });
@@ -1548,13 +1673,13 @@ class Yt extends oe {
       gpuProgram: t,
       resources: {
         // this will be replaced with the texture from the particle container
-        uTexture: S.WHITE.source,
+        uTexture: C.WHITE.source,
         // this will be replaced with the texture style from the particle container
-        uSampler: new W({}),
+        uSampler: new I({}),
         // this will be replaced with the local uniforms from the particle container
         uniforms: {
           uTranslationMatrix: { value: new R(), type: "mat3x3<f32>" },
-          uColor: { value: new we(16777215), type: "vec4<f32>" },
+          uColor: { value: new Se(16777215), type: "vec4<f32>" },
           uRound: { value: 1, type: "f32" },
           uResolution: { value: [0, 0], type: "vec2<f32>" }
         }
@@ -1562,18 +1687,18 @@ class Yt extends oe {
     });
   }
 }
-class Xe {
+class Ne {
   /**
    * @param renderer - The renderer this sprite batch works for.
    * @param adaptor
    */
   constructor(e, t) {
-    this.state = j.for2d(), this.localUniforms = new z({
+    this.state = j.for2d(), this.localUniforms = new A({
       uTranslationMatrix: { value: new R(), type: "mat3x3<f32>" },
       uColor: { value: new Float32Array(4), type: "vec4<f32>" },
       uRound: { value: 1, type: "f32" },
       uResolution: { value: [0, 0], type: "vec2<f32>" }
-    }), this.renderer = e, this.adaptor = t, this.defaultShader = new Yt(), this.state = j.for2d();
+    }), this.renderer = e, this.adaptor = t, this.defaultShader = new qt(), this.state = j.for2d();
   }
   validateRenderable(e) {
     return !1;
@@ -1585,7 +1710,7 @@ class Xe {
     return e._gpuData[this.renderer.uid] || this._initBuffer(e);
   }
   _initBuffer(e) {
-    return e._gpuData[this.renderer.uid] = new It({
+    return e._gpuData[this.renderer.uid] = new Kt({
       size: e.particleChildren.length,
       properties: e._properties
     }), e._gpuData[this.renderer.uid];
@@ -1596,10 +1721,10 @@ class Xe {
     const t = e.particleChildren;
     if (t.length === 0)
       return;
-    const r = this.renderer, s = this.getBuffers(e);
+    const r = this.renderer, i = this.getBuffers(e);
     e.texture || (e.texture = t[0].texture);
-    const i = this.state;
-    s.update(t, e._childrenDirty), e._childrenDirty = !1, i.blendMode = ae(e.blendMode, e.texture._source);
+    const s = this.state;
+    i.update(t, e._childrenDirty), e._childrenDirty = !1, s.blendMode = ae(e.blendMode, e.texture._source);
     const n = this.localUniforms.uniforms, a = n.uTranslationMatrix;
     e.worldTransform.copyTo(a), a.prepend(r.globalUniforms.globalUniformData.projectionMatrix), n.uResolution = r.globalUniforms.globalUniformData.resolution, n.uRound = r._roundPixels | e._roundPixels, $(
       e.groupColorAlpha,
@@ -1609,34 +1734,34 @@ class Xe {
   }
   /** Destroys the ParticleRenderer. */
   destroy() {
-    this.defaultShader && (this.defaultShader.destroy(), this.defaultShader = null);
+    this.renderer = null, this.defaultShader && (this.defaultShader.destroy(), this.defaultShader = null);
   }
 }
-class je extends Xe {
+class qe extends Ne {
   constructor(e) {
-    super(e, new Dt());
+    super(e, new Ht());
   }
 }
-je.extension = {
+qe.extension = {
   type: [
-    g.WebGLPipes
+    m.WebGLPipes
   ],
   name: "particle"
 };
-class $e extends Xe {
+class Qe extends Ne {
   constructor(e) {
-    super(e, new Ot());
+    super(e, new Yt());
   }
 }
-$e.extension = {
+Qe.extension = {
   type: [
-    g.WebGPUPipes
+    m.WebGPUPipes
   ],
   name: "particle"
 };
-const Ne = class qe extends kt {
+const Je = class Ze extends Lt {
   constructor(e = {}) {
-    e = { ...qe.defaultOptions, ...e }, super({
+    e = { ...Ze.defaultOptions, ...e }, super({
       width: e.width,
       height: e.height,
       verticesX: 4,
@@ -1656,14 +1781,14 @@ const Ne = class qe extends kt {
     const e = this.positions, {
       width: t,
       height: r,
-      _leftWidth: s,
-      _rightWidth: i,
+      _leftWidth: i,
+      _rightWidth: s,
       _topHeight: n,
       _bottomHeight: a,
-      _anchorX: l,
-      _anchorY: u
-    } = this, c = s + i, d = t > c ? 1 : t / c, h = n + a, f = r > h ? 1 : r / h, b = Math.min(d, f), m = l * t, x = u * r;
-    e[0] = e[8] = e[16] = e[24] = -m, e[2] = e[10] = e[18] = e[26] = s * b - m, e[4] = e[12] = e[20] = e[28] = t - i * b - m, e[6] = e[14] = e[22] = e[30] = t - m, e[1] = e[3] = e[5] = e[7] = -x, e[9] = e[11] = e[13] = e[15] = n * b - x, e[17] = e[19] = e[21] = e[23] = r - a * b - x, e[25] = e[27] = e[29] = e[31] = r - x, this.getBuffer("aPosition").update();
+      _anchorX: u,
+      _anchorY: l
+    } = this, d = i + s, c = t > d ? 1 : t / d, h = n + a, f = r > h ? 1 : r / h, y = Math.min(c, f), _ = u * t, b = l * r;
+    e[0] = e[8] = e[16] = e[24] = -_, e[2] = e[10] = e[18] = e[26] = i * y - _, e[4] = e[12] = e[20] = e[28] = t - s * y - _, e[6] = e[14] = e[22] = e[30] = t - _, e[1] = e[3] = e[5] = e[7] = -b, e[9] = e[11] = e[13] = e[15] = n * y - b, e[17] = e[19] = e[21] = e[23] = r - a * y - b, e[25] = e[27] = e[29] = e[31] = r - b, this.getBuffer("aPosition").update();
   }
   /** Updates the UVs of the vertices. */
   updateUvs() {
@@ -1673,7 +1798,7 @@ const Ne = class qe extends kt {
     e[2] = e[10] = e[18] = e[26] = t * this._leftWidth, e[9] = e[11] = e[13] = e[15] = r * this._topHeight, e[4] = e[12] = e[20] = e[28] = 1 - t * this._rightWidth, e[17] = e[19] = e[21] = e[23] = 1 - r * this._bottomHeight, this.getBuffer("aUV").update();
   }
 };
-Ne.defaultOptions = {
+Je.defaultOptions = {
   /** The width of the NineSlicePlane, setting this will actually modify the vertices and UV's of this plane. */
   width: 100,
   /** The height of the NineSlicePlane, setting this will actually modify the vertices and UV's of this plane. */
@@ -1691,16 +1816,16 @@ Ne.defaultOptions = {
   /** The original height of the texture */
   originalHeight: 100
 };
-let Vt = Ne;
-class Xt extends ue {
+let Qt = Je;
+class Jt extends le {
   constructor() {
-    super(), this.geometry = new Vt();
+    super(), this.geometry = new Qt();
   }
   destroy() {
     this.geometry.destroy();
   }
 }
-class Ke {
+class et {
   constructor(e) {
     this._renderer = e;
   }
@@ -1726,22 +1851,22 @@ class Ke {
     return e._gpuData[this._renderer.uid] || this._initGPUSprite(e);
   }
   _initGPUSprite(e) {
-    const t = e._gpuData[this._renderer.uid] = new Xt(), r = t;
+    const t = e._gpuData[this._renderer.uid] = new Jt(), r = t;
     return r.renderable = e, r.transform = e.groupTransform, r.texture = e._texture, r.roundPixels = this._renderer._roundPixels | e._roundPixels, e.didViewUpdate || this._updateBatchableSprite(e, r), t;
   }
   destroy() {
     this._renderer = null;
   }
 }
-Ke.extension = {
+et.extension = {
   type: [
-    g.WebGLPipes,
-    g.WebGPUPipes,
-    g.CanvasPipes
+    m.WebGLPipes,
+    m.WebGPUPipes,
+    m.CanvasPipes
   ],
   name: "nineSliceSprite"
 };
-const jt = {
+const Zt = {
   name: "tiling-bit",
   vertex: {
     header: (
@@ -1806,7 +1931,7 @@ const jt = {
         `
     )
   }
-}, $t = {
+}, er = {
   name: "tiling-bit",
   vertex: {
     header: (
@@ -1851,25 +1976,25 @@ const jt = {
     )
   }
 };
-let q, K;
-class Nt extends oe {
+let q, Q;
+class tr extends oe {
   constructor() {
-    q ?? (q = Ce({
+    q ?? (q = Me({
       name: "tiling-sprite-shader",
       bits: [
-        vt,
-        jt,
-        Fe
+        St,
+        Zt,
+        Ue
       ]
-    })), K ?? (K = Be({
+    })), Q ?? (Q = Ge({
       name: "tiling-sprite-shader",
       bits: [
-        Tt,
-        $t,
-        Ue
+        Pt,
+        er,
+        ze
       ]
     }));
-    const e = new z({
+    const e = new A({
       uMapCoord: { value: new R(), type: "mat3x3<f32>" },
       uClampFrame: { value: new Float32Array([0, 0, 1, 1]), type: "vec4<f32>" },
       uClampOffset: { value: new Float32Array([0, 0]), type: "vec2<f32>" },
@@ -1877,33 +2002,33 @@ class Nt extends oe {
       uSizeAnchor: { value: new Float32Array([100, 100, 0.5, 0.5]), type: "vec4<f32>" }
     });
     super({
-      glProgram: K,
+      glProgram: Q,
       gpuProgram: q,
       resources: {
-        localUniforms: new z({
+        localUniforms: new A({
           uTransformMatrix: { value: new R(), type: "mat3x3<f32>" },
           uColor: { value: new Float32Array([1, 1, 1, 1]), type: "vec4<f32>" },
           uRound: { value: 0, type: "f32" }
         }),
         tilingUniforms: e,
-        uTexture: S.EMPTY.source,
-        uSampler: S.EMPTY.source.style
+        uTexture: C.EMPTY.source,
+        uSampler: C.EMPTY.source.style
       }
     });
   }
-  updateUniforms(e, t, r, s, i, n) {
-    const a = this.resources.tilingUniforms, l = n.width, u = n.height, c = n.textureMatrix, d = a.uniforms.uTextureTransform;
-    d.set(
-      r.a * l / e,
-      r.b * l / t,
-      r.c * u / e,
-      r.d * u / t,
+  updateUniforms(e, t, r, i, s, n) {
+    const a = this.resources.tilingUniforms, u = n.width, l = n.height, d = n.textureMatrix, c = a.uniforms.uTextureTransform;
+    c.set(
+      r.a * u / e,
+      r.b * u / t,
+      r.c * l / e,
+      r.d * l / t,
       r.tx / e,
       r.ty / t
-    ), d.invert(), a.uniforms.uMapCoord = c.mapCoord, a.uniforms.uClampFrame = c.uClampFrame, a.uniforms.uClampOffset = c.uClampOffset, a.uniforms.uTextureTransform = d, a.uniforms.uSizeAnchor[0] = e, a.uniforms.uSizeAnchor[1] = t, a.uniforms.uSizeAnchor[2] = s, a.uniforms.uSizeAnchor[3] = i, n && (this.resources.uTexture = n.source, this.resources.uSampler = n.source.style);
+    ), c.invert(), a.uniforms.uMapCoord = d.mapCoord, a.uniforms.uClampFrame = d.uClampFrame, a.uniforms.uClampOffset = d.uClampOffset, a.uniforms.uTextureTransform = c, a.uniforms.uSizeAnchor[0] = e, a.uniforms.uSizeAnchor[1] = t, a.uniforms.uSizeAnchor[2] = i, a.uniforms.uSizeAnchor[3] = s, n && (this.resources.uTexture = n.source, this.resources.uSampler = n.source.style);
   }
 }
-class qt extends le {
+class rr extends ue {
   constructor() {
     super({
       positions: new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]),
@@ -1912,32 +2037,32 @@ class qt extends le {
     });
   }
 }
-function Kt(o, e) {
+function ir(o, e) {
   const t = o.anchor.x, r = o.anchor.y;
   e[0] = -t * o.width, e[1] = -r * o.height, e[2] = (1 - t) * o.width, e[3] = -r * o.height, e[4] = (1 - t) * o.width, e[5] = (1 - r) * o.height, e[6] = -t * o.width, e[7] = (1 - r) * o.height;
 }
-function Qt(o, e, t, r) {
-  let s = 0;
-  const i = o.length / e, n = r.a, a = r.b, l = r.c, u = r.d, c = r.tx, d = r.ty;
-  for (t *= e; s < i; ) {
+function sr(o, e, t, r) {
+  let i = 0;
+  const s = o.length / e, n = r.a, a = r.b, u = r.c, l = r.d, d = r.tx, c = r.ty;
+  for (t *= e; i < s; ) {
     const h = o[t], f = o[t + 1];
-    o[t] = n * h + l * f + c, o[t + 1] = a * h + u * f + d, t += e, s++;
+    o[t] = n * h + u * f + d, o[t + 1] = a * h + l * f + c, t += e, i++;
   }
 }
-function Jt(o, e) {
-  const t = o.texture, r = t.frame.width, s = t.frame.height;
-  let i = 0, n = 0;
-  o.applyAnchorToTexture && (i = o.anchor.x, n = o.anchor.y), e[0] = e[6] = -i, e[2] = e[4] = 1 - i, e[1] = e[3] = -n, e[5] = e[7] = 1 - n;
+function nr(o, e) {
+  const t = o.texture, r = t.frame.width, i = t.frame.height;
+  let s = 0, n = 0;
+  o.applyAnchorToTexture && (s = o.anchor.x, n = o.anchor.y), e[0] = e[6] = -s, e[2] = e[4] = 1 - s, e[1] = e[3] = -n, e[5] = e[7] = 1 - n;
   const a = R.shared;
-  a.copyFrom(o._tileTransform.matrix), a.tx /= o.width, a.ty /= o.height, a.invert(), a.scale(o.width / r, o.height / s), Qt(e, 2, 0, a);
+  a.copyFrom(o._tileTransform.matrix), a.tx /= o.width, a.ty /= o.height, a.invert(), a.scale(o.width / r, o.height / i), sr(e, 2, 0, a);
 }
-const Y = new qt();
-class Zt {
+const H = new rr();
+class ar {
   constructor() {
-    this.canBatch = !0, this.geometry = new le({
-      indices: Y.indices.slice(),
-      positions: Y.positions.slice(),
-      uvs: Y.uvs.slice()
+    this.canBatch = !0, this.geometry = new ue({
+      indices: H.indices.slice(),
+      positions: H.positions.slice(),
+      uvs: H.uvs.slice()
     });
   }
   destroy() {
@@ -1945,33 +2070,33 @@ class Zt {
     this.geometry.destroy(), (e = this.shader) == null || e.destroy();
   }
 }
-class Qe {
+class tt {
   constructor(e) {
     this._state = j.default2d, this._renderer = e;
   }
   validateRenderable(e) {
     const t = this._getTilingSpriteData(e), r = t.canBatch;
     this._updateCanBatch(e);
-    const s = t.canBatch;
-    if (s && s === r) {
-      const { batchableMesh: i } = t;
-      return !i._batcher.checkAndUpdateTexture(
-        i,
+    const i = t.canBatch;
+    if (i && i === r) {
+      const { batchableMesh: s } = t;
+      return !s._batcher.checkAndUpdateTexture(
+        s,
         e.texture
       );
     }
-    return r !== s;
+    return r !== i;
   }
   addRenderable(e, t) {
     const r = this._renderer.renderPipes.batch;
     this._updateCanBatch(e);
-    const s = this._getTilingSpriteData(e), { geometry: i, canBatch: n } = s;
+    const i = this._getTilingSpriteData(e), { geometry: s, canBatch: n } = i;
     if (n) {
-      s.batchableMesh || (s.batchableMesh = new ue());
-      const a = s.batchableMesh;
-      e.didViewUpdate && (this._updateBatchableMesh(e), a.geometry = i, a.renderable = e, a.transform = e.groupTransform, a.setTexture(e._texture)), a.roundPixels = this._renderer._roundPixels | e._roundPixels, r.addToBatch(a, t);
+      i.batchableMesh || (i.batchableMesh = new le());
+      const a = i.batchableMesh;
+      e.didViewUpdate && (this._updateBatchableMesh(e), a.geometry = s, a.renderable = e, a.transform = e.groupTransform, a.setTexture(e._texture)), a.roundPixels = this._renderer._roundPixels | e._roundPixels, r.addToBatch(a, t);
     } else
-      r.break(t), s.shader || (s.shader = new Nt()), this.updateRenderable(e), t.add(e);
+      r.break(t), i.shader || (i.shader = new tr()), this.updateRenderable(e), t.add(e);
   }
   execute(e) {
     const { shader: t } = this._getTilingSpriteData(e);
@@ -1982,7 +2107,7 @@ class Qe {
       r.uColor,
       0
     ), this._state.blendMode = ae(e.groupBlendMode, e.texture._source), this._renderer.encoder.draw({
-      geometry: Y,
+      geometry: H,
       shader: t,
       state: this._state
     });
@@ -1990,11 +2115,11 @@ class Qe {
   updateRenderable(e) {
     const t = this._getTilingSpriteData(e), { canBatch: r } = t;
     if (r) {
-      const { batchableMesh: s } = t;
-      e.didViewUpdate && this._updateBatchableMesh(e), s._batcher.updateElement(s);
+      const { batchableMesh: i } = t;
+      e.didViewUpdate && this._updateBatchableMesh(e), i._batcher.updateElement(i);
     } else if (e.didViewUpdate) {
-      const { shader: s } = t;
-      s.updateUniforms(
+      const { shader: i } = t;
+      i.updateUniforms(
         e.width,
         e.height,
         e._tileTransform.matrix,
@@ -2008,31 +2133,31 @@ class Qe {
     return e._gpuData[this._renderer.uid] || this._initTilingSpriteData(e);
   }
   _initTilingSpriteData(e) {
-    const t = new Zt();
+    const t = new ar();
     return t.renderable = e, e._gpuData[this._renderer.uid] = t, t;
   }
   _updateBatchableMesh(e) {
-    const t = this._getTilingSpriteData(e), { geometry: r } = t, s = e.texture.source.style;
-    s.addressMode !== "repeat" && (s.addressMode = "repeat", s.update()), Jt(e, r.uvs), Kt(e, r.positions);
+    const t = this._getTilingSpriteData(e), { geometry: r } = t, i = e.texture.source.style;
+    i.addressMode !== "repeat" && (i.addressMode = "repeat", i.update()), nr(e, r.uvs), ir(e, r.positions);
   }
   destroy() {
     this._renderer = null;
   }
   _updateCanBatch(e) {
     const t = this._getTilingSpriteData(e), r = e.texture;
-    let s = !0;
-    return this._renderer.type === ie.WEBGL && (s = this._renderer.context.supports.nonPowOf2wrapping), t.canBatch = r.textureMatrix.isSimple && (s || r.source.isPowerOfTwo), t.canBatch;
+    let i = !0;
+    return this._renderer.type === se.WEBGL && (i = this._renderer.context.supports.nonPowOf2wrapping), t.canBatch = r.textureMatrix.isSimple && (i || r.source.isPowerOfTwo), t.canBatch;
   }
 }
-Qe.extension = {
+tt.extension = {
   type: [
-    g.WebGLPipes,
-    g.WebGPUPipes,
-    g.CanvasPipes
+    m.WebGLPipes,
+    m.WebGPUPipes,
+    m.CanvasPipes
   ],
   name: "tilingSprite"
 };
-const er = {
+const or = {
   name: "local-uniform-msdf-bit",
   vertex: {
     header: (
@@ -2085,7 +2210,7 @@ const er = {
         `
     )
   }
-}, tr = {
+}, ur = {
   name: "local-uniform-msdf-bit",
   vertex: {
     header: (
@@ -2127,7 +2252,7 @@ const er = {
         `
     )
   }
-}, rr = {
+}, lr = {
   name: "msdf-bit",
   fragment: {
     header: (
@@ -2162,7 +2287,7 @@ const er = {
         `
     )
   }
-}, sr = {
+}, cr = {
   name: "msdf-bit",
   fragment: {
     header: (
@@ -2198,51 +2323,51 @@ const er = {
     )
   }
 };
-let Q, J;
-class ir extends oe {
+let J, Z;
+class dr extends oe {
   constructor(e) {
-    const t = new z({
+    const t = new A({
       uColor: { value: new Float32Array([1, 1, 1, 1]), type: "vec4<f32>" },
       uTransformMatrix: { value: new R(), type: "mat3x3<f32>" },
       uDistance: { value: 4, type: "f32" },
       uRound: { value: 0, type: "f32" }
     });
-    Q ?? (Q = Ce({
+    J ?? (J = Me({
       name: "sdf-shader",
       bits: [
-        ft,
-        pt(e),
-        er,
-        rr,
-        Fe
+        mt,
+        xt(e),
+        or,
+        lr,
+        Ue
       ]
-    })), J ?? (J = Be({
+    })), Z ?? (Z = Ge({
       name: "sdf-shader",
       bits: [
-        gt,
-        mt(e),
-        tr,
-        sr,
-        Ue
+        _t,
+        yt(e),
+        ur,
+        cr,
+        ze
       ]
     })), super({
-      glProgram: J,
-      gpuProgram: Q,
+      glProgram: Z,
+      gpuProgram: J,
       resources: {
         localUniforms: t,
-        batchSamplers: xt(e)
+        batchSamplers: bt(e)
       }
     });
   }
 }
-class nr extends _t {
+class hr extends vt {
   destroy() {
     this.context.customShader && this.context.customShader.destroy(), super.destroy();
   }
 }
-class Je {
+class rt {
   constructor(e) {
-    this._renderer = e, this._renderer.renderableGC.addManagedHash(this, "_gpuBitmapText");
+    this._renderer = e;
   }
   validateRenderable(e) {
     const t = this._getGpuBitmapText(e);
@@ -2250,77 +2375,77 @@ class Je {
   }
   addRenderable(e, t) {
     const r = this._getGpuBitmapText(e);
-    Te(e, r), e._didTextUpdate && (e._didTextUpdate = !1, this._updateContext(e, r)), this._renderer.renderPipes.graphics.addRenderable(r, t), r.context.customShader && this._updateDistanceField(e);
+    Ce(e, r), e._didTextUpdate && (e._didTextUpdate = !1, this._updateContext(e, r)), this._renderer.renderPipes.graphics.addRenderable(r, t), r.context.customShader && this._updateDistanceField(e);
   }
   updateRenderable(e) {
     const t = this._getGpuBitmapText(e);
-    Te(e, t), this._renderer.renderPipes.graphics.updateRenderable(t), t.context.customShader && this._updateDistanceField(e);
+    Ce(e, t), this._renderer.renderPipes.graphics.updateRenderable(t), t.context.customShader && this._updateDistanceField(e);
   }
   _updateContext(e, t) {
-    const { context: r } = t, s = Ut.getFont(e.text, e._style);
-    r.clear(), s.distanceField.type !== "none" && (r.customShader || (r.customShader = new ir(this._renderer.limits.maxBatchableTextures)));
-    const i = D.graphemeSegmenter(e.text), n = e._style;
-    let a = s.baseLineOffset;
-    const l = ke(i, n, s, !0), u = n.padding, c = l.scale;
-    let d = l.width, h = l.height + l.offsetY;
-    n._stroke && (d += n._stroke.width / c, h += n._stroke.width / c), r.translate(-e._anchor._x * d - u, -e._anchor._y * h - u).scale(c, c);
-    const f = s.applyFillAsTint ? n._fill.color : 16777215;
-    let b = s.fontMetrics.fontSize, m = s.lineHeight;
-    n.lineHeight && (b = n.fontSize / c, m = n.lineHeight / c);
-    let x = (m - b) / 2;
-    x - s.baseLineOffset < 0 && (x = 0);
-    for (let p = 0; p < l.lines.length; p++) {
-      const _ = l.lines[p];
-      for (let y = 0; y < _.charPositions.length; y++) {
-        const v = _.chars[y], P = s.chars[v];
-        if (P != null && P.texture) {
-          const G = P.texture;
+    const { context: r } = t, i = zt.getFont(e.text, e._style);
+    r.clear(), i.distanceField.type !== "none" && (r.customShader || (r.customShader = new dr(this._renderer.limits.maxBatchableTextures)));
+    const s = D.graphemeSegmenter(e.text), n = e._style;
+    let a = i.baseLineOffset;
+    const u = We(s, n, i, !0), l = n.padding, d = u.scale;
+    let c = u.width, h = u.height + u.offsetY;
+    n._stroke && (c += n._stroke.width / d, h += n._stroke.width / d), r.translate(-e._anchor._x * c - l, -e._anchor._y * h - l).scale(d, d);
+    const f = i.applyFillAsTint ? n._fill.color : 16777215;
+    let y = i.fontMetrics.fontSize, _ = i.lineHeight;
+    n.lineHeight && (y = n.fontSize / d, _ = n.lineHeight / d);
+    let b = (_ - y) / 2;
+    b - i.baseLineOffset < 0 && (b = 0);
+    for (let x = 0; x < u.lines.length; x++) {
+      const g = u.lines[x];
+      for (let p = 0; p < g.charPositions.length; p++) {
+        const v = g.chars[p], S = i.chars[v];
+        if (S != null && S.texture) {
+          const G = S.texture;
           r.texture(
             G,
             f || "black",
-            Math.round(_.charPositions[y] + P.xOffset),
-            Math.round(a + P.yOffset + x),
+            Math.round(g.charPositions[p] + S.xOffset),
+            Math.round(a + S.yOffset + b),
             G.orig.width,
             G.orig.height
           );
         }
       }
-      a += m;
+      a += _;
     }
   }
   _getGpuBitmapText(e) {
     return e._gpuData[this._renderer.uid] || this.initGpuText(e);
   }
   initGpuText(e) {
-    const t = new nr();
+    const t = new hr();
     return e._gpuData[this._renderer.uid] = t, this._updateContext(e, t), t;
   }
   _updateDistanceField(e) {
-    const t = this._getGpuBitmapText(e).context, r = e._style.fontFamily, s = C.get(`${r}-bitmap`), { a: i, b: n, c: a, d: l } = e.groupTransform, u = Math.sqrt(i * i + n * n), c = Math.sqrt(a * a + l * l), d = (Math.abs(u) + Math.abs(c)) / 2, h = s.baseRenderedFontSize / e._style.fontSize, f = d * s.distanceField.range * (1 / h);
+    const t = this._getGpuBitmapText(e).context, r = e._style.fontFamily, i = P.get(`${r}-bitmap`), { a: s, b: n, c: a, d: u } = e.groupTransform, l = Math.sqrt(s * s + n * n), d = Math.sqrt(a * a + u * u), c = (Math.abs(l) + Math.abs(d)) / 2, h = i.baseRenderedFontSize / e._style.fontSize, f = c * i.distanceField.range * (1 / h);
     t.customShader.resources.localUniforms.uniforms.uDistance = f;
   }
   destroy() {
     this._renderer = null;
   }
 }
-Je.extension = {
+rt.extension = {
   type: [
-    g.WebGLPipes,
-    g.WebGPUPipes,
-    g.CanvasPipes
+    m.WebGLPipes,
+    m.WebGPUPipes,
+    m.CanvasPipes
   ],
   name: "bitmapText"
 };
-function Te(o, e) {
+function Ce(o, e) {
   e.groupTransform = o.groupTransform, e.groupColorAlpha = o.groupColorAlpha, e.groupColor = o.groupColor, e.groupBlendMode = o.groupBlendMode, e.globalDisplayStatus = o.globalDisplayStatus, e.groupTransform = o.groupTransform, e.localDisplayStatus = o.localDisplayStatus, e.groupAlpha = o.groupAlpha, e._roundPixels = o._roundPixels;
 }
-class ar extends Me {
+class fr extends Ae {
   /**
    * Creates an instance of BatchableHTMLText.
    * @param renderer - The renderer instance to be used.
    */
   constructor(e) {
-    super(), this.generatingTexture = !1, this._renderer = e, e.runners.resolutionChange.add(this);
+    super(), this.generatingTexture = !1, this.currentKey = "--", this._renderer = e, e.runners.resolutionChange.add(this);
   }
   /** Handles resolution changes for the HTML text. If the text has auto resolution enabled, it triggers a view update. */
   resolutionChange() {
@@ -2329,27 +2454,33 @@ class ar extends Me {
   }
   /** Destroys the BatchableHTMLText instance. Returns the texture promise to the renderer and cleans up references. */
   destroy() {
-    this._renderer.htmlText.returnTexturePromise(this.texturePromise), this.texturePromise = null, this._renderer = null;
+    const { htmlText: e } = this._renderer;
+    e.getReferenceCount(this.currentKey) === null ? e.returnTexturePromise(this.texturePromise) : e.decreaseReferenceCount(this.currentKey), this._renderer.runners.resolutionChange.remove(this), this.texturePromise = null, this._renderer = null;
   }
 }
-function te(o, e) {
-  const { texture: t, bounds: r } = o, s = e._style._getFinalPadding();
-  bt(r, e._anchor, t);
-  const i = e._anchor._x * s * 2, n = e._anchor._y * s * 2;
-  r.minX -= s - i, r.minY -= s - n, r.maxX -= s - i, r.maxY -= s - n;
+function re(o, e) {
+  const { texture: t, bounds: r } = o, i = e._style._getFinalPadding();
+  Tt(r, e._anchor, t);
+  const s = e._anchor._x * i * 2, n = e._anchor._y * i * 2;
+  r.minX -= i - s, r.minY -= i - n, r.maxX -= i - s, r.maxY -= i - n;
 }
-class Ze {
+class it {
   constructor(e) {
     this._renderer = e;
   }
   validateRenderable(e) {
-    return e._didTextUpdate;
+    const t = this._getGpuText(e), r = e.styleKey;
+    return t.currentKey !== r;
   }
   addRenderable(e, t) {
     const r = this._getGpuText(e);
-    e._didTextUpdate && (this._updateGpuText(e).catch((s) => {
-      console.error(s);
-    }), e._didTextUpdate = !1, te(r, e)), this._renderer.renderPipes.batch.addToBatch(r, t);
+    if (e._didTextUpdate) {
+      const i = e._autoResolution ? this._renderer.resolution : e.resolution;
+      (r.currentKey !== e.styleKey || e.resolution !== i) && this._updateGpuText(e).catch((s) => {
+        console.error(s);
+      }), e._didTextUpdate = !1, re(r, e);
+    }
+    this._renderer.renderPipes.batch.addToBatch(r, t);
   }
   updateRenderable(e) {
     const t = this._getGpuText(e);
@@ -2360,75 +2491,78 @@ class Ze {
     const t = this._getGpuText(e);
     if (t.generatingTexture)
       return;
-    t.texturePromise && (this._renderer.htmlText.returnTexturePromise(t.texturePromise), t.texturePromise = null), t.generatingTexture = !0, e._resolution = e._autoResolution ? this._renderer.resolution : e.resolution;
-    const r = this._renderer.htmlText.getTexturePromise(e);
-    t.texturePromise = r, t.texture = await r;
+    const r = t.texturePromise;
+    t.texturePromise = null, t.generatingTexture = !0, e._resolution = e._autoResolution ? this._renderer.resolution : e.resolution;
+    let i = this._renderer.htmlText.getTexturePromise(e);
+    r && (i = i.finally(() => {
+      this._renderer.htmlText.decreaseReferenceCount(t.currentKey), this._renderer.htmlText.returnTexturePromise(r);
+    })), t.texturePromise = i, t.currentKey = e.styleKey, t.texture = await i;
     const s = e.renderGroup || e.parentRenderGroup;
-    s && (s.structureDidChange = !0), t.generatingTexture = !1, te(t, e);
+    s && (s.structureDidChange = !0), t.generatingTexture = !1, re(t, e);
   }
   _getGpuText(e) {
     return e._gpuData[this._renderer.uid] || this.initGpuText(e);
   }
   initGpuText(e) {
-    const t = new ar(this._renderer);
-    return t.renderable = e, t.transform = e.groupTransform, t.texture = S.EMPTY, t.bounds = { minX: 0, maxX: 1, minY: 0, maxY: 0 }, t.roundPixels = this._renderer._roundPixels | e._roundPixels, e._resolution = e._autoResolution ? this._renderer.resolution : e.resolution, e._gpuData[this._renderer.uid] = t, t;
+    const t = new fr(this._renderer);
+    return t.renderable = e, t.transform = e.groupTransform, t.texture = C.EMPTY, t.bounds = { minX: 0, maxX: 1, minY: 0, maxY: 0 }, t.roundPixels = this._renderer._roundPixels | e._roundPixels, e._resolution = e._autoResolution ? this._renderer.resolution : e.resolution, e._gpuData[this._renderer.uid] = t, t;
   }
   destroy() {
     this._renderer = null;
   }
 }
-Ze.extension = {
+it.extension = {
   type: [
-    g.WebGLPipes,
-    g.WebGPUPipes,
-    g.CanvasPipes
+    m.WebGLPipes,
+    m.WebGPUPipes,
+    m.CanvasPipes
   ],
   name: "htmlText"
 };
-function or() {
+function pr() {
   const { userAgent: o } = ne.get().getNavigator();
   return /^((?!chrome|android).)*safari/i.test(o);
 }
-const lr = new Pe();
-function et(o, e, t, r) {
-  const s = lr;
-  s.minX = 0, s.minY = 0, s.maxX = o.width / r | 0, s.maxY = o.height / r | 0;
-  const i = F.getOptimalTexture(
-    s.width,
-    s.height,
+const gr = new Re();
+function st(o, e, t, r) {
+  const i = gr;
+  i.minX = 0, i.minY = 0, i.maxX = o.width / r | 0, i.maxY = o.height / r | 0;
+  const s = F.getOptimalTexture(
+    i.width,
+    i.height,
     r,
     !1
   );
-  return i.source.uploadMethodId = "image", i.source.resource = o, i.source.alphaMode = "premultiply-alpha-on-upload", i.frame.width = e / r, i.frame.height = t / r, i.source.emit("update", i.source), i.updateUvs(), i;
+  return s.source.uploadMethodId = "image", s.source.resource = o, s.source.alphaMode = "premultiply-alpha-on-upload", s.frame.width = e / r, s.frame.height = t / r, s.source.emit("update", s.source), s.updateUvs(), s;
 }
-function ur(o, e) {
-  const t = e.fontFamily, r = [], s = {}, i = /font-family:([^;"\s]+)/g, n = o.match(i);
-  function a(l) {
-    s[l] || (r.push(l), s[l] = !0);
+function mr(o, e) {
+  const t = e.fontFamily, r = [], i = {}, s = /font-family:([^;"\s]+)/g, n = o.match(s);
+  function a(u) {
+    i[u] || (r.push(u), i[u] = !0);
   }
   if (Array.isArray(t))
-    for (let l = 0; l < t.length; l++)
-      a(t[l]);
+    for (let u = 0; u < t.length; u++)
+      a(t[u]);
   else
     a(t);
-  n && n.forEach((l) => {
-    const u = l.split(":")[1].trim();
-    a(u);
+  n && n.forEach((u) => {
+    const l = u.split(":")[1].trim();
+    a(l);
   });
-  for (const l in e.tagStyles) {
-    const u = e.tagStyles[l].fontFamily;
-    a(u);
+  for (const u in e.tagStyles) {
+    const l = e.tagStyles[u].fontFamily;
+    a(l);
   }
   return r;
 }
-async function dr(o) {
+async function xr(o) {
   const t = await (await ne.get().fetch(o)).blob(), r = new FileReader();
-  return await new Promise((i, n) => {
-    r.onloadend = () => i(r.result), r.onerror = n, r.readAsDataURL(t);
+  return await new Promise((s, n) => {
+    r.onloadend = () => s(r.result), r.onerror = n, r.readAsDataURL(t);
   });
 }
-async function cr(o, e) {
-  const t = await dr(e);
+async function _r(o, e) {
+  const t = await xr(e);
   return `@font-face {
         font-family: "${o.fontFamily}";
         font-weight: ${o.fontWeight};
@@ -2436,60 +2570,60 @@ async function cr(o, e) {
         src: url('${t}');
     }`;
 }
-const Z = /* @__PURE__ */ new Map();
-async function hr(o) {
-  const e = o.filter((t) => C.has(`${t}-and-url`)).map((t) => {
-    if (!Z.has(t)) {
-      const { entries: r } = C.get(`${t}-and-url`), s = [];
-      r.forEach((i) => {
-        const n = i.url, l = i.faces.map((u) => ({ weight: u.weight, style: u.style }));
-        s.push(
-          ...l.map(
-            (u) => cr(
+const ee = /* @__PURE__ */ new Map();
+async function yr(o) {
+  const e = o.filter((t) => P.has(`${t}-and-url`)).map((t) => {
+    if (!ee.has(t)) {
+      const { entries: r } = P.get(`${t}-and-url`), i = [];
+      r.forEach((s) => {
+        const n = s.url, u = s.faces.map((l) => ({ weight: l.weight, style: l.style }));
+        i.push(
+          ...u.map(
+            (l) => _r(
               {
-                fontWeight: u.weight,
-                fontStyle: u.style,
+                fontWeight: l.weight,
+                fontStyle: l.style,
                 fontFamily: t
               },
               n
             )
           )
         );
-      }), Z.set(
+      }), ee.set(
         t,
-        Promise.all(s).then((i) => i.join(`
+        Promise.all(i).then((s) => s.join(`
 `))
       );
     }
-    return Z.get(t);
+    return ee.get(t);
   });
   return (await Promise.all(e)).join(`
 `);
 }
-function fr(o, e, t, r, s) {
-  const { domElement: i, styleElement: n, svgRoot: a } = s;
-  i.innerHTML = `<style>${e.cssStyle}</style><div style='padding:0;'>${o}</div>`, i.setAttribute("style", `transform: scale(${t});transform-origin: top left; display: inline-block`), n.textContent = r;
-  const { width: l, height: u } = s.image;
-  return a.setAttribute("width", l.toString()), a.setAttribute("height", u.toString()), new XMLSerializer().serializeToString(a);
+function br(o, e, t, r, i) {
+  const { domElement: s, styleElement: n, svgRoot: a } = i;
+  s.innerHTML = `<style>${e.cssStyle}</style><div style='padding:0;'>${o}</div>`, s.setAttribute("style", `transform: scale(${t});transform-origin: top left; display: inline-block`), n.textContent = r;
+  const { width: u, height: l } = i.image;
+  return a.setAttribute("width", u.toString()), a.setAttribute("height", l.toString()), new XMLSerializer().serializeToString(a);
 }
-function pr(o, e) {
-  const t = V.getOptimalCanvasAndContext(
+function vr(o, e) {
+  const t = Y.getOptimalCanvasAndContext(
     o.width,
     o.height,
     e
   ), { context: r } = t;
   return r.clearRect(0, 0, o.width, o.height), r.drawImage(o, 0, 0), t;
 }
-function gr(o, e, t) {
+function Tr(o, e, t) {
   return new Promise(async (r) => {
-    t && await new Promise((s) => setTimeout(s, 100)), o.onload = () => {
+    t && await new Promise((i) => setTimeout(i, 100)), o.onload = () => {
       r();
     }, o.src = `data:image/svg+xml;charset=utf8,${encodeURIComponent(e)}`, o.crossOrigin = "anonymous";
   });
 }
-class tt {
+class nt {
   constructor(e) {
-    this._renderer = e, this._createCanvas = e.type === ie.WEBGPU;
+    this._activeTextures = {}, this._renderer = e, this._createCanvas = e.type === se.WEBGPU;
   }
   /**
    * @param options
@@ -2498,30 +2632,75 @@ class tt {
   getTexture(e) {
     return this.getTexturePromise(e);
   }
+  /**
+   * Increases the reference count for a texture.
+   * @param text - The HTMLText instance associated with the texture.
+   */
+  getManagedTexture(e) {
+    const t = e.styleKey;
+    if (this._activeTextures[t])
+      return this._increaseReferenceCount(t), this._activeTextures[t].promise;
+    const r = this._buildTexturePromise(e).then((i) => (this._activeTextures[t].texture = i, i));
+    return this._activeTextures[t] = {
+      texture: null,
+      promise: r,
+      usageCount: 1
+    }, r;
+  }
+  /**
+   * Gets the current reference count for a texture associated with a text key.
+   * @param textKey - The unique key identifying the text style configuration
+   * @returns The number of Text instances currently using this texture
+   */
+  getReferenceCount(e) {
+    var t;
+    return ((t = this._activeTextures[e]) == null ? void 0 : t.usageCount) ?? null;
+  }
+  _increaseReferenceCount(e) {
+    this._activeTextures[e].usageCount++;
+  }
+  /**
+   * Decreases the reference count for a texture.
+   * If the count reaches zero, the texture is cleaned up.
+   * @param textKey - The key associated with the HTMLText instance.
+   */
+  decreaseReferenceCount(e) {
+    const t = this._activeTextures[e];
+    t && (t.usageCount--, t.usageCount === 0 && (t.texture ? this._cleanUp(t.texture) : t.promise.then((r) => {
+      t.texture = r, this._cleanUp(t.texture);
+    }).catch(() => {
+      X("HTMLTextSystem: Failed to clean texture");
+    }), this._activeTextures[e] = null));
+  }
+  /**
+   * Returns a promise that resolves to a texture for the given HTMLText options.
+   * @param options - The options for the HTMLText.
+   * @returns A promise that resolves to a Texture.
+   */
   getTexturePromise(e) {
     return this._buildTexturePromise(e);
   }
   async _buildTexturePromise(e) {
-    const { text: t, style: r, resolution: s, textureStyle: i } = e, n = X.get(Ee), a = ur(t, r), l = await hr(a), u = At(t, r, l, n), c = Math.ceil(Math.ceil(Math.max(1, u.width) + r.padding * 2) * s), d = Math.ceil(Math.ceil(Math.max(1, u.height) + r.padding * 2) * s), h = n.image, f = 2;
-    h.width = (c | 0) + f, h.height = (d | 0) + f;
-    const b = fr(t, r, s, l, n);
-    await gr(h, b, or() && a.length > 0);
-    const m = h;
-    let x;
-    this._createCanvas && (x = pr(h, s));
-    const p = et(
-      x ? x.canvas : m,
+    const { text: t, style: r, resolution: i, textureStyle: s } = e, n = K.get(Ye), a = mr(t, r), u = await yr(a), l = Et(t, r, u, n), d = Math.ceil(Math.ceil(Math.max(1, l.width) + r.padding * 2) * i), c = Math.ceil(Math.ceil(Math.max(1, l.height) + r.padding * 2) * i), h = n.image, f = 2;
+    h.width = (d | 0) + f, h.height = (c | 0) + f;
+    const y = br(t, r, i, u, n);
+    await Tr(h, y, pr() && a.length > 0);
+    const _ = h;
+    let b;
+    this._createCanvas && (b = vr(h, i));
+    const x = st(
+      b ? b.canvas : _,
       h.width - f,
       h.height - f,
-      s
+      i
     );
-    return i && (p.source.style = i), this._createCanvas && (this._renderer.texture.initSource(p.source), V.returnCanvasAndContext(x)), X.return(n), p;
+    return s && (x.source.style = s), this._createCanvas && (this._renderer.texture.initSource(x.source), Y.returnCanvasAndContext(b)), K.return(n), x;
   }
   returnTexturePromise(e) {
     e.then((t) => {
       this._cleanUp(t);
     }).catch(() => {
-      re("HTMLTextSystem: Failed to clean texture");
+      X("HTMLTextSystem: Failed to clean texture");
     });
   }
   _cleanUp(e) {
@@ -2529,17 +2708,20 @@ class tt {
   }
   destroy() {
     this._renderer = null;
+    for (const e in this._activeTextures)
+      this._activeTextures[e] && this.returnTexturePromise(this._activeTextures[e].promise);
+    this._activeTextures = null;
   }
 }
-tt.extension = {
+nt.extension = {
   type: [
-    g.WebGLSystem,
-    g.WebGPUSystem,
-    g.CanvasSystem
+    m.WebGLSystem,
+    m.WebGPUSystem,
+    m.CanvasSystem
   ],
   name: "htmlText"
 };
-class mr extends Me {
+class wr extends Ae {
   constructor(e) {
     super(), this._renderer = e, e.runners.resolutionChange.add(this);
   }
@@ -2548,19 +2730,25 @@ class mr extends Me {
     e._autoResolution && e.onViewUpdate();
   }
   destroy() {
-    this._renderer.canvasText.returnTexture(this.texture), this._renderer = null;
+    const { canvasText: e } = this._renderer;
+    e.getReferenceCount(this.currentKey) > 0 ? e.decreaseReferenceCount(this.currentKey) : this.texture && e.returnTexture(this.texture), this._renderer.runners.resolutionChange.remove(this), this._renderer = null;
   }
 }
-class rt {
+class at {
   constructor(e) {
     this._renderer = e;
   }
   validateRenderable(e) {
-    return e._didTextUpdate;
+    const t = this._getGpuText(e), r = e.styleKey;
+    return t.currentKey !== r ? !0 : e._didTextUpdate;
   }
   addRenderable(e, t) {
     const r = this._getGpuText(e);
-    e._didTextUpdate && (this._updateGpuText(e), e._didTextUpdate = !1), this._renderer.renderPipes.batch.addToBatch(r, t);
+    if (e._didTextUpdate) {
+      const i = e._autoResolution ? this._renderer.resolution : e.resolution;
+      (r.currentKey !== e.styleKey || e.resolution !== i) && this._updateGpuText(e), e._didTextUpdate = !1, re(r, e);
+    }
+    this._renderer.renderPipes.batch.addToBatch(r, t);
   }
   updateRenderable(e) {
     const t = this._getGpuText(e);
@@ -2568,47 +2756,47 @@ class rt {
   }
   _updateGpuText(e) {
     const t = this._getGpuText(e);
-    t.texture && this._renderer.canvasText.returnTexture(t.texture), e._resolution = e._autoResolution ? this._renderer.resolution : e.resolution, t.texture = this._renderer.canvasText.getTexture(e), te(t, e);
+    t.texture && this._renderer.canvasText.decreaseReferenceCount(t.currentKey), e._resolution = e._autoResolution ? this._renderer.resolution : e.resolution, t.texture = this._renderer.canvasText.getManagedTexture(e), t.currentKey = e.styleKey;
   }
   _getGpuText(e) {
     return e._gpuData[this._renderer.uid] || this.initGpuText(e);
   }
   initGpuText(e) {
-    const t = new mr(this._renderer);
-    return t.renderable = e, t.transform = e.groupTransform, t.bounds = { minX: 0, maxX: 1, minY: 0, maxY: 0 }, t.roundPixels = this._renderer._roundPixels | e._roundPixels, e._gpuData[this._renderer.uid] = t, t;
+    const t = new wr(this._renderer);
+    return t.currentKey = "--", t.renderable = e, t.transform = e.groupTransform, t.bounds = { minX: 0, maxX: 1, minY: 0, maxY: 0 }, t.roundPixels = this._renderer._roundPixels | e._roundPixels, e._gpuData[this._renderer.uid] = t, t;
   }
   destroy() {
     this._renderer = null;
   }
 }
-rt.extension = {
+at.extension = {
   type: [
-    g.WebGLPipes,
-    g.WebGPUPipes,
-    g.CanvasPipes
+    m.WebGLPipes,
+    m.WebGPUPipes,
+    m.CanvasPipes
   ],
   name: "text"
 };
-class st {
+class ot {
   constructor(e) {
-    this._renderer = e;
+    this._activeTextures = {}, this._renderer = e;
   }
-  getTexture(e, t, r, s) {
+  getTexture(e, t, r, i) {
     typeof e == "string" && (w("8.0.0", "CanvasTextSystem.getTexture: Use object TextOptions instead of separate arguments"), e = {
       text: e,
       style: r,
       resolution: t
-    }), e.style instanceof I || (e.style = new I(e.style)), e.textureStyle instanceof W || (e.textureStyle = new W(e.textureStyle)), typeof e.text != "string" && (e.text = e.text.toString());
-    const { text: i, style: n, textureStyle: a } = e, l = e.resolution ?? this._renderer.resolution, { frame: u, canvasAndContext: c } = N.getCanvasAndContext({
-      text: i,
+    }), e.style instanceof W || (e.style = new W(e.style)), e.textureStyle instanceof I || (e.textureStyle = new I(e.textureStyle)), typeof e.text != "string" && (e.text = e.text.toString());
+    const { text: s, style: n, textureStyle: a } = e, u = e.resolution ?? this._renderer.resolution, { frame: l, canvasAndContext: d } = N.getCanvasAndContext({
+      text: s,
       style: n,
-      resolution: l
-    }), d = et(c.canvas, u.width, u.height, l);
-    if (a && (d.source.style = a), n.trim && (u.pad(n.padding), d.frame.copyFrom(u), d.frame.scale(1 / l), d.updateUvs()), n.filters) {
-      const h = this._applyFilters(d, n.filters);
-      return this.returnTexture(d), N.returnCanvasAndContext(c), h;
+      resolution: u
+    }), c = st(d.canvas, l.width, l.height, u);
+    if (a && (c.source.style = a), n.trim && (l.pad(n.padding), c.frame.copyFrom(l), c.frame.scale(1 / u), c.updateUvs()), n.filters) {
+      const h = this._applyFilters(c, n.filters);
+      return this.returnTexture(c), N.returnCanvasAndContext(d), h;
     }
-    return this._renderer.texture.initSource(d._source), N.returnCanvasAndContext(c), d;
+    return this._renderer.texture.initSource(c._source), N.returnCanvasAndContext(d), c;
   }
   /**
    * Returns a texture that was created wit the above `getTexture` function.
@@ -2629,6 +2817,57 @@ class st {
       "CanvasTextSystem.renderTextToCanvas: no longer supported, use CanvasTextSystem.getTexture instead"
     );
   }
+  /**
+   * Gets or creates a managed texture for a Text object. This method handles texture reuse and reference counting.
+   * @param text - The Text object that needs a texture
+   * @returns A Texture instance that represents the rendered text
+   * @remarks
+   * This method performs the following:
+   * 1. Sets the appropriate resolution based on auto-resolution settings
+   * 2. Checks if a texture already exists for the text's style
+   * 3. Creates a new texture if needed or returns an existing one
+   * 4. Manages reference counting for texture reuse
+   */
+  getManagedTexture(e) {
+    e._resolution = e._autoResolution ? this._renderer.resolution : e.resolution;
+    const t = e.styleKey;
+    if (this._activeTextures[t])
+      return this._increaseReferenceCount(t), this._activeTextures[t].texture;
+    const r = this.getTexture({
+      text: e.text,
+      style: e.style,
+      resolution: e._resolution,
+      textureStyle: e.textureStyle
+    });
+    return this._activeTextures[t] = {
+      texture: r,
+      usageCount: 1
+    }, r;
+  }
+  /**
+   * Decreases the reference count for a texture associated with a text key.
+   * When the reference count reaches zero, the texture is returned to the pool.
+   * @param textKey - The unique key identifying the text style configuration
+   * @remarks
+   * This method is crucial for memory management, ensuring textures are properly
+   * cleaned up when they are no longer needed by any Text instances.
+   */
+  decreaseReferenceCount(e) {
+    const t = this._activeTextures[e];
+    t.usageCount--, t.usageCount === 0 && (this.returnTexture(t.texture), this._activeTextures[e] = null);
+  }
+  /**
+   * Gets the current reference count for a texture associated with a text key.
+   * @param textKey - The unique key identifying the text style configuration
+   * @returns The number of Text instances currently using this texture
+   */
+  getReferenceCount(e) {
+    var t;
+    return ((t = this._activeTextures[e]) == null ? void 0 : t.usageCount) ?? 0;
+  }
+  _increaseReferenceCount(e) {
+    this._activeTextures[e].usageCount++;
+  }
   /**
    * Applies the specified filters to the given texture.
    *
@@ -2640,37 +2879,40 @@ class st {
    * @returns {Texture} The resulting texture after all filters have been applied.
    */
   _applyFilters(e, t) {
-    const r = this._renderer.renderTarget.renderTarget, s = this._renderer.filter.generateFilteredTexture({
+    const r = this._renderer.renderTarget.renderTarget, i = this._renderer.filter.generateFilteredTexture({
       texture: e,
       filters: t
     });
-    return this._renderer.renderTarget.bind(r, !1), s;
+    return this._renderer.renderTarget.bind(r, !1), i;
   }
   destroy() {
     this._renderer = null;
+    for (const e in this._activeTextures)
+      this._activeTextures[e] && this.returnTexture(this._activeTextures[e].texture);
+    this._activeTextures = null;
   }
 }
-st.extension = {
+ot.extension = {
   type: [
-    g.WebGLSystem,
-    g.WebGPUSystem,
-    g.CanvasSystem
+    m.WebGLSystem,
+    m.WebGPUSystem,
+    m.CanvasSystem
   ],
   name: "canvasText"
 };
-T.add(Re);
-T.add(Ge);
-T.add(Le);
-T.add(yt);
-T.add(Ve);
-T.add(je);
+T.add(ke);
+T.add(De);
+T.add(Xe);
+T.add(wt);
 T.add($e);
-T.add(st);
+T.add(qe);
+T.add(Qe);
+T.add(ot);
+T.add(at);
 T.add(rt);
-T.add(Je);
+T.add(nt);
+T.add(it);
 T.add(tt);
-T.add(Ze);
-T.add(Qe);
-T.add(Ke);
-T.add(Oe);
-T.add(De);
+T.add(et);
+T.add(Ve);
+T.add(Ee);