@micjanic/recursive-grid 1.0.4 → 1.0.6

package/dist/webworkerAll-pikqGfAy.js

@@ -1,3856 +0,0 @@
-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
-   * @param {object} [options] - See application options
-   */
-  static init(e) {
-    Object.defineProperty(
-      this,
-      "resizeTo",
-      {
-        set(t) {
-          globalThis.removeEventListener("resize", this.queueResize), this._resizeTo = t, t && (globalThis.addEventListener("resize", this.queueResize), this.resize());
-        },
-        get() {
-          return this._resizeTo;
-        }
-      }
-    ), this.queueResize = () => {
-      this._resizeTo && (this._cancelResize(), this._resizeId = requestAnimationFrame(() => this.resize()));
-    }, this._cancelResize = () => {
-      this._resizeId && (cancelAnimationFrame(this._resizeId), this._resizeId = null);
-    }, this.resize = () => {
-      if (!this._resizeTo)
-        return;
-      this._cancelResize();
-      let t, r;
-      if (this._resizeTo === globalThis.window)
-        t = globalThis.innerWidth, r = globalThis.innerHeight;
-      else {
-        const { clientWidth: i, clientHeight: n } = this._resizeTo;
-        t = i, r = n;
-      }
-      this.renderer.resize(t, r), this.render();
-    }, this._resizeId = null, this._resizeTo = null, this.resizeTo = e.resizeTo || null;
-  }
-  /**
-   * Clean up the ticker, scoped to application
-   * @private
-   */
-  static destroy() {
-    globalThis.removeEventListener("resize", this.queueResize), this._cancelResize(), this._cancelResize = null, this.queueResize = null, this.resizeTo = null, this.resize = null;
-  }
-}
-je.extension = y.Application;
-class qe {
-  /**
-   * Initialize the plugin with scope of application instance
-   * @private
-   * @param {object} [options] - See application options
-   */
-  static init(e) {
-    e = Object.assign({
-      autoStart: !0,
-      sharedTicker: !1
-    }, e), Object.defineProperty(
-      this,
-      "ticker",
-      {
-        set(t) {
-          this._ticker && this._ticker.remove(this.render, this), this._ticker = t, t && t.add(this.render, this, Pt.LOW);
-        },
-        get() {
-          return this._ticker;
-        }
-      }
-    ), this.stop = () => {
-      this._ticker.stop();
-    }, this.start = () => {
-      this._ticker.start();
-    }, this._ticker = null, this.ticker = e.sharedTicker ? we.shared : new we(), e.autoStart && this.start();
-  }
-  /**
-   * Clean up the ticker, scoped to application.
-   * @private
-   */
-  static destroy() {
-    if (this._ticker) {
-      const e = this._ticker;
-      this.ticker = null, e.destroy();
-    }
-  }
-}
-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;
-  }
-  /**
-   * The name of the font face.
-   * @deprecated since 8.0.0 Use `fontFamily` instead.
-   */
-  get font() {
-    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 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 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 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 z(L, "BitmapFont.distanceFieldType is deprecated, please use BitmapFont.distanceField.type instead."), this.distanceField.type;
-  }
-  destroy(e = !1) {
-    var t;
-    this.emit("destroy", this), this.removeAllListeners();
-    for (const r in this.chars)
-      (t = this.chars[r].texture) == null || t.destroy();
-    this.chars = null, e && (this.pages.forEach((r) => r.texture.destroy(!0)), this.pages = null);
-  }
-}
-/**
- * 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",
-  "cursive",
-  "fantasy",
-  "system-ui"
-];
-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) && !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
-}, k = class p {
-  /**
-   * Checking that we can use modern canvas 2D API.
-   *
-   * Note: This is an unstable API, Chrome < 94 use `textLetterSpacing`, later versions use `letterSpacing`.
-   * @see TextMetrics.experimentalLetterSpacing
-   * @see https://developer.mozilla.org/en-US/docs/Web/API/ICanvasRenderingContext2D/letterSpacing
-   * @see https://developer.chrome.com/origintrials/#/view_trial/3585991203293757441
-   */
-  static get experimentalLetterSpacingSupported() {
-    let e = p._experimentalLetterSpacingSupported;
-    if (e === void 0) {
-      const t = H.get().getCanvasRenderingContext2D().prototype;
-      e = p._experimentalLetterSpacingSupported = "letterSpacing" in t || "textLetterSpacing" in t;
-    }
-    return e;
-  }
-  /**
-   * @param text - the text that was measured
-   * @param style - the style that was measured
-   * @param width - the measured width of the text
-   * @param height - the measured height of the text
-   * @param lines - an array of the lines of text broken by new lines and wrapping if specified in style
-   * @param lineWidths - an array of the line widths for each line matched to `lines`
-   * @param lineHeight - the measured line height for this style
-   * @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, 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.
-   * @param text - The text to measure.
-   * @param style - The text style to use for measuring
-   * @param canvas - optional specification of the canvas to use for measuring.
-   * @param wordWrap
-   * @returns Measured width and height of the text.
-   */
-  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 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,
-      x,
-      v,
-      h,
-      c,
-      _ + t.leading,
-      d,
-      a
-    );
-    return p._measurementCache.set(n, g), g;
-  }
-  static _measureText(e, t, r) {
-    let i = !1;
-    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 l = n.actualBoundingBoxRight - a;
-    if (s > 0)
-      if (i)
-        s -= t, l -= t;
-      else {
-        const h = (p.graphemeSegmenter(e).length - 1) * t;
-        s += h, l += h;
-      }
-    return Math.max(s, l);
-  }
-  /**
-   * Applies newlines to a string to have it optimally fit into the horizontal
-   * bounds set by the Text object's wordWrapWidth property.
-   * @param text - String to apply word wrapping to
-   * @param style - the style to use when wrapping
-   * @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 = p._canvas) {
-    const i = r.getContext("2d", oe);
-    let n = 0, s = "", a = "";
-    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;
-        }
-        g = " ";
-      }
-      if (c) {
-        const m = p.isBreakingSpace(g), T = p.isBreakingSpace(s[s.length - 1]);
-        if (m && T)
-          continue;
-      }
-      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 = R, w++;
-            }
-            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 += p._addLine(s), s = "", n = 0);
-          const m = v === _.length - 1;
-          a += p._addLine(g, !m), f = !1, s = "", n = 0;
-        }
-      else
-        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 += p._addLine(s, !1), a;
-  }
-  /**
-   * Convenience function for logging each line added during the wordWrap method.
-   * @param line    - The line of text to add
-   * @param newLine - Add new line character to end
-   * @returns A formatted line
-   */
-  static _addLine(e, t = !0) {
-    return e = p._trimRight(e), e = t ? `${e}
-` : e, e;
-  }
-  /**
-   * Gets & sets the widths of calculated characters in a cache object
-   * @param key            - The key
-   * @param letterSpacing  - The letter spacing
-   * @param cache          - The cache
-   * @param context        - The canvas context
-   * @returns The from cache.
-   */
-  static _getFromCache(e, t, r, i) {
-    let n = r[e];
-    return typeof n != "number" && (n = p._measureText(e, t, i) + t, r[e] = n), n;
-  }
-  /**
-   * Determines whether we should collapse breaking spaces.
-   * @param whiteSpace - The TextStyle property whiteSpace
-   * @returns Should collapse
-   */
-  static _collapseSpaces(e) {
-    return e === "normal" || e === "pre-line";
-  }
-  /**
-   * Determines whether we should collapse newLine chars.
-   * @param whiteSpace - The white space
-   * @returns should collapse
-   */
-  static _collapseNewlines(e) {
-    return e === "normal";
-  }
-  /**
-   * Trims breaking whitespaces from string.
-   * @param text - The text
-   * @returns Trimmed string
-   */
-  static _trimRight(e) {
-    if (typeof e != "string")
-      return "";
-    for (let t = e.length - 1; t >= 0; t--) {
-      const r = e[t];
-      if (!p.isBreakingSpace(r))
-        break;
-      e = e.slice(0, -1);
-    }
-    return e;
-  }
-  /**
-   * Determines if char is a newline.
-   * @param char - The character
-   * @returns True if newline, False otherwise.
-   */
-  static _isNewline(e) {
-    return typeof e != "string" ? !1 : p._newlines.includes(e.charCodeAt(0));
-  }
-  /**
-   * Determines if char is a breaking whitespace.
-   *
-   * It allows one to determine whether char should be a breaking whitespace
-   * For example certain characters in CJK langs or numbers.
-   * It must return a boolean.
-   * @param char - The character
-   * @param [_nextChar] - The next character
-   * @returns True if whitespace, False otherwise.
-   */
-  static isBreakingSpace(e, t) {
-    return typeof e != "string" ? !1 : p._breakingSpaces.includes(e.charCodeAt(0));
-  }
-  /**
-   * Splits a string into words, breaking-spaces and newLine characters
-   * @param text - The text
-   * @returns A tokenized array
-   */
-  static _tokenize(e) {
-    const t = [];
-    let r = "";
-    if (typeof e != "string")
-      return t;
-    for (let i = 0; i < e.length; i++) {
-      const n = e[i], s = e[i + 1];
-      if (p.isBreakingSpace(n, s) || p._isNewline(n)) {
-        r !== "" && (t.push(r), r = ""), n === "\r" && s === `
-` ? (t.push(`\r
-`), i++) : t.push(n);
-        continue;
-      }
-      r += n;
-    }
-    return r !== "" && t.push(r), t;
-  }
-  /**
-   * Overridable helper method used internally by TextMetrics, exposed to allow customizing the class's behavior.
-   *
-   * It allows one to customise which words should break
-   * Examples are if the token is CJK or numbers.
-   * It must return a boolean.
-   * @param _token - The token
-   * @param breakWords - The style attr break words
-   * @returns Whether to break word or not
-   */
-  static canBreakWords(e, t) {
-    return t;
-  }
-  /**
-   * Overridable helper method used internally by TextMetrics, exposed to allow customizing the class's behavior.
-   *
-   * It allows one to determine whether a pair of characters
-   * should be broken by newlines
-   * For example certain characters in CJK langs or numbers.
-   * It must return a boolean.
-   * @param _char - The character
-   * @param _nextChar - The next character
-   * @param _token - The token/word the characters are from
-   * @param _index - The index in the token of the char
-   * @param _breakWords - The style attr break words
-   * @returns whether to break word or not
-   */
-  static canBreakChars(e, t, r, i, n) {
-    return !0;
-  }
-  /**
-   * Overridable helper method used internally by TextMetrics, exposed to allow customizing the class's behavior.
-   *
-   * It is called when a token (usually a word) has to be split into separate pieces
-   * in order to determine the point to break a word.
-   * It must return an array of characters.
-   * @param token - The token to split
-   * @returns The characters of the token
-   * @see CanvasTextMetrics.graphemeSegmenter
-   */
-  static wordWrapSplit(e) {
-    return p.graphemeSegmenter(e);
-  }
-  /**
-   * Calculates the ascent, descent and fontSize of a given font-style
-   * @param font - String representing the style of the font
-   * @returns Font properties object
-   */
-  static measureFont(e) {
-    if (p._fonts[e])
-      return p._fonts[e];
-    const t = p._context;
-    t.font = e;
-    const r = t.measureText(p.METRICS_STRING + p.BASELINE_SYMBOL), i = {
-      ascent: r.actualBoundingBoxAscent,
-      descent: r.actualBoundingBoxDescent,
-      fontSize: r.actualBoundingBoxAscent + r.actualBoundingBoxDescent
-    };
-    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 p._fonts[e] : p._fonts = {};
-  }
-  /**
-   * Cached canvas element for measuring text
-   * TODO: this should be private, but isn't because of backward compat, will fix later.
-   * @ignore
-   */
-  static get _canvas() {
-    if (!p.__canvas) {
-      let e;
-      try {
-        const t = new OffscreenCanvas(0, 0), r = t.getContext("2d", oe);
-        if (r != null && r.measureText)
-          return p.__canvas = t, t;
-        e = H.get().createCanvas();
-      } catch {
-        e = H.get().createCanvas();
-      }
-      e.width = e.height = 10, p.__canvas = e;
-    }
-    return p.__canvas;
-  }
-  /**
-   * TODO: this should be private, but isn't because of backward compat, will fix later.
-   * @ignore
-   */
-  static get _context() {
-    return p.__context || (p.__context = p._canvas.getContext("2d", oe)), p.__context;
-  }
-};
-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) => {
-      const t = o.segment(e), r = [];
-      let i = 0;
-      for (const n of t)
-        r[i++] = n.segment;
-      return r;
-    };
-  }
-  return (o) => [...o];
-})();
-k.experimentalLetterSpacing = !1;
-k._fonts = {};
-k._newlines = [
-  10,
-  // line feed
-  13
-  // carriage return
-];
-k._breakingSpaces = [
-  9,
-  // character tabulation
-  32,
-  // space
-  8192,
-  // en quad
-  8193,
-  // em quad
-  8194,
-  // en space
-  8195,
-  // em space
-  8196,
-  // three-per-em space
-  8197,
-  // four-per-em space
-  8198,
-  // six-per-em space
-  8200,
-  // punctuation space
-  8201,
-  // thin space
-  8202,
-  // hair space
-  8287,
-  // medium mathematical space
-  12288
-  // ideographic space
-];
-k._measurementCache = Qe(1e3);
-let O = k;
-const Ce = 1e5;
-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 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 Rt) {
-      const i = o.fill, n = i.type === "linear", s = i.textureSpace === "local";
-      let a = 1, u = 1;
-      s && t && (a = t.width + r, u = t.height + r);
-      let l, h = !1;
-      if (n) {
-        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: c, innerRadius: d, outerCenter: f, outerRadius: x } = i;
-        l = e.createRadialGradient(
-          c.x * a,
-          c.y * u,
-          d * a,
-          f.x * a,
-          f.y * u,
-          x * a
-        );
-      }
-      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(_ * Ce) / Ce,
-              V.shared.setValue(x.color).toHex()
-            );
-          });
-        }
-      } else
-        i.colorStops.forEach((c) => {
-          l.addColorStop(c.offset, V.shared.setValue(c.color).toHex());
-        });
-      return l;
-    }
-  } else {
-    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 K("FillStyle not recognised", o), "red";
-}
-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 = { ...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 = M.WHITE, r._fill.fill = null), this.applyFillAsTint = t.overrideFill;
-    const i = r.fontSize;
-    r.fontSize = this.baseMeasurementFontSize;
-    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 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];
-    let r;
-    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 u = this._currentX, l = this._currentY, h = this._currentMaxCharHeight;
-    const c = this.baseRenderedFontSize / this.baseMeasurementFontSize, d = this._padding * c;
-    let f = !1;
-    const x = i.width / this.resolution, _ = i.height / this.resolution;
-    for (let b = 0; b < t.length; b++) {
-      const m = t[b], T = O.measureText(m, a, i, !1);
-      T.lineHeight = T.height;
-      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 I = this._nextPage();
-        i = I.canvasAndContext.canvas, n = I.canvasAndContext.context, s = I.texture.source, u = 0, l = 0, h = 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,
-        kerning: {}
-      }, f) {
-        this._drawGlyph(
-          n,
-          T,
-          u + d,
-          l + d,
-          c,
-          a
-        );
-        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[m].texture = new M({
-          source: s,
-          frame: C
-        }), u += Math.ceil(F);
-      }
-    }
-    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 z(L, "BitmapFont.pageTextures is deprecated, please use BitmapFont.pages instead."), this.pages;
-  }
-  _applyKerning(e, t) {
-    const r = this._measureCache;
-    for (let i = 0; i < e.length; i++) {
-      const n = e[i];
-      for (let s = 0; s < this._currentChars.length; s++) {
-        const a = this._currentChars[s];
-        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);
-      }
-    }
-  }
-  _nextPage() {
-    this._currentPageIndex++;
-    const e = this.resolution, t = X.getOptimalCanvasAndContext(
-      this._textureSize,
-      this._textureSize,
-      e
-    );
-    this._setupContext(t.context, this._style, e);
-    const r = e * (this.baseRenderedFontSize / this.baseMeasurementFontSize), i = new M({
-      source: new Mt({
-        resource: t.canvas,
-        resolution: r,
-        alphaMode: "premultiply-alpha-on-upload",
-        autoGenerateMipmaps: this._mipmap
-      })
-    });
-    this._textureStyle && (i.source.style = this._textureStyle);
-    const n = {
-      canvasAndContext: t,
-      texture: i
-    };
-    return this.pages[this._currentPageIndex] = n, n;
-  }
-  // canvas style!
-  _setupContext(e, t, r) {
-    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 = 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, 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();
-    for (let e = 0; e < this.pages.length; e++) {
-      const { canvasAndContext: t, texture: r } = this.pages[e];
-      X.returnCanvasAndContext(t), r.destroy(!0);
-    }
-    this.pages = null;
-  }
-};
-Je.defaultOptions = {
-  textureSize: 512,
-  style: new q(),
-  mipmap: !0
-};
-let Pe = Je;
-function et(o, e, t, r) {
-  const i = {
-    width: 0,
-    height: 0,
-    offsetY: 0,
-    scale: e.fontSize / t.baseMeasurementFontSize,
-    lines: [{
-      width: 0,
-      charPositions: [],
-      spaceWidth: 0,
-      spacesIndex: [],
-      chars: []
-    }]
-  };
-  i.offsetY = t.baseLineOffset;
-  let n = i.lines[0], s = null, a = !0;
-  const u = {
-    width: 0,
-    start: 0,
-    index: 0,
-    // use index to not modify the array as we use it a lot!
-    positions: [],
-    chars: []
-  }, 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 m = 0; m < u.index; m++) {
-      const T = g.positions[m];
-      n.chars.push(g.chars[m]), n.charPositions.push(T + b);
-    }
-    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[g];
-      for (; b === " "; )
-        n.width -= t.chars[b].xAdvance, b = n.chars[--g];
-    }
-    i.width = Math.max(i.width, n.width), n = {
-      width: 0,
-      charPositions: [],
-      chars: [],
-      spaceWidth: 0,
-      spacesIndex: []
-    }, 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 m = g === o.length;
-    m || (b = o[g]);
-    const T = t.chars[b] || t.chars[" "];
-    if (/(?:\s)/.test(b) || 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 === `
-`)
-        _();
-      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 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 _(), e.align === "center" ? $t(i) : e.align === "right" ? Nt(i) : e.align === "justify" && Kt(i), i;
-}
-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 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 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, 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 jt(o) {
-  if (o === "")
-    return [];
-  typeof o == "string" && (o = [o]);
-  const e = [];
-  for (let t = 0, r = o.length; t < r; t++) {
-    const i = o[t];
-    if (Array.isArray(i)) {
-      if (i.length !== 2)
-        throw new Error(`[BitmapFont]: Invalid character range length, expecting 2 got ${i.length}.`);
-      if (i[0].length === 0 || i[1].length === 0)
-        throw new Error("[BitmapFont]: Invalid character delimiter.");
-      const n = i[0].charCodeAt(0), s = i[1].charCodeAt(0);
-      if (s < n)
-        throw new Error("[BitmapFont]: Invalid character range.");
-      for (let a = n, u = s; a <= u; a++)
-        e.push(String.fromCharCode(a));
-    } else
-      e.push(...Array.from(i));
-  }
-  if (e.length === 0)
-    throw new Error("[BitmapFont]: Empty set when resolving characters.");
-  return e;
-}
-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,
-      resolution: 1,
-      padding: 4,
-      skipKerning: !1,
-      textureStyle: null
-    }, this.measureCache = Qe(1e3);
-  }
-  /**
-   * Get a font for the specified text and style.
-   * @param text - The text to get the font for
-   * @param style - The style to use
-   */
-  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) : (t._stroke || t.dropShadow) && (r = `${t.styleKey}-bitmap`, i = !1), !G.has(r)) {
-      const a = Object.create(t);
-      a.lineHeight = 0;
-      const u = new Pe({
-        style: a,
-        overrideFill: i,
-        overrideSize: !0,
-        ...this.defaultOptions
-      });
-      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,
-        u
-      );
-    }
-    const n = G.get(r);
-    return (s = n.ensureCharacters) == null || s.call(n, e), n;
-  }
-  /**
-   * Get the layout of a text for the specified style.
-   * @param text - The text to get the layout for
-   * @param style - The style to use
-   * @param trimEnd - Whether to ignore whitespaces at the end of each line
-   */
-  getLayout(e, t, r = !0) {
-    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.
-   * @param text - The text to measure
-   * @param style - The style to use
-   * @param trimEnd - Whether to ignore whitespaces at the end of each line
-   */
-  measureText(e, t, r = !0) {
-    return this.getLayout(e, t, r);
-  }
-  // eslint-disable-next-line max-len
-  install(...e) {
-    var l, h, c, d;
-    let t = e[0];
-    typeof t == "string" && (t = {
-      name: t,
-      style: e[1],
-      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.");
-    t = { ...this.defaultOptions, ...t };
-    const i = t.style, n = i instanceof q ? i : new q(i), s = t.dynamicFill ?? this._canUseTintForStyle(n), a = new Pe({
-      style: n,
-      overrideFill: s,
-      skipKerning: t.skipKerning,
-      padding: t.padding,
-      resolution: t.resolution,
-      overrideSize: !1,
-      textureStyle: t.textureStyle
-    }), 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.
-   * @param {string} name - The name of the bitmap font to uninstall.
-   */
-  uninstall(e) {
-    const t = `${e}-bitmap`, r = G.get(t);
-    r && r.destroy();
-  }
-  /**
-   * Determines if a style can use tinting instead of baking colors into the bitmap.
-   * Tinting is more efficient as it allows reusing the same bitmap with different colors.
-   * @param style - The text style to evaluate
-   * @returns true if the style can use tinting, false if colors must be baked in
-   * @private
-   */
-  _canUseTintForStyle(e) {
-    return !e._stroke && (!e.dropShadow || e.dropShadow.color === 0) && !e._fill.fill && e._fill.color === 16777215;
-  }
-}
-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;
-  }
-  push(e, t, r) {
-    this._renderer.renderPipes.batch.break(r), r.add({
-      renderPipeId: "filter",
-      canBundle: !1,
-      action: "pushFilter",
-      container: t,
-      filterEffect: e
-    });
-  }
-  pop(e, t, r) {
-    this._renderer.renderPipes.batch.break(r), r.add({
-      renderPipeId: "filter",
-      action: "popFilter",
-      canBundle: !1
-    });
-  }
-  execute(e) {
-    e.action === "pushFilter" ? this._renderer.filter.push(e) : e.action === "popFilter" && this._renderer.filter.pop();
-  }
-  destroy() {
-    this._renderer = null;
-  }
-}
-tt.extension = {
-  type: [
-    y.WebGLPipes,
-    y.WebGPUPipes,
-    y.CanvasPipes
-  ],
-  name: "filter"
-};
-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];
-    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 rr = new me({
-  attributes: {
-    aPosition: {
-      buffer: new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]),
-      format: "float32x2",
-      stride: 8,
-      offset: 0
-    }
-  },
-  indexBuffer: new Uint32Array([0, 1, 2, 0, 2, 3])
-});
-class ir {
-  constructor() {
-    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 rt {
-  constructor(e) {
-    this._filterStackIndex = 0, this._filterStack = [], this._filterGlobalUniforms = new Y({
-      uInputSize: { value: new Float32Array(4), type: "vec4<f32>" },
-      uInputPixel: { value: new Float32Array(4), type: "vec4<f32>" },
-      uInputClamp: { value: new Float32Array(4), type: "vec4<f32>" },
-      uOutputFrame: { value: new Float32Array(4), type: "vec4<f32>" },
-      uGlobalFrame: { value: new Float32Array(4), type: "vec4<f32>" },
-      uOutputTexture: { value: new Float32Array(4), type: "vec4<f32>" }
-    }), this._globalFilterBindGroup = new He({}), this.renderer = e;
-  }
-  /**
-   * The back texture of the currently active filter. Requires the filter to have `blendRequired` set to true.
-   * @readonly
-   */
-  get activeBackTexture() {
-    var e;
-    return (e = this._activeFilterData) == null ? void 0 : e.backTexture;
-  }
-  /**
-   * Pushes a filter instruction onto the filter stack.
-   * @param instruction - The instruction containing the filter effect and container.
-   * @internal
-   */
-  push(e) {
-    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.every((f) => !f.enabled)) {
-      i.skip = !0;
-      return;
-    }
-    const u = i.bounds;
-    if (this._calculateFilterArea(e, u), this._calculateFilterBounds(i, t.renderTarget.rootViewPort, a, s, 1), i.skip)
-      return;
-    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,
-      c,
-      d,
-      h,
-      n.width,
-      n.height
-    ), this._setupFilterTextures(i, u, t, l);
-  }
-  /**
-   * Applies filters to a texture.
-   *
-   * This method takes a texture and a list of filters, applies the filters to the texture,
-   * and returns the resulting texture.
-   * @param {object} params - The parameters for applying filters.
-   * @param {Texture} params.texture - The texture to apply filters to.
-   * @param {Filter[]} params.filters - The filters to apply.
-   * @returns {Texture} The resulting texture after all filters have been applied.
-   * @example
-   *
-   * ```ts
-   * // Create a texture and a list of filters
-   * const texture = new Texture(...);
-   * const filters = [new BlurFilter(), new ColorMatrixFilter()];
-   *
-   * // Apply the filters to the texture
-   * const resultTexture = filterSystem.applyToTexture({ texture, filters });
-   *
-   * // Use the resulting texture
-   * sprite.texture = resultTexture;
-   * ```
-   *
-   * Key Points:
-   * 1. padding is not currently supported here - so clipping may occur with filters that use padding.
-   * 2. If all filters are disabled or skipped, the original texture is returned.
-   */
-  generateFilteredTexture({ texture: e, filters: t }) {
-    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.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 u = n;
-    this._calculateGlobalFrame(
-      r,
-      0,
-      0,
-      u,
-      i.width,
-      i.height
-    ), r.outputRenderSurface = A.getOptimalTexture(
-      a.width,
-      a.height,
-      r.resolution,
-      r.antialias
-    ), 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() {
-    const e = this.renderer, t = this._popFilterData();
-    t.skip || (e.globalUniforms.pop(), e.renderTarget.finishRenderPass(), this._activeFilterData = t, this._applyFiltersToTexture(t, !1), t.blendRequired && A.returnTexture(t.backTexture), A.returnTexture(t.inputTexture));
-  }
-  /**
-   * Copies the last render surface to a texture.
-   * @param lastRenderSurface - The last render surface to copy from.
-   * @param bounds - The bounds of the area to copy.
-   * @param previousBounds - The previous bounds to use for offsetting the copy.
-   */
-  getBackTexture(e, t, r) {
-    const i = e.colorTexture.source._resolution, n = A.getOptimalTexture(
-      t.width,
-      t.height,
-      i,
-      !1
-    );
-    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 u = Math.ceil(t.width * i), l = Math.ceil(t.height * i);
-    return this.renderer.renderTarget.copyToTexture(
-      e,
-      n,
-      { x: s, y: a },
-      { width: u, height: l },
-      { x: 0, y: 0 }
-    ), n;
-  }
-  /**
-   * Applies a filter to a texture.
-   * @param filter - The filter to apply.
-   * @param input - The input texture.
-   * @param output - The output render surface.
-   * @param clear - Whether to clear the output surface before applying the filter.
-   */
-  applyFilter(e, t, r, i) {
-    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, 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_.
-   *
-   * Use `outputMatrix * vTextureCoord` in the shader.
-   * @param outputMatrix - The matrix to output to.
-   * @param {Sprite} sprite - The sprite to map to.
-   * @returns The mapped matrix.
-   */
-  calculateSpriteMatrix(e, t) {
-    const r = this._activeFilterData, i = e.set(
-      r.inputTexture._source.width,
-      0,
-      0,
-      r.inputTexture._source.height,
-      r.bounds.minX,
-      r.bounds.minY
-    ), 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.
-   * @param filter - The filter to apply
-   * @param input - The input texture
-   * @param renderer - The renderer instance
-   */
-  _setupBindGroupsAndRender(e, t, r) {
-    if (r.renderPipes.uniformBatch) {
-      const i = r.renderPipes.uniformBatch.getUboResource(this._filterGlobalUniforms);
-      this._globalFilterBindGroup.setResource(i, 0);
-    } else
-      this._globalFilterBindGroup.setResource(this._filterGlobalUniforms, 0);
-    this._globalFilterBindGroup.setResource(t.source, 1), this._globalFilterBindGroup.setResource(t.source.style, 2), e.groups[0] = this._globalFilterBindGroup, r.encoder.draw({
-      geometry: rr,
-      shader: e,
-      state: e._state,
-      topology: "triangle-list"
-    }), r.type === xe.WEBGL && r.renderTarget.finishRenderPass();
-  }
-  /**
-   * Sets up the filter textures including input texture and back texture if needed.
-   * @param filterData - The filter data to update
-   * @param bounds - The bounds for the texture
-   * @param renderer - The renderer instance
-   * @param previousFilterData - The previous filter data for back texture calculation
-   */
-  _setupFilterTextures(e, t, r, i) {
-    if (e.backTexture = M.EMPTY, e.inputTexture = A.getOptimalTexture(
-      t.width,
-      t.height,
-      e.resolution,
-      e.antialias
-    ), 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
-    });
-  }
-  /**
-   * Calculates and sets the global frame for the filter.
-   * @param filterData - The filter data to update
-   * @param offsetX - The X offset
-   * @param offsetY - The Y offset
-   * @param globalResolution - The global resolution
-   * @param sourceWidth - The source texture width
-   * @param sourceHeight - The source texture height
-   */
-  _calculateGlobalFrame(e, t, r, i, n, s) {
-    const a = e.globalFrame;
-    a.x = t * i, a.y = r * i, a.width = n * i, a.height = s * i;
-  }
-  /**
-   * Updates the filter uniforms with the current filter state.
-   * @param input - The input texture
-   * @param output - The output render surface
-   * @param filterData - The current filter data
-   * @param offsetX - The X offset for positioning
-   * @param offsetY - The Y offset for positioning
-   * @param resolution - The current resolution
-   * @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, 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.
-   * @param rootResolution - The fallback root resolution to use
-   * @returns The resolution from the previous filter or root resolution
-   */
-  _findFilterResolution(e) {
-    let t = this._filterStackIndex - 1;
-    for (; t > 0 && this._filterStack[t].skip; )
-      --t;
-    return t > 0 && this._filterStack[t].inputTexture ? this._filterStack[t].inputTexture.source._resolution : e;
-  }
-  /**
-   * Finds the offset from the previous non-skipped filter in the stack.
-   * @returns The offset coordinates from the previous filter
-   */
-  _findPreviousFilterOffset() {
-    let e = 0, t = 0, r = this._filterStackIndex;
-    for (; r > 0; ) {
-      r--;
-      const i = this._filterStack[r];
-      if (!i.skip) {
-        e = i.bounds.minX, t = i.bounds.minY;
-        break;
-      }
-    }
-    return { x: e, y: t };
-  }
-  /**
-   * Calculates the filter area bounds based on the instruction type.
-   * @param instruction - The filter instruction
-   * @param bounds - The bounds object to populate
-   */
-  _calculateFilterArea(e, t) {
-    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, 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 u = e.inputTexture;
-      const l = A.getOptimalTexture(
-        i.width,
-        i.height,
-        u.source._resolution,
-        !1
-      );
-      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[a].apply(this, u, e.outputRenderSurface, t), A.returnTexture(l);
-    }
-  }
-  _calculateFilterBounds(e, t, r, i, n) {
-    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 (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 = !0, d || (d = m.blendRequired);
-    }
-    if (!f) {
-      e.skip = !0;
-      return;
-    }
-    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 = 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 > 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 ir()), this._filterStackIndex++, e;
-  }
-}
-rt.extension = {
-  type: [
-    y.WebGLSystem,
-    y.WebGPUSystem
-  ],
-  name: "filter"
-};
-const it = class nt extends me {
-  constructor(...e) {
-    let t = e[0] ?? {};
-    t instanceof Float32Array && (z(L, "use new MeshGeometry({ positions, uvs, indices }) instead"), t = {
-      positions: t,
-      uvs: e[1],
-      indices: e[2]
-    }), 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]));
-    const n = t.indices || new Uint32Array([0, 1, 2, 0, 2, 3]), s = t.shrinkBuffersToFit, a = new N({
-      data: r,
-      label: "attribute-mesh-positions",
-      shrinkToFit: s,
-      usage: D.VERTEX | D.COPY_DST
-    }), u = new N({
-      data: i,
-      label: "attribute-mesh-uvs",
-      shrinkToFit: s,
-      usage: D.VERTEX | D.COPY_DST
-    }), l = new N({
-      data: n,
-      label: "index-mesh-buffer",
-      shrinkToFit: s,
-      usage: D.INDEX | D.COPY_DST
-    });
-    super({
-      attributes: {
-        aPosition: {
-          buffer: a,
-          format: "float32x2",
-          stride: 8,
-          offset: 0
-        },
-        aUV: {
-          buffer: u,
-          format: "float32x2",
-          stride: 8,
-          offset: 0
-        }
-      },
-      indexBuffer: l,
-      topology: t.topology
-    }), this.batchMode = "auto";
-  }
-  /** The positions of the mesh. */
-  get positions() {
-    return this.attributes.aPosition.buffer.data;
-  }
-  /**
-   * Set the positions of the mesh.
-   * When setting the positions, its important that the uvs array is at least as long as the positions array.
-   * otherwise the geometry will not be valid.
-   * @param {Float32Array} value - The positions of the mesh.
-   */
-  set positions(e) {
-    this.attributes.aPosition.buffer.data = e;
-  }
-  /** The UVs of the mesh. */
-  get uvs() {
-    return this.attributes.aUV.buffer.data;
-  }
-  /**
-   * Set the UVs of the mesh.
-   * Its important that the uvs array you set is at least as long as the positions array.
-   * otherwise the geometry will not be valid.
-   * @param {Float32Array} value - The UVs of the mesh.
-   */
-  set uvs(e) {
-    this.attributes.aUV.buffer.data = e;
-  }
-  /** The indices of the mesh. */
-  get indices() {
-    return this.indexBuffer.data;
-  }
-  set indices(e) {
-    this.indexBuffer.data = e;
-  }
-};
-it.defaultOptions = {
-  topology: "triangle-list",
-  shrinkBuffersToFit: !1
-};
-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 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 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 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 (nr(i, n), !W)
-    throw new TypeError("Failed to get canvas 2D context");
-  W.drawImage(
-    t,
-    0,
-    0,
-    i,
-    n,
-    0,
-    0,
-    i * r,
-    n * r
-  );
-  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.
-   *
-   * Generates a canvas of appropriate size, renders the text with the provided style,
-   * and returns both the canvas/context and a Rectangle representing the text bounds.
-   *
-   * When trim is enabled in the style, the frame will represent the bounds of the
-   * non-transparent pixels, which can be smaller than the full canvas.
-   * @param options - The options for generating the text canvas
-   * @param options.text - The text to render
-   * @param options.style - The style to apply to the text
-   * @param options.resolution - The resolution of the canvas (defaults to 1)
-   * @param options.padding
-   * @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 = 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: l,
-      frame: h
-    };
-  }
-  /**
-   * Returns a canvas and context to the pool.
-   *
-   * This should be called when you're done with the canvas to allow reuse
-   * and prevent memory leaks.
-   * @param canvasAndContext - The canvas and context to return to the pool
-   */
-  returnCanvasAndContext(e) {
-    X.returnCanvasAndContext(e);
-  }
-  /**
-   * Renders text to its canvas, and updates its texture.
-   * @param text - The text to render
-   * @param style - The style of the text
-   * @param padding - The padding of the text
-   * @param resolution - The resolution of the text
-   * @param canvasAndContext - The canvas and context to render the text to
-   */
-  _renderTextToCanvas(e, t, r, i, n) {
-    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 = u;
-    let v, g;
-    const b = t.dropShadow ? 2 : 1;
-    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, 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 ? 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 = ne(t._stroke, a, l, C);
-        }
-        a.shadowColor = "black";
-      }
-      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 < 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,
-          v + r,
-          g + r - R,
-          !0
-        ), t._fill !== void 0 && this._drawLetterSpacing(
-          h[C],
-          t,
-          n,
-          v + r,
-          g + r - R
-        );
-    }
-  }
-  /**
-   * Render the text with letter-spacing.
-   *
-   * This method handles rendering text with the correct letter spacing, using either:
-   * 1. Native letter spacing if supported by the browser
-   * 2. Manual letter spacing calculation if not natively supported
-   *
-   * For manual letter spacing, it calculates the position of each character
-   * based on its width and the desired spacing.
-   * @param text - The text to draw
-   * @param style - The text style to apply
-   * @param canvasAndContext - The canvas and context to draw to
-   * @param x - Horizontal position to draw the text
-   * @param y - Vertical position to draw the text
-   * @param isStroke - Whether to render the stroke (true) or fill (false)
-   * @private
-   */
-  _drawLetterSpacing(e, t, r, i, n, s = !1) {
-    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 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 ue = new ar(), ze = "http://www.w3.org/2000/svg", ke = "http://www.w3.org/1999/xhtml";
-class st {
-  constructor() {
-    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 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 u = e.padding * 2;
-  return {
-    width: a.width - u,
-    height: a.height - u
-  };
-}
-class ur {
-  constructor() {
-    this.batches = [], this.batched = !1;
-  }
-  destroy() {
-    this.batches.forEach((e) => {
-      re.return(e);
-    }), this.batches.length = 0;
-  }
-}
-class at {
-  constructor(e, t) {
-    this.state = te.for2d(), this.renderer = e, this._adaptor = t, this.renderer.runners.contextChange.add(this);
-  }
-  contextChange() {
-    this._adaptor.contextChange(this.renderer);
-  }
-  validateRenderable(e) {
-    const t = e.context, r = !!e._gpuData, i = this.renderer.graphicsContext.updateGpuContext(t);
-    return !!(i.isBatchable || r !== i.isBatchable);
-  }
-  addRenderable(e, t) {
-    const r = this.renderer.graphicsContext.updateGpuContext(e.context);
-    e.didViewUpdate && this._rebuild(e), r.isBatchable ? this._addToBatcher(e, t) : (this.renderer.renderPipes.batch.break(t), t.add(e));
-  }
-  updateRenderable(e) {
-    const r = this._getGpuDataForRenderable(e).batches;
-    for (let i = 0; i < r.length; i++) {
-      const n = r[i];
-      n._batcher.updateElement(n);
-    }
-  }
-  execute(e) {
-    if (!e.isRenderable)
-      return;
-    const t = this.renderer, r = e.context;
-    if (!t.graphicsContext.getGpuContext(r).batches.length)
-      return;
-    const n = r.customShader || this._adaptor.shader;
-    this.state.blendMode = e.groupBlendMode;
-    const s = n.resources.localUniforms.uniforms;
-    s.uTransformMatrix = e.groupTransform, s.uRound = t._roundPixels | e._roundPixels, se(
-      e.groupColorAlpha,
-      s.uColor,
-      0
-    ), this._adaptor.execute(this, e);
-  }
-  _rebuild(e) {
-    const t = this._getGpuDataForRenderable(e), r = this.renderer.graphicsContext.updateGpuContext(e.context);
-    t.destroy(), r.isBatchable && this._updateBatchesForRenderable(e, t);
-  }
-  _addToBatcher(e, t) {
-    const r = this.renderer.renderPipes.batch, i = this._getGpuDataForRenderable(e).batches;
-    for (let n = 0; n < i.length; n++) {
-      const s = i[n];
-      r.addToBatch(s, t);
-    }
-  }
-  _getGpuDataForRenderable(e) {
-    return e._gpuData[this.renderer.uid] || this._initGpuDataForRenderable(e);
-  }
-  _initGpuDataForRenderable(e) {
-    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 = re.get(zt);
-      return s.copyTo(a), a.renderable = e, a.roundPixels = n, a;
-    });
-  }
-  destroy() {
-    this.renderer = null, this._adaptor.destroy(), this._adaptor = null, this.state = null;
-  }
-}
-at.extension = {
-  type: [
-    y.WebGLPipes,
-    y.WebGPUPipes,
-    y.CanvasPipes
-  ],
-  name: "graphics"
-};
-const ot = class ut extends be {
-  constructor(...e) {
-    super({});
-    let t = e[0] ?? {};
-    typeof t == "number" && (z(L, "PlaneGeometry constructor changed please use { width, height, verticesX, verticesY } instead"), t = {
-      width: t,
-      height: e[1],
-      verticesX: e[2],
-      verticesY: e[3]
-    }), this.build(t);
-  }
-  /**
-   * Refreshes plane coordinates
-   * @param options - Options to be applied to plane geometry
-   */
-  build(e) {
-    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 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(
-        x,
-        _,
-        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();
-  }
-};
-ot.defaultOptions = {
-  width: 100,
-  height: 100,
-  verticesX: 10,
-  verticesY: 10
-};
-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;
-  }
-  get blendMode() {
-    return this.renderable.groupBlendMode;
-  }
-  get topology() {
-    return this._topology || this.geometry.topology;
-  }
-  set topology(e) {
-    this._topology = e;
-  }
-  reset() {
-    this.renderable = null, this.texture = null, this._batcher = null, this._batch = null, this.geometry = null, this._uvUpdateId = -1, this._textureMatrixUpdateId = -1;
-  }
-  /**
-   * Sets the texture for the batchable mesh.
-   * As it does so, it resets the texture matrix update ID.
-   * this is to ensure that the texture matrix is recalculated when the uvs are referenced
-   * @param value - The texture to set.
-   */
-  setTexture(e) {
-    this.texture !== e && (this.texture = e, this._textureMatrixUpdateId = -1);
-  }
-  get uvs() {
-    const t = this.geometry.getBuffer("aUV"), r = t.data;
-    let i = r;
-    const n = this.texture.textureMatrix;
-    return n.isSimple || (i = this._transformedUvs, (this._textureMatrixUpdateId !== n._updateID || this._uvUpdateId !== t._updateID) && ((!i || i.length < r.length) && (i = this._transformedUvs = new Float32Array(r.length)), this._textureMatrixUpdateId = n._updateID, this._uvUpdateId = t._updateID, n.multiplyUvs(r, i))), i;
-  }
-  get positions() {
-    return this.geometry.positions;
-  }
-  get indices() {
-    return this.geometry.indices;
-  }
-  get color() {
-    return this.renderable.groupColorAlpha;
-  }
-  get groupTransform() {
-    return this.renderable.groupTransform;
-  }
-  get attributeSize() {
-    return this.geometry.positions.length / 2;
-  }
-  get indexSize() {
-    return this.geometry.indices.length;
-  }
-}
-class Ae {
-  destroy() {
-  }
-}
-class lt {
-  constructor(e, t) {
-    this.localUniforms = new Y({
-      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 He({
-      0: this.localUniforms
-    }), this.renderer = e, this._adaptor = t, this._adaptor.init();
-  }
-  validateRenderable(e) {
-    const t = this._getMeshData(e), r = t.batched, i = e.batched;
-    if (t.batched = i, r !== i)
-      return !0;
-    if (i) {
-      const n = e._geometry;
-      if (n.indices.length !== t.indexSize || n.positions.length !== t.vertexSize)
-        return t.indexSize = n.indices.length, t.vertexSize = n.positions.length, !0;
-      const s = this._getBatchableMesh(e);
-      return s.texture.uid !== e._texture.uid && (s._textureMatrixUpdateId = -1), !s._batcher.checkAndUpdateTexture(
-        s,
-        e._texture
-      );
-    }
-    return !1;
-  }
-  addRenderable(e, t) {
-    var n, s;
-    const r = this.renderer.renderPipes.batch, i = this._getMeshData(e);
-    if (e.didViewUpdate && (i.indexSize = (n = e._geometry.indices) == null ? void 0 : n.length, i.vertexSize = (s = e._geometry.positions) == null ? void 0 : s.length), i.batched) {
-      const a = this._getBatchableMesh(e);
-      a.setTexture(e._texture), a.geometry = e._geometry, r.addToBatch(a, t);
-    } else
-      r.break(t), t.add(e);
-  }
-  updateRenderable(e) {
-    if (e.batched) {
-      const t = this._getBatchableMesh(e);
-      t.setTexture(e._texture), t.geometry = e._geometry, t._batcher.updateElement(t);
-    }
-  }
-  execute(e) {
-    if (!e.isRenderable)
-      return;
-    e.state.blendMode = _e(e.groupBlendMode, e.texture._source);
-    const t = this.localUniforms;
-    t.uniforms.uTransformMatrix = e.groupTransform, t.uniforms.uRound = this.renderer._roundPixels | e._roundPixels, t.update(), se(
-      e.groupColorAlpha,
-      t.uniforms.uColor,
-      0
-    ), this._adaptor.execute(this, e);
-  }
-  _getMeshData(e) {
-    var t, r;
-    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 = {
-      batched: e.batched,
-      indexSize: 0,
-      vertexSize: 0
-    }, e._gpuData[this.renderer.uid].meshData;
-  }
-  _getBatchableMesh(e) {
-    var t, r;
-    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 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;
-  }
-}
-lt.extension = {
-  type: [
-    y.WebGLPipes,
-    y.WebGPUPipes,
-    y.CanvasPipes
-  ],
-  name: "mesh"
-};
-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 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 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);
-    const n = e.state, s = e.getBuffers(t);
-    r.encoder.draw({
-      geometry: s.geometry,
-      shader: t.shader || e.defaultShader,
-      state: n,
-      size: t.particleChildren.length * 6
-    });
-  }
-}
-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}`);
-  for (let r = 0, i = 0; r < t; r += 6, i += 4)
-    e[r + 0] = i + 0, e[r + 1] = i + 1, e[r + 2] = i + 2, e[r + 3] = i + 0, e[r + 4] = i + 2, e[r + 5] = i + 3;
-  return e;
-}
-function dr(o) {
-  return {
-    dynamicUpdate: Oe(o, !0),
-    staticUpdate: Oe(o, !1)
-  };
-}
-function Oe(o, e) {
-  const t = [];
-  t.push(`
-
-        var index = 0;
-
-        for (let i = 0; i < ps.length; ++i)
-        {
-            const p = ps[i];
-
-            `);
-  let r = 0;
-  for (const n in o) {
-    const s = o[n];
-    if (e !== s.dynamic)
-      continue;
-    t.push(`offset = index + ${r}`), t.push(s.code);
-    const a = pe(s.format);
-    r += a.stride / 4;
-  }
-  t.push(`
-            index += stride * 4;
-        }
-    `), t.unshift(`
-        var stride = ${r};
-    `);
-  const i = t.join(`
-`);
-  return new Function("ps", "f32v", "u32v", i);
-}
-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 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 Q(t * 4 * i), this.dynamicAttributeBuffer = new Q(t * 4 * n), this.indexBuffer = De(t);
-    const s = new me();
-    let a = 0, u = 0;
-    this._staticBuffer = new N({
-      data: new Float32Array(1),
-      label: "static-particle-buffer",
-      shrinkToFit: !1,
-      usage: D.VERTEX | D.COPY_DST
-    }), this._dynamicBuffer = new N({
-      data: new Float32Array(1),
-      label: "dynamic-particle-buffer",
-      shrinkToFit: !1,
-      usage: D.VERTEX | D.COPY_DST
-    });
-    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: c.format
-      }), a += d.size) : (s.addAttribute(c.attributeName, {
-        buffer: this._staticBuffer,
-        stride: this._staticStride * 4,
-        offset: u * 4,
-        format: c.format
-      }), u += d.size);
-    }
-    s.addIndex(this.indexBuffer);
-    const l = this.getParticleUpdate(r);
-    this._dynamicUpload = l.dynamicUpdate, this._staticUpload = l.staticUpdate, this.geometry = s;
-  }
-  getParticleUpdate(e) {
-    const t = pr(e);
-    return this._generateParticleUpdateCache[t] ? this._generateParticleUpdateCache[t] : (this._generateParticleUpdateCache[t] = this.generateParticleUpdate(e), this._generateParticleUpdateCache[t]);
-  }
-  generateParticleUpdate(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 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
-    ));
-    const r = this.dynamicAttributeBuffer;
-    if (this._dynamicUpload(e, r.float32View, r.uint32View), this._dynamicBuffer.setDataWithSize(
-      this.dynamicAttributeBuffer.float32View,
-      e.length * this._dynamicStride * 4,
-      !0
-    ), t) {
-      const i = this.staticAttributeBuffer;
-      this._staticUpload(e, i.float32View, i.uint32View), this._staticBuffer.setDataWithSize(
-        i.float32View,
-        e.length * this._staticStride * 4,
-        !0
-      );
-    }
-  }
-  destroy() {
-    this._staticBuffer.destroy(), this._dynamicBuffer.destroy(), this.geometry.destroy();
-  }
-}
-function pr(o) {
-  const e = [];
-  for (const t in o) {
-    const r = o[t];
-    e.push(t, r.code, r.dynamic ? "d" : "s");
-  }
-  return e.join("_");
-}
-var gr = `varying vec2 vUV;
-varying vec4 vColor;
-
-uniform sampler2D uTexture;
-
-void main(void){
-    vec4 color = texture2D(uTexture, vUV) * vColor;
-    gl_FragColor = color;
-}`, mr = `attribute vec2 aVertex;
-attribute vec2 aUV;
-attribute vec4 aColor;
-
-attribute vec2 aPosition;
-attribute float aRotation;
-
-uniform mat3 uTranslationMatrix;
-uniform float uRound;
-uniform vec2 uResolution;
-uniform vec4 uColor;
-
-varying vec2 vUV;
-varying vec4 vColor;
-
-vec2 roundPixels(vec2 position, vec2 targetSize)
-{       
-    return (floor(((position * 0.5 + 0.5) * targetSize) + 0.5) / targetSize) * 2.0 - 1.0;
-}
-
-void main(void){
-    float cosRotation = cos(aRotation);
-    float sinRotation = sin(aRotation);
-    float x = aVertex.x * cosRotation - aVertex.y * sinRotation;
-    float y = aVertex.x * sinRotation + aVertex.y * cosRotation;
-
-    vec2 v = vec2(x, y);
-    v = v + aPosition;
-
-    gl_Position = vec4((uTranslationMatrix * vec3(v, 1.0)).xy, 0.0, 1.0);
-
-    if(uRound == 1.0)
-    {
-        gl_Position.xy = roundPixels(gl_Position.xy, uResolution);
-    }
-
-    vUV = aUV;
-    vColor = vec4(aColor.rgb * aColor.a, aColor.a) * uColor;
-}
-`, Ie = `
-struct ParticleUniforms {
-  uTranslationMatrix:mat3x3<f32>,
-  uColor:vec4<f32>,
-  uRound:f32,
-  uResolution:vec2<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>;
-@group(1) @binding(1) var uSampler : sampler;
-
-struct VSOutput {
-    @builtin(position) position: vec4<f32>,
-    @location(0) uv : vec2<f32>,
-    @location(1) color : vec4<f32>,
-  };
-@vertex
-fn mainVertex(
-  @location(0) aVertex: vec2<f32>,
-  @location(1) aPosition: vec2<f32>,
-  @location(2) aUV: vec2<f32>,
-  @location(3) aColor: vec4<f32>,
-  @location(4) aRotation: f32,
-) -> VSOutput {
-  
-   let v = vec2(
-       aVertex.x * cos(aRotation) - aVertex.y * sin(aRotation),
-       aVertex.x * sin(aRotation) + aVertex.y * cos(aRotation)
-   ) + aPosition;
-
-   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;
-
-  return VSOutput(
-   position,
-   aUV,
-   vColor,
-  );
-}
-
-@fragment
-fn mainFragment(
-  @location(0) uv: vec2<f32>,
-  @location(1) color: vec4<f32>,
-  @builtin(position) position: vec4<f32>,
-) -> @location(0) vec4<f32> {
-
-    var sample = textureSample(uTexture, uSampler, uv) * color;
-   
-    return sample;
-}`;
-class xr extends ve {
-  constructor() {
-    const e = Ee.from({
-      vertex: mr,
-      fragment: gr
-    }), t = Le.from({
-      fragment: {
-        source: Ie,
-        entryPoint: "mainFragment"
-      },
-      vertex: {
-        source: Ie,
-        entryPoint: "mainVertex"
-      }
-    });
-    super({
-      glProgram: e,
-      gpuProgram: t,
-      resources: {
-        // this will be replaced with the texture from the particle container
-        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 U(), type: "mat3x3<f32>" },
-          uColor: { value: new V(16777215), type: "vec4<f32>" },
-          uRound: { value: 1, type: "f32" },
-          uResolution: { value: [0, 0], type: "vec2<f32>" }
-        }
-      }
-    });
-  }
-}
-class ct {
-  /**
-   * @param renderer - The renderer this sprite batch works for.
-   * @param adaptor
-   */
-  constructor(e, t) {
-    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 xr(), this.state = te.for2d();
-  }
-  validateRenderable(e) {
-    return !1;
-  }
-  addRenderable(e, t) {
-    this.renderer.renderPipes.batch.break(t), t.add(e);
-  }
-  getBuffers(e) {
-    return e._gpuData[this.renderer.uid] || this._initBuffer(e);
-  }
-  _initBuffer(e) {
-    return e._gpuData[this.renderer.uid] = new fr({
-      size: e.particleChildren.length,
-      properties: e._properties
-    }), e._gpuData[this.renderer.uid];
-  }
-  updateRenderable(e) {
-  }
-  execute(e) {
-    const t = e.particleChildren;
-    if (t.length === 0)
-      return;
-    const r = this.renderer, i = this.getBuffers(e);
-    e.texture || (e.texture = t[0].texture);
-    const n = this.state;
-    i.update(t, e._childrenDirty), e._childrenDirty = !1, n.blendMode = _e(e.blendMode, e.texture._source);
-    const s = this.localUniforms.uniforms, a = s.uTranslationMatrix;
-    e.worldTransform.copyTo(a), a.prepend(r.globalUniforms.globalUniformData.projectionMatrix), s.uResolution = r.globalUniforms.globalUniformData.resolution, s.uRound = r._roundPixels | e._roundPixels, se(
-      e.groupColorAlpha,
-      s.uColor,
-      0
-    ), this.adaptor.execute(this, e);
-  }
-  /** Destroys the ParticleRenderer. */
-  destroy() {
-    this.renderer = null, this.defaultShader && (this.defaultShader.destroy(), this.defaultShader = null);
-  }
-}
-class ht extends ct {
-  constructor(e) {
-    super(e, new cr());
-  }
-}
-ht.extension = {
-  type: [
-    y.WebGLPipes
-  ],
-  name: "particle"
-};
-class dt extends ct {
-  constructor(e) {
-    super(e, new hr());
-  }
-}
-dt.extension = {
-  type: [
-    y.WebGPUPipes
-  ],
-  name: "particle"
-};
-const ft = class pt extends lr {
-  constructor(e = {}) {
-    e = { ...pt.defaultOptions, ...e }, super({
-      width: e.width,
-      height: e.height,
-      verticesX: 4,
-      verticesY: 4
-    }), this.update(e);
-  }
-  /**
-   * Updates the NineSliceGeometry with the options.
-   * @param options - The options of the NineSliceGeometry.
-   */
-  update(e) {
-    var t, r;
-    this.width = e.width ?? this.width, this.height = e.height ?? this.height, this._originalWidth = e.originalWidth ?? this._originalWidth, this._originalHeight = e.originalHeight ?? this._originalHeight, this._leftWidth = e.leftWidth ?? this._leftWidth, this._rightWidth = e.rightWidth ?? this._rightWidth, this._topHeight = e.topHeight ?? this._topHeight, this._bottomHeight = e.bottomHeight ?? this._bottomHeight, this._anchorX = (t = e.anchor) == null ? void 0 : t.x, this._anchorY = (r = e.anchor) == null ? void 0 : r.y, this.updateUvs(), this.updatePositions();
-  }
-  /** Updates the positions of the vertices. */
-  updatePositions() {
-    const e = this.positions, {
-      width: t,
-      height: r,
-      _leftWidth: i,
-      _rightWidth: n,
-      _topHeight: s,
-      _bottomHeight: a,
-      _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() {
-    const e = this.uvs;
-    e[0] = e[8] = e[16] = e[24] = 0, e[1] = e[3] = e[5] = e[7] = 0, e[6] = e[14] = e[22] = e[30] = 1, e[25] = e[27] = e[29] = e[31] = 1;
-    const t = 1 / this._originalWidth, r = 1 / this._originalHeight;
-    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();
-  }
-};
-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. */
-  height: 100,
-  /** The width of the left column. */
-  leftWidth: 10,
-  /** The height of the top row. */
-  topHeight: 10,
-  /** The width of the right column. */
-  rightWidth: 10,
-  /** The height of the bottom row. */
-  bottomHeight: 10,
-  /** The original width of the texture */
-  originalWidth: 100,
-  /** The original height of the texture */
-  originalHeight: 100
-};
-let _r = ft;
-class vr extends ye {
-  constructor() {
-    super(), this.geometry = new _r();
-  }
-  destroy() {
-    this.geometry.destroy();
-  }
-}
-class gt {
-  constructor(e) {
-    this._renderer = e;
-  }
-  addRenderable(e, t) {
-    const r = this._getGpuSprite(e);
-    e.didViewUpdate && this._updateBatchableSprite(e, r), this._renderer.renderPipes.batch.addToBatch(r, t);
-  }
-  updateRenderable(e) {
-    const t = this._getGpuSprite(e);
-    e.didViewUpdate && this._updateBatchableSprite(e, t), t._batcher.updateElement(t);
-  }
-  validateRenderable(e) {
-    const t = this._getGpuSprite(e);
-    return !t._batcher.checkAndUpdateTexture(
-      t,
-      e._texture
-    );
-  }
-  _updateBatchableSprite(e, t) {
-    t.geometry.update(e), t.setTexture(e._texture);
-  }
-  _getGpuSprite(e) {
-    return e._gpuData[this._renderer.uid] || this._initGPUSprite(e);
-  }
-  _initGPUSprite(e) {
-    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;
-  }
-}
-gt.extension = {
-  type: [
-    y.WebGLPipes,
-    y.WebGPUPipes,
-    y.CanvasPipes
-  ],
-  name: "nineSliceSprite"
-};
-const br = {
-  name: "tiling-bit",
-  vertex: {
-    header: (
-      /* wgsl */
-      `
-            struct TilingUniforms {
-                uMapCoord:mat3x3<f32>,
-                uClampFrame:vec4<f32>,
-                uClampOffset:vec2<f32>,
-                uTextureTransform:mat3x3<f32>,
-                uSizeAnchor:vec4<f32>
-            };
-
-            @group(2) @binding(0) var<uniform> tilingUniforms: TilingUniforms;
-            @group(2) @binding(1) var uTexture: texture_2d<f32>;
-            @group(2) @binding(2) var uSampler: sampler;
-        `
-    ),
-    main: (
-      /* wgsl */
-      `
-            uv = (tilingUniforms.uTextureTransform * vec3(uv, 1.0)).xy;
-
-            position = (position - tilingUniforms.uSizeAnchor.zw) * tilingUniforms.uSizeAnchor.xy;
-        `
-    )
-  },
-  fragment: {
-    header: (
-      /* wgsl */
-      `
-            struct TilingUniforms {
-                uMapCoord:mat3x3<f32>,
-                uClampFrame:vec4<f32>,
-                uClampOffset:vec2<f32>,
-                uTextureTransform:mat3x3<f32>,
-                uSizeAnchor:vec4<f32>
-            };
-
-            @group(2) @binding(0) var<uniform> tilingUniforms: TilingUniforms;
-            @group(2) @binding(1) var uTexture: texture_2d<f32>;
-            @group(2) @binding(2) var uSampler: sampler;
-        `
-    ),
-    main: (
-      /* wgsl */
-      `
-
-            var coord = vUV + ceil(tilingUniforms.uClampOffset - vUV);
-            coord = (tilingUniforms.uMapCoord * vec3(coord, 1.0)).xy;
-            var unclamped = coord;
-            coord = clamp(coord, tilingUniforms.uClampFrame.xy, tilingUniforms.uClampFrame.zw);
-
-            var bias = 0.;
-
-            if(unclamped.x == coord.x && unclamped.y == coord.y)
-            {
-                bias = -32.;
-            }
-
-            outColor = textureSampleBias(uTexture, uSampler, coord, bias);
-        `
-    )
-  }
-}, yr = {
-  name: "tiling-bit",
-  vertex: {
-    header: (
-      /* glsl */
-      `
-            uniform mat3 uTextureTransform;
-            uniform vec4 uSizeAnchor;
-
-        `
-    ),
-    main: (
-      /* glsl */
-      `
-            uv = (uTextureTransform * vec3(aUV, 1.0)).xy;
-
-            position = (position - uSizeAnchor.zw) * uSizeAnchor.xy;
-        `
-    )
-  },
-  fragment: {
-    header: (
-      /* glsl */
-      `
-            uniform sampler2D uTexture;
-            uniform mat3 uMapCoord;
-            uniform vec4 uClampFrame;
-            uniform vec2 uClampOffset;
-        `
-    ),
-    main: (
-      /* glsl */
-      `
-
-        vec2 coord = vUV + ceil(uClampOffset - vUV);
-        coord = (uMapCoord * vec3(coord, 1.0)).xy;
-        vec2 unclamped = coord;
-        coord = clamp(coord, uClampFrame.xy, uClampFrame.zw);
-
-        outColor = texture(uTexture, coord, unclamped == coord ? 0.0 : -32.0);// lod-bias very negative to force lod 0
-
-        `
-    )
-  }
-};
-let le, ce;
-class Tr extends ve {
-  constructor() {
-    le ?? (le = Ye({
-      name: "tiling-sprite-shader",
-      bits: [
-        Et,
-        br,
-        Xe
-      ]
-    })), ce ?? (ce = $e({
-      name: "tiling-sprite-shader",
-      bits: [
-        Ht,
-        yr,
-        Ne
-      ]
-    }));
-    const e = new Y({
-      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 U(), type: "mat3x3<f32>" },
-      uSizeAnchor: { value: new Float32Array([100, 100, 0.5, 0.5]), type: "vec4<f32>" }
-    });
-    super({
-      glProgram: ce,
-      gpuProgram: le,
-      resources: {
-        localUniforms: new Y({
-          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: M.EMPTY.source,
-        uSampler: M.EMPTY.source.style
-      }
-    });
-  }
-  updateUniforms(e, t, r, i, n, s) {
-    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
-    ), 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 wr extends be {
-  constructor() {
-    super({
-      positions: new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]),
-      uvs: new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]),
-      indices: new Uint32Array([0, 1, 2, 0, 2, 3])
-    });
-  }
-}
-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 Cr(o, e, t, r) {
-  let i = 0;
-  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 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 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 = 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 Z = new wr();
-class Fr {
-  constructor() {
-    this.canBatch = !0, this.geometry = new be({
-      indices: Z.indices.slice(),
-      positions: Z.positions.slice(),
-      uvs: Z.uvs.slice()
-    });
-  }
-  destroy() {
-    var e;
-    this.geometry.destroy(), (e = this.shader) == null || e.destroy();
-  }
-}
-class mt {
-  constructor(e) {
-    this._state = te.default2d, this._renderer = e;
-  }
-  validateRenderable(e) {
-    const t = this._getTilingSpriteData(e), r = t.canBatch;
-    this._updateCanBatch(e);
-    const i = t.canBatch;
-    if (i && i === r) {
-      const { batchableMesh: n } = t;
-      return !n._batcher.checkAndUpdateTexture(
-        n,
-        e.texture
-      );
-    }
-    return r !== i;
-  }
-  addRenderable(e, t) {
-    const r = this._renderer.renderPipes.batch;
-    this._updateCanBatch(e);
-    const i = this._getTilingSpriteData(e), { geometry: n, canBatch: s } = i;
-    if (s) {
-      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 Tr()), this.updateRenderable(e), t.add(e);
-  }
-  execute(e) {
-    const { shader: t } = this._getTilingSpriteData(e);
-    t.groups[0] = this._renderer.globalUniforms.bindGroup;
-    const r = t.resources.localUniforms.uniforms;
-    r.uTransformMatrix = e.groupTransform, r.uRound = this._renderer._roundPixels | e._roundPixels, se(
-      e.groupColorAlpha,
-      r.uColor,
-      0
-    ), this._state.blendMode = _e(e.groupBlendMode, e.texture._source), this._renderer.encoder.draw({
-      geometry: Z,
-      shader: t,
-      state: this._state
-    });
-  }
-  updateRenderable(e) {
-    const t = this._getTilingSpriteData(e), { canBatch: r } = t;
-    if (r) {
-      const { batchableMesh: i } = t;
-      e.didViewUpdate && this._updateBatchableMesh(e), i._batcher.updateElement(i);
-    } else if (e.didViewUpdate) {
-      const { shader: i } = t;
-      i.updateUniforms(
-        e.width,
-        e.height,
-        e._tileTransform.matrix,
-        e.anchor.x,
-        e.anchor.y,
-        e.texture
-      );
-    }
-  }
-  _getTilingSpriteData(e) {
-    return e._gpuData[this._renderer.uid] || this._initTilingSpriteData(e);
-  }
-  _initTilingSpriteData(e) {
-    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()), Pr(e, r.uvs), Sr(e, r.positions);
-  }
-  destroy() {
-    this._renderer = null;
-  }
-  _updateCanBatch(e) {
-    const t = this._getTilingSpriteData(e), r = e.texture;
-    let i = !0;
-    return this._renderer.type === xe.WEBGL && (i = this._renderer.context.supports.nonPowOf2wrapping), t.canBatch = r.textureMatrix.isSimple && (i || r.source.isPowerOfTwo), t.canBatch;
-  }
-}
-mt.extension = {
-  type: [
-    y.WebGLPipes,
-    y.WebGPUPipes,
-    y.CanvasPipes
-  ],
-  name: "tilingSprite"
-};
-const Br = {
-  name: "local-uniform-msdf-bit",
-  vertex: {
-    header: (
-      /* wgsl */
-      `
-            struct LocalUniforms {
-                uColor:vec4<f32>,
-                uTransformMatrix:mat3x3<f32>,
-                uDistance: f32,
-                uRound:f32,
-            }
-
-            @group(2) @binding(0) var<uniform> localUniforms : LocalUniforms;
-        `
-    ),
-    main: (
-      /* wgsl */
-      `
-            vColor *= localUniforms.uColor;
-            modelMatrix *= localUniforms.uTransformMatrix;
-        `
-    ),
-    end: (
-      /* wgsl */
-      `
-            if(localUniforms.uRound == 1)
-            {
-                vPosition = vec4(roundPixels(vPosition.xy, globalUniforms.uResolution), vPosition.zw);
-            }
-        `
-    )
-  },
-  fragment: {
-    header: (
-      /* wgsl */
-      `
-            struct LocalUniforms {
-                uColor:vec4<f32>,
-                uTransformMatrix:mat3x3<f32>,
-                uDistance: f32
-            }
-
-            @group(2) @binding(0) var<uniform> localUniforms : LocalUniforms;
-         `
-    ),
-    main: (
-      /* wgsl */
-      `
-            outColor = vec4<f32>(calculateMSDFAlpha(outColor, localUniforms.uColor, localUniforms.uDistance));
-        `
-    )
-  }
-}, Rr = {
-  name: "local-uniform-msdf-bit",
-  vertex: {
-    header: (
-      /* glsl */
-      `
-            uniform mat3 uTransformMatrix;
-            uniform vec4 uColor;
-            uniform float uRound;
-        `
-    ),
-    main: (
-      /* glsl */
-      `
-            vColor *= uColor;
-            modelMatrix *= uTransformMatrix;
-        `
-    ),
-    end: (
-      /* glsl */
-      `
-            if(uRound == 1.)
-            {
-                gl_Position.xy = roundPixels(gl_Position.xy, uResolution);
-            }
-        `
-    )
-  },
-  fragment: {
-    header: (
-      /* glsl */
-      `
-            uniform float uDistance;
-         `
-    ),
-    main: (
-      /* glsl */
-      `
-            outColor = vec4(calculateMSDFAlpha(outColor, vColor, uDistance));
-        `
-    )
-  }
-}, Mr = {
-  name: "msdf-bit",
-  fragment: {
-    header: (
-      /* wgsl */
-      `
-            fn calculateMSDFAlpha(msdfColor:vec4<f32>, shapeColor:vec4<f32>, distance:f32) -> f32 {
-
-                // MSDF
-                var median = msdfColor.r + msdfColor.g + msdfColor.b -
-                    min(msdfColor.r, min(msdfColor.g, msdfColor.b)) -
-                    max(msdfColor.r, max(msdfColor.g, msdfColor.b));
-
-                // SDF
-                median = min(median, msdfColor.a);
-
-                var screenPxDistance = distance * (median - 0.5);
-                var alpha = clamp(screenPxDistance + 0.5, 0.0, 1.0);
-                if (median < 0.01) {
-                    alpha = 0.0;
-                } else if (median > 0.99) {
-                    alpha = 1.0;
-                }
-
-                // Gamma correction for coverage-like alpha
-                var luma: f32 = dot(shapeColor.rgb, vec3<f32>(0.299, 0.587, 0.114));
-                var gamma: f32 = mix(1.0, 1.0 / 2.2, luma);
-                var coverage: f32 = pow(shapeColor.a * alpha, gamma);
-
-                return coverage;
-
-            }
-        `
-    )
-  }
-}, Ur = {
-  name: "msdf-bit",
-  fragment: {
-    header: (
-      /* glsl */
-      `
-            float calculateMSDFAlpha(vec4 msdfColor, vec4 shapeColor, float distance) {
-
-                // MSDF
-                float median = msdfColor.r + msdfColor.g + msdfColor.b -
-                                min(msdfColor.r, min(msdfColor.g, msdfColor.b)) -
-                                max(msdfColor.r, max(msdfColor.g, msdfColor.b));
-
-                // SDF
-                median = min(median, msdfColor.a);
-
-                float screenPxDistance = distance * (median - 0.5);
-                float alpha = clamp(screenPxDistance + 0.5, 0.0, 1.0);
-
-                if (median < 0.01) {
-                    alpha = 0.0;
-                } else if (median > 0.99) {
-                    alpha = 1.0;
-                }
-
-                // Gamma correction for coverage-like alpha
-                float luma = dot(shapeColor.rgb, vec3(0.299, 0.587, 0.114));
-                float gamma = mix(1.0, 1.0 / 2.2, luma);
-                float coverage = pow(shapeColor.a * alpha, gamma);
-
-                return coverage;
-            }
-        `
-    )
-  }
-};
-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 U(), type: "mat3x3<f32>" },
-      uDistance: { value: 4, type: "f32" },
-      uRound: { value: 0, type: "f32" }
-    });
-    he ?? (he = Ye({
-      name: "sdf-shader",
-      bits: [
-        kt,
-        Gt(e),
-        Br,
-        Mr,
-        Xe
-      ]
-    })), de ?? (de = $e({
-      name: "sdf-shader",
-      bits: [
-        At,
-        Dt(e),
-        Rr,
-        Ur,
-        Ne
-      ]
-    })), super({
-      glProgram: de,
-      gpuProgram: he,
-      resources: {
-        localUniforms: t,
-        batchSamplers: Ot(e)
-      }
-    });
-  }
-}
-class kr extends It {
-  destroy() {
-    this.context.customShader && this.context.customShader.destroy(), super.destroy();
-  }
-}
-class xt {
-  constructor(e) {
-    this._renderer = e;
-  }
-  validateRenderable(e) {
-    const t = this._getGpuBitmapText(e);
-    return this._renderer.renderPipes.graphics.validateRenderable(t);
-  }
-  addRenderable(e, t) {
-    const r = this._getGpuBitmapText(e);
-    We(e, r), e._didTextUpdate && (e._didTextUpdate = !1, this._updateContext(e, r)), this._renderer.renderPipes.graphics.addRenderable(r, t), r.context.customShader && this._updateDistanceField(e);
-  }
-  updateRenderable(e) {
-    const t = this._getGpuBitmapText(e);
-    We(e, t), this._renderer.renderPipes.graphics.updateRenderable(t), t.context.customShader && this._updateDistanceField(e);
-  }
-  _updateContext(e, t) {
-    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 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 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[m] + S.xOffset),
-            Math.round(a + S.yOffset + v),
-            B.orig.width,
-            B.orig.height
-          );
-        }
-      }
-      a += _;
-    }
-  }
-  _getGpuBitmapText(e) {
-    return e._gpuData[this._renderer.uid] || this.initGpuText(e);
-  }
-  initGpuText(e) {
-    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: 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;
-  }
-}
-xt.extension = {
-  type: [
-    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 Gr extends Ke {
-  /**
-   * Creates an instance of BatchableHTMLText.
-   * @param renderer - The renderer instance to be used.
-   */
-  constructor(e) {
-    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() {
-    const e = this.renderable;
-    e._autoResolution && e.onViewUpdate();
-  }
-  /** Destroys the BatchableHTMLText instance. Returns the texture promise to the renderer and cleans up references. */
-  destroy() {
-    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();
-  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 _t {
-  constructor(e) {
-    this._renderer = e;
-  }
-  validateRenderable(e) {
-    const t = this._getGpuText(e), r = e.styleKey;
-    return t.currentKey !== r;
-  }
-  addRenderable(e, t) {
-    const r = this._getGpuText(e);
-    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);
-    t._batcher.updateElement(t);
-  }
-  async _updateGpuText(e) {
-    e._didTextUpdate = !1;
-    const t = this._getGpuText(e);
-    if (t.generatingTexture)
-      return;
-    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 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;
-  }
-}
-_t.extension = {
-  type: [
-    y.WebGLPipes,
-    y.WebGPUPipes,
-    y.CanvasPipes
-  ],
-  name: "htmlText"
-};
-function Ar() {
-  const { userAgent: o } = H.get().getNavigator();
-  return /^((?!chrome|android).)*safari/i.test(o);
-}
-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,
-    i.height,
-    r,
-    !1
-  );
-  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 Or(o, e) {
-  const t = e.fontFamily, r = [], i = {}, n = /font-family:([^;"\s]+)/g, s = o.match(n);
-  function a(u) {
-    i[u] || (r.push(u), i[u] = !0);
-  }
-  if (Array.isArray(t))
-    for (let u = 0; u < t.length; u++)
-      a(t[u]);
-  else
-    a(t);
-  s && s.forEach((u) => {
-    const l = u.split(":")[1].trim();
-    a(l);
-  });
-  for (const u in e.tagStyles) {
-    const l = e.tagStyles[u].fontFamily;
-    a(l);
-  }
-  return r;
-}
-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 Wr(o, e) {
-  const t = await Ir(e);
-  return `@font-face {
-        font-family: "${o.fontFamily}";
-        font-weight: ${o.fontWeight};
-        font-style: ${o.fontStyle};
-        src: url('${t}');
-    }`;
-}
-const fe = /* @__PURE__ */ new Map();
-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, u = n.faces.map((l) => ({ weight: l.weight, style: l.style }));
-        i.push(
-          ...u.map(
-            (l) => Wr(
-              {
-                fontWeight: l.weight,
-                fontStyle: l.style,
-                fontFamily: t
-              },
-              s
-            )
-          )
-        );
-      }), fe.set(
-        t,
-        Promise.all(i).then((n) => n.join(`
-`))
-      );
-    }
-    return fe.get(t);
-  });
-  return (await Promise.all(e)).join(`
-`);
-}
-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: u, height: l } = i.image;
-  return a.setAttribute("width", u.toString()), a.setAttribute("height", l.toString()), new XMLSerializer().serializeToString(a);
-}
-function Hr(o, e) {
-  const t = X.getOptimalCanvasAndContext(
-    o.width,
-    o.height,
-    e
-  ), { context: r } = t;
-  return r.clearRect(0, 0, o.width, o.height), r.drawImage(o, 0, 0), t;
-}
-function 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 bt {
-  constructor(e) {
-    this._activeTextures = {}, this._renderer = e, this._createCanvas = e.type === xe.WEBGPU;
-  }
-  /**
-   * @param options
-   * @deprecated Use getTexturePromise instead
-   */
-  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 = 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 && (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(() => {
-      K("HTMLTextSystem: Failed to clean texture");
-    });
-  }
-  _cleanUp(e) {
-    A.returnTexture(e, !0), e.source.resource = null, e.source.uploadMethodId = "unknown";
-  }
-  destroy() {
-    this._renderer = null;
-    for (const e in this._activeTextures)
-      this._activeTextures[e] && this.returnTexturePromise(this._activeTextures[e].promise);
-    this._activeTextures = null;
-  }
-}
-bt.extension = {
-  type: [
-    y.WebGLSystem,
-    y.WebGPUSystem,
-    y.CanvasSystem
-  ],
-  name: "htmlText"
-};
-class Yr extends Ke {
-  constructor(e) {
-    super(), this._renderer = e, e.runners.resolutionChange.add(this);
-  }
-  resolutionChange() {
-    const e = this.renderable;
-    e._autoResolution && e.onViewUpdate();
-  }
-  destroy() {
-    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 yt {
-  constructor(e) {
-    this._renderer = e;
-  }
-  validateRenderable(e) {
-    const t = this._getGpuText(e), r = e.styleKey;
-    return t.currentKey !== r ? !0 : e._didTextUpdate;
-  }
-  addRenderable(e, t) {
-    const r = this._getGpuText(e);
-    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);
-    t._batcher.updateElement(t);
-  }
-  _updateGpuText(e) {
-    const t = this._getGpuText(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 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;
-  }
-}
-yt.extension = {
-  type: [
-    y.WebGLPipes,
-    y.WebGPUPipes,
-    y.CanvasPipes
-  ],
-  name: "text"
-};
-class Tt {
-  constructor(e) {
-    this._activeTextures = {}, this._renderer = e;
-  }
-  getTexture(e, t, r, i) {
-    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, u = e.resolution ?? this._renderer.resolution, { frame: l, canvasAndContext: h } = ue.getCanvasAndContext({
-      text: n,
-      style: s,
-      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(c._source), ue.returnCanvasAndContext(h), c;
-  }
-  /**
-   * Returns a texture that was created wit the above `getTexture` function.
-   * Handy if you are done with a texture and want to return it to the pool.
-   * @param texture - The texture to be returned.
-   */
-  returnTexture(e) {
-    const t = e.source;
-    t.resource = null, t.uploadMethodId = "unknown", t.alphaMode = "no-premultiply-alpha", A.returnTexture(e, !0);
-  }
-  /**
-   * Renders text to its canvas, and updates its texture.
-   * @deprecated since 8.10.0
-   */
-  renderTextToCanvas() {
-    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.
-   *
-   * This method takes a texture and a list of filters, applies the filters to the texture,
-   * and returns the resulting texture. It also ensures that the alpha mode of the resulting
-   * texture is set to 'premultiplied-alpha'.
-   * @param {Texture} texture - The texture to which the filters will be applied.
-   * @param {Filter[]} filters - The filters to apply to the texture.
-   * @returns {Texture} The resulting texture after all filters have been applied.
-   */
-  _applyFilters(e, t) {
-    const r = this._renderer.renderTarget.renderTarget, i = this._renderer.filter.generateFilteredTexture({
-      texture: e,
-      filters: t
-    });
-    return this._renderer.renderTarget.bind(r, !1), i;
-  }
-  destroy() {
-    this._renderer = null;
-    for (const e in this._activeTextures)
-      this._activeTextures[e] && this.returnTexture(this._activeTextures[e].texture);
-    this._activeTextures = null;
-  }
-}
-Tt.extension = {
-  type: [
-    y.WebGLSystem,
-    y.WebGPUSystem,
-    y.CanvasSystem
-  ],
-  name: "canvasText"
-};
-P.add(je);
-P.add(qe);
-P.add(at);
-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(gt);
-P.add(rt);
-P.add(tt);
-//# sourceMappingURL=webworkerAll-pikqGfAy.js.map