@micjanic/recursive-grid 1.0.2

package/dist/webworkerAll-CI8_Z7rX.js

@@ -0,0 +1,3321 @@
+import { E as w, U as wt, T as ve, a as Tt, a2 as U, a3 as O, D as H, t as R, $ as V, M as k, ac as vt, ad as St, w as ne, _ as j, Q as Z, ae as Ct, af as q, ag as G, l as Y, d as Le, I as A, a5 as me, R as xe, H as Ie, c as N, B as z, n as Se, S as ee, y as te, ah as Pt, ai as _e, L as pe, aj as K, s as be, v as Ft, G as Bt, m as Oe, q as Ee, a7 as He, aa as Ve, o as Mt, p as Rt, a8 as Ut, a9 as kt, ab as Gt, ak as At, al as zt, e as P, am as Dt } from "./PixiApp-D4xu0PT4.js";
+import { c as se, a as Wt, b as Lt, B as Ye } from "./colorToUniform-C2jGzNe1.js";
+import { C as X } from "./CanvasPool-BvJplAOp.js";
+class Xe {
+  /**
+   * 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;
+  }
+}
+Xe.extension = w.Application;
+class $e {
+  /**
+   * 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, wt.LOW);
+        },
+        get() {
+          return this._ticker;
+        }
+      }
+    ), this.stop = () => {
+      this._ticker.stop();
+    }, this.start = () => {
+      this._ticker.start();
+    }, this._ticker = null, this.ticker = e.sharedTicker ? ve.shared : new ve(), 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();
+    }
+  }
+}
+$e.extension = w.Application;
+class It extends Tt {
+  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 U(O, "BitmapFont.font is deprecated, please use BitmapFont.fontFamily instead."), this.fontFamily;
+  }
+  /**
+   * The map of base page textures (i.e., sheets of glyphs).
+   * @deprecated since 8.0.0 Use `pages` instead.
+   */
+  get pageTextures() {
+    return U(O, "BitmapFont.pageTextures is deprecated, please use BitmapFont.pages instead."), this.pages;
+  }
+  /**
+   * The size of the font face in pixels.
+   * @deprecated since 8.0.0 Use `fontMetrics.fontSize` instead.
+   */
+  get size() {
+    return U(O, "BitmapFont.size is deprecated, please use BitmapFont.fontMetrics.fontSize instead."), this.fontMetrics.fontSize;
+  }
+  /**
+   * The kind of distance field for this font or "none".
+   * @deprecated since 8.0.0 Use `distanceField.type` instead.
+   */
+  get distanceFieldRange() {
+    return U(O, "BitmapFont.distanceFieldRange is deprecated, please use BitmapFont.distanceField.range instead."), this.distanceField.range;
+  }
+  /**
+   * The range of the distance field in pixels.
+   * @deprecated since 8.0.0 Use `distanceField.range` instead.
+   */
+  get distanceFieldType() {
+    return U(O, "BitmapFont.distanceFieldType is deprecated, please use BitmapFont.distanceField.type instead."), this.distanceField.type;
+  }
+  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);
+  }
+}
+const Ot = [
+  "serif",
+  "sans-serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui"
+];
+function re(o) {
+  const e = typeof o.fontSize == "number" ? `${o.fontSize}px` : o.fontSize;
+  let t = o.fontFamily;
+  Array.isArray(o.fontFamily) || (t = o.fontFamily.split(","));
+  for (let r = t.length - 1; r >= 0; r--) {
+    let i = t[r].trim();
+    !/([\"\'])[^\'\"]+\1/.test(i) && !Ot.includes(i) && (i = `"${i}"`), t[r] = i;
+  }
+  return `${o.fontStyle} ${o.fontVariant} ${o.fontWeight} ${e} ${t.join(",")}`;
+}
+const oe = {
+  // TextMetrics requires getImageData readback for measuring fonts.
+  willReadFrequently: !0
+}, W = class g {
+  /**
+   * 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 = g._experimentalLetterSpacingSupported;
+    if (e === void 0) {
+      const t = H.get().getCanvasRenderingContext2D().prototype;
+      e = g._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, l, c) {
+    this.text = e, this.style = t, this.width = r, this.height = i, this.lines = n, this.lineWidths = s, this.lineHeight = a, this.maxLineWidth = l, this.fontProperties = c;
+  }
+  /**
+   * 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 = g._canvas, i = t.wordWrap) {
+    var p;
+    const n = re(t), s = g.measureFont(n);
+    s.fontSize === 0 && (s.fontSize = t.fontSize, s.ascent = t.fontSize);
+    const a = g.__context;
+    a.font = n;
+    const c = (i ? g._wordWrap(e, t, r) : e).split(/(?:\r\n|\r|\n)/), d = new Array(c.length);
+    let u = 0;
+    for (let b = 0; b < c.length; b++) {
+      const y = g._measureText(c[b], t.letterSpacing, a);
+      d[b] = y, u = Math.max(u, y);
+    }
+    const h = ((p = t._stroke) == null ? void 0 : p.width) || 0;
+    let f = u + h;
+    t.dropShadow && (f += t.dropShadow.distance);
+    const m = t.lineHeight || s.fontSize;
+    let x = Math.max(m, s.fontSize + h) + (c.length - 1) * (m + t.leading);
+    return t.dropShadow && (x += t.dropShadow.distance), new g(
+      e,
+      t,
+      f,
+      x,
+      c,
+      d,
+      m + t.leading,
+      u,
+      s
+    );
+  }
+  static _measureText(e, t, r) {
+    let i = !1;
+    g.experimentalLetterSpacingSupported && (g.experimentalLetterSpacing ? (r.letterSpacing = `${t}px`, r.textLetterSpacing = `${t}px`, i = !0) : (r.letterSpacing = "0px", r.textLetterSpacing = "0px"));
+    const n = r.measureText(e);
+    let s = n.width;
+    const a = -n.actualBoundingBoxLeft;
+    let c = n.actualBoundingBoxRight - a;
+    if (s > 0)
+      if (i)
+        s -= t, c -= t;
+      else {
+        const d = (g.graphemeSegmenter(e).length - 1) * t;
+        s += d, c += d;
+      }
+    return Math.max(s, c);
+  }
+  /**
+   * 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 = g._canvas) {
+    const i = r.getContext("2d", oe);
+    let n = 0, s = "", a = "";
+    const l = /* @__PURE__ */ Object.create(null), { letterSpacing: c, whiteSpace: d } = t, u = g._collapseSpaces(d), h = g._collapseNewlines(d);
+    let f = !u;
+    const m = t.wordWrapWidth + c, x = g._tokenize(e);
+    for (let _ = 0; _ < x.length; _++) {
+      let p = x[_];
+      if (g._isNewline(p)) {
+        if (!h) {
+          a += g._addLine(s), f = !u, s = "", n = 0;
+          continue;
+        }
+        p = " ";
+      }
+      if (u) {
+        const y = g.isBreakingSpace(p), T = g.isBreakingSpace(s[s.length - 1]);
+        if (y && T)
+          continue;
+      }
+      const b = g._getFromCache(p, c, l, i);
+      if (b > m)
+        if (s !== "" && (a += g._addLine(s), s = "", n = 0), g.canBreakWords(p, t.breakWords)) {
+          const y = g.wordWrapSplit(p);
+          for (let T = 0; T < y.length; T++) {
+            let S = y[T], B = S, v = 1;
+            for (; y[T + v]; ) {
+              const M = y[T + v];
+              if (!g.canBreakChars(B, M, p, T, t.breakWords))
+                S += M;
+              else
+                break;
+              B = M, v++;
+            }
+            T += v - 1;
+            const F = g._getFromCache(S, c, l, i);
+            F + n > m && (a += g._addLine(s), f = !1, s = "", n = 0), s += S, n += F;
+          }
+        } else {
+          s.length > 0 && (a += g._addLine(s), s = "", n = 0);
+          const y = _ === x.length - 1;
+          a += g._addLine(p, !y), f = !1, s = "", n = 0;
+        }
+      else
+        b + n > m && (f = !1, a += g._addLine(s), s = "", n = 0), (s.length > 0 || !g.isBreakingSpace(p) || f) && (s += p, n += b);
+    }
+    return a += g._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 = g._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 = g._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 (!g.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 : g._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 : g._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 (g.isBreakingSpace(n, s) || g._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 g.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 (g._fonts[e])
+      return g._fonts[e];
+    const t = g._context;
+    t.font = e;
+    const r = t.measureText(g.METRICS_STRING + g.BASELINE_SYMBOL), i = {
+      ascent: r.actualBoundingBoxAscent,
+      descent: r.actualBoundingBoxDescent,
+      fontSize: r.actualBoundingBoxAscent + r.actualBoundingBoxDescent
+    };
+    return g._fonts[e] = i, i;
+  }
+  /**
+   * Clear font metrics in metrics cache.
+   * @param {string} [font] - font name. If font name not set then clear cache for all fonts.
+   */
+  static clearMetrics(e = "") {
+    e ? delete g._fonts[e] : g._fonts = {};
+  }
+  /**
+   * 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 (!g.__canvas) {
+      let e;
+      try {
+        const t = new OffscreenCanvas(0, 0), r = t.getContext("2d", oe);
+        if (r != null && r.measureText)
+          return g.__canvas = t, t;
+        e = H.get().createCanvas();
+      } catch {
+        e = H.get().createCanvas();
+      }
+      e.width = e.height = 10, g.__canvas = e;
+    }
+    return g.__canvas;
+  }
+  /**
+   * TODO: this should be private, but isn't because of backward compat, will fix later.
+   * @ignore
+   */
+  static get _context() {
+    return g.__context || (g.__context = g._canvas.getContext("2d", oe)), g.__context;
+  }
+};
+W.METRICS_STRING = "|ÉqÅ";
+W.BASELINE_SYMBOL = "M";
+W.BASELINE_MULTIPLIER = 1.4;
+W.HEIGHT_MULTIPLIER = 2;
+W.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];
+})();
+W.experimentalLetterSpacing = !1;
+W._fonts = {};
+W._newlines = [
+  10,
+  // line feed
+  13
+  // carriage return
+];
+W._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
+];
+let D = W;
+const Ce = 1e5;
+function ie(o, e, t, r = 0) {
+  if (o.texture === R.WHITE && !o.fill)
+    return V.shared.setValue(o.color).setAlpha(o.alpha ?? 1).toHexa();
+  if (o.fill) {
+    if (o.fill instanceof vt) {
+      const i = o.fill, n = e.createPattern(i.texture.source.resource, "repeat"), s = i.transform.copyTo(k.shared);
+      return s.scale(
+        i.texture.frame.width,
+        i.texture.frame.height
+      ), n.setTransform(s), n;
+    } else if (o.fill instanceof St) {
+      const i = o.fill, n = i.type === "linear", s = i.textureSpace === "local";
+      let a = 1, l = 1;
+      s && t && (a = t.width + r, l = t.height + r);
+      let c, d = !1;
+      if (n) {
+        const { start: u, end: h } = i;
+        c = e.createLinearGradient(
+          u.x * a,
+          u.y * l,
+          h.x * a,
+          h.y * l
+        ), d = Math.abs(h.x - u.x) < Math.abs((h.y - u.y) * 0.1);
+      } else {
+        const { center: u, innerRadius: h, outerCenter: f, outerRadius: m } = i;
+        c = e.createRadialGradient(
+          u.x * a,
+          u.y * l,
+          h * a,
+          f.x * a,
+          f.y * l,
+          m * a
+        );
+      }
+      if (d && s && t) {
+        const u = t.lineHeight / l;
+        for (let h = 0; h < t.lines.length; h++) {
+          const f = (h * t.lineHeight + r / 2) / l;
+          i.colorStops.forEach((m) => {
+            const x = f + m.offset * u;
+            c.addColorStop(
+              // fix to 5 decimal places to avoid floating point precision issues
+              Math.floor(x * Ce) / Ce,
+              V.shared.setValue(m.color).toHex()
+            );
+          });
+        }
+      } else
+        i.colorStops.forEach((u) => {
+          c.addColorStop(u.offset, V.shared.setValue(u.color).toHex());
+        });
+      return c;
+    }
+  } else {
+    const i = e.createPattern(o.texture.source.resource, "repeat"), n = o.matrix.copyTo(k.shared);
+    return n.scale(o.texture.frame.width, o.texture.frame.height), i.setTransform(n), i;
+  }
+  return ne("FillStyle not recognised", o), "red";
+}
+const Ne = class je extends It {
+  /**
+   * @param options - The options for the dynamic bitmap font.
+   */
+  constructor(e) {
+    super(), this.resolution = 1, this.pages = [], this._padding = 0, this._measureCache = /* @__PURE__ */ Object.create(null), this._currentChars = [], this._currentX = 0, this._currentY = 0, this._currentMaxCharHeight = 0, this._currentPageIndex = -1, this._skipKerning = !1;
+    const t = { ...je.defaultOptions, ...e };
+    this._textureSize = t.textureSize, this._mipmap = t.mipmap;
+    const r = t.style.clone();
+    t.overrideFill && (r._fill.color = 16777215, r._fill.alpha = 1, r._fill.texture = R.WHITE, r._fill.fill = null), this.applyFillAsTint = t.overrideFill;
+    const i = r.fontSize;
+    r.fontSize = this.baseMeasurementFontSize;
+    const n = re(r);
+    t.overrideSize ? r._stroke && (r._stroke.width *= this.baseRenderedFontSize / i) : r.fontSize = this.baseRenderedFontSize = i, this._style = r, this._skipKerning = t.skipKerning ?? !1, this.resolution = t.resolution ?? 1, this._padding = t.padding ?? 4, t.textureStyle && (this._textureStyle = t.textureStyle instanceof j ? t.textureStyle : new j(t.textureStyle)), this.fontMetrics = D.measureFont(n), this.lineHeight = r.lineHeight || this.fontMetrics.fontSize || r.fontSize;
+  }
+  ensureCharacters(e) {
+    var _, p;
+    const t = D.graphemeSegmenter(e).filter((b) => !this._currentChars.includes(b)).filter((b, y, T) => T.indexOf(b) === y);
+    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 l = this._currentX, c = this._currentY, d = this._currentMaxCharHeight;
+    const u = this.baseRenderedFontSize / this.baseMeasurementFontSize, h = this._padding * u;
+    let f = !1;
+    const m = i.width / this.resolution, x = i.height / this.resolution;
+    for (let b = 0; b < t.length; b++) {
+      const y = t[b], T = D.measureText(y, a, i, !1);
+      T.lineHeight = T.height;
+      const S = T.width * u, B = Math.ceil((a.fontStyle === "italic" ? 2 : 1) * S), v = T.height * u, F = B + h * 2, M = v + h * 2;
+      if (f = !1, y !== `
+` && y !== "\r" && y !== "	" && y !== " " && (f = !0, d = Math.ceil(Math.max(M, d))), l + F > m && (c += d, d = M, l = 0, c + d > x)) {
+        s.update();
+        const L = this._nextPage();
+        i = L.canvasAndContext.canvas, n = L.canvasAndContext.context, s = L.texture.source, l = 0, c = 0, d = 0;
+      }
+      const ae = S / u - (((_ = a.dropShadow) == null ? void 0 : _.distance) ?? 0) - (((p = a._stroke) == null ? void 0 : p.width) ?? 0);
+      if (this.chars[y] = {
+        id: y.codePointAt(0),
+        xOffset: -this._padding,
+        yOffset: -this._padding,
+        xAdvance: ae,
+        kerning: {}
+      }, f) {
+        this._drawGlyph(
+          n,
+          T,
+          l + h,
+          c + h,
+          u,
+          a
+        );
+        const L = s.width * u, $ = s.height * u, C = new Z(
+          l / L * s.width,
+          c / $ * s.height,
+          F / L * s.width,
+          M / $ * s.height
+        );
+        this.chars[y].texture = new R({
+          source: s,
+          frame: C
+        }), l += Math.ceil(F);
+      }
+    }
+    s.update(), this._currentX = l, this._currentY = c, this._currentMaxCharHeight = d, this._skipKerning && this._applyKerning(t, n);
+  }
+  /**
+   * @deprecated since 8.0.0
+   * The map of base page textures (i.e., sheets of glyphs).
+   */
+  get pageTextures() {
+    return U(O, "BitmapFont.pageTextures is deprecated, please use BitmapFont.pages instead."), this.pages;
+  }
+  _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 l = r[n];
+        l || (l = r[n] = t.measureText(n).width);
+        let c = r[a];
+        c || (c = r[a] = t.measureText(a).width);
+        let d = t.measureText(n + a).width, u = d - (l + c);
+        u && (this.chars[n].kerning[a] = u), d = t.measureText(n + a).width, u = d - (l + c), u && (this.chars[a].kerning[n] = u);
+      }
+    }
+  }
+  _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 R({
+      source: new Ct({
+        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 = re(t), t.fontSize = this.baseMeasurementFontSize, e.textBaseline = t.textBaseline;
+    const i = t._stroke, n = (i == null ? void 0 : i.width) ?? 0;
+    if (i && (e.lineWidth = n, e.lineJoin = i.join, e.miterLimit = i.miterLimit, e.strokeStyle = ie(i, e)), t._fill && (e.fillStyle = ie(t._fill, e)), t.dropShadow) {
+      const s = t.dropShadow, a = V.shared.setValue(s.color).toArray(), l = s.blur * r, c = s.distance * r;
+      e.shadowColor = `rgba(${a[0] * 255},${a[1] * 255},${a[2] * 255},${s.alpha})`, e.shadowBlur = l, e.shadowOffsetX = Math.cos(s.angle) * c, e.shadowOffsetY = Math.sin(s.angle) * c;
+    } else
+      e.shadowColor = "black", e.shadowBlur = 0, e.shadowOffsetX = 0, e.shadowOffsetY = 0;
+  }
+  _drawGlyph(e, t, r, i, n, s) {
+    const a = t.text, l = t.fontProperties, c = s._stroke, d = ((c == null ? void 0 : c.width) ?? 0) * n, u = r + d / 2, h = i - d / 2, f = l.descent * n, m = t.lineHeight * n;
+    let x = !1;
+    s.stroke && d && (x = !0, e.strokeText(a, u, h + m - f));
+    const { shadowBlur: _, shadowOffsetX: p, shadowOffsetY: b } = e;
+    s._fill && (x && (e.shadowBlur = 0, e.shadowOffsetX = 0, e.shadowOffsetY = 0), e.fillText(a, u, h + m - f)), x && (e.shadowBlur = _, e.shadowOffsetX = p, e.shadowOffsetY = b);
+  }
+  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;
+  }
+};
+Ne.defaultOptions = {
+  textureSize: 512,
+  style: new q(),
+  mipmap: !0
+};
+let Pe = Ne;
+function qe(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 l = {
+    width: 0,
+    start: 0,
+    index: 0,
+    // use index to not modify the array as we use it a lot!
+    positions: [],
+    chars: []
+  }, c = t.baseMeasurementFontSize / e.fontSize, d = e.letterSpacing * c, u = e.wordWrapWidth * c, h = e.lineHeight ? e.lineHeight * c : t.lineHeight, f = e.wordWrap && e.breakWords, m = (p) => {
+    const b = n.width;
+    for (let y = 0; y < l.index; y++) {
+      const T = p.positions[y];
+      n.chars.push(p.chars[y]), n.charPositions.push(T + b);
+    }
+    n.width += p.width, a = !1, l.width = 0, l.index = 0, l.chars.length = 0;
+  }, x = () => {
+    let p = n.chars.length - 1;
+    if (r) {
+      let b = n.chars[p];
+      for (; b === " "; )
+        n.width -= t.chars[b].xAdvance, b = n.chars[--p];
+    }
+    i.width = Math.max(i.width, n.width), n = {
+      width: 0,
+      charPositions: [],
+      chars: [],
+      spaceWidth: 0,
+      spacesIndex: []
+    }, a = !0, i.lines.push(n), i.height += h;
+  }, _ = (p) => p - d > u;
+  for (let p = 0; p < o.length + 1; p++) {
+    let b;
+    const y = p === o.length;
+    y || (b = o[p]);
+    const T = t.chars[b] || t.chars[" "];
+    if (/(?:\s)/.test(b) || b === "\r" || b === `
+` || y) {
+      if (!a && e.wordWrap && _(n.width + l.width) ? (x(), m(l), y || n.charPositions.push(0)) : (l.start = n.width, m(l), y || n.charPositions.push(0)), b === "\r" || b === `
+`)
+        n.width !== 0 && x();
+      else if (!y) {
+        const F = T.xAdvance + (T.kerning[s] || 0) + d;
+        n.width += F, n.spaceWidth = F, n.spacesIndex.push(n.charPositions.length), n.chars.push(b);
+      }
+    } else {
+      const v = T.kerning[s] || 0, F = T.xAdvance + v + d;
+      f && _(n.width + l.width + F) && (m(l), x()), l.positions[l.index++] = l.width + v, l.chars.push(b), l.width += F;
+    }
+    s = b;
+  }
+  return x(), e.align === "center" ? Et(i) : e.align === "right" ? Ht(i) : e.align === "justify" && Vt(i), i;
+}
+function Et(o) {
+  for (let e = 0; e < o.lines.length; e++) {
+    const t = o.lines[e], r = o.width / 2 - t.width / 2;
+    for (let i = 0; i < t.charPositions.length; i++)
+      t.charPositions[i] += r;
+  }
+}
+function Ht(o) {
+  for (let e = 0; e < o.lines.length; e++) {
+    const t = o.lines[e], r = o.width - t.width;
+    for (let i = 0; i < t.charPositions.length; i++)
+      t.charPositions[i] += r;
+  }
+}
+function Vt(o) {
+  const e = o.width;
+  for (let t = 0; t < o.lines.length; t++) {
+    const r = o.lines[t];
+    let i = 0, n = r.spacesIndex[i++], s = 0;
+    const a = r.spacesIndex.length, c = (e - r.width) / a;
+    for (let d = 0; d < r.charPositions.length; d++)
+      d === n && (n = r.spacesIndex[i++], s += c), r.charPositions[d] += s;
+  }
+}
+function Yt(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, l = s; a <= l; 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 Q = 0;
+class Xt {
+  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
+    };
+  }
+  /**
+   * 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;
+    else if (t._stroke || t.dropShadow) {
+      let a = t.styleKey;
+      a = a.substring(0, a.lastIndexOf("-")), r = `${a}-bitmap`, i = !1;
+    }
+    if (!G.has(r)) {
+      const a = Object.create(t);
+      a.lineHeight = 0;
+      const l = new Pe({
+        style: a,
+        overrideFill: i,
+        overrideSize: !0,
+        ...this.defaultOptions
+      });
+      Q++, Q > 50 && ne("BitmapText", `You have dynamically created ${Q} bitmap fonts, this can be inefficient. Try pre installing your font styles using \`BitmapFont.install({name:"style1", style})\``), l.once("destroy", () => {
+        Q--, G.remove(r);
+      }), G.set(
+        r,
+        l
+      );
+    }
+    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 = D.graphemeSegmenter(e);
+    return qe(n, t, i, r);
+  }
+  /**
+   * 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 c, d, u, h;
+    let t = e[0];
+    typeof t == "string" && (t = {
+      name: t,
+      style: e[1],
+      chars: (c = e[2]) == null ? void 0 : c.chars,
+      resolution: (d = e[2]) == null ? void 0 : d.resolution,
+      padding: (u = e[2]) == null ? void 0 : u.padding,
+      skipKerning: (h = e[2]) == null ? void 0 : h.skipKerning
+    }, U(O, "BitmapFontManager.install(name, style, options) is deprecated, use BitmapFontManager.install({name, style, ...options})"));
+    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
+    }), l = Yt(t.chars);
+    return a.ensureCharacters(l.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 $t = new Xt();
+class Ke {
+  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;
+  }
+}
+Ke.extension = {
+  type: [
+    w.WebGLPipes,
+    w.WebGPUPipes,
+    w.CanvasPipes
+  ],
+  name: "filter"
+};
+function Nt(o, e) {
+  e.clear();
+  const t = e.matrix;
+  for (let r = 0; r < o.length; r++) {
+    const i = o[r];
+    i.globalDisplayStatus < 7 || (e.matrix = i.worldTransform, e.addBounds(i.bounds));
+  }
+  return e.matrix = t, e;
+}
+const jt = 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 qt {
+  constructor() {
+    this.skip = !1, this.inputTexture = null, this.backTexture = null, this.filters = null, this.bounds = new Ie(), this.container = null, this.blendRequired = !1, this.outputRenderSurface = null, this.globalFrame = { x: 0, y: 0, width: 0, height: 0 };
+  }
+}
+class Qe {
+  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 Le({}), 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.length === 0) {
+      i.skip = !0;
+      return;
+    }
+    const l = i.bounds;
+    if (this._calculateFilterArea(e, l), this._calculateFilterBounds(i, t.renderTarget.rootViewPort, a, s, 1), i.skip)
+      return;
+    const c = this._getPreviousFilterData(), d = this._findFilterResolution(s);
+    let u = 0, h = 0;
+    c && (u = c.bounds.minX, h = c.bounds.minY), this._calculateGlobalFrame(
+      i,
+      u,
+      h,
+      d,
+      n.width,
+      n.height
+    ), this._setupFilterTextures(i, l, t, c);
+  }
+  /**
+   * 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.length === 0)
+      return r.skip = !0, e;
+    const a = r.bounds;
+    if (a.addRect(e.frame), this._calculateFilterBounds(r, a.rectangle, s, n, 0), r.skip)
+      return e;
+    const l = n;
+    this._calculateGlobalFrame(
+      r,
+      0,
+      0,
+      l,
+      i.width,
+      i.height
+    ), r.outputRenderSurface = A.getOptimalTexture(
+      a.width,
+      a.height,
+      r.resolution,
+      r.antialias
+    ), r.backTexture = R.EMPTY, r.inputTexture = e, this.renderer.renderTarget.finishRenderPass(), this._applyFiltersToTexture(r, !0);
+    const h = r.outputRenderSurface;
+    return h.source.alphaMode = "premultiplied-alpha", h;
+  }
+  /** @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 l = Math.ceil(t.width * i), c = Math.ceil(t.height * i);
+    return this.renderer.renderTarget.copyToTexture(
+      e,
+      n,
+      { x: s, y: a },
+      { width: l, height: c },
+      { 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, l = s.outputRenderSurface === r, c = n.renderTarget.rootRenderTarget.colorTexture.source._resolution, d = this._findFilterResolution(c);
+    let u = 0, h = 0;
+    if (l) {
+      const f = this._findPreviousFilterOffset();
+      u = f.x, h = f.y;
+    }
+    this._updateFilterUniforms(t, r, s, u, h, d, l, i), this._setupBindGroupsAndRender(e, 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(k.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() {
+  }
+  /**
+   * 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: jt,
+      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 = R.EMPTY, e.blendRequired) {
+      r.renderTarget.finishRenderPass();
+      const n = r.renderTarget.getRenderTarget(e.outputRenderSurface);
+      e.backTexture = this.getBackTexture(n, t, i == null ? void 0 : i.bounds);
+    }
+    e.inputTexture = A.getOptimalTexture(
+      t.width,
+      t.height,
+      e.resolution,
+      e.antialias
+    ), 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, l) {
+    const c = this._filterGlobalUniforms.uniforms, d = c.uOutputFrame, u = c.uInputSize, h = c.uInputPixel, f = c.uInputClamp, m = c.uGlobalFrame, x = c.uOutputTexture;
+    a ? (d[0] = r.bounds.minX - i, d[1] = r.bounds.minY - n) : (d[0] = 0, d[1] = 0), d[2] = e.frame.width, d[3] = e.frame.height, u[0] = e.source.width, u[1] = e.source.height, u[2] = 1 / u[0], u[3] = 1 / u[1], h[0] = e.source.pixelWidth, h[1] = e.source.pixelHeight, h[2] = 1 / h[0], h[3] = 1 / h[1], f[0] = 0.5 * h[2], f[1] = 0.5 * h[3], f[2] = e.frame.width * u[2] - 0.5 * h[2], f[3] = e.frame.height * u[3] - 0.5 * h[3];
+    const _ = this.renderer.renderTarget.rootRenderTarget.colorTexture;
+    m[0] = i * s, m[1] = n * s, m[2] = _.source.width * s, m[3] = _.source.height * s, t instanceof R && (t.source.resource = null);
+    const p = this.renderer.renderTarget.getRenderTarget(t);
+    this.renderer.renderTarget.bind(t, !!l), t instanceof R ? (x[0] = t.frame.width, x[1] = t.frame.height) : (x[0] = p.width, x[1] = p.height), x[2] = p.isRoot ? -1 : 1, this._filterGlobalUniforms.update();
+  }
+  /**
+   * 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 ? Nt(e.renderables, t) : e.filterEffect.filterArea ? (t.clear(), t.addRect(e.filterEffect.filterArea), t.applyMatrix(e.container.worldTransform)) : e.container.getFastGlobalBounds(!0, t), e.container) {
+      const i = (e.container.renderGroup || e.container.parentRenderGroup).cacheToLocalTransform;
+      i && t.applyMatrix(i);
+    }
+  }
+  _applyFiltersToTexture(e, t) {
+    const r = e.inputTexture, i = e.bounds, n = e.filters;
+    if (this._globalFilterBindGroup.setResource(r.source.style, 2), this._globalFilterBindGroup.setResource(e.backTexture.source, 3), n.length === 1)
+      n[0].apply(this, r, e.outputRenderSurface, t);
+    else {
+      let s = e.inputTexture;
+      const a = A.getOptimalTexture(
+        i.width,
+        i.height,
+        s.source._resolution,
+        !1
+      );
+      let l = a, c = 0;
+      for (c = 0; c < n.length - 1; ++c) {
+        n[c].apply(this, s, l, !0);
+        const u = s;
+        s = l, l = u;
+      }
+      n[c].apply(this, s, e.outputRenderSurface, t), A.returnTexture(a);
+    }
+  }
+  _calculateFilterBounds(e, t, r, i, n) {
+    var x;
+    const s = this.renderer, a = e.bounds, l = e.filters;
+    let c = 1 / 0, d = 0, u = !0, h = !1, f = !1, m = !0;
+    for (let _ = 0; _ < l.length; _++) {
+      const p = l[_];
+      if (c = Math.min(c, p.resolution === "inherit" ? i : p.resolution), d += p.padding, p.antialias === "off" ? u = !1 : p.antialias === "inherit" && u && (u = r), p.clipToViewport || (m = !1), !!!(p.compatibleRenderers & s.type)) {
+        f = !1;
+        break;
+      }
+      if (p.blendRequired && !(((x = s.backBuffer) == null ? void 0 : x.useBackBuffer) ?? !0)) {
+        ne("Blend filter requires backBuffer on WebGL renderer to be enabled. Set `useBackBuffer: true` in the renderer options."), f = !1;
+        break;
+      }
+      f = p.enabled || f, h || (h = p.blendRequired);
+    }
+    if (!f) {
+      e.skip = !0;
+      return;
+    }
+    if (m && a.fitBounds(0, t.width / i, 0, t.height / i), a.scale(c).ceil().scale(1 / c).pad((d | 0) * n), !a.isPositive) {
+      e.skip = !0;
+      return;
+    }
+    e.antialias = u, e.resolution = c, e.blendRequired = h;
+  }
+  _popFilterData() {
+    return this._filterStackIndex--, this._filterStack[this._filterStackIndex];
+  }
+  _getPreviousFilterData() {
+    let e, t = this._filterStackIndex - 1;
+    for (; t > 1 && (t--, e = this._filterStack[t], !!e.skip); )
+      ;
+    return e;
+  }
+  _pushFilterData() {
+    let e = this._filterStack[this._filterStackIndex];
+    return e || (e = this._filterStack[this._filterStackIndex] = new qt()), this._filterStackIndex++, e;
+  }
+}
+Qe.extension = {
+  type: [
+    w.WebGLSystem,
+    w.WebGPUSystem
+  ],
+  name: "filter"
+};
+const Je = class Ze extends me {
+  constructor(...e) {
+    let t = e[0] ?? {};
+    t instanceof Float32Array && (U(O, "use new MeshGeometry({ positions, uvs, indices }) instead"), t = {
+      positions: t,
+      uvs: e[1],
+      indices: e[2]
+    }), t = { ...Ze.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: z.VERTEX | z.COPY_DST
+    }), l = new N({
+      data: i,
+      label: "attribute-mesh-uvs",
+      shrinkToFit: s,
+      usage: z.VERTEX | z.COPY_DST
+    }), c = new N({
+      data: n,
+      label: "index-mesh-buffer",
+      shrinkToFit: s,
+      usage: z.INDEX | z.COPY_DST
+    });
+    super({
+      attributes: {
+        aPosition: {
+          buffer: a,
+          format: "float32x2",
+          stride: 8,
+          offset: 0
+        },
+        aUV: {
+          buffer: l,
+          format: "float32x2",
+          stride: 8,
+          offset: 0
+        }
+      },
+      indexBuffer: c,
+      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;
+  }
+};
+Je.defaultOptions = {
+  topology: "triangle-list",
+  shrinkBuffersToFit: !1
+};
+let ye = Je, E = null, I = null;
+function Kt(o, e) {
+  E || (E = H.get().createCanvas(256, 128), I = E.getContext("2d", { willReadFrequently: !0 }), I.globalCompositeOperation = "copy", I.globalAlpha = 1), (E.width < o || E.height < e) && (E.width = Se(o), E.height = Se(e));
+}
+function Fe(o, e, t) {
+  for (let r = 0, i = 4 * t * e; r < e; ++r, i += 4)
+    if (o[i + 3] !== 0)
+      return !1;
+  return !0;
+}
+function Be(o, e, t, r, i) {
+  const n = 4 * e;
+  for (let s = r, a = r * n + 4 * t; s <= i; ++s, a += n)
+    if (o[a + 3] !== 0)
+      return !1;
+  return !0;
+}
+function Qt(...o) {
+  let e = o[0];
+  e.canvas || (e = { canvas: o[0], resolution: o[1] });
+  const { canvas: t } = e, r = Math.min(e.resolution ?? 1, 1), i = e.width ?? t.width, n = e.height ?? t.height;
+  let s = e.output;
+  if (Kt(i, n), !I)
+    throw new TypeError("Failed to get canvas 2D context");
+  I.drawImage(
+    t,
+    0,
+    0,
+    i,
+    n,
+    0,
+    0,
+    i * r,
+    n * r
+  );
+  const l = I.getImageData(0, 0, i, n).data;
+  let c = 0, d = 0, u = i - 1, h = n - 1;
+  for (; d < n && Fe(l, i, d); )
+    ++d;
+  if (d === n)
+    return Z.EMPTY;
+  for (; Fe(l, i, h); )
+    --h;
+  for (; Be(l, i, c, d, h); )
+    ++c;
+  for (; Be(l, i, u, d, h); )
+    --u;
+  return ++u, ++h, I.globalCompositeOperation = "source-over", I.strokeRect(c, d, u - c, h - d), I.globalCompositeOperation = "copy", s ?? (s = new Z()), s.set(c / r, d / r, (u - c) / r, (h - d) / r), s;
+}
+const Me = new Z();
+class Jt {
+  /**
+   * 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 = D.measureText(t || " ", r), a = Math.ceil(Math.ceil(Math.max(1, s.width) + n * 2) * i), l = Math.ceil(Math.ceil(Math.max(1, s.height) + n * 2) * i), c = X.getOptimalCanvasAndContext(a, l);
+    this._renderTextToCanvas(t, r, n, i, c);
+    const d = r.trim ? Qt({ canvas: c.canvas, width: a, height: l, resolution: 1, output: Me }) : Me.set(0, 0, a, l);
+    return {
+      canvasAndContext: c,
+      frame: d
+    };
+  }
+  /**
+   * 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 y, T, S, B;
+    const { canvas: s, context: a } = n, l = re(t), c = D.measureText(e || " ", t), d = c.lines, u = c.lineHeight, h = c.lineWidths, f = c.maxLineWidth, m = c.fontProperties, x = s.height;
+    if (a.resetTransform(), a.scale(i, i), a.textBaseline = t.textBaseline, (y = t._stroke) != null && y.width) {
+      const v = t._stroke;
+      a.lineWidth = v.width, a.miterLimit = v.miterLimit, a.lineJoin = v.join, a.lineCap = v.cap;
+    }
+    a.font = l;
+    let _, p;
+    const b = t.dropShadow ? 2 : 1;
+    for (let v = 0; v < b; ++v) {
+      const F = t.dropShadow && v === 0, M = F ? Math.ceil(Math.max(1, x) + r * 2) : 0, ae = M * i;
+      if (F) {
+        a.fillStyle = "black", a.strokeStyle = "black";
+        const C = t.dropShadow, _t = C.color, bt = C.alpha;
+        a.shadowColor = V.shared.setValue(_t).setAlpha(bt).toRgbaString();
+        const yt = C.blur * i, Te = C.distance * i;
+        a.shadowBlur = yt, a.shadowOffsetX = Math.cos(C.angle) * Te, a.shadowOffsetY = Math.sin(C.angle) * Te + ae;
+      } else {
+        if (a.fillStyle = t._fill ? ie(t._fill, a, c, r * 2) : null, (T = t._stroke) != null && T.width) {
+          const C = t._stroke.width * 0.5 + r * 2;
+          a.strokeStyle = ie(t._stroke, a, c, C);
+        }
+        a.shadowColor = "black";
+      }
+      let L = (u - m.fontSize) / 2;
+      u - m.fontSize < 0 && (L = 0);
+      const $ = ((S = t._stroke) == null ? void 0 : S.width) ?? 0;
+      for (let C = 0; C < d.length; C++)
+        _ = $ / 2, p = $ / 2 + C * u + m.ascent + L, t.align === "right" ? _ += f - h[C] : t.align === "center" && (_ += (f - h[C]) / 2), (B = t._stroke) != null && B.width && this._drawLetterSpacing(
+          d[C],
+          t,
+          n,
+          _ + r,
+          p + r - M,
+          !0
+        ), t._fill !== void 0 && this._drawLetterSpacing(
+          d[C],
+          t,
+          n,
+          _ + r,
+          p + r - M
+        );
+    }
+  }
+  /**
+   * 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, l = t.letterSpacing;
+    let c = !1;
+    if (D.experimentalLetterSpacingSupported && (D.experimentalLetterSpacing ? (a.letterSpacing = `${l}px`, a.textLetterSpacing = `${l}px`, c = !0) : (a.letterSpacing = "0px", a.textLetterSpacing = "0px")), l === 0 || c) {
+      s ? a.strokeText(e, i, n) : a.fillText(e, i, n);
+      return;
+    }
+    let d = i;
+    const u = D.graphemeSegmenter(e);
+    let h = a.measureText(e).width, f = 0;
+    for (let m = 0; m < u.length; ++m) {
+      const x = u[m];
+      s ? a.strokeText(x, d, n) : a.fillText(x, d, n);
+      let _ = "";
+      for (let p = m + 1; p < u.length; ++p)
+        _ += u[p];
+      f = a.measureText(_).width, d += h - f + l, h = f;
+    }
+  }
+}
+const le = new Jt(), Re = "http://www.w3.org/2000/svg", Ue = "http://www.w3.org/1999/xhtml";
+class et {
+  constructor() {
+    this.svgRoot = document.createElementNS(Re, "svg"), this.foreignObject = document.createElementNS(Re, "foreignObject"), this.domElement = document.createElementNS(Ue, "div"), this.styleElement = document.createElementNS(Ue, "style");
+    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();
+  }
+}
+let ke;
+function Zt(o, e, t, r) {
+  r || (r = ke || (ke = new et()));
+  const { domElement: i, styleElement: n, svgRoot: s } = r;
+  i.innerHTML = `<style>${e.cssStyle};</style><div style='padding:0'>${o}</div>`, i.setAttribute("style", "transform-origin: top left; display: inline-block"), t && (n.textContent = t), document.body.appendChild(s);
+  const a = i.getBoundingClientRect();
+  s.remove();
+  const l = e.padding * 2;
+  return {
+    width: a.width - l,
+    height: a.height - l
+  };
+}
+class er {
+  constructor() {
+    this.batches = [], this.batched = !1;
+  }
+  destroy() {
+    this.batches.forEach((e) => {
+      te.return(e);
+    }), this.batches.length = 0;
+  }
+}
+class tt {
+  constructor(e, t) {
+    this.state = ee.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 er();
+    return e._gpuData[this.renderer.uid] = t, t;
+  }
+  _updateBatchesForRenderable(e, t) {
+    const r = e.context, i = this.renderer.graphicsContext.getGpuContext(r), n = this.renderer._roundPixels | e._roundPixels;
+    t.batches = i.batches.map((s) => {
+      const a = te.get(Pt);
+      return s.copyTo(a), a.renderable = e, a.roundPixels = n, a;
+    });
+  }
+  destroy() {
+    this.renderer = null, this._adaptor.destroy(), this._adaptor = null, this.state = null;
+  }
+}
+tt.extension = {
+  type: [
+    w.WebGLPipes,
+    w.WebGPUPipes,
+    w.CanvasPipes
+  ],
+  name: "graphics"
+};
+const rt = class it extends ye {
+  constructor(...e) {
+    super({});
+    let t = e[0] ?? {};
+    typeof t == "number" && (U(O, "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 = { ...it.defaultOptions, ...e }, this.verticesX = this.verticesX ?? e.verticesX, this.verticesY = this.verticesY ?? e.verticesY, this.width = this.width ?? e.width, this.height = this.height ?? e.height;
+    const t = this.verticesX * this.verticesY, r = [], i = [], n = [], s = this.verticesX - 1, a = this.verticesY - 1, l = this.width / s, c = this.height / a;
+    for (let u = 0; u < t; u++) {
+      const h = u % this.verticesX, f = u / this.verticesX | 0;
+      r.push(h * l, f * c), i.push(h / s, f / a);
+    }
+    const d = s * a;
+    for (let u = 0; u < d; u++) {
+      const h = u % s, f = u / s | 0, m = f * this.verticesX + h, x = f * this.verticesX + h + 1, _ = (f + 1) * this.verticesX + h, p = (f + 1) * this.verticesX + h + 1;
+      n.push(
+        m,
+        x,
+        _,
+        x,
+        p,
+        _
+      );
+    }
+    this.buffers[0].data = new Float32Array(r), this.buffers[1].data = new Float32Array(i), this.indexBuffer.data = new Uint32Array(n), this.buffers[0].update(), this.buffers[1].update(), this.indexBuffer.update();
+  }
+};
+rt.defaultOptions = {
+  width: 100,
+  height: 100,
+  verticesX: 10,
+  verticesY: 10
+};
+let tr = rt;
+class we {
+  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 Ge {
+  destroy() {
+  }
+}
+class nt {
+  constructor(e, t) {
+    this.localUniforms = new Y({
+      uTransformMatrix: { value: new k(), type: "mat3x3<f32>" },
+      uColor: { value: new Float32Array([1, 1, 1, 1]), type: "vec4<f32>" },
+      uRound: { value: 0, type: "f32" }
+    }), this.localUniformsBindGroup = new Le({
+      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 Ge()), 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 Ge()), e._gpuData[this.renderer.uid].batchableMesh || this._initBatchableMesh(e);
+  }
+  _initBatchableMesh(e) {
+    const t = new we();
+    return t.renderable = e, t.setTexture(e._texture), t.transform = e.groupTransform, t.roundPixels = this.renderer._roundPixels | e._roundPixels, e._gpuData[this.renderer.uid].batchableMesh = t, t;
+  }
+  destroy() {
+    this.localUniforms = null, this.localUniformsBindGroup = null, this._adaptor.destroy(), this._adaptor = null, this.renderer = null;
+  }
+}
+nt.extension = {
+  type: [
+    w.WebGLPipes,
+    w.WebGPUPipes,
+    w.CanvasPipes
+  ],
+  name: "mesh"
+};
+class rr {
+  execute(e, t) {
+    const r = e.state, i = e.renderer, n = t.shader || e.defaultShader;
+    n.resources.uTexture = t.texture._source, n.resources.uniforms = e.localUniforms;
+    const s = i.gl, a = e.getBuffers(t);
+    i.shader.bind(n), i.state.set(r), i.geometry.bind(a.geometry, n.glProgram);
+    const c = a.geometry.indexBuffer.data.BYTES_PER_ELEMENT === 2 ? s.UNSIGNED_SHORT : s.UNSIGNED_INT;
+    s.drawElements(s.TRIANGLES, t.particleChildren.length * 6, c, 0);
+  }
+}
+class ir {
+  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 Ae(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 nr(o) {
+  return {
+    dynamicUpdate: ze(o, !0),
+    staticUpdate: ze(o, !1)
+  };
+}
+function ze(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 sr {
+  constructor(e) {
+    this._size = 0, this._generateParticleUpdateCache = {};
+    const t = this._size = e.size ?? 1e3, r = e.properties;
+    let i = 0, n = 0;
+    for (const d in r) {
+      const u = r[d], h = pe(u.format);
+      u.dynamic ? n += h.stride : i += h.stride;
+    }
+    this._dynamicStride = n / 4, this._staticStride = i / 4, this.staticAttributeBuffer = new K(t * 4 * i), this.dynamicAttributeBuffer = new K(t * 4 * n), this.indexBuffer = Ae(t);
+    const s = new me();
+    let a = 0, l = 0;
+    this._staticBuffer = new N({
+      data: new Float32Array(1),
+      label: "static-particle-buffer",
+      shrinkToFit: !1,
+      usage: z.VERTEX | z.COPY_DST
+    }), this._dynamicBuffer = new N({
+      data: new Float32Array(1),
+      label: "dynamic-particle-buffer",
+      shrinkToFit: !1,
+      usage: z.VERTEX | z.COPY_DST
+    });
+    for (const d in r) {
+      const u = r[d], h = pe(u.format);
+      u.dynamic ? (s.addAttribute(u.attributeName, {
+        buffer: this._dynamicBuffer,
+        stride: this._dynamicStride * 4,
+        offset: a * 4,
+        format: u.format
+      }), a += h.size) : (s.addAttribute(u.attributeName, {
+        buffer: this._staticBuffer,
+        stride: this._staticStride * 4,
+        offset: l * 4,
+        format: u.format
+      }), l += h.size);
+    }
+    s.addIndex(this.indexBuffer);
+    const c = this.getParticleUpdate(r);
+    this._dynamicUpload = c.dynamicUpdate, this._staticUpload = c.staticUpdate, this.geometry = s;
+  }
+  getParticleUpdate(e) {
+    const t = ar(e);
+    return this._generateParticleUpdateCache[t] ? this._generateParticleUpdateCache[t] : (this._generateParticleUpdateCache[t] = this.generateParticleUpdate(e), this._generateParticleUpdateCache[t]);
+  }
+  generateParticleUpdate(e) {
+    return nr(e);
+  }
+  update(e, t) {
+    e.length > this._size && (t = !0, this._size = Math.max(e.length, this._size * 1.5 | 0), this.staticAttributeBuffer = new K(this._size * this._staticStride * 4 * 4), this.dynamicAttributeBuffer = new K(this._size * this._dynamicStride * 4 * 4), this.indexBuffer = Ae(this._size), this.geometry.indexBuffer.setDataWithSize(
+      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 ar(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 or = `varying vec2 vUV;
+varying vec4 vColor;
+
+uniform sampler2D uTexture;
+
+void main(void){
+    vec4 color = texture2D(uTexture, vUV) * vColor;
+    gl_FragColor = color;
+}`, lr = `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;
+}
+`, De = `
+struct ParticleUniforms {
+  uProjectionMatrix:mat3x3<f32>,
+  uColor:vec4<f32>,
+  uResolution:vec2<f32>,
+  uRoundPixels:f32,
+};
+
+@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;
+
+   let position = vec4((uniforms.uProjectionMatrix * vec3(v, 1.0)).xy, 0.0, 1.0);
+
+    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 cr extends be {
+  constructor() {
+    const e = Ft.from({
+      vertex: lr,
+      fragment: or
+    }), t = Bt.from({
+      fragment: {
+        source: De,
+        entryPoint: "mainFragment"
+      },
+      vertex: {
+        source: De,
+        entryPoint: "mainVertex"
+      }
+    });
+    super({
+      glProgram: e,
+      gpuProgram: t,
+      resources: {
+        // this will be replaced with the texture from the particle container
+        uTexture: R.WHITE.source,
+        // this will be replaced with the texture style from the particle container
+        uSampler: new j({}),
+        // this will be replaced with the local uniforms from the particle container
+        uniforms: {
+          uTranslationMatrix: { value: new k(), type: "mat3x3<f32>" },
+          uColor: { value: new V(16777215), type: "vec4<f32>" },
+          uRound: { value: 1, type: "f32" },
+          uResolution: { value: [0, 0], type: "vec2<f32>" }
+        }
+      }
+    });
+  }
+}
+class st {
+  /**
+   * @param renderer - The renderer this sprite batch works for.
+   * @param adaptor
+   */
+  constructor(e, t) {
+    this.state = ee.for2d(), this.localUniforms = new Y({
+      uTranslationMatrix: { value: new k(), type: "mat3x3<f32>" },
+      uColor: { value: new Float32Array(4), type: "vec4<f32>" },
+      uRound: { value: 1, type: "f32" },
+      uResolution: { value: [0, 0], type: "vec2<f32>" }
+    }), this.renderer = e, this.adaptor = t, this.defaultShader = new cr(), this.state = ee.for2d();
+  }
+  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 sr({
+      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.defaultShader && (this.defaultShader.destroy(), this.defaultShader = null);
+  }
+}
+class at extends st {
+  constructor(e) {
+    super(e, new rr());
+  }
+}
+at.extension = {
+  type: [
+    w.WebGLPipes
+  ],
+  name: "particle"
+};
+class ot extends st {
+  constructor(e) {
+    super(e, new ir());
+  }
+}
+ot.extension = {
+  type: [
+    w.WebGPUPipes
+  ],
+  name: "particle"
+};
+const lt = class ct extends tr {
+  constructor(e = {}) {
+    e = { ...ct.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: l,
+      _anchorY: c
+    } = this, d = i + n, u = t > d ? 1 : t / d, h = s + a, f = r > h ? 1 : r / h, m = Math.min(u, f), x = l * t, _ = c * r;
+    e[0] = e[8] = e[16] = e[24] = -x, e[2] = e[10] = e[18] = e[26] = i * m - x, e[4] = e[12] = e[20] = e[28] = t - n * m - x, e[6] = e[14] = e[22] = e[30] = t - x, e[1] = e[3] = e[5] = e[7] = -_, e[9] = e[11] = e[13] = e[15] = s * m - _, e[17] = e[19] = e[21] = e[23] = r - a * m - _, e[25] = e[27] = e[29] = e[31] = r - _, this.getBuffer("aPosition").update();
+  }
+  /** 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();
+  }
+};
+lt.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 ur = lt;
+class dr extends we {
+  constructor() {
+    super(), this.geometry = new ur();
+  }
+  destroy() {
+    this.geometry.destroy();
+  }
+}
+class ut {
+  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 dr(), r = t;
+    return r.renderable = e, r.transform = e.groupTransform, r.texture = e._texture, r.roundPixels = this._renderer._roundPixels | e._roundPixels, e.didViewUpdate || this._updateBatchableSprite(e, r), t;
+  }
+  destroy() {
+    this._renderer = null;
+  }
+}
+ut.extension = {
+  type: [
+    w.WebGLPipes,
+    w.WebGPUPipes,
+    w.CanvasPipes
+  ],
+  name: "nineSliceSprite"
+};
+const hr = {
+  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);
+        `
+    )
+  }
+}, fr = {
+  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 ce, ue;
+class pr extends be {
+  constructor() {
+    ce ?? (ce = Oe({
+      name: "tiling-sprite-shader",
+      bits: [
+        Wt,
+        hr,
+        Ee
+      ]
+    })), ue ?? (ue = He({
+      name: "tiling-sprite-shader",
+      bits: [
+        Lt,
+        fr,
+        Ve
+      ]
+    }));
+    const e = new Y({
+      uMapCoord: { value: new k(), type: "mat3x3<f32>" },
+      uClampFrame: { value: new Float32Array([0, 0, 1, 1]), type: "vec4<f32>" },
+      uClampOffset: { value: new Float32Array([0, 0]), type: "vec2<f32>" },
+      uTextureTransform: { value: new k(), type: "mat3x3<f32>" },
+      uSizeAnchor: { value: new Float32Array([100, 100, 0.5, 0.5]), type: "vec4<f32>" }
+    });
+    super({
+      glProgram: ue,
+      gpuProgram: ce,
+      resources: {
+        localUniforms: new Y({
+          uTransformMatrix: { value: new k(), type: "mat3x3<f32>" },
+          uColor: { value: new Float32Array([1, 1, 1, 1]), type: "vec4<f32>" },
+          uRound: { value: 0, type: "f32" }
+        }),
+        tilingUniforms: e,
+        uTexture: R.EMPTY.source,
+        uSampler: R.EMPTY.source.style
+      }
+    });
+  }
+  updateUniforms(e, t, r, i, n, s) {
+    const a = this.resources.tilingUniforms, l = s.width, c = s.height, d = s.textureMatrix, u = a.uniforms.uTextureTransform;
+    u.set(
+      r.a * l / e,
+      r.b * l / t,
+      r.c * c / e,
+      r.d * c / t,
+      r.tx / e,
+      r.ty / t
+    ), u.invert(), a.uniforms.uMapCoord = d.mapCoord, a.uniforms.uClampFrame = d.uClampFrame, a.uniforms.uClampOffset = d.uClampOffset, a.uniforms.uTextureTransform = u, a.uniforms.uSizeAnchor[0] = e, a.uniforms.uSizeAnchor[1] = t, a.uniforms.uSizeAnchor[2] = i, a.uniforms.uSizeAnchor[3] = n, s && (this.resources.uTexture = s.source, this.resources.uSampler = s.source.style);
+  }
+}
+class gr extends ye {
+  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 mr(o, e) {
+  const t = o.anchor.x, r = o.anchor.y;
+  e[0] = -t * o.width, e[1] = -r * o.height, e[2] = (1 - t) * o.width, e[3] = -r * o.height, e[4] = (1 - t) * o.width, e[5] = (1 - r) * o.height, e[6] = -t * o.width, e[7] = (1 - r) * o.height;
+}
+function xr(o, e, t, r) {
+  let i = 0;
+  const n = o.length / e, s = r.a, a = r.b, l = r.c, c = r.d, d = r.tx, u = r.ty;
+  for (t *= e; i < n; ) {
+    const h = o[t], f = o[t + 1];
+    o[t] = s * h + l * f + d, o[t + 1] = a * h + c * f + u, t += e, i++;
+  }
+}
+function _r(o, e) {
+  const t = o.texture, r = t.frame.width, i = t.frame.height;
+  let n = 0, s = 0;
+  o.applyAnchorToTexture && (n = o.anchor.x, s = o.anchor.y), e[0] = e[6] = -n, e[2] = e[4] = 1 - n, e[1] = e[3] = -s, e[5] = e[7] = 1 - s;
+  const a = k.shared;
+  a.copyFrom(o._tileTransform.matrix), a.tx /= o.width, a.ty /= o.height, a.invert(), a.scale(o.width / r, o.height / i), xr(e, 2, 0, a);
+}
+const J = new gr();
+class br {
+  constructor() {
+    this.canBatch = !0, this.geometry = new ye({
+      indices: J.indices.slice(),
+      positions: J.positions.slice(),
+      uvs: J.uvs.slice()
+    });
+  }
+  destroy() {
+    var e;
+    this.geometry.destroy(), (e = this.shader) == null || e.destroy();
+  }
+}
+class dt {
+  constructor(e) {
+    this._state = ee.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 we());
+      const a = i.batchableMesh;
+      e.didViewUpdate && (this._updateBatchableMesh(e), a.geometry = n, a.renderable = e, a.transform = e.groupTransform, a.setTexture(e._texture)), a.roundPixels = this._renderer._roundPixels | e._roundPixels, r.addToBatch(a, t);
+    } else
+      r.break(t), i.shader || (i.shader = new pr()), this.updateRenderable(e), t.add(e);
+  }
+  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: J,
+      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 br();
+    return t.renderable = e, e._gpuData[this._renderer.uid] = t, t;
+  }
+  _updateBatchableMesh(e) {
+    const t = this._getTilingSpriteData(e), { geometry: r } = t, i = e.texture.source.style;
+    i.addressMode !== "repeat" && (i.addressMode = "repeat", i.update()), _r(e, r.uvs), mr(e, r.positions);
+  }
+  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;
+  }
+}
+dt.extension = {
+  type: [
+    w.WebGLPipes,
+    w.WebGPUPipes,
+    w.CanvasPipes
+  ],
+  name: "tilingSprite"
+};
+const yr = {
+  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));
+        `
+    )
+  }
+}, wr = {
+  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));
+        `
+    )
+  }
+}, Tr = {
+  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;
+
+            }
+        `
+    )
+  }
+}, vr = {
+  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 de, he;
+class Sr extends be {
+  constructor(e) {
+    const t = new Y({
+      uColor: { value: new Float32Array([1, 1, 1, 1]), type: "vec4<f32>" },
+      uTransformMatrix: { value: new k(), type: "mat3x3<f32>" },
+      uDistance: { value: 4, type: "f32" },
+      uRound: { value: 0, type: "f32" }
+    });
+    de ?? (de = Oe({
+      name: "sdf-shader",
+      bits: [
+        Mt,
+        Rt(e),
+        yr,
+        Tr,
+        Ee
+      ]
+    })), he ?? (he = He({
+      name: "sdf-shader",
+      bits: [
+        Ut,
+        kt(e),
+        wr,
+        vr,
+        Ve
+      ]
+    })), super({
+      glProgram: he,
+      gpuProgram: de,
+      resources: {
+        localUniforms: t,
+        batchSamplers: Gt(e)
+      }
+    });
+  }
+}
+class Cr extends At {
+  destroy() {
+    this.context.customShader && this.context.customShader.destroy(), super.destroy();
+  }
+}
+class ht {
+  constructor(e) {
+    this._renderer = e, this._renderer.renderableGC.addManagedHash(this, "_gpuBitmapText");
+  }
+  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 = $t.getFont(e.text, e._style);
+    r.clear(), i.distanceField.type !== "none" && (r.customShader || (r.customShader = new Sr(this._renderer.limits.maxBatchableTextures)));
+    const n = D.graphemeSegmenter(e.text), s = e._style;
+    let a = i.baseLineOffset;
+    const l = qe(n, s, i, !0), c = s.padding, d = l.scale;
+    let u = l.width, h = l.height + l.offsetY;
+    s._stroke && (u += s._stroke.width / d, h += s._stroke.width / d), r.translate(-e._anchor._x * u - c, -e._anchor._y * h - c).scale(d, d);
+    const f = i.applyFillAsTint ? s._fill.color : 16777215;
+    let m = i.fontMetrics.fontSize, x = i.lineHeight;
+    s.lineHeight && (m = s.fontSize / d, x = s.lineHeight / d);
+    let _ = (x - m) / 2;
+    _ - i.baseLineOffset < 0 && (_ = 0);
+    for (let p = 0; p < l.lines.length; p++) {
+      const b = l.lines[p];
+      for (let y = 0; y < b.charPositions.length; y++) {
+        const T = b.chars[y], S = i.chars[T];
+        if (S != null && S.texture) {
+          const B = S.texture;
+          r.texture(
+            B,
+            f || "black",
+            Math.round(b.charPositions[y] + S.xOffset),
+            Math.round(a + S.yOffset + _),
+            B.orig.width,
+            B.orig.height
+          );
+        }
+      }
+      a += x;
+    }
+  }
+  _getGpuBitmapText(e) {
+    return e._gpuData[this._renderer.uid] || this.initGpuText(e);
+  }
+  initGpuText(e) {
+    const t = new Cr();
+    return e._gpuData[this._renderer.uid] = t, this._updateContext(e, t), t;
+  }
+  _updateDistanceField(e) {
+    const t = this._getGpuBitmapText(e).context, r = e._style.fontFamily, i = G.get(`${r}-bitmap`), { a: n, b: s, c: a, d: l } = e.groupTransform, c = Math.sqrt(n * n + s * s), d = Math.sqrt(a * a + l * l), u = (Math.abs(c) + Math.abs(d)) / 2, h = i.baseRenderedFontSize / e._style.fontSize, f = u * i.distanceField.range * (1 / h);
+    t.customShader.resources.localUniforms.uniforms.uDistance = f;
+  }
+  destroy() {
+    this._renderer = null;
+  }
+}
+ht.extension = {
+  type: [
+    w.WebGLPipes,
+    w.WebGPUPipes,
+    w.CanvasPipes
+  ],
+  name: "bitmapText"
+};
+function We(o, e) {
+  e.groupTransform = o.groupTransform, e.groupColorAlpha = o.groupColorAlpha, e.groupColor = o.groupColor, e.groupBlendMode = o.groupBlendMode, e.globalDisplayStatus = o.globalDisplayStatus, e.groupTransform = o.groupTransform, e.localDisplayStatus = o.localDisplayStatus, e.groupAlpha = o.groupAlpha, e._roundPixels = o._roundPixels;
+}
+class Pr extends Ye {
+  /**
+   * Creates an instance of BatchableHTMLText.
+   * @param renderer - The renderer instance to be used.
+   */
+  constructor(e) {
+    super(), this.generatingTexture = !1, this._renderer = e, e.runners.resolutionChange.add(this);
+  }
+  /** 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() {
+    this._renderer.htmlText.returnTexturePromise(this.texturePromise), this.texturePromise = null, this._renderer = null;
+  }
+}
+function ge(o, e) {
+  const { texture: t, bounds: r } = o, i = e._style._getFinalPadding();
+  zt(r, e._anchor, t);
+  const n = e._anchor._x * i * 2, s = e._anchor._y * i * 2;
+  r.minX -= i - n, r.minY -= i - s, r.maxX -= i - n, r.maxY -= i - s;
+}
+class ft {
+  constructor(e) {
+    this._renderer = e;
+  }
+  validateRenderable(e) {
+    return e._didTextUpdate;
+  }
+  addRenderable(e, t) {
+    const r = this._getGpuText(e);
+    e._didTextUpdate && (this._updateGpuText(e).catch((i) => {
+      console.error(i);
+    }), e._didTextUpdate = !1, ge(r, e)), this._renderer.renderPipes.batch.addToBatch(r, t);
+  }
+  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;
+    t.texturePromise && (this._renderer.htmlText.returnTexturePromise(t.texturePromise), t.texturePromise = null), t.generatingTexture = !0, e._resolution = e._autoResolution ? this._renderer.resolution : e.resolution;
+    const r = this._renderer.htmlText.getTexturePromise(e);
+    t.texturePromise = r, t.texture = await r;
+    const i = e.renderGroup || e.parentRenderGroup;
+    i && (i.structureDidChange = !0), t.generatingTexture = !1, ge(t, e);
+  }
+  _getGpuText(e) {
+    return e._gpuData[this._renderer.uid] || this.initGpuText(e);
+  }
+  initGpuText(e) {
+    const t = new Pr(this._renderer);
+    return t.renderable = e, t.transform = e.groupTransform, t.texture = R.EMPTY, t.bounds = { minX: 0, maxX: 1, minY: 0, maxY: 0 }, t.roundPixels = this._renderer._roundPixels | e._roundPixels, e._resolution = e._autoResolution ? this._renderer.resolution : e.resolution, e._gpuData[this._renderer.uid] = t, t;
+  }
+  destroy() {
+    this._renderer = null;
+  }
+}
+ft.extension = {
+  type: [
+    w.WebGLPipes,
+    w.WebGPUPipes,
+    w.CanvasPipes
+  ],
+  name: "htmlText"
+};
+function Fr() {
+  const { userAgent: o } = H.get().getNavigator();
+  return /^((?!chrome|android).)*safari/i.test(o);
+}
+const Br = new Ie();
+function pt(o, e, t, r) {
+  const i = Br;
+  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 Mr(o, e) {
+  const t = e.fontFamily, r = [], i = {}, n = /font-family:([^;"\s]+)/g, s = o.match(n);
+  function a(l) {
+    i[l] || (r.push(l), i[l] = !0);
+  }
+  if (Array.isArray(t))
+    for (let l = 0; l < t.length; l++)
+      a(t[l]);
+  else
+    a(t);
+  s && s.forEach((l) => {
+    const c = l.split(":")[1].trim();
+    a(c);
+  });
+  for (const l in e.tagStyles) {
+    const c = e.tagStyles[l].fontFamily;
+    a(c);
+  }
+  return r;
+}
+async function Rr(o) {
+  const t = await (await H.get().fetch(o)).blob(), r = new FileReader();
+  return await new Promise((n, s) => {
+    r.onloadend = () => n(r.result), r.onerror = s, r.readAsDataURL(t);
+  });
+}
+async function Ur(o, e) {
+  const t = await Rr(e);
+  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 kr(o) {
+  const e = o.filter((t) => G.has(`${t}-and-url`)).map((t) => {
+    if (!fe.has(t)) {
+      const { entries: r } = G.get(`${t}-and-url`), i = [];
+      r.forEach((n) => {
+        const s = n.url, l = n.faces.map((c) => ({ weight: c.weight, style: c.style }));
+        i.push(
+          ...l.map(
+            (c) => Ur(
+              {
+                fontWeight: c.weight,
+                fontStyle: c.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 Gr(o, e, t, r, i) {
+  const { domElement: n, styleElement: s, svgRoot: a } = i;
+  n.innerHTML = `<style>${e.cssStyle}</style><div style='padding:0;'>${o}</div>`, n.setAttribute("style", `transform: scale(${t});transform-origin: top left; display: inline-block`), s.textContent = r;
+  const { width: l, height: c } = i.image;
+  return a.setAttribute("width", l.toString()), a.setAttribute("height", c.toString()), new XMLSerializer().serializeToString(a);
+}
+function Ar(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 zr(o, e, t) {
+  return new Promise(async (r) => {
+    t && await new Promise((i) => setTimeout(i, 100)), o.onload = () => {
+      r();
+    }, o.src = `data:image/svg+xml;charset=utf8,${encodeURIComponent(e)}`, o.crossOrigin = "anonymous";
+  });
+}
+class gt {
+  constructor(e) {
+    this._renderer = e, this._createCanvas = e.type === xe.WEBGPU;
+  }
+  /**
+   * @param options
+   * @deprecated Use getTexturePromise instead
+   */
+  getTexture(e) {
+    return this.getTexturePromise(e);
+  }
+  getTexturePromise(e) {
+    return this._buildTexturePromise(e);
+  }
+  async _buildTexturePromise(e) {
+    const { text: t, style: r, resolution: i, textureStyle: n } = e, s = te.get(et), a = Mr(t, r), l = await kr(a), c = Zt(t, r, l, s), d = Math.ceil(Math.ceil(Math.max(1, c.width) + r.padding * 2) * i), u = Math.ceil(Math.ceil(Math.max(1, c.height) + r.padding * 2) * i), h = s.image, f = 2;
+    h.width = (d | 0) + f, h.height = (u | 0) + f;
+    const m = Gr(t, r, i, l, s);
+    await zr(h, m, Fr() && a.length > 0);
+    const x = h;
+    let _;
+    this._createCanvas && (_ = Ar(h, i));
+    const p = pt(
+      _ ? _.canvas : x,
+      h.width - f,
+      h.height - f,
+      i
+    );
+    return n && (p.source.style = n), this._createCanvas && (this._renderer.texture.initSource(p.source), X.returnCanvasAndContext(_)), te.return(s), p;
+  }
+  returnTexturePromise(e) {
+    e.then((t) => {
+      this._cleanUp(t);
+    }).catch(() => {
+      ne("HTMLTextSystem: Failed to clean texture");
+    });
+  }
+  _cleanUp(e) {
+    A.returnTexture(e, !0), e.source.resource = null, e.source.uploadMethodId = "unknown";
+  }
+  destroy() {
+    this._renderer = null;
+  }
+}
+gt.extension = {
+  type: [
+    w.WebGLSystem,
+    w.WebGPUSystem,
+    w.CanvasSystem
+  ],
+  name: "htmlText"
+};
+class Dr extends Ye {
+  constructor(e) {
+    super(), this._renderer = e, e.runners.resolutionChange.add(this);
+  }
+  resolutionChange() {
+    const e = this.renderable;
+    e._autoResolution && e.onViewUpdate();
+  }
+  destroy() {
+    this._renderer.canvasText.returnTexture(this.texture), this._renderer = null;
+  }
+}
+class mt {
+  constructor(e) {
+    this._renderer = e;
+  }
+  validateRenderable(e) {
+    return e._didTextUpdate;
+  }
+  addRenderable(e, t) {
+    const r = this._getGpuText(e);
+    e._didTextUpdate && (this._updateGpuText(e), e._didTextUpdate = !1), this._renderer.renderPipes.batch.addToBatch(r, t);
+  }
+  updateRenderable(e) {
+    const t = this._getGpuText(e);
+    t._batcher.updateElement(t);
+  }
+  _updateGpuText(e) {
+    const t = this._getGpuText(e);
+    t.texture && this._renderer.canvasText.returnTexture(t.texture), e._resolution = e._autoResolution ? this._renderer.resolution : e.resolution, t.texture = this._renderer.canvasText.getTexture(e), ge(t, e);
+  }
+  _getGpuText(e) {
+    return e._gpuData[this._renderer.uid] || this.initGpuText(e);
+  }
+  initGpuText(e) {
+    const t = new Dr(this._renderer);
+    return t.renderable = e, t.transform = e.groupTransform, t.bounds = { minX: 0, maxX: 1, minY: 0, maxY: 0 }, t.roundPixels = this._renderer._roundPixels | e._roundPixels, e._gpuData[this._renderer.uid] = t, t;
+  }
+  destroy() {
+    this._renderer = null;
+  }
+}
+mt.extension = {
+  type: [
+    w.WebGLPipes,
+    w.WebGPUPipes,
+    w.CanvasPipes
+  ],
+  name: "text"
+};
+class xt {
+  constructor(e) {
+    this._renderer = e;
+  }
+  getTexture(e, t, r, i) {
+    typeof e == "string" && (U("8.0.0", "CanvasTextSystem.getTexture: Use object TextOptions instead of separate arguments"), e = {
+      text: e,
+      style: r,
+      resolution: t
+    }), e.style instanceof q || (e.style = new q(e.style)), e.textureStyle instanceof j || (e.textureStyle = new j(e.textureStyle)), typeof e.text != "string" && (e.text = e.text.toString());
+    const { text: n, style: s, textureStyle: a } = e, l = e.resolution ?? this._renderer.resolution, { frame: c, canvasAndContext: d } = le.getCanvasAndContext({
+      text: n,
+      style: s,
+      resolution: l
+    }), u = pt(d.canvas, c.width, c.height, l);
+    if (a && (u.source.style = a), s.trim && (c.pad(s.padding), u.frame.copyFrom(c), u.frame.scale(1 / l), u.updateUvs()), s.filters) {
+      const h = this._applyFilters(u, s.filters);
+      return this.returnTexture(u), le.returnCanvasAndContext(d), h;
+    }
+    return this._renderer.texture.initSource(u._source), le.returnCanvasAndContext(d), u;
+  }
+  /**
+   * 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() {
+    U(
+      "8.10.0",
+      "CanvasTextSystem.renderTextToCanvas: no longer supported, use CanvasTextSystem.getTexture instead"
+    );
+  }
+  /**
+   * 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;
+  }
+}
+xt.extension = {
+  type: [
+    w.WebGLSystem,
+    w.WebGPUSystem,
+    w.CanvasSystem
+  ],
+  name: "canvasText"
+};
+P.add(Xe);
+P.add($e);
+P.add(tt);
+P.add(Dt);
+P.add(nt);
+P.add(at);
+P.add(ot);
+P.add(xt);
+P.add(mt);
+P.add(ht);
+P.add(gt);
+P.add(ft);
+P.add(dt);
+P.add(ut);
+P.add(Qe);
+P.add(Ke);
+//# sourceMappingURL=webworkerAll-CI8_Z7rX.js.map