@micjanic/recursive-grid 1.0.2 → 1.0.4

package/dist/{webworkerAll-CI8_Z7rX.js → webworkerAll-pikqGfAy.js}

@@ -1,7 +1,7 @@
-import { E as w, U as wt, T as ve, a as Tt, a2 as U, a3 as O, D as H, t as R, $ as V, M as k, ac as vt, ad as St, w as ne, _ as j, Q as Z, ae as Ct, af as q, ag as G, l as Y, d as Le, I as A, a5 as me, R as xe, H as Ie, c as N, B as z, n as Se, S as ee, y as te, ah as Pt, ai as _e, L as pe, aj as K, s as be, v as Ft, G as Bt, m as Oe, q as Ee, a7 as He, aa as Ve, o as Mt, p as Rt, a8 as Ut, a9 as kt, ab as Gt, ak as At, al as zt, e as P, am as Dt } from "./PixiApp-D4xu0PT4.js";
-import { c as se, a as Wt, b as Lt, B as Ye } from "./colorToUniform-C2jGzNe1.js";
-import { C as X } from "./CanvasPool-BvJplAOp.js";
-class Xe {
+import { E as y, U as Pt, T as we, a as Ft, a4 as z, a5 as L, D as H, t as M, a0 as V, M as U, ae as Bt, af as Rt, w as K, $ as j, V as ee, ag as Mt, ah as q, ai as G, F as Ut, v as Le, x as Ee, l as Y, d as He, J as A, a7 as me, R as xe, I as Ve, c as N, B as D, n as Se, S as te, z as re, aj as zt, ak as _e, N as pe, al as Q, s as ve, m as Ye, q as Xe, a9 as $e, ac as Ne, o as kt, p as Gt, aa as At, ab as Dt, ad as Ot, am as It, an as Wt, e as P, ao as Lt } from "./PixiApp-BHmY2ZMg.js";
+import { c as se, a as Et, b as Ht, B as Ke } from "./colorToUniform-C2jGzNe1.js";
+import { C as X } from "./CanvasPool-D2Uot4VE.js";
+class je {
   /**
    * Initialize the plugin with scope of application instance
    * @private
@@ -45,8 +45,8 @@ class Xe {
     globalThis.removeEventListener("resize", this.queueResize), this._cancelResize(), this._cancelResize = null, this.queueResize = null, this.resizeTo = null, this.resize = null;
   }
 }
-Xe.extension = w.Application;
-class $e {
+je.extension = y.Application;
+class qe {
   /**
    * Initialize the plugin with scope of application instance
    * @private
@@ -61,7 +61,7 @@ class $e {
       "ticker",
       {
         set(t) {
-          this._ticker && this._ticker.remove(this.render, this), this._ticker = t, t && t.add(this.render, this, wt.LOW);
+          this._ticker && this._ticker.remove(this.render, this), this._ticker = t, t && t.add(this.render, this, Pt.LOW);
         },
         get() {
           return this._ticker;
@@ -71,7 +71,7 @@ class $e {
       this._ticker.stop();
     }, this.start = () => {
       this._ticker.start();
-    }, this._ticker = null, this.ticker = e.sharedTicker ? ve.shared : new ve(), e.autoStart && this.start();
+    }, this._ticker = null, this.ticker = e.sharedTicker ? we.shared : new we(), e.autoStart && this.start();
   }
   /**
    * Clean up the ticker, scoped to application.
@@ -84,8 +84,8 @@ class $e {
     }
   }
 }
-$e.extension = w.Application;
-class It extends Tt {
+qe.extension = y.Application;
+class Vt extends Ft {
   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;
   }
@@ -94,35 +94,35 @@ class It extends Tt {
    * @deprecated since 8.0.0 Use `fontFamily` instead.
    */
   get font() {
-    return U(O, "BitmapFont.font is deprecated, please use BitmapFont.fontFamily instead."), this.fontFamily;
+    return z(L, "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 U(O, "BitmapFont.pageTextures is deprecated, please use BitmapFont.pages instead."), this.pages;
+    return z(L, "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 U(O, "BitmapFont.size is deprecated, please use BitmapFont.fontMetrics.fontSize instead."), this.fontMetrics.fontSize;
+    return z(L, "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 U(O, "BitmapFont.distanceFieldRange is deprecated, please use BitmapFont.distanceField.range instead."), this.distanceField.range;
+    return z(L, "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 U(O, "BitmapFont.distanceFieldType is deprecated, please use BitmapFont.distanceField.type instead."), this.distanceField.type;
+    return z(L, "BitmapFont.distanceFieldType is deprecated, please use BitmapFont.distanceField.type instead."), this.distanceField.type;
   }
   destroy(e = !1) {
     var t;
@@ -132,7 +132,294 @@ class It extends Tt {
     this.chars = null, e && (this.pages.forEach((r) => r.texture.destroy(!0)), this.pages = null);
   }
 }
-const Ot = [
+/**
+ * tiny-lru
+ *
+ * @copyright 2025 Jason Mulligan <jason.mulligan@avoidwork.com>
+ * @license BSD-3-Clause
+ * @version 11.4.5
+ */
+class Yt {
+  /**
+   * Creates a new LRU cache instance.
+   * Note: Constructor does not validate parameters. Use lru() factory function for parameter validation.
+   *
+   * @constructor
+   * @param {number} [max=0] - Maximum number of items to store. 0 means unlimited.
+   * @param {number} [ttl=0] - Time to live in milliseconds. 0 means no expiration.
+   * @param {boolean} [resetTtl=false] - Whether to reset TTL when accessing existing items via get().
+   * @example
+   * const cache = new LRU(1000, 60000, true); // 1000 items, 1 minute TTL, reset on access
+   * @see {@link lru} For parameter validation
+   * @since 1.0.0
+   */
+  constructor(e = 0, t = 0, r = !1) {
+    this.first = null, this.items = /* @__PURE__ */ Object.create(null), this.last = null, this.max = e, this.resetTtl = r, this.size = 0, this.ttl = t;
+  }
+  /**
+   * Removes all items from the cache.
+   *
+   * @method clear
+   * @memberof LRU
+   * @returns {LRU} The LRU instance for method chaining.
+   * @example
+   * cache.clear();
+   * console.log(cache.size); // 0
+   * @since 1.0.0
+   */
+  clear() {
+    return this.first = null, this.items = /* @__PURE__ */ Object.create(null), this.last = null, this.size = 0, this;
+  }
+  /**
+   * Removes an item from the cache by key.
+   *
+   * @method delete
+   * @memberof LRU
+   * @param {string} key - The key of the item to delete.
+   * @returns {LRU} The LRU instance for method chaining.
+   * @example
+   * cache.set('key1', 'value1');
+   * cache.delete('key1');
+   * console.log(cache.has('key1')); // false
+   * @see {@link LRU#has}
+   * @see {@link LRU#clear}
+   * @since 1.0.0
+   */
+  delete(e) {
+    if (this.has(e)) {
+      const t = this.items[e];
+      delete this.items[e], this.size--, t.prev !== null && (t.prev.next = t.next), t.next !== null && (t.next.prev = t.prev), this.first === t && (this.first = t.next), this.last === t && (this.last = t.prev);
+    }
+    return this;
+  }
+  /**
+   * Returns an array of [key, value] pairs for the specified keys.
+   * Order follows LRU order (least to most recently used).
+   *
+   * @method entries
+   * @memberof LRU
+   * @param {string[]} [keys=this.keys()] - Array of keys to get entries for. Defaults to all keys.
+   * @returns {Array<Array<*>>} Array of [key, value] pairs in LRU order.
+   * @example
+   * cache.set('a', 1).set('b', 2);
+   * console.log(cache.entries()); // [['a', 1], ['b', 2]]
+   * console.log(cache.entries(['a'])); // [['a', 1]]
+   * @see {@link LRU#keys}
+   * @see {@link LRU#values}
+   * @since 11.1.0
+   */
+  entries(e = this.keys()) {
+    return e.map((t) => [t, this.get(t)]);
+  }
+  /**
+   * Removes the least recently used item from the cache.
+   *
+   * @method evict
+   * @memberof LRU
+   * @param {boolean} [bypass=false] - Whether to force eviction even when cache is empty.
+   * @returns {LRU} The LRU instance for method chaining.
+   * @example
+   * cache.set('old', 'value').set('new', 'value');
+   * cache.evict(); // Removes 'old' item
+   * @see {@link LRU#setWithEvicted}
+   * @since 1.0.0
+   */
+  evict(e = !1) {
+    if (e || this.size > 0) {
+      const t = this.first;
+      delete this.items[t.key], --this.size === 0 ? (this.first = null, this.last = null) : (this.first = t.next, this.first.prev = null);
+    }
+    return this;
+  }
+  /**
+   * Returns the expiration timestamp for a given key.
+   *
+   * @method expiresAt
+   * @memberof LRU
+   * @param {string} key - The key to check expiration for.
+   * @returns {number|undefined} The expiration timestamp in milliseconds, or undefined if key doesn't exist.
+   * @example
+   * const cache = new LRU(100, 5000); // 5 second TTL
+   * cache.set('key1', 'value1');
+   * console.log(cache.expiresAt('key1')); // timestamp 5 seconds from now
+   * @see {@link LRU#get}
+   * @see {@link LRU#has}
+   * @since 1.0.0
+   */
+  expiresAt(e) {
+    let t;
+    return this.has(e) && (t = this.items[e].expiry), t;
+  }
+  /**
+   * Retrieves a value from the cache by key. Updates the item's position to most recently used.
+   *
+   * @method get
+   * @memberof LRU
+   * @param {string} key - The key to retrieve.
+   * @returns {*} The value associated with the key, or undefined if not found or expired.
+   * @example
+   * cache.set('key1', 'value1');
+   * console.log(cache.get('key1')); // 'value1'
+   * console.log(cache.get('nonexistent')); // undefined
+   * @see {@link LRU#set}
+   * @see {@link LRU#has}
+   * @since 1.0.0
+   */
+  get(e) {
+    const t = this.items[e];
+    if (t !== void 0) {
+      if (this.ttl > 0 && t.expiry <= Date.now()) {
+        this.delete(e);
+        return;
+      }
+      return this.moveToEnd(t), t.value;
+    }
+  }
+  /**
+   * Checks if a key exists in the cache.
+   *
+   * @method has
+   * @memberof LRU
+   * @param {string} key - The key to check for.
+   * @returns {boolean} True if the key exists, false otherwise.
+   * @example
+   * cache.set('key1', 'value1');
+   * console.log(cache.has('key1')); // true
+   * console.log(cache.has('nonexistent')); // false
+   * @see {@link LRU#get}
+   * @see {@link LRU#delete}
+   * @since 9.0.0
+   */
+  has(e) {
+    return e in this.items;
+  }
+  /**
+   * Efficiently moves an item to the end of the LRU list (most recently used position).
+   * This is an internal optimization method that avoids the overhead of the full set() operation
+   * when only LRU position needs to be updated.
+   *
+   * @method moveToEnd
+   * @memberof LRU
+   * @param {Object} item - The cache item with prev/next pointers to reposition.
+   * @private
+   * @since 11.3.5
+   */
+  moveToEnd(e) {
+    this.last !== e && (e.prev !== null && (e.prev.next = e.next), e.next !== null && (e.next.prev = e.prev), this.first === e && (this.first = e.next), e.prev = this.last, e.next = null, this.last !== null && (this.last.next = e), this.last = e, this.first === null && (this.first = e));
+  }
+  /**
+   * Returns an array of all keys in the cache, ordered from least to most recently used.
+   *
+   * @method keys
+   * @memberof LRU
+   * @returns {string[]} Array of keys in LRU order.
+   * @example
+   * cache.set('a', 1).set('b', 2);
+   * cache.get('a'); // Move 'a' to most recent
+   * console.log(cache.keys()); // ['b', 'a']
+   * @see {@link LRU#values}
+   * @see {@link LRU#entries}
+   * @since 9.0.0
+   */
+  keys() {
+    const e = [];
+    let t = this.first;
+    for (; t !== null; )
+      e.push(t.key), t = t.next;
+    return e;
+  }
+  /**
+   * Sets a value in the cache and returns any evicted item.
+   *
+   * @method setWithEvicted
+   * @memberof LRU
+   * @param {string} key - The key to set.
+   * @param {*} value - The value to store.
+   * @param {boolean} [resetTtl=this.resetTtl] - Whether to reset the TTL for this operation.
+   * @returns {Object|null} The evicted item (if any) with shape {key, value, expiry, prev, next}, or null.
+   * @example
+   * const cache = new LRU(2);
+   * cache.set('a', 1).set('b', 2);
+   * const evicted = cache.setWithEvicted('c', 3); // evicted = {key: 'a', value: 1, ...}
+   * @see {@link LRU#set}
+   * @see {@link LRU#evict}
+   * @since 11.3.0
+   */
+  setWithEvicted(e, t, r = this.resetTtl) {
+    let i = null;
+    if (this.has(e))
+      this.set(e, t, !0, r);
+    else {
+      this.max > 0 && this.size === this.max && (i = { ...this.first }, this.evict(!0));
+      let n = this.items[e] = {
+        expiry: this.ttl > 0 ? Date.now() + this.ttl : this.ttl,
+        key: e,
+        prev: this.last,
+        next: null,
+        value: t
+      };
+      ++this.size === 1 ? this.first = n : this.last.next = n, this.last = n;
+    }
+    return i;
+  }
+  /**
+   * Sets a value in the cache. Updates the item's position to most recently used.
+   *
+   * @method set
+   * @memberof LRU
+   * @param {string} key - The key to set.
+   * @param {*} value - The value to store.
+   * @param {boolean} [bypass=false] - Internal parameter for setWithEvicted method.
+   * @param {boolean} [resetTtl=this.resetTtl] - Whether to reset the TTL for this operation.
+   * @returns {LRU} The LRU instance for method chaining.
+   * @example
+   * cache.set('key1', 'value1')
+   *      .set('key2', 'value2')
+   *      .set('key3', 'value3');
+   * @see {@link LRU#get}
+   * @see {@link LRU#setWithEvicted}
+   * @since 1.0.0
+   */
+  set(e, t, r = !1, i = this.resetTtl) {
+    let n = this.items[e];
+    return r || n !== void 0 ? (n.value = t, r === !1 && i && (n.expiry = this.ttl > 0 ? Date.now() + this.ttl : this.ttl), this.moveToEnd(n)) : (this.max > 0 && this.size === this.max && this.evict(!0), n = this.items[e] = {
+      expiry: this.ttl > 0 ? Date.now() + this.ttl : this.ttl,
+      key: e,
+      prev: this.last,
+      next: null,
+      value: t
+    }, ++this.size === 1 ? this.first = n : this.last.next = n, this.last = n), this;
+  }
+  /**
+   * Returns an array of all values in the cache for the specified keys.
+   * Order follows LRU order (least to most recently used).
+   *
+   * @method values
+   * @memberof LRU
+   * @param {string[]} [keys=this.keys()] - Array of keys to get values for. Defaults to all keys.
+   * @returns {Array<*>} Array of values corresponding to the keys in LRU order.
+   * @example
+   * cache.set('a', 1).set('b', 2);
+   * console.log(cache.values()); // [1, 2]
+   * console.log(cache.values(['a'])); // [1]
+   * @see {@link LRU#keys}
+   * @see {@link LRU#entries}
+   * @since 11.1.0
+   */
+  values(e = this.keys()) {
+    return e.map((t) => this.get(t));
+  }
+}
+function Qe(o = 1e3, e = 0, t = !1) {
+  if (isNaN(o) || o < 0)
+    throw new TypeError("Invalid max value");
+  if (isNaN(e) || e < 0)
+    throw new TypeError("Invalid ttl value");
+  if (typeof t != "boolean")
+    throw new TypeError("Invalid resetTtl value");
+  return new Yt(o, e, t);
+}
+const Xt = [
   "serif",
   "sans-serif",
   "monospace",
@@ -140,20 +427,20 @@ const Ot = [
   "fantasy",
   "system-ui"
 ];
-function re(o) {
+function ie(o) {
   const e = typeof o.fontSize == "number" ? `${o.fontSize}px` : o.fontSize;
   let t = o.fontFamily;
   Array.isArray(o.fontFamily) || (t = o.fontFamily.split(","));
   for (let r = t.length - 1; r >= 0; r--) {
     let i = t[r].trim();
-    !/([\"\'])[^\'\"]+\1/.test(i) && !Ot.includes(i) && (i = `"${i}"`), t[r] = i;
+    !/([\"\'])[^\'\"]+\1/.test(i) && !Xt.includes(i) && (i = `"${i}"`), t[r] = i;
   }
   return `${o.fontStyle} ${o.fontVariant} ${o.fontWeight} ${e} ${t.join(",")}`;
 }
 const oe = {
   // TextMetrics requires getImageData readback for measuring fonts.
   willReadFrequently: !0
-}, W = class g {
+}, k = class p {
   /**
    * Checking that we can use modern canvas 2D API.
    *
@@ -163,10 +450,10 @@ const oe = {
    * @see https://developer.chrome.com/origintrials/#/view_trial/3585991203293757441
    */
   static get experimentalLetterSpacingSupported() {
-    let e = g._experimentalLetterSpacingSupported;
+    let e = p._experimentalLetterSpacingSupported;
     if (e === void 0) {
       const t = H.get().getCanvasRenderingContext2D().prototype;
-      e = g._experimentalLetterSpacingSupported = "letterSpacing" in t || "textLetterSpacing" in t;
+      e = p._experimentalLetterSpacingSupported = "letterSpacing" in t || "textLetterSpacing" in t;
     }
     return e;
   }
@@ -181,8 +468,8 @@ const oe = {
    * @param maxLineWidth - the maximum line width for all measured lines
    * @param {FontMetrics} fontProperties - the font properties object from TextMetrics.measureFont
    */
-  constructor(e, t, r, i, n, s, a, l, c) {
-    this.text = e, this.style = t, this.width = r, this.height = i, this.lines = n, this.lineWidths = s, this.lineHeight = a, this.maxLineWidth = l, this.fontProperties = c;
+  constructor(e, t, r, i, n, s, a, u, l) {
+    this.text = e, this.style = t, this.width = r, this.height = i, this.lines = n, this.lineWidths = s, this.lineHeight = a, this.maxLineWidth = u, this.fontProperties = l;
   }
   /**
    * Measures the supplied string of text and returns a Rectangle.
@@ -192,50 +479,55 @@ const oe = {
    * @param wordWrap
    * @returns Measured width and height of the text.
    */
-  static measureText(e = " ", t, r = g._canvas, i = t.wordWrap) {
-    var p;
-    const n = re(t), s = g.measureFont(n);
-    s.fontSize === 0 && (s.fontSize = t.fontSize, s.ascent = t.fontSize);
-    const a = g.__context;
-    a.font = n;
-    const c = (i ? g._wordWrap(e, t, r) : e).split(/(?:\r\n|\r|\n)/), d = new Array(c.length);
-    let u = 0;
-    for (let b = 0; b < c.length; b++) {
-      const y = g._measureText(c[b], t.letterSpacing, a);
-      d[b] = y, u = Math.max(u, y);
+  static measureText(e = " ", t, r = p._canvas, i = t.wordWrap) {
+    var b;
+    const n = `${e}-${t.styleKey}-wordWrap-${i}`;
+    if (p._measurementCache.has(n))
+      return p._measurementCache.get(n);
+    const s = ie(t), a = p.measureFont(s);
+    a.fontSize === 0 && (a.fontSize = t.fontSize, a.ascent = t.fontSize);
+    const u = p.__context;
+    u.font = s;
+    const h = (i ? p._wordWrap(e, t, r) : e).split(/(?:\r\n|\r|\n)/), c = new Array(h.length);
+    let d = 0;
+    for (let m = 0; m < h.length; m++) {
+      const T = p._measureText(h[m], t.letterSpacing, u);
+      c[m] = T, d = Math.max(d, T);
     }
-    const h = ((p = t._stroke) == null ? void 0 : p.width) || 0;
-    let f = u + h;
-    t.dropShadow && (f += t.dropShadow.distance);
-    const m = t.lineHeight || s.fontSize;
-    let x = Math.max(m, s.fontSize + h) + (c.length - 1) * (m + t.leading);
-    return t.dropShadow && (x += t.dropShadow.distance), new g(
+    const f = ((b = t._stroke) == null ? void 0 : b.width) || 0;
+    let x = d + f;
+    t.dropShadow && (x += t.dropShadow.distance);
+    const _ = t.lineHeight || a.fontSize;
+    let v = Math.max(_, a.fontSize + f) + (h.length - 1) * (_ + t.leading);
+    t.dropShadow && (v += t.dropShadow.distance);
+    const g = new p(
       e,
       t,
-      f,
       x,
+      v,
+      h,
       c,
+      _ + t.leading,
       d,
-      m + t.leading,
-      u,
-      s
+      a
     );
+    return p._measurementCache.set(n, g), g;
   }
   static _measureText(e, t, r) {
     let i = !1;
-    g.experimentalLetterSpacingSupported && (g.experimentalLetterSpacing ? (r.letterSpacing = `${t}px`, r.textLetterSpacing = `${t}px`, i = !0) : (r.letterSpacing = "0px", r.textLetterSpacing = "0px"));
+    p.experimentalLetterSpacingSupported && (p.experimentalLetterSpacing ? (r.letterSpacing = `${t}px`, r.textLetterSpacing = `${t}px`, i = !0) : (r.letterSpacing = "0px", r.textLetterSpacing = "0px"));
     const n = r.measureText(e);
     let s = n.width;
     const a = -n.actualBoundingBoxLeft;
-    let c = n.actualBoundingBoxRight - a;
+    let l = n.actualBoundingBoxRight - a;
     if (s > 0)
       if (i)
-        s -= t, c -= t;
+        s -= t, l -= t;
       else {
-        const d = (g.graphemeSegmenter(e).length - 1) * t;
-        s += d, c += d;
+        const h = (p.graphemeSegmenter(e).length - 1) * t;
+        s += h, l += h;
       }
-    return Math.max(s, c);
+    return Math.max(s, l);
   }
   /**
    * Applies newlines to a string to have it optimally fit into the horizontal
@@ -245,53 +537,53 @@ const oe = {
    * @param canvas - optional specification of the canvas to use for measuring.
    * @returns New string with new lines applied where required
    */
-  static _wordWrap(e, t, r = g._canvas) {
+  static _wordWrap(e, t, r = p._canvas) {
     const i = r.getContext("2d", oe);
     let n = 0, s = "", a = "";
-    const l = /* @__PURE__ */ Object.create(null), { letterSpacing: c, whiteSpace: d } = t, u = g._collapseSpaces(d), h = g._collapseNewlines(d);
-    let f = !u;
-    const m = t.wordWrapWidth + c, x = g._tokenize(e);
-    for (let _ = 0; _ < x.length; _++) {
-      let p = x[_];
-      if (g._isNewline(p)) {
-        if (!h) {
-          a += g._addLine(s), f = !u, s = "", n = 0;
+    const u = /* @__PURE__ */ Object.create(null), { letterSpacing: l, whiteSpace: h } = t, c = p._collapseSpaces(h), d = p._collapseNewlines(h);
+    let f = !c;
+    const x = t.wordWrapWidth + l, _ = p._tokenize(e);
+    for (let v = 0; v < _.length; v++) {
+      let g = _[v];
+      if (p._isNewline(g)) {
+        if (!d) {
+          a += p._addLine(s), f = !c, s = "", n = 0;
           continue;
         }
-        p = " ";
+        g = " ";
       }
-      if (u) {
-        const y = g.isBreakingSpace(p), T = g.isBreakingSpace(s[s.length - 1]);
-        if (y && T)
+      if (c) {
+        const m = p.isBreakingSpace(g), T = p.isBreakingSpace(s[s.length - 1]);
+        if (m && T)
           continue;
       }
-      const b = g._getFromCache(p, c, l, i);
-      if (b > m)
-        if (s !== "" && (a += g._addLine(s), s = "", n = 0), g.canBreakWords(p, t.breakWords)) {
-          const y = g.wordWrapSplit(p);
-          for (let T = 0; T < y.length; T++) {
-            let S = y[T], B = S, v = 1;
-            for (; y[T + v]; ) {
-              const M = y[T + v];
-              if (!g.canBreakChars(B, M, p, T, t.breakWords))
-                S += M;
+      const b = p._getFromCache(g, l, u, i);
+      if (b > x)
+        if (s !== "" && (a += p._addLine(s), s = "", n = 0), p.canBreakWords(g, t.breakWords)) {
+          const m = p.wordWrapSplit(g);
+          for (let T = 0; T < m.length; T++) {
+            let S = m[T], B = S, w = 1;
+            for (; m[T + w]; ) {
+              const R = m[T + w];
+              if (!p.canBreakChars(B, R, g, T, t.breakWords))
+                S += R;
               else
                 break;
-              B = M, v++;
+              B = R, w++;
             }
-            T += v - 1;
-            const F = g._getFromCache(S, c, l, i);
-            F + n > m && (a += g._addLine(s), f = !1, s = "", n = 0), s += S, n += F;
+            T += w - 1;
+            const F = p._getFromCache(S, l, u, i);
+            F + n > x && (a += p._addLine(s), f = !1, s = "", n = 0), s += S, n += F;
           }
         } else {
-          s.length > 0 && (a += g._addLine(s), s = "", n = 0);
-          const y = _ === x.length - 1;
-          a += g._addLine(p, !y), f = !1, s = "", n = 0;
+          s.length > 0 && (a += p._addLine(s), s = "", n = 0);
+          const m = v === _.length - 1;
+          a += p._addLine(g, !m), f = !1, s = "", n = 0;
         }
       else
-        b + n > m && (f = !1, a += g._addLine(s), s = "", n = 0), (s.length > 0 || !g.isBreakingSpace(p) || f) && (s += p, n += b);
+        b + n > x && (f = !1, a += p._addLine(s), s = "", n = 0), (s.length > 0 || !p.isBreakingSpace(g) || f) && (s += g, n += b);
     }
-    return a += g._addLine(s, !1), a;
+    return a += p._addLine(s, !1), a;
   }
   /**
    * Convenience function for logging each line added during the wordWrap method.
@@ -300,7 +592,7 @@ const oe = {
    * @returns A formatted line
    */
   static _addLine(e, t = !0) {
-    return e = g._trimRight(e), e = t ? `${e}
+    return e = p._trimRight(e), e = t ? `${e}
 ` : e, e;
   }
   /**
@@ -313,7 +605,7 @@ const oe = {
    */
   static _getFromCache(e, t, r, i) {
     let n = r[e];
-    return typeof n != "number" && (n = g._measureText(e, t, i) + t, r[e] = n), n;
+    return typeof n != "number" && (n = p._measureText(e, t, i) + t, r[e] = n), n;
   }
   /**
    * Determines whether we should collapse breaking spaces.
@@ -341,7 +633,7 @@ const oe = {
       return "";
     for (let t = e.length - 1; t >= 0; t--) {
       const r = e[t];
-      if (!g.isBreakingSpace(r))
+      if (!p.isBreakingSpace(r))
         break;
       e = e.slice(0, -1);
     }
@@ -353,7 +645,7 @@ const oe = {
    * @returns True if newline, False otherwise.
    */
   static _isNewline(e) {
-    return typeof e != "string" ? !1 : g._newlines.includes(e.charCodeAt(0));
+    return typeof e != "string" ? !1 : p._newlines.includes(e.charCodeAt(0));
   }
   /**
    * Determines if char is a breaking whitespace.
@@ -366,7 +658,7 @@ const oe = {
    * @returns True if whitespace, False otherwise.
    */
   static isBreakingSpace(e, t) {
-    return typeof e != "string" ? !1 : g._breakingSpaces.includes(e.charCodeAt(0));
+    return typeof e != "string" ? !1 : p._breakingSpaces.includes(e.charCodeAt(0));
   }
   /**
    * Splits a string into words, breaking-spaces and newLine characters
@@ -380,7 +672,7 @@ const oe = {
       return t;
     for (let i = 0; i < e.length; i++) {
       const n = e[i], s = e[i + 1];
-      if (g.isBreakingSpace(n, s) || g._isNewline(n)) {
+      if (p.isBreakingSpace(n, s) || p._isNewline(n)) {
         r !== "" && (t.push(r), r = ""), n === "\r" && s === `
 ` ? (t.push(`\r
 `), i++) : t.push(n);
@@ -431,7 +723,7 @@ const oe = {
    * @see CanvasTextMetrics.graphemeSegmenter
    */
   static wordWrapSplit(e) {
-    return g.graphemeSegmenter(e);
+    return p.graphemeSegmenter(e);
   }
   /**
    * Calculates the ascent, descent and fontSize of a given font-style
@@ -439,23 +731,23 @@ const oe = {
    * @returns Font properties object
    */
   static measureFont(e) {
-    if (g._fonts[e])
-      return g._fonts[e];
-    const t = g._context;
+    if (p._fonts[e])
+      return p._fonts[e];
+    const t = p._context;
     t.font = e;
-    const r = t.measureText(g.METRICS_STRING + g.BASELINE_SYMBOL), i = {
+    const r = t.measureText(p.METRICS_STRING + p.BASELINE_SYMBOL), i = {
       ascent: r.actualBoundingBoxAscent,
       descent: r.actualBoundingBoxDescent,
       fontSize: r.actualBoundingBoxAscent + r.actualBoundingBoxDescent
     };
-    return g._fonts[e] = i, i;
+    return p._fonts[e] = i, i;
   }
   /**
    * Clear font metrics in metrics cache.
    * @param {string} [font] - font name. If font name not set then clear cache for all fonts.
    */
   static clearMetrics(e = "") {
-    e ? delete g._fonts[e] : g._fonts = {};
+    e ? delete p._fonts[e] : p._fonts = {};
   }
   /**
    * Cached canvas element for measuring text
@@ -463,33 +755,33 @@ const oe = {
    * @ignore
    */
   static get _canvas() {
-    if (!g.__canvas) {
+    if (!p.__canvas) {
       let e;
       try {
         const t = new OffscreenCanvas(0, 0), r = t.getContext("2d", oe);
         if (r != null && r.measureText)
-          return g.__canvas = t, t;
+          return p.__canvas = t, t;
         e = H.get().createCanvas();
       } catch {
         e = H.get().createCanvas();
       }
-      e.width = e.height = 10, g.__canvas = e;
+      e.width = e.height = 10, p.__canvas = e;
     }
-    return g.__canvas;
+    return p.__canvas;
   }
   /**
    * TODO: this should be private, but isn't because of backward compat, will fix later.
    * @ignore
    */
   static get _context() {
-    return g.__context || (g.__context = g._canvas.getContext("2d", oe)), g.__context;
+    return p.__context || (p.__context = p._canvas.getContext("2d", oe)), p.__context;
   }
 };
-W.METRICS_STRING = "|ÉqÅ";
-W.BASELINE_SYMBOL = "M";
-W.BASELINE_MULTIPLIER = 1.4;
-W.HEIGHT_MULTIPLIER = 2;
-W.graphemeSegmenter = (() => {
+k.METRICS_STRING = "|ÉqÅ";
+k.BASELINE_SYMBOL = "M";
+k.BASELINE_MULTIPLIER = 1.4;
+k.HEIGHT_MULTIPLIER = 2;
+k.graphemeSegmenter = (() => {
   if (typeof (Intl == null ? void 0 : Intl.Segmenter) == "function") {
     const o = new Intl.Segmenter();
     return (e) => {
@@ -502,15 +794,15 @@ W.graphemeSegmenter = (() => {
   }
   return (o) => [...o];
 })();
-W.experimentalLetterSpacing = !1;
-W._fonts = {};
-W._newlines = [
+k.experimentalLetterSpacing = !1;
+k._fonts = {};
+k._newlines = [
   10,
   // line feed
   13
   // carriage return
 ];
-W._breakingSpaces = [
+k._breakingSpaces = [
   9,
   // character tabulation
   32,
@@ -540,85 +832,86 @@ W._breakingSpaces = [
   12288
   // ideographic space
 ];
-let D = W;
+k._measurementCache = Qe(1e3);
+let O = k;
 const Ce = 1e5;
-function ie(o, e, t, r = 0) {
-  if (o.texture === R.WHITE && !o.fill)
+function ne(o, e, t, r = 0) {
+  if (o.texture === M.WHITE && !o.fill)
     return V.shared.setValue(o.color).setAlpha(o.alpha ?? 1).toHexa();
   if (o.fill) {
-    if (o.fill instanceof vt) {
-      const i = o.fill, n = e.createPattern(i.texture.source.resource, "repeat"), s = i.transform.copyTo(k.shared);
+    if (o.fill instanceof Bt) {
+      const i = o.fill, n = e.createPattern(i.texture.source.resource, "repeat"), s = i.transform.copyTo(U.shared);
       return s.scale(
         i.texture.frame.width,
         i.texture.frame.height
       ), n.setTransform(s), n;
-    } else if (o.fill instanceof St) {
+    } else if (o.fill instanceof Rt) {
       const i = o.fill, n = i.type === "linear", s = i.textureSpace === "local";
-      let a = 1, l = 1;
-      s && t && (a = t.width + r, l = t.height + r);
-      let c, d = !1;
+      let a = 1, u = 1;
+      s && t && (a = t.width + r, u = t.height + r);
+      let l, h = !1;
       if (n) {
-        const { start: u, end: h } = i;
-        c = e.createLinearGradient(
-          u.x * a,
-          u.y * l,
-          h.x * a,
-          h.y * l
-        ), d = Math.abs(h.x - u.x) < Math.abs((h.y - u.y) * 0.1);
+        const { start: c, end: d } = i;
+        l = e.createLinearGradient(
+          c.x * a,
+          c.y * u,
+          d.x * a,
+          d.y * u
+        ), h = Math.abs(d.x - c.x) < Math.abs((d.y - c.y) * 0.1);
       } else {
-        const { center: u, innerRadius: h, outerCenter: f, outerRadius: m } = i;
-        c = e.createRadialGradient(
-          u.x * a,
-          u.y * l,
-          h * a,
+        const { center: c, innerRadius: d, outerCenter: f, outerRadius: x } = i;
+        l = e.createRadialGradient(
+          c.x * a,
+          c.y * u,
+          d * a,
           f.x * a,
-          f.y * l,
-          m * a
+          f.y * u,
+          x * a
         );
       }
-      if (d && s && t) {
-        const u = t.lineHeight / l;
-        for (let h = 0; h < t.lines.length; h++) {
-          const f = (h * t.lineHeight + r / 2) / l;
-          i.colorStops.forEach((m) => {
-            const x = f + m.offset * u;
-            c.addColorStop(
+      if (h && s && t) {
+        const c = t.lineHeight / u;
+        for (let d = 0; d < t.lines.length; d++) {
+          const f = (d * t.lineHeight + r / 2) / u;
+          i.colorStops.forEach((x) => {
+            const _ = f + x.offset * c;
+            l.addColorStop(
               // fix to 5 decimal places to avoid floating point precision issues
-              Math.floor(x * Ce) / Ce,
-              V.shared.setValue(m.color).toHex()
+              Math.floor(_ * Ce) / Ce,
+              V.shared.setValue(x.color).toHex()
             );
           });
         }
       } else
-        i.colorStops.forEach((u) => {
-          c.addColorStop(u.offset, V.shared.setValue(u.color).toHex());
+        i.colorStops.forEach((c) => {
+          l.addColorStop(c.offset, V.shared.setValue(c.color).toHex());
         });
-      return c;
+      return l;
     }
   } else {
-    const i = e.createPattern(o.texture.source.resource, "repeat"), n = o.matrix.copyTo(k.shared);
+    const i = e.createPattern(o.texture.source.resource, "repeat"), n = o.matrix.copyTo(U.shared);
     return n.scale(o.texture.frame.width, o.texture.frame.height), i.setTransform(n), i;
   }
-  return ne("FillStyle not recognised", o), "red";
+  return K("FillStyle not recognised", o), "red";
 }
-const Ne = class je extends It {
+const Je = class Ze extends Vt {
   /**
    * @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 = { ...je.defaultOptions, ...e };
+    const t = { ...Ze.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 = R.WHITE, r._fill.fill = null), this.applyFillAsTint = t.overrideFill;
+    t.overrideFill && (r._fill.color = 16777215, r._fill.alpha = 1, r._fill.texture = M.WHITE, r._fill.fill = null), this.applyFillAsTint = t.overrideFill;
     const i = r.fontSize;
     r.fontSize = this.baseMeasurementFontSize;
-    const n = re(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 j ? t.textureStyle : new j(t.textureStyle)), this.fontMetrics = D.measureFont(n), this.lineHeight = r.lineHeight || this.fontMetrics.fontSize || r.fontSize;
+    const n = ie(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 j ? t.textureStyle : new j(t.textureStyle)), this.fontMetrics = O.measureFont(n), this.lineHeight = r.lineHeight || this.fontMetrics.fontSize || r.fontSize;
   }
   ensureCharacters(e) {
-    var _, p;
-    const t = D.graphemeSegmenter(e).filter((b) => !this._currentChars.includes(b)).filter((b, y, T) => T.indexOf(b) === y);
+    var v, g;
+    const t = O.graphemeSegmenter(e).filter((b) => !this._currentChars.includes(b)).filter((b, m, T) => T.indexOf(b) === m);
     if (!t.length)
       return;
     this._currentChars = [...this._currentChars, ...t];
@@ -626,23 +919,23 @@ const Ne = class je extends It {
     this._currentPageIndex === -1 ? r = this._nextPage() : r = this.pages[this._currentPageIndex];
     let { canvas: i, context: n } = r.canvasAndContext, s = r.texture.source;
     const a = this._style;
-    let l = this._currentX, c = this._currentY, d = this._currentMaxCharHeight;
-    const u = this.baseRenderedFontSize / this.baseMeasurementFontSize, h = this._padding * u;
+    let u = this._currentX, l = this._currentY, h = this._currentMaxCharHeight;
+    const c = this.baseRenderedFontSize / this.baseMeasurementFontSize, d = this._padding * c;
     let f = !1;
-    const m = i.width / this.resolution, x = i.height / this.resolution;
+    const x = i.width / this.resolution, _ = i.height / this.resolution;
     for (let b = 0; b < t.length; b++) {
-      const y = t[b], T = D.measureText(y, a, i, !1);
+      const m = t[b], T = O.measureText(m, a, i, !1);
       T.lineHeight = T.height;
-      const S = T.width * u, B = Math.ceil((a.fontStyle === "italic" ? 2 : 1) * S), v = T.height * u, F = B + h * 2, M = v + h * 2;
-      if (f = !1, y !== `
-` && y !== "\r" && y !== "	" && y !== " " && (f = !0, d = Math.ceil(Math.max(M, d))), l + F > m && (c += d, d = M, l = 0, c + d > x)) {
+      const S = T.width * c, B = Math.ceil((a.fontStyle === "italic" ? 2 : 1) * S), w = T.height * c, F = B + d * 2, R = w + d * 2;
+      if (f = !1, m !== `
+` && m !== "\r" && m !== "	" && m !== " " && (f = !0, h = Math.ceil(Math.max(R, h))), u + F > x && (l += h, h = R, u = 0, l + h > _)) {
         s.update();
-        const L = this._nextPage();
-        i = L.canvasAndContext.canvas, n = L.canvasAndContext.context, s = L.texture.source, l = 0, c = 0, d = 0;
+        const I = this._nextPage();
+        i = I.canvasAndContext.canvas, n = I.canvasAndContext.context, s = I.texture.source, u = 0, l = 0, h = 0;
       }
-      const ae = S / u - (((_ = a.dropShadow) == null ? void 0 : _.distance) ?? 0) - (((p = a._stroke) == null ? void 0 : p.width) ?? 0);
-      if (this.chars[y] = {
-        id: y.codePointAt(0),
+      const ae = S / c - (((v = a.dropShadow) == null ? void 0 : v.distance) ?? 0) - (((g = a._stroke) == null ? void 0 : g.width) ?? 0);
+      if (this.chars[m] = {
+        id: m.codePointAt(0),
         xOffset: -this._padding,
         yOffset: -this._padding,
         xAdvance: ae,
@@ -651,31 +944,31 @@ const Ne = class je extends It {
         this._drawGlyph(
           n,
           T,
-          l + h,
-          c + h,
-          u,
+          u + d,
+          l + d,
+          c,
           a
         );
-        const L = s.width * u, $ = s.height * u, C = new Z(
-          l / L * s.width,
-          c / $ * s.height,
-          F / L * s.width,
-          M / $ * s.height
+        const I = s.width * c, $ = s.height * c, C = new ee(
+          u / I * s.width,
+          l / $ * s.height,
+          F / I * s.width,
+          R / $ * s.height
         );
-        this.chars[y].texture = new R({
+        this.chars[m].texture = new M({
           source: s,
           frame: C
-        }), l += Math.ceil(F);
+        }), u += Math.ceil(F);
       }
     }
-    s.update(), this._currentX = l, this._currentY = c, this._currentMaxCharHeight = d, this._skipKerning && this._applyKerning(t, n);
+    s.update(), this._currentX = u, this._currentY = l, this._currentMaxCharHeight = h, this._skipKerning && this._applyKerning(t, n);
   }
   /**
    * @deprecated since 8.0.0
    * The map of base page textures (i.e., sheets of glyphs).
    */
   get pageTextures() {
-    return U(O, "BitmapFont.pageTextures is deprecated, please use BitmapFont.pages instead."), this.pages;
+    return z(L, "BitmapFont.pageTextures is deprecated, please use BitmapFont.pages instead."), this.pages;
   }
   _applyKerning(e, t) {
     const r = this._measureCache;
@@ -683,12 +976,12 @@ const Ne = class je extends It {
       const n = e[i];
       for (let s = 0; s < this._currentChars.length; s++) {
         const a = this._currentChars[s];
-        let l = r[n];
-        l || (l = r[n] = t.measureText(n).width);
-        let c = r[a];
-        c || (c = r[a] = t.measureText(a).width);
-        let d = t.measureText(n + a).width, u = d - (l + c);
-        u && (this.chars[n].kerning[a] = u), d = t.measureText(n + a).width, u = d - (l + c), u && (this.chars[a].kerning[n] = u);
+        let u = r[n];
+        u || (u = r[n] = t.measureText(n).width);
+        let l = r[a];
+        l || (l = r[a] = t.measureText(a).width);
+        let h = t.measureText(n + a).width, c = h - (u + l);
+        c && (this.chars[n].kerning[a] = c), h = t.measureText(n + a).width, c = h - (u + l), c && (this.chars[a].kerning[n] = c);
       }
     }
   }
@@ -700,8 +993,8 @@ const Ne = class je extends It {
       e
     );
     this._setupContext(t.context, this._style, e);
-    const r = e * (this.baseRenderedFontSize / this.baseMeasurementFontSize), i = new R({
-      source: new Ct({
+    const r = e * (this.baseRenderedFontSize / this.baseMeasurementFontSize), i = new M({
+      source: new Mt({
         resource: t.canvas,
         resolution: r,
         alphaMode: "premultiply-alpha-on-upload",
@@ -717,20 +1010,20 @@ const Ne = class je extends It {
   }
   // canvas style!
   _setupContext(e, t, r) {
-    t.fontSize = this.baseRenderedFontSize, e.scale(r, r), e.font = re(t), t.fontSize = this.baseMeasurementFontSize, e.textBaseline = t.textBaseline;
+    t.fontSize = this.baseRenderedFontSize, e.scale(r, r), e.font = ie(t), t.fontSize = this.baseMeasurementFontSize, e.textBaseline = t.textBaseline;
     const i = t._stroke, n = (i == null ? void 0 : i.width) ?? 0;
-    if (i && (e.lineWidth = n, e.lineJoin = i.join, e.miterLimit = i.miterLimit, e.strokeStyle = ie(i, e)), t._fill && (e.fillStyle = ie(t._fill, e)), t.dropShadow) {
-      const s = t.dropShadow, a = V.shared.setValue(s.color).toArray(), l = s.blur * r, c = s.distance * r;
-      e.shadowColor = `rgba(${a[0] * 255},${a[1] * 255},${a[2] * 255},${s.alpha})`, e.shadowBlur = l, e.shadowOffsetX = Math.cos(s.angle) * c, e.shadowOffsetY = Math.sin(s.angle) * c;
+    if (i && (e.lineWidth = n, e.lineJoin = i.join, e.miterLimit = i.miterLimit, e.strokeStyle = ne(i, e)), t._fill && (e.fillStyle = ne(t._fill, e)), t.dropShadow) {
+      const s = t.dropShadow, a = V.shared.setValue(s.color).toArray(), u = s.blur * r, l = s.distance * r;
+      e.shadowColor = `rgba(${a[0] * 255},${a[1] * 255},${a[2] * 255},${s.alpha})`, e.shadowBlur = u, e.shadowOffsetX = Math.cos(s.angle) * l, e.shadowOffsetY = Math.sin(s.angle) * l;
     } else
       e.shadowColor = "black", e.shadowBlur = 0, e.shadowOffsetX = 0, e.shadowOffsetY = 0;
   }
   _drawGlyph(e, t, r, i, n, s) {
-    const a = t.text, l = t.fontProperties, c = s._stroke, d = ((c == null ? void 0 : c.width) ?? 0) * n, u = r + d / 2, h = i - d / 2, f = l.descent * n, m = t.lineHeight * n;
-    let x = !1;
-    s.stroke && d && (x = !0, e.strokeText(a, u, h + m - f));
-    const { shadowBlur: _, shadowOffsetX: p, shadowOffsetY: b } = e;
-    s._fill && (x && (e.shadowBlur = 0, e.shadowOffsetX = 0, e.shadowOffsetY = 0), e.fillText(a, u, h + m - f)), x && (e.shadowBlur = _, e.shadowOffsetX = p, e.shadowOffsetY = b);
+    const a = t.text, u = t.fontProperties, l = s._stroke, h = ((l == null ? void 0 : l.width) ?? 0) * n, c = r + h / 2, d = i - h / 2, f = u.descent * n, x = t.lineHeight * n;
+    let _ = !1;
+    s.stroke && h && (_ = !0, e.strokeText(a, c, d + x - f));
+    const { shadowBlur: v, shadowOffsetX: g, shadowOffsetY: b } = e;
+    s._fill && (_ && (e.shadowBlur = 0, e.shadowOffsetX = 0, e.shadowOffsetY = 0), e.fillText(a, c, d + x - f)), _ && (e.shadowBlur = v, e.shadowOffsetX = g, e.shadowOffsetY = b);
   }
   destroy() {
     super.destroy();
@@ -741,13 +1034,13 @@ const Ne = class je extends It {
     this.pages = null;
   }
 };
-Ne.defaultOptions = {
+Je.defaultOptions = {
   textureSize: 512,
   style: new q(),
   mipmap: !0
 };
-let Pe = Ne;
-function qe(o, e, t, r) {
+let Pe = Je;
+function et(o, e, t, r) {
   const i = {
     width: 0,
     height: 0,
@@ -763,26 +1056,26 @@ function qe(o, e, t, r) {
   };
   i.offsetY = t.baseLineOffset;
   let n = i.lines[0], s = null, a = !0;
-  const l = {
+  const u = {
     width: 0,
     start: 0,
     index: 0,
     // use index to not modify the array as we use it a lot!
     positions: [],
     chars: []
-  }, c = t.baseMeasurementFontSize / e.fontSize, d = e.letterSpacing * c, u = e.wordWrapWidth * c, h = e.lineHeight ? e.lineHeight * c : t.lineHeight, f = e.wordWrap && e.breakWords, m = (p) => {
+  }, l = t.baseMeasurementFontSize / e.fontSize, h = e.letterSpacing * l, c = e.wordWrapWidth * l, d = e.lineHeight ? e.lineHeight * l : t.lineHeight, f = e.wordWrap && e.breakWords, x = (g) => {
     const b = n.width;
-    for (let y = 0; y < l.index; y++) {
-      const T = p.positions[y];
-      n.chars.push(p.chars[y]), n.charPositions.push(T + b);
+    for (let m = 0; m < u.index; m++) {
+      const T = g.positions[m];
+      n.chars.push(g.chars[m]), n.charPositions.push(T + b);
     }
-    n.width += p.width, a = !1, l.width = 0, l.index = 0, l.chars.length = 0;
-  }, x = () => {
-    let p = n.chars.length - 1;
+    n.width += g.width, a = !1, u.width = 0, u.index = 0, u.chars.length = 0;
+  }, _ = () => {
+    let g = n.chars.length - 1;
     if (r) {
-      let b = n.chars[p];
+      let b = n.chars[g];
       for (; b === " "; )
-        n.width -= t.chars[b].xAdvance, b = n.chars[--p];
+        n.width -= t.chars[b].xAdvance, b = n.chars[--g];
     }
     i.width = Math.max(i.width, n.width), n = {
       width: 0,
@@ -790,55 +1083,55 @@ function qe(o, e, t, r) {
       chars: [],
       spaceWidth: 0,
       spacesIndex: []
-    }, a = !0, i.lines.push(n), i.height += h;
-  }, _ = (p) => p - d > u;
-  for (let p = 0; p < o.length + 1; p++) {
+    }, a = !0, i.lines.push(n), i.height += d;
+  }, v = (g) => g - h > c;
+  for (let g = 0; g < o.length + 1; g++) {
     let b;
-    const y = p === o.length;
-    y || (b = o[p]);
+    const m = g === o.length;
+    m || (b = o[g]);
     const T = t.chars[b] || t.chars[" "];
     if (/(?:\s)/.test(b) || b === "\r" || b === `
-` || y) {
-      if (!a && e.wordWrap && _(n.width + l.width) ? (x(), m(l), y || n.charPositions.push(0)) : (l.start = n.width, m(l), y || n.charPositions.push(0)), b === "\r" || b === `
+` || m) {
+      if (!a && e.wordWrap && v(n.width + u.width) ? (_(), x(u), m || n.charPositions.push(0)) : (u.start = n.width, x(u), m || n.charPositions.push(0)), b === "\r" || b === `
 `)
-        n.width !== 0 && x();
-      else if (!y) {
-        const F = T.xAdvance + (T.kerning[s] || 0) + d;
+        _();
+      else if (!m) {
+        const F = T.xAdvance + (T.kerning[s] || 0) + h;
         n.width += F, n.spaceWidth = F, n.spacesIndex.push(n.charPositions.length), n.chars.push(b);
       }
     } else {
-      const v = T.kerning[s] || 0, F = T.xAdvance + v + d;
-      f && _(n.width + l.width + F) && (m(l), x()), l.positions[l.index++] = l.width + v, l.chars.push(b), l.width += F;
+      const w = T.kerning[s] || 0, F = T.xAdvance + w + h;
+      f && v(n.width + u.width + F) && (x(u), _()), u.positions[u.index++] = u.width + w, u.chars.push(b), u.width += F;
     }
     s = b;
   }
-  return x(), e.align === "center" ? Et(i) : e.align === "right" ? Ht(i) : e.align === "justify" && Vt(i), i;
+  return _(), e.align === "center" ? $t(i) : e.align === "right" ? Nt(i) : e.align === "justify" && Kt(i), i;
 }
-function Et(o) {
+function $t(o) {
   for (let e = 0; e < o.lines.length; e++) {
     const t = o.lines[e], r = o.width / 2 - t.width / 2;
     for (let i = 0; i < t.charPositions.length; i++)
       t.charPositions[i] += r;
   }
 }
-function Ht(o) {
+function Nt(o) {
   for (let e = 0; e < o.lines.length; e++) {
     const t = o.lines[e], r = o.width - t.width;
     for (let i = 0; i < t.charPositions.length; i++)
       t.charPositions[i] += r;
   }
 }
-function Vt(o) {
+function Kt(o) {
   const e = o.width;
   for (let t = 0; t < o.lines.length; t++) {
     const r = o.lines[t];
     let i = 0, n = r.spacesIndex[i++], s = 0;
-    const a = r.spacesIndex.length, c = (e - r.width) / a;
-    for (let d = 0; d < r.charPositions.length; d++)
-      d === n && (n = r.spacesIndex[i++], s += c), r.charPositions[d] += s;
+    const a = r.spacesIndex.length, l = (e - r.width) / a;
+    for (let h = 0; h < r.charPositions.length; h++)
+      h === n && (n = r.spacesIndex[i++], s += l), r.charPositions[h] += s;
   }
 }
-function Yt(o) {
+function jt(o) {
   if (o === "")
     return [];
   typeof o == "string" && (o = [o]);
@@ -853,7 +1146,7 @@ function Yt(o) {
       const n = i[0].charCodeAt(0), s = i[1].charCodeAt(0);
       if (s < n)
         throw new Error("[BitmapFont]: Invalid character range.");
-      for (let a = n, l = s; a <= l; a++)
+      for (let a = n, u = s; a <= u; a++)
         e.push(String.fromCharCode(a));
     } else
       e.push(...Array.from(i));
@@ -862,8 +1155,8 @@ function Yt(o) {
     throw new Error("[BitmapFont]: Empty set when resolving characters.");
   return e;
 }
-let Q = 0;
-class Xt {
+let J = 0;
+class qt {
   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,
@@ -871,7 +1164,7 @@ class Xt {
       padding: 4,
       skipKerning: !1,
       textureStyle: null
-    };
+    }, this.measureCache = Qe(1e3);
   }
   /**
    * Get a font for the specified text and style.
@@ -881,26 +1174,20 @@ class Xt {
   getFont(e, t) {
     var s;
     let r = `${t.fontFamily}-bitmap`, i = !0;
-    if (t._fill.fill && !t._stroke)
-      r += t._fill.fill.styleKey, i = !1;
-    else if (t._stroke || t.dropShadow) {
-      let a = t.styleKey;
-      a = a.substring(0, a.lastIndexOf("-")), r = `${a}-bitmap`, i = !1;
-    }
-    if (!G.has(r)) {
+    if (t._fill.fill && !t._stroke ? (r += t._fill.fill.styleKey, i = !1) : (t._stroke || t.dropShadow) && (r = `${t.styleKey}-bitmap`, i = !1), !G.has(r)) {
       const a = Object.create(t);
       a.lineHeight = 0;
-      const l = new Pe({
+      const u = new Pe({
         style: a,
         overrideFill: i,
         overrideSize: !0,
         ...this.defaultOptions
       });
-      Q++, Q > 50 && ne("BitmapText", `You have dynamically created ${Q} bitmap fonts, this can be inefficient. Try pre installing your font styles using \`BitmapFont.install({name:"style1", style})\``), l.once("destroy", () => {
-        Q--, G.remove(r);
+      J++, J > 50 && K("BitmapText", `You have dynamically created ${J} bitmap fonts, this can be inefficient. Try pre installing your font styles using \`BitmapFont.install({name:"style1", style})\``), u.once("destroy", () => {
+        J--, G.remove(r);
       }), G.set(
         r,
-        l
+        u
       );
     }
     const n = G.get(r);
@@ -913,8 +1200,11 @@ class Xt {
    * @param trimEnd - Whether to ignore whitespaces at the end of each line
    */
   getLayout(e, t, r = !0) {
-    const i = this.getFont(e, t), n = D.graphemeSegmenter(e);
-    return qe(n, t, i, r);
+    const i = this.getFont(e, t), n = `${e}-${t.styleKey}-${r}`;
+    if (this.measureCache.has(n))
+      return this.measureCache.get(n);
+    const s = O.graphemeSegmenter(e), a = et(s, t, i, r);
+    return this.measureCache.set(n, a), a;
   }
   /**
    * Measure the text using the specified style.
@@ -927,16 +1217,16 @@ class Xt {
   }
   // eslint-disable-next-line max-len
   install(...e) {
-    var c, d, u, h;
+    var l, h, c, d;
     let t = e[0];
     typeof t == "string" && (t = {
       name: t,
       style: e[1],
-      chars: (c = e[2]) == null ? void 0 : c.chars,
-      resolution: (d = e[2]) == null ? void 0 : d.resolution,
-      padding: (u = e[2]) == null ? void 0 : u.padding,
-      skipKerning: (h = e[2]) == null ? void 0 : h.skipKerning
-    }, U(O, "BitmapFontManager.install(name, style, options) is deprecated, use BitmapFontManager.install({name, style, ...options})"));
+      chars: (l = e[2]) == null ? void 0 : l.chars,
+      resolution: (h = e[2]) == null ? void 0 : h.resolution,
+      padding: (c = e[2]) == null ? void 0 : c.padding,
+      skipKerning: (d = e[2]) == null ? void 0 : d.skipKerning
+    }, z(L, "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.");
@@ -949,8 +1239,8 @@ class Xt {
       resolution: t.resolution,
       overrideSize: !1,
       textureStyle: t.textureStyle
-    }), l = Yt(t.chars);
-    return a.ensureCharacters(l.join("")), G.set(`${r}-bitmap`, a), a.once("destroy", () => G.remove(`${r}-bitmap`)), a;
+    }), u = jt(t.chars);
+    return a.ensureCharacters(u.join("")), G.set(`${r}-bitmap`, a), a.once("destroy", () => G.remove(`${r}-bitmap`)), a;
   }
   /**
    * Uninstalls a bitmap font from the cache.
@@ -971,8 +1261,108 @@ class Xt {
     return !e._stroke && (!e.dropShadow || e.dropShadow.color === 0) && !e._fill.fill && e._fill.color === 16777215;
   }
 }
-const $t = new Xt();
-class Ke {
+const Qt = new qt();
+var Jt = `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();
+}
+`, Zt = `in vec2 vTextureCoord;
+out vec4 finalColor;
+uniform sampler2D uTexture;
+void main() {
+    finalColor = texture(uTexture, vTextureCoord);
+}
+`, Fe = `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 er extends Ut {
+  constructor() {
+    const e = Le.from({
+      vertex: { source: Fe, entryPoint: "mainVertex" },
+      fragment: { source: Fe, entryPoint: "mainFragment" },
+      name: "passthrough-filter"
+    }), t = Ee.from({
+      vertex: Jt,
+      fragment: Zt,
+      name: "passthrough-filter"
+    });
+    super({
+      gpuProgram: e,
+      glProgram: t
+    });
+  }
+}
+class tt {
   constructor(e) {
     this._renderer = e;
   }
@@ -999,24 +1389,28 @@ class Ke {
     this._renderer = null;
   }
 }
-Ke.extension = {
+tt.extension = {
   type: [
-    w.WebGLPipes,
-    w.WebGPUPipes,
-    w.CanvasPipes
+    y.WebGLPipes,
+    y.WebGPUPipes,
+    y.CanvasPipes
   ],
   name: "filter"
 };
-function Nt(o, e) {
+const Be = new U();
+function tr(o, e) {
   e.clear();
   const t = e.matrix;
   for (let r = 0; r < o.length; r++) {
     const i = o[r];
-    i.globalDisplayStatus < 7 || (e.matrix = i.worldTransform, e.addBounds(i.bounds));
+    if (i.globalDisplayStatus < 7)
+      continue;
+    const n = i.renderGroup ?? i.parentRenderGroup;
+    n != null && n.isCachedAsTexture ? e.matrix = Be.copyFrom(n.textureOffsetInverseTransform).append(i.worldTransform) : n != null && n._parentCacheAsTextureRenderGroup ? e.matrix = Be.copyFrom(n._parentCacheAsTextureRenderGroup.inverseWorldTransform).append(i.groupTransform) : e.matrix = i.worldTransform, e.addBounds(i.bounds);
   }
   return e.matrix = t, e;
 }
-const jt = new me({
+const rr = new me({
   attributes: {
     aPosition: {
       buffer: new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]),
@@ -1027,12 +1421,12 @@ const jt = new me({
   },
   indexBuffer: new Uint32Array([0, 1, 2, 0, 2, 3])
 });
-class qt {
+class ir {
   constructor() {
-    this.skip = !1, this.inputTexture = null, this.backTexture = null, this.filters = null, this.bounds = new Ie(), 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 Ve(), 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 Qe {
+class rt {
   constructor(e) {
     this._filterStackIndex = 0, this._filterStack = [], this._filterGlobalUniforms = new Y({
       uInputSize: { value: new Float32Array(4), type: "vec4<f32>" },
@@ -1041,7 +1435,7 @@ class Qe {
       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 Le({}), this.renderer = e;
+    }), this._globalFilterBindGroup = new He({}), this.renderer = e;
   }
   /**
    * The back texture of the currently active filter. Requires the filter to have `blendRequired` set to true.
@@ -1060,23 +1454,23 @@ class Qe {
     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 n = t.renderTarget.renderTarget.colorTexture.source, s = n.resolution, a = n.antialias;
-    if (r.length === 0) {
+    if (r.every((f) => !f.enabled)) {
       i.skip = !0;
       return;
     }
-    const l = i.bounds;
-    if (this._calculateFilterArea(e, l), this._calculateFilterBounds(i, t.renderTarget.rootViewPort, a, s, 1), i.skip)
+    const u = i.bounds;
+    if (this._calculateFilterArea(e, u), this._calculateFilterBounds(i, t.renderTarget.rootViewPort, a, s, 1), i.skip)
       return;
-    const c = this._getPreviousFilterData(), d = this._findFilterResolution(s);
-    let u = 0, h = 0;
-    c && (u = c.bounds.minX, h = c.bounds.minY), this._calculateGlobalFrame(
+    const l = this._getPreviousFilterData(), h = this._findFilterResolution(s);
+    let c = 0, d = 0;
+    l && (c = l.bounds.minX, d = l.bounds.minY), this._calculateGlobalFrame(
       i,
-      u,
-      h,
+      c,
       d,
+      h,
       n.width,
       n.height
-    ), this._setupFilterTextures(i, l, t, c);
+    ), this._setupFilterTextures(i, u, t, l);
   }
   /**
    * Applies filters to a texture.
@@ -1109,17 +1503,17 @@ class Qe {
     const r = this._pushFilterData();
     this._activeFilterData = r, r.skip = !1, r.filters = t;
     const i = e.source, n = i.resolution, s = i.antialias;
-    if (t.length === 0)
+    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, s, n, 0), r.skip)
       return e;
-    const l = n;
+    const u = n;
     this._calculateGlobalFrame(
       r,
       0,
       0,
-      l,
+      u,
       i.width,
       i.height
     ), r.outputRenderSurface = A.getOptimalTexture(
@@ -1127,9 +1521,9 @@ class Qe {
       a.height,
       r.resolution,
       r.antialias
-    ), r.backTexture = R.EMPTY, r.inputTexture = e, this.renderer.renderTarget.finishRenderPass(), this._applyFiltersToTexture(r, !0);
-    const h = r.outputRenderSurface;
-    return h.source.alphaMode = "premultiplied-alpha", h;
+    ), r.backTexture = M.EMPTY, r.inputTexture = e, this.renderer.renderTarget.finishRenderPass(), this._applyFiltersToTexture(r, !0);
+    const d = r.outputRenderSurface;
+    return d.source.alphaMode = "premultiplied-alpha", d;
   }
   /** @internal */
   pop() {
@@ -1151,12 +1545,12 @@ class Qe {
     );
     let s = t.minX, a = t.minY;
     r && (s -= r.minX, a -= r.minY), s = Math.floor(s * i), a = Math.floor(a * i);
-    const l = Math.ceil(t.width * i), c = Math.ceil(t.height * i);
+    const u = Math.ceil(t.width * i), l = Math.ceil(t.height * i);
     return this.renderer.renderTarget.copyToTexture(
       e,
       n,
       { x: s, y: a },
-      { width: l, height: c },
+      { width: u, height: l },
       { x: 0, y: 0 }
     ), n;
   }
@@ -1168,13 +1562,15 @@ class Qe {
    * @param clear - Whether to clear the output surface before applying the filter.
    */
   applyFilter(e, t, r, i) {
-    const n = this.renderer, s = this._activeFilterData, l = s.outputRenderSurface === r, c = n.renderTarget.rootRenderTarget.colorTexture.source._resolution, d = this._findFilterResolution(c);
-    let u = 0, h = 0;
-    if (l) {
-      const f = this._findPreviousFilterOffset();
-      u = f.x, h = f.y;
+    const n = this.renderer, s = this._activeFilterData, u = s.outputRenderSurface === r, l = n.renderTarget.rootRenderTarget.colorTexture.source._resolution, h = this._findFilterResolution(l);
+    let c = 0, d = 0;
+    if (u) {
+      const x = this._findPreviousFilterOffset();
+      c = x.x, d = x.y;
     }
-    this._updateFilterUniforms(t, r, s, u, h, d, l, i), this._setupBindGroupsAndRender(e, t, n);
+    this._updateFilterUniforms(t, r, s, c, d, h, u, i);
+    const f = e.enabled ? e : this._getPassthroughFilter();
+    this._setupBindGroupsAndRender(f, t, n);
   }
   /**
    * Multiply _input normalized coordinates_ to this matrix to get _sprite texture normalized coordinates_.
@@ -1192,13 +1588,18 @@ class Qe {
       r.inputTexture._source.height,
       r.bounds.minX,
       r.bounds.minY
-    ), n = t.worldTransform.copyTo(k.shared), s = t.renderGroup || t.parentRenderGroup;
+    ), n = t.worldTransform.copyTo(U.shared), s = t.renderGroup || t.parentRenderGroup;
     return s && s.cacheToLocalTransform && n.prepend(s.cacheToLocalTransform), n.invert(), i.prepend(n), i.scale(
       1 / t.texture.orig.width,
       1 / t.texture.orig.height
     ), 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 er()), this._passthroughFilter;
   }
   /**
    * Sets up the bind groups and renders the filter.
@@ -1213,7 +1614,7 @@ class Qe {
     } 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: jt,
+      geometry: rr,
       shader: e,
       state: e._state,
       topology: "triangle-list"
@@ -1227,17 +1628,17 @@ class Qe {
    * @param previousFilterData - The previous filter data for back texture calculation
    */
   _setupFilterTextures(e, t, r, i) {
-    if (e.backTexture = R.EMPTY, e.blendRequired) {
-      r.renderTarget.finishRenderPass();
-      const n = r.renderTarget.getRenderTarget(e.outputRenderSurface);
-      e.backTexture = this.getBackTexture(n, t, i == null ? void 0 : i.bounds);
-    }
-    e.inputTexture = A.getOptimalTexture(
+    if (e.backTexture = M.EMPTY, e.inputTexture = A.getOptimalTexture(
       t.width,
       t.height,
       e.resolution,
       e.antialias
-    ), r.renderTarget.bind(e.inputTexture, !0), r.globalUniforms.push({
+    ), e.blendRequired) {
+      r.renderTarget.finishRenderPass();
+      const n = r.renderTarget.getRenderTarget(e.outputRenderSurface);
+      e.backTexture = this.getBackTexture(n, t, i == null ? void 0 : i.bounds);
+    }
+    r.renderTarget.bind(e.inputTexture, !0), r.globalUniforms.push({
       offset: t
     });
   }
@@ -1265,13 +1666,13 @@ class Qe {
    * @param isFinalTarget - Whether this is the final render target
    * @param clear - Whether to clear the output surface
    */
-  _updateFilterUniforms(e, t, r, i, n, s, a, l) {
-    const c = this._filterGlobalUniforms.uniforms, d = c.uOutputFrame, u = c.uInputSize, h = c.uInputPixel, f = c.uInputClamp, m = c.uGlobalFrame, x = c.uOutputTexture;
-    a ? (d[0] = r.bounds.minX - i, d[1] = r.bounds.minY - n) : (d[0] = 0, d[1] = 0), d[2] = e.frame.width, d[3] = e.frame.height, u[0] = e.source.width, u[1] = e.source.height, u[2] = 1 / u[0], u[3] = 1 / u[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 * u[2] - 0.5 * h[2], f[3] = e.frame.height * u[3] - 0.5 * h[3];
-    const _ = this.renderer.renderTarget.rootRenderTarget.colorTexture;
-    m[0] = i * s, m[1] = n * s, m[2] = _.source.width * s, m[3] = _.source.height * s, t instanceof R && (t.source.resource = null);
-    const p = this.renderer.renderTarget.getRenderTarget(t);
-    this.renderer.renderTarget.bind(t, !!l), t instanceof R ? (x[0] = t.frame.width, x[1] = t.frame.height) : (x[0] = p.width, x[1] = p.height), x[2] = p.isRoot ? -1 : 1, this._filterGlobalUniforms.update();
+  _updateFilterUniforms(e, t, r, i, n, s, a, u) {
+    const l = this._filterGlobalUniforms.uniforms, h = l.uOutputFrame, c = l.uInputSize, d = l.uInputPixel, f = l.uInputClamp, x = l.uGlobalFrame, _ = l.uOutputTexture;
+    a ? (h[0] = r.bounds.minX - i, h[1] = r.bounds.minY - n) : (h[0] = 0, h[1] = 0), h[2] = e.frame.width, h[3] = e.frame.height, c[0] = e.source.width, c[1] = e.source.height, c[2] = 1 / c[0], c[3] = 1 / c[1], d[0] = e.source.pixelWidth, d[1] = e.source.pixelHeight, d[2] = 1 / d[0], d[3] = 1 / d[1], f[0] = 0.5 * d[2], f[1] = 0.5 * d[3], f[2] = e.frame.width * c[2] - 0.5 * d[2], f[3] = e.frame.height * c[3] - 0.5 * d[3];
+    const v = this.renderer.renderTarget.rootRenderTarget.colorTexture;
+    x[0] = i * s, x[1] = n * s, x[2] = v.source.width * s, x[3] = v.source.height * s, t instanceof M && (t.source.resource = null);
+    const g = this.renderer.renderTarget.getRenderTarget(t);
+    this.renderer.renderTarget.bind(t, !!u), t instanceof M ? (_[0] = t.frame.width, _[1] = t.frame.height) : (_[0] = g.width, _[1] = g.height), _[2] = g.isRoot ? -1 : 1, this._filterGlobalUniforms.update();
   }
   /**
    * Finds the correct resolution by looking back through the filter stack.
@@ -1306,87 +1707,92 @@ class Qe {
    * @param bounds - The bounds object to populate
    */
   _calculateFilterArea(e, t) {
-    if (e.renderables ? Nt(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) {
+    if (e.renderables ? tr(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, i = e.bounds, n = e.filters;
-    if (this._globalFilterBindGroup.setResource(r.source.style, 2), this._globalFilterBindGroup.setResource(e.backTexture.source, 3), n.length === 1)
-      n[0].apply(this, r, e.outputRenderSurface, t);
+    const r = e.inputTexture, i = e.bounds, n = e.filters, s = e.firstEnabledIndex, a = e.lastEnabledIndex;
+    if (this._globalFilterBindGroup.setResource(r.source.style, 2), this._globalFilterBindGroup.setResource(e.backTexture.source, 3), s === a)
+      n[s].apply(this, r, e.outputRenderSurface, t);
     else {
-      let s = e.inputTexture;
-      const a = A.getOptimalTexture(
+      let u = e.inputTexture;
+      const l = A.getOptimalTexture(
         i.width,
         i.height,
-        s.source._resolution,
+        u.source._resolution,
         !1
       );
-      let l = a, c = 0;
-      for (c = 0; c < n.length - 1; ++c) {
-        n[c].apply(this, s, l, !0);
-        const u = s;
-        s = l, l = u;
+      let h = l;
+      for (let c = s; c < a; c++) {
+        const d = n[c];
+        if (!d.enabled)
+          continue;
+        d.apply(this, u, h, !0);
+        const f = u;
+        u = h, h = f;
       }
-      n[c].apply(this, s, e.outputRenderSurface, t), A.returnTexture(a);
+      n[a].apply(this, u, e.outputRenderSurface, t), A.returnTexture(l);
     }
   }
   _calculateFilterBounds(e, t, r, i, n) {
-    var x;
-    const s = this.renderer, a = e.bounds, l = e.filters;
-    let c = 1 / 0, d = 0, u = !0, h = !1, f = !1, m = !0;
-    for (let _ = 0; _ < l.length; _++) {
-      const p = l[_];
-      if (c = Math.min(c, p.resolution === "inherit" ? i : p.resolution), d += p.padding, p.antialias === "off" ? u = !1 : p.antialias === "inherit" && u && (u = r), p.clipToViewport || (m = !1), !!!(p.compatibleRenderers & s.type)) {
+    var g;
+    const s = this.renderer, a = e.bounds, u = e.filters;
+    let l = 1 / 0, h = 0, c = !0, d = !1, f = !1, x = !0, _ = -1, v = -1;
+    for (let b = 0; b < u.length; b++) {
+      const m = u[b];
+      if (!m.enabled)
+        continue;
+      if (_ === -1 && (_ = b), v = b, l = Math.min(l, m.resolution === "inherit" ? i : m.resolution), h += m.padding, m.antialias === "off" ? c = !1 : m.antialias === "inherit" && c && (c = r), m.clipToViewport || (x = !1), !!!(m.compatibleRenderers & s.type)) {
         f = !1;
         break;
       }
-      if (p.blendRequired && !(((x = s.backBuffer) == null ? void 0 : x.useBackBuffer) ?? !0)) {
-        ne("Blend filter requires backBuffer on WebGL renderer to be enabled. Set `useBackBuffer: true` in the renderer options."), f = !1;
+      if (m.blendRequired && !(((g = s.backBuffer) == null ? void 0 : g.useBackBuffer) ?? !0)) {
+        K("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, d || (d = m.blendRequired);
     }
     if (!f) {
       e.skip = !0;
       return;
     }
-    if (m && a.fitBounds(0, t.width / i, 0, t.height / i), a.scale(c).ceil().scale(1 / c).pad((d | 0) * n), !a.isPositive) {
+    if (x && a.fitBounds(0, t.width / i, 0, t.height / i), a.scale(l).ceil().scale(1 / l).pad((h | 0) * n), !a.isPositive) {
       e.skip = !0;
       return;
     }
-    e.antialias = u, e.resolution = c, e.blendRequired = h;
+    e.antialias = c, e.resolution = l, e.blendRequired = d, e.firstEnabledIndex = _, e.lastEnabledIndex = v;
   }
   _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 qt()), this._filterStackIndex++, e;
+    return e || (e = this._filterStack[this._filterStackIndex] = new ir()), this._filterStackIndex++, e;
   }
 }
-Qe.extension = {
+rt.extension = {
   type: [
-    w.WebGLSystem,
-    w.WebGPUSystem
+    y.WebGLSystem,
+    y.WebGPUSystem
   ],
   name: "filter"
 };
-const Je = class Ze extends me {
+const it = class nt extends me {
   constructor(...e) {
     let t = e[0] ?? {};
-    t instanceof Float32Array && (U(O, "use new MeshGeometry({ positions, uvs, indices }) instead"), t = {
+    t instanceof Float32Array && (z(L, "use new MeshGeometry({ positions, uvs, indices }) instead"), t = {
       positions: t,
       uvs: e[1],
       indices: e[2]
-    }), t = { ...Ze.defaultOptions, ...t };
+    }), t = { ...nt.defaultOptions, ...t };
     const r = t.positions || new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]);
     let i = t.uvs;
     i || (t.positions ? i = new Float32Array(r.length) : i = new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]));
@@ -1394,17 +1800,17 @@ const Je = class Ze extends me {
       data: r,
       label: "attribute-mesh-positions",
       shrinkToFit: s,
-      usage: z.VERTEX | z.COPY_DST
-    }), l = new N({
+      usage: D.VERTEX | D.COPY_DST
+    }), u = new N({
       data: i,
       label: "attribute-mesh-uvs",
       shrinkToFit: s,
-      usage: z.VERTEX | z.COPY_DST
-    }), c = new N({
+      usage: D.VERTEX | D.COPY_DST
+    }), l = new N({
       data: n,
       label: "index-mesh-buffer",
       shrinkToFit: s,
-      usage: z.INDEX | z.COPY_DST
+      usage: D.INDEX | D.COPY_DST
     });
     super({
       attributes: {
@@ -1415,13 +1821,13 @@ const Je = class Ze extends me {
           offset: 0
         },
         aUV: {
-          buffer: l,
+          buffer: u,
           format: "float32x2",
           stride: 8,
           offset: 0
         }
       },
-      indexBuffer: c,
+      indexBuffer: l,
       topology: t.topology
     }), this.batchMode = "auto";
   }
@@ -1459,35 +1865,35 @@ const Je = class Ze extends me {
     this.indexBuffer.data = e;
   }
 };
-Je.defaultOptions = {
+it.defaultOptions = {
   topology: "triangle-list",
   shrinkBuffersToFit: !1
 };
-let ye = Je, E = null, I = null;
-function Kt(o, e) {
-  E || (E = H.get().createCanvas(256, 128), I = E.getContext("2d", { willReadFrequently: !0 }), I.globalCompositeOperation = "copy", I.globalAlpha = 1), (E.width < o || E.height < e) && (E.width = Se(o), E.height = Se(e));
+let be = it, E = null, W = null;
+function nr(o, e) {
+  E || (E = H.get().createCanvas(256, 128), W = E.getContext("2d", { willReadFrequently: !0 }), W.globalCompositeOperation = "copy", W.globalAlpha = 1), (E.width < o || E.height < e) && (E.width = Se(o), E.height = Se(e));
 }
-function Fe(o, e, t) {
+function Re(o, e, t) {
   for (let r = 0, i = 4 * t * e; r < e; ++r, i += 4)
     if (o[i + 3] !== 0)
       return !1;
   return !0;
 }
-function Be(o, e, t, r, i) {
+function Me(o, e, t, r, i) {
   const n = 4 * e;
   for (let s = r, a = r * n + 4 * t; s <= i; ++s, a += n)
     if (o[a + 3] !== 0)
       return !1;
   return !0;
 }
-function Qt(...o) {
+function sr(...o) {
   let e = o[0];
   e.canvas || (e = { canvas: o[0], resolution: o[1] });
   const { canvas: t } = e, r = Math.min(e.resolution ?? 1, 1), i = e.width ?? t.width, n = e.height ?? t.height;
   let s = e.output;
-  if (Kt(i, n), !I)
+  if (nr(i, n), !W)
     throw new TypeError("Failed to get canvas 2D context");
-  I.drawImage(
+  W.drawImage(
     t,
     0,
     0,
@@ -1498,22 +1904,22 @@ function Qt(...o) {
     i * r,
     n * r
   );
-  const l = I.getImageData(0, 0, i, n).data;
-  let c = 0, d = 0, u = i - 1, h = n - 1;
-  for (; d < n && Fe(l, i, d); )
-    ++d;
-  if (d === n)
-    return Z.EMPTY;
-  for (; Fe(l, i, h); )
-    --h;
-  for (; Be(l, i, c, d, h); )
-    ++c;
-  for (; Be(l, i, u, d, h); )
-    --u;
-  return ++u, ++h, I.globalCompositeOperation = "source-over", I.strokeRect(c, d, u - c, h - d), I.globalCompositeOperation = "copy", s ?? (s = new Z()), s.set(c / r, d / r, (u - c) / r, (h - d) / r), s;
-}
-const Me = new Z();
-class Jt {
+  const u = W.getImageData(0, 0, i, n).data;
+  let l = 0, h = 0, c = i - 1, d = n - 1;
+  for (; h < n && Re(u, i, h); )
+    ++h;
+  if (h === n)
+    return ee.EMPTY;
+  for (; Re(u, i, d); )
+    --d;
+  for (; Me(u, i, l, h, d); )
+    ++l;
+  for (; Me(u, i, c, h, d); )
+    --c;
+  return ++c, ++d, W.globalCompositeOperation = "source-over", W.strokeRect(l, h, c - l, d - h), W.globalCompositeOperation = "copy", s ?? (s = new ee()), s.set(l / r, h / r, (c - l) / r, (d - h) / r), s;
+}
+const Ue = new ee();
+class ar {
   /**
    * Creates a canvas with the specified text rendered to it.
    *
@@ -1530,12 +1936,12 @@ class Jt {
    * @returns An object containing the canvas/context and the frame (bounds) of the text
    */
   getCanvasAndContext(e) {
-    const { text: t, style: r, resolution: i = 1 } = e, n = r._getFinalPadding(), s = D.measureText(t || " ", r), a = Math.ceil(Math.ceil(Math.max(1, s.width) + n * 2) * i), l = Math.ceil(Math.ceil(Math.max(1, s.height) + n * 2) * i), c = X.getOptimalCanvasAndContext(a, l);
-    this._renderTextToCanvas(t, r, n, i, c);
-    const d = r.trim ? Qt({ canvas: c.canvas, width: a, height: l, resolution: 1, output: Me }) : Me.set(0, 0, a, l);
+    const { text: t, style: r, resolution: i = 1 } = e, n = r._getFinalPadding(), s = O.measureText(t || " ", r), a = Math.ceil(Math.ceil(Math.max(1, s.width) + n * 2) * i), u = Math.ceil(Math.ceil(Math.max(1, s.height) + n * 2) * i), l = X.getOptimalCanvasAndContext(a, u);
+    this._renderTextToCanvas(t, r, n, i, l);
+    const h = r.trim ? sr({ canvas: l.canvas, width: a, height: u, resolution: 1, output: Ue }) : Ue.set(0, 0, a, u);
     return {
-      canvasAndContext: c,
-      frame: d
+      canvasAndContext: l,
+      frame: h
     };
   }
   /**
@@ -1557,47 +1963,47 @@ class Jt {
    * @param canvasAndContext - The canvas and context to render the text to
    */
   _renderTextToCanvas(e, t, r, i, n) {
-    var y, T, S, B;
-    const { canvas: s, context: a } = n, l = re(t), c = D.measureText(e || " ", t), d = c.lines, u = c.lineHeight, h = c.lineWidths, f = c.maxLineWidth, m = c.fontProperties, x = s.height;
-    if (a.resetTransform(), a.scale(i, i), a.textBaseline = t.textBaseline, (y = t._stroke) != null && y.width) {
-      const v = t._stroke;
-      a.lineWidth = v.width, a.miterLimit = v.miterLimit, a.lineJoin = v.join, a.lineCap = v.cap;
+    var m, T, S, B;
+    const { canvas: s, context: a } = n, u = ie(t), l = O.measureText(e || " ", t), h = l.lines, c = l.lineHeight, d = l.lineWidths, f = l.maxLineWidth, x = l.fontProperties, _ = s.height;
+    if (a.resetTransform(), a.scale(i, i), a.textBaseline = t.textBaseline, (m = t._stroke) != null && m.width) {
+      const w = t._stroke;
+      a.lineWidth = w.width, a.miterLimit = w.miterLimit, a.lineJoin = w.join, a.lineCap = w.cap;
     }
-    a.font = l;
-    let _, p;
+    a.font = u;
+    let v, g;
     const b = t.dropShadow ? 2 : 1;
-    for (let v = 0; v < b; ++v) {
-      const F = t.dropShadow && v === 0, M = F ? Math.ceil(Math.max(1, x) + r * 2) : 0, ae = M * i;
+    for (let w = 0; w < b; ++w) {
+      const F = t.dropShadow && w === 0, R = F ? Math.ceil(Math.max(1, _) + r * 2) : 0, ae = R * i;
       if (F) {
         a.fillStyle = "black", a.strokeStyle = "black";
-        const C = t.dropShadow, _t = C.color, bt = C.alpha;
-        a.shadowColor = V.shared.setValue(_t).setAlpha(bt).toRgbaString();
-        const yt = C.blur * i, Te = C.distance * i;
-        a.shadowBlur = yt, a.shadowOffsetX = Math.cos(C.angle) * Te, a.shadowOffsetY = Math.sin(C.angle) * Te + ae;
+        const C = t.dropShadow, wt = C.color, St = C.alpha;
+        a.shadowColor = V.shared.setValue(wt).setAlpha(St).toRgbaString();
+        const Ct = C.blur * i, Te = C.distance * i;
+        a.shadowBlur = Ct, a.shadowOffsetX = Math.cos(C.angle) * Te, a.shadowOffsetY = Math.sin(C.angle) * Te + ae;
       } else {
-        if (a.fillStyle = t._fill ? ie(t._fill, a, c, r * 2) : null, (T = t._stroke) != null && T.width) {
+        if (a.fillStyle = t._fill ? ne(t._fill, a, l, r * 2) : null, (T = t._stroke) != null && T.width) {
           const C = t._stroke.width * 0.5 + r * 2;
-          a.strokeStyle = ie(t._stroke, a, c, C);
+          a.strokeStyle = ne(t._stroke, a, l, C);
         }
         a.shadowColor = "black";
       }
-      let L = (u - m.fontSize) / 2;
-      u - m.fontSize < 0 && (L = 0);
+      let I = (c - x.fontSize) / 2;
+      c - x.fontSize < 0 && (I = 0);
       const $ = ((S = t._stroke) == null ? void 0 : S.width) ?? 0;
-      for (let C = 0; C < d.length; C++)
-        _ = $ / 2, p = $ / 2 + C * u + m.ascent + L, t.align === "right" ? _ += f - h[C] : t.align === "center" && (_ += (f - h[C]) / 2), (B = t._stroke) != null && B.width && this._drawLetterSpacing(
-          d[C],
+      for (let C = 0; C < h.length; C++)
+        v = $ / 2, g = $ / 2 + C * c + x.ascent + I, t.align === "right" ? v += f - d[C] : t.align === "center" && (v += (f - d[C]) / 2), (B = t._stroke) != null && B.width && this._drawLetterSpacing(
+          h[C],
           t,
           n,
-          _ + r,
-          p + r - M,
+          v + r,
+          g + r - R,
           !0
         ), t._fill !== void 0 && this._drawLetterSpacing(
-          d[C],
+          h[C],
           t,
           n,
-          _ + r,
-          p + r - M
+          v + r,
+          g + r - R
         );
     }
   }
@@ -1619,59 +2025,62 @@ class Jt {
    * @private
    */
   _drawLetterSpacing(e, t, r, i, n, s = !1) {
-    const { context: a } = r, l = t.letterSpacing;
-    let c = !1;
-    if (D.experimentalLetterSpacingSupported && (D.experimentalLetterSpacing ? (a.letterSpacing = `${l}px`, a.textLetterSpacing = `${l}px`, c = !0) : (a.letterSpacing = "0px", a.textLetterSpacing = "0px")), l === 0 || c) {
+    const { context: a } = r, u = t.letterSpacing;
+    let l = !1;
+    if (O.experimentalLetterSpacingSupported && (O.experimentalLetterSpacing ? (a.letterSpacing = `${u}px`, a.textLetterSpacing = `${u}px`, l = !0) : (a.letterSpacing = "0px", a.textLetterSpacing = "0px")), u === 0 || l) {
       s ? a.strokeText(e, i, n) : a.fillText(e, i, n);
       return;
     }
-    let d = i;
-    const u = D.graphemeSegmenter(e);
-    let h = a.measureText(e).width, f = 0;
-    for (let m = 0; m < u.length; ++m) {
-      const x = u[m];
-      s ? a.strokeText(x, d, n) : a.fillText(x, d, n);
-      let _ = "";
-      for (let p = m + 1; p < u.length; ++p)
-        _ += u[p];
-      f = a.measureText(_).width, d += h - f + l, h = f;
+    let h = i;
+    const c = O.graphemeSegmenter(e);
+    let d = a.measureText(e).width, f = 0;
+    for (let x = 0; x < c.length; ++x) {
+      const _ = c[x];
+      s ? a.strokeText(_, h, n) : a.fillText(_, h, n);
+      let v = "";
+      for (let g = x + 1; g < c.length; ++g)
+        v += c[g];
+      f = a.measureText(v).width, h += d - f + u, d = f;
     }
   }
 }
-const le = new Jt(), Re = "http://www.w3.org/2000/svg", Ue = "http://www.w3.org/1999/xhtml";
-class et {
+const ue = new ar(), ze = "http://www.w3.org/2000/svg", ke = "http://www.w3.org/1999/xhtml";
+class st {
   constructor() {
-    this.svgRoot = document.createElementNS(Re, "svg"), this.foreignObject = document.createElementNS(Re, "foreignObject"), this.domElement = document.createElementNS(Ue, "div"), this.styleElement = document.createElementNS(Ue, "style");
+    this.svgRoot = document.createElementNS(ze, "svg"), this.foreignObject = document.createElementNS(ze, "foreignObject"), this.domElement = document.createElementNS(ke, "div"), this.styleElement = document.createElementNS(ke, "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 = H.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 ke;
-function Zt(o, e, t, r) {
-  r || (r = ke || (ke = new et()));
+let Ge;
+function or(o, e, t, r) {
+  r || (r = Ge || (Ge = new st()));
   const { domElement: i, styleElement: n, svgRoot: s } = r;
   i.innerHTML = `<style>${e.cssStyle};</style><div style='padding:0'>${o}</div>`, i.setAttribute("style", "transform-origin: top left; display: inline-block"), t && (n.textContent = t), document.body.appendChild(s);
   const a = i.getBoundingClientRect();
   s.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 er {
+class ur {
   constructor() {
     this.batches = [], this.batched = !1;
   }
   destroy() {
     this.batches.forEach((e) => {
-      te.return(e);
+      re.return(e);
     }), this.batches.length = 0;
   }
 }
-class tt {
+class at {
   constructor(e, t) {
-    this.state = ee.for2d(), this.renderer = e, this._adaptor = t, this.renderer.runners.contextChange.add(this);
+    this.state = te.for2d(), this.renderer = e, this._adaptor = t, this.renderer.runners.contextChange.add(this);
   }
   contextChange() {
     this._adaptor.contextChange(this.renderer);
@@ -1721,13 +2130,13 @@ class tt {
     return e._gpuData[this.renderer.uid] || this._initGpuDataForRenderable(e);
   }
   _initGpuDataForRenderable(e) {
-    const t = new er();
+    const t = new ur();
     return e._gpuData[this.renderer.uid] = t, t;
   }
   _updateBatchesForRenderable(e, t) {
     const r = e.context, i = this.renderer.graphicsContext.getGpuContext(r), n = this.renderer._roundPixels | e._roundPixels;
     t.batches = i.batches.map((s) => {
-      const a = te.get(Pt);
+      const a = re.get(zt);
       return s.copyTo(a), a.renderable = e, a.roundPixels = n, a;
     });
   }
@@ -1735,19 +2144,19 @@ class tt {
     this.renderer = null, this._adaptor.destroy(), this._adaptor = null, this.state = null;
   }
 }
-tt.extension = {
+at.extension = {
   type: [
-    w.WebGLPipes,
-    w.WebGPUPipes,
-    w.CanvasPipes
+    y.WebGLPipes,
+    y.WebGPUPipes,
+    y.CanvasPipes
   ],
   name: "graphics"
 };
-const rt = class it extends ye {
+const ot = class ut extends be {
   constructor(...e) {
     super({});
     let t = e[0] ?? {};
-    typeof t == "number" && (U(O, "PlaneGeometry constructor changed please use { width, height, verticesX, verticesY } instead"), t = {
+    typeof t == "number" && (z(L, "PlaneGeometry constructor changed please use { width, height, verticesX, verticesY } instead"), t = {
       width: t,
       height: e[1],
       verticesX: e[2],
@@ -1759,35 +2168,35 @@ const rt = class it extends ye {
    * @param options - Options to be applied to plane geometry
    */
   build(e) {
-    e = { ...it.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 = [], n = [], s = this.verticesX - 1, a = this.verticesY - 1, l = this.width / s, c = this.height / a;
-    for (let u = 0; u < t; u++) {
-      const h = u % this.verticesX, f = u / this.verticesX | 0;
-      r.push(h * l, f * c), i.push(h / s, f / a);
+    e = { ...ut.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 = [], n = [], s = this.verticesX - 1, a = this.verticesY - 1, u = this.width / s, l = this.height / a;
+    for (let c = 0; c < t; c++) {
+      const d = c % this.verticesX, f = c / this.verticesX | 0;
+      r.push(d * u, f * l), i.push(d / s, f / a);
     }
-    const d = s * a;
-    for (let u = 0; u < d; u++) {
-      const h = u % s, f = u / s | 0, m = f * this.verticesX + h, x = f * this.verticesX + h + 1, _ = (f + 1) * this.verticesX + h, p = (f + 1) * this.verticesX + h + 1;
+    const h = s * a;
+    for (let c = 0; c < h; c++) {
+      const d = c % s, f = c / s | 0, x = f * this.verticesX + d, _ = f * this.verticesX + d + 1, v = (f + 1) * this.verticesX + d, g = (f + 1) * this.verticesX + d + 1;
       n.push(
-        m,
         x,
         _,
-        x,
-        p,
-        _
+        v,
+        _,
+        g,
+        v
       );
     }
     this.buffers[0].data = new Float32Array(r), this.buffers[1].data = new Float32Array(i), this.indexBuffer.data = new Uint32Array(n), this.buffers[0].update(), this.buffers[1].update(), this.indexBuffer.update();
   }
 };
-rt.defaultOptions = {
+ot.defaultOptions = {
   width: 100,
   height: 100,
   verticesX: 10,
   verticesY: 10
 };
-let tr = rt;
-class we {
+let lr = ot;
+class ye {
   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;
   }
@@ -1837,17 +2246,17 @@ class we {
     return this.geometry.indices.length;
   }
 }
-class Ge {
+class Ae {
   destroy() {
   }
 }
-class nt {
+class lt {
   constructor(e, t) {
     this.localUniforms = new Y({
-      uTransformMatrix: { value: new k(), type: "mat3x3<f32>" },
+      uTransformMatrix: { value: new U(), type: "mat3x3<f32>" },
       uColor: { value: new Float32Array([1, 1, 1, 1]), type: "vec4<f32>" },
       uRound: { value: 0, type: "f32" }
-    }), this.localUniformsBindGroup = new Le({
+    }), this.localUniformsBindGroup = new He({
       0: this.localUniforms
     }), this.renderer = e, this._adaptor = t, this._adaptor.init();
   }
@@ -1895,7 +2304,7 @@ class nt {
   }
   _getMeshData(e) {
     var t, r;
-    return (t = e._gpuData)[r = this.renderer.uid] || (t[r] = new Ge()), e._gpuData[this.renderer.uid].meshData || this._initMeshData(e);
+    return (t = e._gpuData)[r = this.renderer.uid] || (t[r] = new Ae()), e._gpuData[this.renderer.uid].meshData || this._initMeshData(e);
   }
   _initMeshData(e) {
     return e._gpuData[this.renderer.uid].meshData = {
@@ -1906,35 +2315,35 @@ class nt {
   }
   _getBatchableMesh(e) {
     var t, r;
-    return (t = e._gpuData)[r = this.renderer.uid] || (t[r] = new Ge()), e._gpuData[this.renderer.uid].batchableMesh || this._initBatchableMesh(e);
+    return (t = e._gpuData)[r = this.renderer.uid] || (t[r] = new Ae()), e._gpuData[this.renderer.uid].batchableMesh || this._initBatchableMesh(e);
   }
   _initBatchableMesh(e) {
-    const t = new we();
+    const t = new ye();
     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;
   }
 }
-nt.extension = {
+lt.extension = {
   type: [
-    w.WebGLPipes,
-    w.WebGPUPipes,
-    w.CanvasPipes
+    y.WebGLPipes,
+    y.WebGPUPipes,
+    y.CanvasPipes
   ],
   name: "mesh"
 };
-class rr {
+class cr {
   execute(e, t) {
     const r = e.state, i = e.renderer, n = t.shader || e.defaultShader;
     n.resources.uTexture = t.texture._source, n.resources.uniforms = e.localUniforms;
     const s = i.gl, a = e.getBuffers(t);
     i.shader.bind(n), i.state.set(r), i.geometry.bind(a.geometry, n.glProgram);
-    const c = a.geometry.indexBuffer.data.BYTES_PER_ELEMENT === 2 ? s.UNSIGNED_SHORT : s.UNSIGNED_INT;
-    s.drawElements(s.TRIANGLES, t.particleChildren.length * 6, c, 0);
+    const l = a.geometry.indexBuffer.data.BYTES_PER_ELEMENT === 2 ? s.UNSIGNED_SHORT : s.UNSIGNED_INT;
+    s.drawElements(s.TRIANGLES, t.particleChildren.length * 6, l, 0);
   }
 }
-class ir {
+class hr {
   execute(e, 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);
@@ -1947,7 +2356,7 @@ class ir {
     });
   }
 }
-function Ae(o, e = null) {
+function De(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}`);
@@ -1955,13 +2364,13 @@ function Ae(o, e = null) {
     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 nr(o) {
+function dr(o) {
   return {
-    dynamicUpdate: ze(o, !0),
-    staticUpdate: ze(o, !1)
+    dynamicUpdate: Oe(o, !0),
+    staticUpdate: Oe(o, !1)
   };
 }
-function ze(o, e) {
+function Oe(o, e) {
   const t = [];
   t.push(`
 
@@ -1991,56 +2400,56 @@ function ze(o, e) {
 `);
   return new Function("ps", "f32v", "u32v", i);
 }
-class sr {
+class fr {
   constructor(e) {
     this._size = 0, this._generateParticleUpdateCache = {};
     const t = this._size = e.size ?? 1e3, r = e.properties;
     let i = 0, n = 0;
-    for (const d in r) {
-      const u = r[d], h = pe(u.format);
-      u.dynamic ? n += h.stride : i += h.stride;
+    for (const h in r) {
+      const c = r[h], d = pe(c.format);
+      c.dynamic ? n += d.stride : i += d.stride;
     }
-    this._dynamicStride = n / 4, this._staticStride = i / 4, this.staticAttributeBuffer = new K(t * 4 * i), this.dynamicAttributeBuffer = new K(t * 4 * n), this.indexBuffer = Ae(t);
+    this._dynamicStride = n / 4, this._staticStride = i / 4, this.staticAttributeBuffer = new Q(t * 4 * i), this.dynamicAttributeBuffer = new Q(t * 4 * n), this.indexBuffer = De(t);
     const s = new me();
-    let a = 0, l = 0;
+    let a = 0, u = 0;
     this._staticBuffer = new N({
       data: new Float32Array(1),
       label: "static-particle-buffer",
       shrinkToFit: !1,
-      usage: z.VERTEX | z.COPY_DST
+      usage: D.VERTEX | D.COPY_DST
     }), this._dynamicBuffer = new N({
       data: new Float32Array(1),
       label: "dynamic-particle-buffer",
       shrinkToFit: !1,
-      usage: z.VERTEX | z.COPY_DST
+      usage: D.VERTEX | D.COPY_DST
     });
-    for (const d in r) {
-      const u = r[d], h = pe(u.format);
-      u.dynamic ? (s.addAttribute(u.attributeName, {
+    for (const h in r) {
+      const c = r[h], d = pe(c.format);
+      c.dynamic ? (s.addAttribute(c.attributeName, {
         buffer: this._dynamicBuffer,
         stride: this._dynamicStride * 4,
         offset: a * 4,
-        format: u.format
-      }), a += h.size) : (s.addAttribute(u.attributeName, {
+        format: c.format
+      }), a += d.size) : (s.addAttribute(c.attributeName, {
         buffer: this._staticBuffer,
         stride: this._staticStride * 4,
-        offset: l * 4,
-        format: u.format
-      }), l += h.size);
+        offset: u * 4,
+        format: c.format
+      }), u += d.size);
     }
     s.addIndex(this.indexBuffer);
-    const c = this.getParticleUpdate(r);
-    this._dynamicUpload = c.dynamicUpdate, this._staticUpload = c.staticUpdate, this.geometry = s;
+    const l = this.getParticleUpdate(r);
+    this._dynamicUpload = l.dynamicUpdate, this._staticUpload = l.staticUpdate, this.geometry = s;
   }
   getParticleUpdate(e) {
-    const t = ar(e);
+    const t = pr(e);
     return this._generateParticleUpdateCache[t] ? this._generateParticleUpdateCache[t] : (this._generateParticleUpdateCache[t] = this.generateParticleUpdate(e), this._generateParticleUpdateCache[t]);
   }
   generateParticleUpdate(e) {
-    return nr(e);
+    return dr(e);
   }
   update(e, t) {
-    e.length > this._size && (t = !0, this._size = Math.max(e.length, this._size * 1.5 | 0), this.staticAttributeBuffer = new K(this._size * this._staticStride * 4 * 4), this.dynamicAttributeBuffer = new K(this._size * this._dynamicStride * 4 * 4), this.indexBuffer = Ae(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 Q(this._size * this._staticStride * 4 * 4), this.dynamicAttributeBuffer = new Q(this._size * this._dynamicStride * 4 * 4), this.indexBuffer = De(this._size), this.geometry.indexBuffer.setDataWithSize(
       this.indexBuffer,
       this.indexBuffer.byteLength,
       !0
@@ -2063,7 +2472,7 @@ class sr {
     this._staticBuffer.destroy(), this._dynamicBuffer.destroy(), this.geometry.destroy();
   }
 }
-function ar(o) {
+function pr(o) {
   const e = [];
   for (const t in o) {
     const r = o[t];
@@ -2071,7 +2480,7 @@ function ar(o) {
   }
   return e.join("_");
 }
-var or = `varying vec2 vUV;
+var gr = `varying vec2 vUV;
 varying vec4 vColor;
 
 uniform sampler2D uTexture;
@@ -2079,7 +2488,7 @@ uniform sampler2D uTexture;
 void main(void){
     vec4 color = texture2D(uTexture, vUV) * vColor;
     gl_FragColor = color;
-}`, lr = `attribute vec2 aVertex;
+}`, mr = `attribute vec2 aVertex;
 attribute vec2 aUV;
 attribute vec4 aColor;
 
@@ -2118,14 +2527,19 @@ void main(void){
     vUV = aUV;
     vColor = vec4(aColor.rgb * aColor.a, aColor.a) * uColor;
 }
-`, De = `
+`, Ie = `
 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>;
@@ -2150,7 +2564,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;
 
@@ -2172,18 +2590,18 @@ fn mainFragment(
    
     return sample;
 }`;
-class cr extends be {
+class xr extends ve {
   constructor() {
-    const e = Ft.from({
-      vertex: lr,
-      fragment: or
-    }), t = Bt.from({
+    const e = Ee.from({
+      vertex: mr,
+      fragment: gr
+    }), t = Le.from({
       fragment: {
-        source: De,
+        source: Ie,
         entryPoint: "mainFragment"
       },
       vertex: {
-        source: De,
+        source: Ie,
         entryPoint: "mainVertex"
       }
     });
@@ -2192,12 +2610,12 @@ class cr extends be {
       gpuProgram: t,
       resources: {
         // this will be replaced with the texture from the particle container
-        uTexture: R.WHITE.source,
+        uTexture: M.WHITE.source,
         // this will be replaced with the texture style from the particle container
         uSampler: new j({}),
         // this will be replaced with the local uniforms from the particle container
         uniforms: {
-          uTranslationMatrix: { value: new k(), type: "mat3x3<f32>" },
+          uTranslationMatrix: { value: new U(), type: "mat3x3<f32>" },
           uColor: { value: new V(16777215), type: "vec4<f32>" },
           uRound: { value: 1, type: "f32" },
           uResolution: { value: [0, 0], type: "vec2<f32>" }
@@ -2206,18 +2624,18 @@ class cr extends be {
     });
   }
 }
-class st {
+class ct {
   /**
    * @param renderer - The renderer this sprite batch works for.
    * @param adaptor
    */
   constructor(e, t) {
-    this.state = ee.for2d(), this.localUniforms = new Y({
-      uTranslationMatrix: { value: new k(), type: "mat3x3<f32>" },
+    this.state = te.for2d(), this.localUniforms = new Y({
+      uTranslationMatrix: { value: new U(), 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 cr(), this.state = ee.for2d();
+    }), this.renderer = e, this.adaptor = t, this.defaultShader = new xr(), this.state = te.for2d();
   }
   validateRenderable(e) {
     return !1;
@@ -2229,7 +2647,7 @@ class st {
     return e._gpuData[this.renderer.uid] || this._initBuffer(e);
   }
   _initBuffer(e) {
-    return e._gpuData[this.renderer.uid] = new sr({
+    return e._gpuData[this.renderer.uid] = new fr({
       size: e.particleChildren.length,
       properties: e._properties
     }), e._gpuData[this.renderer.uid];
@@ -2253,34 +2671,34 @@ class st {
   }
   /** Destroys the ParticleRenderer. */
   destroy() {
-    this.defaultShader && (this.defaultShader.destroy(), this.defaultShader = null);
+    this.renderer = null, this.defaultShader && (this.defaultShader.destroy(), this.defaultShader = null);
   }
 }
-class at extends st {
+class ht extends ct {
   constructor(e) {
-    super(e, new rr());
+    super(e, new cr());
   }
 }
-at.extension = {
+ht.extension = {
   type: [
-    w.WebGLPipes
+    y.WebGLPipes
   ],
   name: "particle"
 };
-class ot extends st {
+class dt extends ct {
   constructor(e) {
-    super(e, new ir());
+    super(e, new hr());
   }
 }
-ot.extension = {
+dt.extension = {
   type: [
-    w.WebGPUPipes
+    y.WebGPUPipes
   ],
   name: "particle"
 };
-const lt = class ct extends tr {
+const ft = class pt extends lr {
   constructor(e = {}) {
-    e = { ...ct.defaultOptions, ...e }, super({
+    e = { ...pt.defaultOptions, ...e }, super({
       width: e.width,
       height: e.height,
       verticesX: 4,
@@ -2304,10 +2722,10 @@ const lt = class ct extends tr {
       _rightWidth: n,
       _topHeight: s,
       _bottomHeight: a,
-      _anchorX: l,
-      _anchorY: c
-    } = this, d = i + n, u = t > d ? 1 : t / d, h = s + a, f = r > h ? 1 : r / h, m = Math.min(u, f), x = l * t, _ = c * r;
-    e[0] = e[8] = e[16] = e[24] = -x, e[2] = e[10] = e[18] = e[26] = i * m - x, e[4] = e[12] = e[20] = e[28] = t - n * m - x, e[6] = e[14] = e[22] = e[30] = t - x, e[1] = e[3] = e[5] = e[7] = -_, e[9] = e[11] = e[13] = e[15] = s * m - _, e[17] = e[19] = e[21] = e[23] = r - a * m - _, e[25] = e[27] = e[29] = e[31] = r - _, this.getBuffer("aPosition").update();
+      _anchorX: u,
+      _anchorY: l
+    } = this, h = i + n, c = t > h ? 1 : t / h, d = s + a, f = r > d ? 1 : r / d, x = Math.min(c, f), _ = u * t, v = l * r;
+    e[0] = e[8] = e[16] = e[24] = -_, e[2] = e[10] = e[18] = e[26] = i * x - _, e[4] = e[12] = e[20] = e[28] = t - n * x - _, e[6] = e[14] = e[22] = e[30] = t - _, e[1] = e[3] = e[5] = e[7] = -v, e[9] = e[11] = e[13] = e[15] = s * x - v, e[17] = e[19] = e[21] = e[23] = r - a * x - v, e[25] = e[27] = e[29] = e[31] = r - v, this.getBuffer("aPosition").update();
   }
   /** Updates the UVs of the vertices. */
   updateUvs() {
@@ -2317,7 +2735,7 @@ const lt = class ct extends tr {
     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();
   }
 };
-lt.defaultOptions = {
+ft.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. */
@@ -2335,16 +2753,16 @@ lt.defaultOptions = {
   /** The original height of the texture */
   originalHeight: 100
 };
-let ur = lt;
-class dr extends we {
+let _r = ft;
+class vr extends ye {
   constructor() {
-    super(), this.geometry = new ur();
+    super(), this.geometry = new _r();
   }
   destroy() {
     this.geometry.destroy();
   }
 }
-class ut {
+class gt {
   constructor(e) {
     this._renderer = e;
   }
@@ -2370,22 +2788,22 @@ class ut {
     return e._gpuData[this._renderer.uid] || this._initGPUSprite(e);
   }
   _initGPUSprite(e) {
-    const t = e._gpuData[this._renderer.uid] = new dr(), r = t;
+    const t = e._gpuData[this._renderer.uid] = new vr(), 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;
   }
 }
-ut.extension = {
+gt.extension = {
   type: [
-    w.WebGLPipes,
-    w.WebGPUPipes,
-    w.CanvasPipes
+    y.WebGLPipes,
+    y.WebGPUPipes,
+    y.CanvasPipes
   ],
   name: "nineSliceSprite"
 };
-const hr = {
+const br = {
   name: "tiling-bit",
   vertex: {
     header: (
@@ -2450,7 +2868,7 @@ const hr = {
         `
     )
   }
-}, fr = {
+}, yr = {
   name: "tiling-bit",
   vertex: {
     header: (
@@ -2495,59 +2913,59 @@ const hr = {
     )
   }
 };
-let ce, ue;
-class pr extends be {
+let le, ce;
+class Tr extends ve {
   constructor() {
-    ce ?? (ce = Oe({
+    le ?? (le = Ye({
       name: "tiling-sprite-shader",
       bits: [
-        Wt,
-        hr,
-        Ee
+        Et,
+        br,
+        Xe
       ]
-    })), ue ?? (ue = He({
+    })), ce ?? (ce = $e({
       name: "tiling-sprite-shader",
       bits: [
-        Lt,
-        fr,
-        Ve
+        Ht,
+        yr,
+        Ne
       ]
     }));
     const e = new Y({
-      uMapCoord: { value: new k(), type: "mat3x3<f32>" },
+      uMapCoord: { value: new U(), type: "mat3x3<f32>" },
       uClampFrame: { value: new Float32Array([0, 0, 1, 1]), type: "vec4<f32>" },
       uClampOffset: { value: new Float32Array([0, 0]), type: "vec2<f32>" },
-      uTextureTransform: { value: new k(), type: "mat3x3<f32>" },
+      uTextureTransform: { value: new U(), type: "mat3x3<f32>" },
       uSizeAnchor: { value: new Float32Array([100, 100, 0.5, 0.5]), type: "vec4<f32>" }
     });
     super({
-      glProgram: ue,
-      gpuProgram: ce,
+      glProgram: ce,
+      gpuProgram: le,
       resources: {
         localUniforms: new Y({
-          uTransformMatrix: { value: new k(), type: "mat3x3<f32>" },
+          uTransformMatrix: { value: new U(), type: "mat3x3<f32>" },
           uColor: { value: new Float32Array([1, 1, 1, 1]), type: "vec4<f32>" },
           uRound: { value: 0, type: "f32" }
         }),
         tilingUniforms: e,
-        uTexture: R.EMPTY.source,
-        uSampler: R.EMPTY.source.style
+        uTexture: M.EMPTY.source,
+        uSampler: M.EMPTY.source.style
       }
     });
   }
   updateUniforms(e, t, r, i, n, s) {
-    const a = this.resources.tilingUniforms, l = s.width, c = s.height, d = s.textureMatrix, u = a.uniforms.uTextureTransform;
-    u.set(
-      r.a * l / e,
-      r.b * l / t,
-      r.c * c / e,
-      r.d * c / t,
+    const a = this.resources.tilingUniforms, u = s.width, l = s.height, h = s.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
-    ), u.invert(), a.uniforms.uMapCoord = d.mapCoord, a.uniforms.uClampFrame = d.uClampFrame, a.uniforms.uClampOffset = d.uClampOffset, a.uniforms.uTextureTransform = u, a.uniforms.uSizeAnchor[0] = e, a.uniforms.uSizeAnchor[1] = t, a.uniforms.uSizeAnchor[2] = i, a.uniforms.uSizeAnchor[3] = n, s && (this.resources.uTexture = s.source, this.resources.uSampler = s.source.style);
+    ), c.invert(), a.uniforms.uMapCoord = h.mapCoord, a.uniforms.uClampFrame = h.uClampFrame, a.uniforms.uClampOffset = h.uClampOffset, a.uniforms.uTextureTransform = c, a.uniforms.uSizeAnchor[0] = e, a.uniforms.uSizeAnchor[1] = t, a.uniforms.uSizeAnchor[2] = i, a.uniforms.uSizeAnchor[3] = n, s && (this.resources.uTexture = s.source, this.resources.uSampler = s.source.style);
   }
 }
-class gr extends ye {
+class wr extends be {
   constructor() {
     super({
       positions: new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]),
@@ -2556,32 +2974,32 @@ class gr extends ye {
     });
   }
 }
-function mr(o, e) {
+function Sr(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 xr(o, e, t, r) {
+function Cr(o, e, t, r) {
   let i = 0;
-  const n = o.length / e, s = r.a, a = r.b, l = r.c, c = r.d, d = r.tx, u = r.ty;
+  const n = o.length / e, s = r.a, a = r.b, u = r.c, l = r.d, h = r.tx, c = r.ty;
   for (t *= e; i < n; ) {
-    const h = o[t], f = o[t + 1];
-    o[t] = s * h + l * f + d, o[t + 1] = a * h + c * f + u, t += e, i++;
+    const d = o[t], f = o[t + 1];
+    o[t] = s * d + u * f + h, o[t + 1] = a * d + l * f + c, t += e, i++;
   }
 }
-function _r(o, e) {
+function Pr(o, e) {
   const t = o.texture, r = t.frame.width, i = t.frame.height;
   let n = 0, s = 0;
   o.applyAnchorToTexture && (n = o.anchor.x, s = o.anchor.y), e[0] = e[6] = -n, e[2] = e[4] = 1 - n, e[1] = e[3] = -s, e[5] = e[7] = 1 - s;
-  const a = k.shared;
-  a.copyFrom(o._tileTransform.matrix), a.tx /= o.width, a.ty /= o.height, a.invert(), a.scale(o.width / r, o.height / i), xr(e, 2, 0, a);
+  const a = U.shared;
+  a.copyFrom(o._tileTransform.matrix), a.tx /= o.width, a.ty /= o.height, a.invert(), a.scale(o.width / r, o.height / i), Cr(e, 2, 0, a);
 }
-const J = new gr();
-class br {
+const Z = new wr();
+class Fr {
   constructor() {
-    this.canBatch = !0, this.geometry = new ye({
-      indices: J.indices.slice(),
-      positions: J.positions.slice(),
-      uvs: J.uvs.slice()
+    this.canBatch = !0, this.geometry = new be({
+      indices: Z.indices.slice(),
+      positions: Z.positions.slice(),
+      uvs: Z.uvs.slice()
     });
   }
   destroy() {
@@ -2589,9 +3007,9 @@ class br {
     this.geometry.destroy(), (e = this.shader) == null || e.destroy();
   }
 }
-class dt {
+class mt {
   constructor(e) {
-    this._state = ee.default2d, this._renderer = e;
+    this._state = te.default2d, this._renderer = e;
   }
   validateRenderable(e) {
     const t = this._getTilingSpriteData(e), r = t.canBatch;
@@ -2611,11 +3029,11 @@ class dt {
     this._updateCanBatch(e);
     const i = this._getTilingSpriteData(e), { geometry: n, canBatch: s } = i;
     if (s) {
-      i.batchableMesh || (i.batchableMesh = new we());
+      i.batchableMesh || (i.batchableMesh = new ye());
       const a = i.batchableMesh;
       e.didViewUpdate && (this._updateBatchableMesh(e), a.geometry = n, 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), i.shader || (i.shader = new pr()), 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);
@@ -2626,7 +3044,7 @@ class dt {
       r.uColor,
       0
     ), this._state.blendMode = _e(e.groupBlendMode, e.texture._source), this._renderer.encoder.draw({
-      geometry: J,
+      geometry: Z,
       shader: t,
       state: this._state
     });
@@ -2652,12 +3070,12 @@ class dt {
     return e._gpuData[this._renderer.uid] || this._initTilingSpriteData(e);
   }
   _initTilingSpriteData(e) {
-    const t = new br();
+    const t = new Fr();
     return t.renderable = e, e._gpuData[this._renderer.uid] = t, t;
   }
   _updateBatchableMesh(e) {
     const t = this._getTilingSpriteData(e), { geometry: r } = t, i = e.texture.source.style;
-    i.addressMode !== "repeat" && (i.addressMode = "repeat", i.update()), _r(e, r.uvs), mr(e, r.positions);
+    i.addressMode !== "repeat" && (i.addressMode = "repeat", i.update()), Pr(e, r.uvs), Sr(e, r.positions);
   }
   destroy() {
     this._renderer = null;
@@ -2668,15 +3086,15 @@ class dt {
     return this._renderer.type === xe.WEBGL && (i = this._renderer.context.supports.nonPowOf2wrapping), t.canBatch = r.textureMatrix.isSimple && (i || r.source.isPowerOfTwo), t.canBatch;
   }
 }
-dt.extension = {
+mt.extension = {
   type: [
-    w.WebGLPipes,
-    w.WebGPUPipes,
-    w.CanvasPipes
+    y.WebGLPipes,
+    y.WebGPUPipes,
+    y.CanvasPipes
   ],
   name: "tilingSprite"
 };
-const yr = {
+const Br = {
   name: "local-uniform-msdf-bit",
   vertex: {
     header: (
@@ -2729,7 +3147,7 @@ const yr = {
         `
     )
   }
-}, wr = {
+}, Rr = {
   name: "local-uniform-msdf-bit",
   vertex: {
     header: (
@@ -2771,7 +3189,7 @@ const yr = {
         `
     )
   }
-}, Tr = {
+}, Mr = {
   name: "msdf-bit",
   fragment: {
     header: (
@@ -2806,7 +3224,7 @@ const yr = {
         `
     )
   }
-}, vr = {
+}, Ur = {
   name: "msdf-bit",
   fragment: {
     header: (
@@ -2842,51 +3260,51 @@ const yr = {
     )
   }
 };
-let de, he;
-class Sr extends be {
+let he, de;
+class zr extends ve {
   constructor(e) {
     const t = new Y({
       uColor: { value: new Float32Array([1, 1, 1, 1]), type: "vec4<f32>" },
-      uTransformMatrix: { value: new k(), type: "mat3x3<f32>" },
+      uTransformMatrix: { value: new U(), type: "mat3x3<f32>" },
       uDistance: { value: 4, type: "f32" },
       uRound: { value: 0, type: "f32" }
     });
-    de ?? (de = Oe({
+    he ?? (he = Ye({
       name: "sdf-shader",
       bits: [
-        Mt,
-        Rt(e),
-        yr,
-        Tr,
-        Ee
+        kt,
+        Gt(e),
+        Br,
+        Mr,
+        Xe
       ]
-    })), he ?? (he = He({
+    })), de ?? (de = $e({
       name: "sdf-shader",
       bits: [
-        Ut,
-        kt(e),
-        wr,
-        vr,
-        Ve
+        At,
+        Dt(e),
+        Rr,
+        Ur,
+        Ne
       ]
     })), super({
-      glProgram: he,
-      gpuProgram: de,
+      glProgram: de,
+      gpuProgram: he,
       resources: {
         localUniforms: t,
-        batchSamplers: Gt(e)
+        batchSamplers: Ot(e)
       }
     });
   }
 }
-class Cr extends At {
+class kr extends It {
   destroy() {
     this.context.customShader && this.context.customShader.destroy(), super.destroy();
   }
 }
-class ht {
+class xt {
   constructor(e) {
-    this._renderer = e, this._renderer.renderableGC.addManagedHash(this, "_gpuBitmapText");
+    this._renderer = e;
   }
   validateRenderable(e) {
     const t = this._getGpuBitmapText(e);
@@ -2901,70 +3319,70 @@ class ht {
     We(e, t), this._renderer.renderPipes.graphics.updateRenderable(t), t.context.customShader && this._updateDistanceField(e);
   }
   _updateContext(e, t) {
-    const { context: r } = t, i = $t.getFont(e.text, e._style);
-    r.clear(), i.distanceField.type !== "none" && (r.customShader || (r.customShader = new Sr(this._renderer.limits.maxBatchableTextures)));
-    const n = D.graphemeSegmenter(e.text), s = e._style;
+    const { context: r } = t, i = Qt.getFont(e.text, e._style);
+    r.clear(), i.distanceField.type !== "none" && (r.customShader || (r.customShader = new zr(this._renderer.limits.maxBatchableTextures)));
+    const n = O.graphemeSegmenter(e.text), s = e._style;
     let a = i.baseLineOffset;
-    const l = qe(n, s, i, !0), c = s.padding, d = l.scale;
-    let u = l.width, h = l.height + l.offsetY;
-    s._stroke && (u += s._stroke.width / d, h += s._stroke.width / d), r.translate(-e._anchor._x * u - c, -e._anchor._y * h - c).scale(d, d);
+    const u = et(n, s, i, !0), l = s.padding, h = u.scale;
+    let c = u.width, d = u.height + u.offsetY;
+    s._stroke && (c += s._stroke.width / h, d += s._stroke.width / h), r.translate(-e._anchor._x * c - l, -e._anchor._y * d - l).scale(h, h);
     const f = i.applyFillAsTint ? s._fill.color : 16777215;
-    let m = i.fontMetrics.fontSize, x = i.lineHeight;
-    s.lineHeight && (m = s.fontSize / d, x = s.lineHeight / d);
-    let _ = (x - m) / 2;
-    _ - i.baseLineOffset < 0 && (_ = 0);
-    for (let p = 0; p < l.lines.length; p++) {
-      const b = l.lines[p];
-      for (let y = 0; y < b.charPositions.length; y++) {
-        const T = b.chars[y], S = i.chars[T];
+    let x = i.fontMetrics.fontSize, _ = i.lineHeight;
+    s.lineHeight && (x = s.fontSize / h, _ = s.lineHeight / h);
+    let v = (_ - x) / 2;
+    v - i.baseLineOffset < 0 && (v = 0);
+    for (let g = 0; g < u.lines.length; g++) {
+      const b = u.lines[g];
+      for (let m = 0; m < b.charPositions.length; m++) {
+        const T = b.chars[m], S = i.chars[T];
         if (S != null && S.texture) {
           const B = S.texture;
           r.texture(
             B,
             f || "black",
-            Math.round(b.charPositions[y] + S.xOffset),
-            Math.round(a + S.yOffset + _),
+            Math.round(b.charPositions[m] + S.xOffset),
+            Math.round(a + S.yOffset + v),
             B.orig.width,
             B.orig.height
           );
         }
       }
-      a += x;
+      a += _;
     }
   }
   _getGpuBitmapText(e) {
     return e._gpuData[this._renderer.uid] || this.initGpuText(e);
   }
   initGpuText(e) {
-    const t = new Cr();
+    const t = new kr();
     return e._gpuData[this._renderer.uid] = t, this._updateContext(e, t), t;
   }
   _updateDistanceField(e) {
-    const t = this._getGpuBitmapText(e).context, r = e._style.fontFamily, i = G.get(`${r}-bitmap`), { a: n, b: s, c: a, d: l } = e.groupTransform, c = Math.sqrt(n * n + s * s), d = Math.sqrt(a * a + l * l), u = (Math.abs(c) + Math.abs(d)) / 2, h = i.baseRenderedFontSize / e._style.fontSize, f = u * i.distanceField.range * (1 / h);
+    const t = this._getGpuBitmapText(e).context, r = e._style.fontFamily, i = G.get(`${r}-bitmap`), { a: n, b: s, c: a, d: u } = e.groupTransform, l = Math.sqrt(n * n + s * s), h = Math.sqrt(a * a + u * u), c = (Math.abs(l) + Math.abs(h)) / 2, d = i.baseRenderedFontSize / e._style.fontSize, f = c * i.distanceField.range * (1 / d);
     t.customShader.resources.localUniforms.uniforms.uDistance = f;
   }
   destroy() {
     this._renderer = null;
   }
 }
-ht.extension = {
+xt.extension = {
   type: [
-    w.WebGLPipes,
-    w.WebGPUPipes,
-    w.CanvasPipes
+    y.WebGLPipes,
+    y.WebGPUPipes,
+    y.CanvasPipes
   ],
   name: "bitmapText"
 };
 function We(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 Pr extends Ye {
+class Gr extends Ke {
   /**
    * 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() {
@@ -2973,27 +3391,33 @@ class Pr extends Ye {
   }
   /** 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 ge(o, e) {
   const { texture: t, bounds: r } = o, i = e._style._getFinalPadding();
-  zt(r, e._anchor, t);
+  Wt(r, e._anchor, t);
   const n = e._anchor._x * i * 2, s = e._anchor._y * i * 2;
   r.minX -= i - n, r.minY -= i - s, r.maxX -= i - n, r.maxY -= i - s;
 }
-class ft {
+class _t {
   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((i) => {
-      console.error(i);
-    }), e._didTextUpdate = !1, ge(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((n) => {
+        console.error(n);
+      }), e._didTextUpdate = !1, ge(r, e);
+    }
+    this._renderer.renderPipes.batch.addToBatch(r, t);
   }
   updateRenderable(e) {
     const t = this._getGpuText(e);
@@ -3004,38 +3428,41 @@ class ft {
     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 i = e.renderGroup || e.parentRenderGroup;
-    i && (i.structureDidChange = !0), t.generatingTexture = !1, ge(t, e);
+    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 n = e.renderGroup || e.parentRenderGroup;
+    n && (n.structureDidChange = !0), t.generatingTexture = !1, ge(t, e);
   }
   _getGpuText(e) {
     return e._gpuData[this._renderer.uid] || this.initGpuText(e);
   }
   initGpuText(e) {
-    const t = new Pr(this._renderer);
-    return t.renderable = e, t.transform = e.groupTransform, t.texture = R.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 Gr(this._renderer);
+    return t.renderable = e, t.transform = e.groupTransform, t.texture = M.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;
   }
 }
-ft.extension = {
+_t.extension = {
   type: [
-    w.WebGLPipes,
-    w.WebGPUPipes,
-    w.CanvasPipes
+    y.WebGLPipes,
+    y.WebGPUPipes,
+    y.CanvasPipes
   ],
   name: "htmlText"
 };
-function Fr() {
+function Ar() {
   const { userAgent: o } = H.get().getNavigator();
   return /^((?!chrome|android).)*safari/i.test(o);
 }
-const Br = new Ie();
-function pt(o, e, t, r) {
-  const i = Br;
+const Dr = new Ve();
+function vt(o, e, t, r) {
+  const i = Dr;
   i.minX = 0, i.minY = 0, i.maxX = o.width / r | 0, i.maxY = o.height / r | 0;
   const n = A.getOptimalTexture(
     i.width,
@@ -3045,34 +3472,34 @@ function pt(o, e, t, r) {
   );
   return n.source.uploadMethodId = "image", n.source.resource = o, n.source.alphaMode = "premultiply-alpha-on-upload", n.frame.width = e / r, n.frame.height = t / r, n.source.emit("update", n.source), n.updateUvs(), n;
 }
-function Mr(o, e) {
+function Or(o, e) {
   const t = e.fontFamily, r = [], i = {}, n = /font-family:([^;"\s]+)/g, s = o.match(n);
-  function a(l) {
-    i[l] || (r.push(l), i[l] = !0);
+  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);
-  s && s.forEach((l) => {
-    const c = l.split(":")[1].trim();
-    a(c);
+  s && s.forEach((u) => {
+    const l = u.split(":")[1].trim();
+    a(l);
   });
-  for (const l in e.tagStyles) {
-    const c = e.tagStyles[l].fontFamily;
-    a(c);
+  for (const u in e.tagStyles) {
+    const l = e.tagStyles[u].fontFamily;
+    a(l);
   }
   return r;
 }
-async function Rr(o) {
+async function Ir(o) {
   const t = await (await H.get().fetch(o)).blob(), r = new FileReader();
   return await new Promise((n, s) => {
     r.onloadend = () => n(r.result), r.onerror = s, r.readAsDataURL(t);
   });
 }
-async function Ur(o, e) {
-  const t = await Rr(e);
+async function Wr(o, e) {
+  const t = await Ir(e);
   return `@font-face {
         font-family: "${o.fontFamily}";
         font-weight: ${o.fontWeight};
@@ -3081,18 +3508,18 @@ async function Ur(o, e) {
     }`;
 }
 const fe = /* @__PURE__ */ new Map();
-async function kr(o) {
+async function Lr(o) {
   const e = o.filter((t) => G.has(`${t}-and-url`)).map((t) => {
     if (!fe.has(t)) {
       const { entries: r } = G.get(`${t}-and-url`), i = [];
       r.forEach((n) => {
-        const s = n.url, l = n.faces.map((c) => ({ weight: c.weight, style: c.style }));
+        const s = n.url, u = n.faces.map((l) => ({ weight: l.weight, style: l.style }));
         i.push(
-          ...l.map(
-            (c) => Ur(
+          ...u.map(
+            (l) => Wr(
               {
-                fontWeight: c.weight,
-                fontStyle: c.style,
+                fontWeight: l.weight,
+                fontStyle: l.style,
                 fontFamily: t
               },
               s
@@ -3110,13 +3537,13 @@ async function kr(o) {
   return (await Promise.all(e)).join(`
 `);
 }
-function Gr(o, e, t, r, i) {
+function Er(o, e, t, r, i) {
   const { domElement: n, styleElement: s, svgRoot: a } = i;
   n.innerHTML = `<style>${e.cssStyle}</style><div style='padding:0;'>${o}</div>`, n.setAttribute("style", `transform: scale(${t});transform-origin: top left; display: inline-block`), s.textContent = r;
-  const { width: l, height: c } = i.image;
-  return a.setAttribute("width", l.toString()), a.setAttribute("height", c.toString()), new XMLSerializer().serializeToString(a);
+  const { width: u, height: l } = i.image;
+  return a.setAttribute("width", u.toString()), a.setAttribute("height", l.toString()), new XMLSerializer().serializeToString(a);
 }
-function Ar(o, e) {
+function Hr(o, e) {
   const t = X.getOptimalCanvasAndContext(
     o.width,
     o.height,
@@ -3124,16 +3551,16 @@ function Ar(o, e) {
   ), { context: r } = t;
   return r.clearRect(0, 0, o.width, o.height), r.drawImage(o, 0, 0), t;
 }
-function zr(o, e, t) {
+function Vr(o, e, t) {
   return new Promise(async (r) => {
     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 gt {
+class bt {
   constructor(e) {
-    this._renderer = e, this._createCanvas = e.type === xe.WEBGPU;
+    this._activeTextures = {}, this._renderer = e, this._createCanvas = e.type === xe.WEBGPU;
   }
   /**
    * @param options
@@ -3142,30 +3569,75 @@ class gt {
   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(() => {
+      K("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: i, textureStyle: n } = e, s = te.get(et), a = Mr(t, r), l = await kr(a), c = Zt(t, r, l, s), d = Math.ceil(Math.ceil(Math.max(1, c.width) + r.padding * 2) * i), u = Math.ceil(Math.ceil(Math.max(1, c.height) + r.padding * 2) * i), h = s.image, f = 2;
-    h.width = (d | 0) + f, h.height = (u | 0) + f;
-    const m = Gr(t, r, i, l, s);
-    await zr(h, m, Fr() && a.length > 0);
-    const x = h;
-    let _;
-    this._createCanvas && (_ = Ar(h, i));
-    const p = pt(
-      _ ? _.canvas : x,
-      h.width - f,
-      h.height - f,
+    const { text: t, style: r, resolution: i, textureStyle: n } = e, s = re.get(st), a = Or(t, r), u = await Lr(a), l = or(t, r, u, s), h = 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), d = s.image, f = 2;
+    d.width = (h | 0) + f, d.height = (c | 0) + f;
+    const x = Er(t, r, i, u, s);
+    await Vr(d, x, Ar() && a.length > 0);
+    const _ = d;
+    let v;
+    this._createCanvas && (v = Hr(d, i));
+    const g = vt(
+      v ? v.canvas : _,
+      d.width - f,
+      d.height - f,
       i
     );
-    return n && (p.source.style = n), this._createCanvas && (this._renderer.texture.initSource(p.source), X.returnCanvasAndContext(_)), te.return(s), p;
+    return n && (g.source.style = n), this._createCanvas && (this._renderer.texture.initSource(g.source), X.returnCanvasAndContext(v)), re.return(s), g;
   }
   returnTexturePromise(e) {
     e.then((t) => {
       this._cleanUp(t);
     }).catch(() => {
-      ne("HTMLTextSystem: Failed to clean texture");
+      K("HTMLTextSystem: Failed to clean texture");
     });
   }
   _cleanUp(e) {
@@ -3173,17 +3645,20 @@ class gt {
   }
   destroy() {
     this._renderer = null;
+    for (const e in this._activeTextures)
+      this._activeTextures[e] && this.returnTexturePromise(this._activeTextures[e].promise);
+    this._activeTextures = null;
   }
 }
-gt.extension = {
+bt.extension = {
   type: [
-    w.WebGLSystem,
-    w.WebGPUSystem,
-    w.CanvasSystem
+    y.WebGLSystem,
+    y.WebGPUSystem,
+    y.CanvasSystem
   ],
   name: "htmlText"
 };
-class Dr extends Ye {
+class Yr extends Ke {
   constructor(e) {
     super(), this._renderer = e, e.runners.resolutionChange.add(this);
   }
@@ -3192,19 +3667,25 @@ class Dr extends Ye {
     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 mt {
+class yt {
   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, ge(r, e);
+    }
+    this._renderer.renderPipes.batch.addToBatch(r, t);
   }
   updateRenderable(e) {
     const t = this._getGpuText(e);
@@ -3212,47 +3693,47 @@ class mt {
   }
   _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), ge(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 Dr(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 Yr(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;
   }
 }
-mt.extension = {
+yt.extension = {
   type: [
-    w.WebGLPipes,
-    w.WebGPUPipes,
-    w.CanvasPipes
+    y.WebGLPipes,
+    y.WebGPUPipes,
+    y.CanvasPipes
   ],
   name: "text"
 };
-class xt {
+class Tt {
   constructor(e) {
-    this._renderer = e;
+    this._activeTextures = {}, this._renderer = e;
   }
   getTexture(e, t, r, i) {
-    typeof e == "string" && (U("8.0.0", "CanvasTextSystem.getTexture: Use object TextOptions instead of separate arguments"), e = {
+    typeof e == "string" && (z("8.0.0", "CanvasTextSystem.getTexture: Use object TextOptions instead of separate arguments"), e = {
       text: e,
       style: r,
       resolution: t
     }), e.style instanceof q || (e.style = new q(e.style)), e.textureStyle instanceof j || (e.textureStyle = new j(e.textureStyle)), typeof e.text != "string" && (e.text = e.text.toString());
-    const { text: n, style: s, textureStyle: a } = e, l = e.resolution ?? this._renderer.resolution, { frame: c, canvasAndContext: d } = le.getCanvasAndContext({
+    const { text: n, style: s, textureStyle: a } = e, u = e.resolution ?? this._renderer.resolution, { frame: l, canvasAndContext: h } = ue.getCanvasAndContext({
       text: n,
       style: s,
-      resolution: l
-    }), u = pt(d.canvas, c.width, c.height, l);
-    if (a && (u.source.style = a), s.trim && (c.pad(s.padding), u.frame.copyFrom(c), u.frame.scale(1 / l), u.updateUvs()), s.filters) {
-      const h = this._applyFilters(u, s.filters);
-      return this.returnTexture(u), le.returnCanvasAndContext(d), h;
+      resolution: u
+    }), c = vt(h.canvas, l.width, l.height, u);
+    if (a && (c.source.style = a), s.trim && (l.pad(s.padding), c.frame.copyFrom(l), c.frame.scale(1 / u), c.updateUvs()), s.filters) {
+      const d = this._applyFilters(c, s.filters);
+      return this.returnTexture(c), ue.returnCanvasAndContext(h), d;
     }
-    return this._renderer.texture.initSource(u._source), le.returnCanvasAndContext(d), u;
+    return this._renderer.texture.initSource(c._source), ue.returnCanvasAndContext(h), c;
   }
   /**
    * Returns a texture that was created wit the above `getTexture` function.
@@ -3268,11 +3749,62 @@ class xt {
    * @deprecated since 8.10.0
    */
   renderTextToCanvas() {
-    U(
+    z(
       "8.10.0",
       "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.
    *
@@ -3292,30 +3824,33 @@ class xt {
   }
   destroy() {
     this._renderer = null;
+    for (const e in this._activeTextures)
+      this._activeTextures[e] && this.returnTexture(this._activeTextures[e].texture);
+    this._activeTextures = null;
   }
 }
-xt.extension = {
+Tt.extension = {
   type: [
-    w.WebGLSystem,
-    w.WebGPUSystem,
-    w.CanvasSystem
+    y.WebGLSystem,
+    y.WebGPUSystem,
+    y.CanvasSystem
   ],
   name: "canvasText"
 };
-P.add(Xe);
-P.add($e);
-P.add(tt);
-P.add(Dt);
-P.add(nt);
+P.add(je);
+P.add(qe);
 P.add(at);
-P.add(ot);
+P.add(Lt);
+P.add(lt);
+P.add(ht);
+P.add(dt);
+P.add(Tt);
+P.add(yt);
 P.add(xt);
+P.add(bt);
+P.add(_t);
 P.add(mt);
-P.add(ht);
 P.add(gt);
-P.add(ft);
-P.add(dt);
-P.add(ut);
-P.add(Qe);
-P.add(Ke);
-//# sourceMappingURL=webworkerAll-CI8_Z7rX.js.map
+P.add(rt);
+P.add(tt);
+//# sourceMappingURL=webworkerAll-pikqGfAy.js.map