@designcombo/video 0.0.0

package/dist/webworkerAll-DsE6HIYE.js

@@ -0,0 +1,2497 @@
+import { E as p, U as $e, T as ee, G as he, a as fe, M as P, m as C, h as pe, F as v, t as w, a6 as N, R as $, w as Y, z as me, a3 as G, a4 as ge, d as F, B as T, D as j, x as M, ad as je, ae as q, J as L, af as U, S as Q, _ as qe, Z as X, o as xe, s as _e, a8 as be, ab as ye, p as Qe, q as Je, a9 as Ze, aa as et, ac as tt, ag as rt, ah as nt, ai as st, aj as H, ak as it, al as at, n as ve, am as te, an as k, e as b, ao as ot } from "./index-CjzowIhV.js";
+import { F as ut, S as D, c as z, a as lt, b as ct, B as Te } from "./colorToUniform-Du0ROyNd.js";
+class Pe {
+  /**
+   * Initialize the plugin with scope of application instance
+   * @private
+   * @param {object} [options] - See application options
+   */
+  static init(e) {
+    Object.defineProperty(
+      this,
+      "resizeTo",
+      {
+        configurable: !0,
+        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: n, clientHeight: s } = this._resizeTo;
+        t = n, r = s;
+      }
+      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;
+  }
+}
+Pe.extension = p.Application;
+class we {
+  /**
+   * 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",
+      {
+        configurable: !0,
+        set(t) {
+          this._ticker && this._ticker.remove(this.render, this), this._ticker = t, t && t.add(this.render, this, $e.LOW);
+        },
+        get() {
+          return this._ticker;
+        }
+      }
+    ), this.stop = () => {
+      this._ticker.stop();
+    }, this.start = () => {
+      this._ticker.start();
+    }, this._ticker = null, this.ticker = e.sharedTicker ? ee.shared : new ee(), 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();
+    }
+  }
+}
+we.extension = p.Application;
+var dt = `in vec2 aPosition;
+out vec2 vTextureCoord;
+
+uniform vec4 uInputSize;
+uniform vec4 uOutputFrame;
+uniform vec4 uOutputTexture;
+
+vec4 filterVertexPosition( void )
+{
+    vec2 position = aPosition * uOutputFrame.zw + uOutputFrame.xy;
+    
+    position.x = position.x * (2.0 / uOutputTexture.x) - 1.0;
+    position.y = position.y * (2.0*uOutputTexture.z / uOutputTexture.y) - uOutputTexture.z;
+
+    return vec4(position, 0.0, 1.0);
+}
+
+vec2 filterTextureCoord( void )
+{
+    return aPosition * (uOutputFrame.zw * uInputSize.zw);
+}
+
+void main(void)
+{
+    gl_Position = filterVertexPosition();
+    vTextureCoord = filterTextureCoord();
+}
+`, ht = `in vec2 vTextureCoord;
+out vec4 finalColor;
+uniform sampler2D uTexture;
+void main() {
+    finalColor = texture(uTexture, vTextureCoord);
+}
+`, re = `struct GlobalFilterUniforms {
+  uInputSize: vec4<f32>,
+  uInputPixel: vec4<f32>,
+  uInputClamp: vec4<f32>,
+  uOutputFrame: vec4<f32>,
+  uGlobalFrame: vec4<f32>,
+  uOutputTexture: vec4<f32>,
+};
+
+@group(0) @binding(0) var <uniform> gfu: GlobalFilterUniforms;
+@group(0) @binding(1) var uTexture: texture_2d<f32>;
+@group(0) @binding(2) var uSampler: sampler;
+
+struct VSOutput {
+  @builtin(position) position: vec4<f32>,
+  @location(0) uv: vec2<f32>
+};
+
+fn filterVertexPosition(aPosition: vec2<f32>) -> vec4<f32>
+{
+    var position = aPosition * gfu.uOutputFrame.zw + gfu.uOutputFrame.xy;
+
+    position.x = position.x * (2.0 / gfu.uOutputTexture.x) - 1.0;
+    position.y = position.y * (2.0 * gfu.uOutputTexture.z / gfu.uOutputTexture.y) - gfu.uOutputTexture.z;
+
+    return vec4(position, 0.0, 1.0);
+}
+
+fn filterTextureCoord(aPosition: vec2<f32>) -> vec2<f32>
+{
+    return aPosition * (gfu.uOutputFrame.zw * gfu.uInputSize.zw);
+}
+
+@vertex
+fn mainVertex(
+  @location(0) aPosition: vec2<f32>,
+) -> VSOutput {
+  return VSOutput(
+   filterVertexPosition(aPosition),
+   filterTextureCoord(aPosition)
+  );
+}
+
+@fragment
+fn mainFragment(
+  @location(0) uv: vec2<f32>,
+) -> @location(0) vec4<f32> {
+    return textureSample(uTexture, uSampler, uv);
+}
+`;
+class ft extends ut {
+  constructor() {
+    const e = he.from({
+      vertex: { source: re, entryPoint: "mainVertex" },
+      fragment: { source: re, entryPoint: "mainFragment" },
+      name: "passthrough-filter"
+    }), t = fe.from({
+      vertex: dt,
+      fragment: ht,
+      name: "passthrough-filter"
+    });
+    super({
+      gpuProgram: e,
+      glProgram: t
+    });
+  }
+}
+class Ce {
+  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;
+  }
+}
+Ce.extension = {
+  type: [
+    p.WebGLPipes,
+    p.WebGPUPipes,
+    p.CanvasPipes
+  ],
+  name: "filter"
+};
+const ne = new P();
+function pt(a, e) {
+  e.clear();
+  const t = e.matrix;
+  for (let r = 0; r < a.length; r++) {
+    const n = a[r];
+    if (n.globalDisplayStatus < 7)
+      continue;
+    const s = n.renderGroup ?? n.parentRenderGroup;
+    s?.isCachedAsTexture ? e.matrix = ne.copyFrom(s.textureOffsetInverseTransform).append(n.worldTransform) : s?._parentCacheAsTextureRenderGroup ? e.matrix = ne.copyFrom(s._parentCacheAsTextureRenderGroup.inverseWorldTransform).append(n.groupTransform) : e.matrix = n.worldTransform, e.addBounds(n.bounds);
+  }
+  return e.matrix = t, e;
+}
+const mt = new N({
+  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 gt {
+  constructor() {
+    this.skip = !1, this.inputTexture = null, this.backTexture = null, this.filters = null, this.bounds = new me(), this.container = null, this.blendRequired = !1, this.outputRenderSurface = null, this.globalFrame = { x: 0, y: 0, width: 0, height: 0 }, this.firstEnabledIndex = -1, this.lastEnabledIndex = -1;
+  }
+}
+class Se {
+  constructor(e) {
+    this._filterStackIndex = 0, this._filterStack = [], this._filterGlobalUniforms = new C({
+      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 pe({}), this.renderer = e;
+  }
+  /**
+   * The back texture of the currently active filter. Requires the filter to have `blendRequired` set to true.
+   * @readonly
+   */
+  get activeBackTexture() {
+    return this._activeFilterData?.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, n = this._pushFilterData();
+    n.skip = !1, n.filters = r, n.container = e.container, n.outputRenderSurface = t.renderTarget.renderSurface;
+    const s = t.renderTarget.renderTarget.colorTexture.source, i = s.resolution, o = s.antialias;
+    if (r.every((f) => !f.enabled)) {
+      n.skip = !0;
+      return;
+    }
+    const u = n.bounds;
+    if (this._calculateFilterArea(e, u), this._calculateFilterBounds(n, t.renderTarget.rootViewPort, o, i, 1), n.skip)
+      return;
+    const c = this._getPreviousFilterData(), h = this._findFilterResolution(i);
+    let l = 0, d = 0;
+    c && (l = c.bounds.minX, d = c.bounds.minY), this._calculateGlobalFrame(
+      n,
+      l,
+      d,
+      h,
+      s.width,
+      s.height
+    ), this._setupFilterTextures(n, u, 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 n = e.source, s = n.resolution, i = n.antialias;
+    if (t.every((f) => !f.enabled))
+      return r.skip = !0, e;
+    const o = r.bounds;
+    if (o.addRect(e.frame), this._calculateFilterBounds(r, o.rectangle, i, s, 0), r.skip)
+      return e;
+    const u = s;
+    this._calculateGlobalFrame(
+      r,
+      0,
+      0,
+      u,
+      n.width,
+      n.height
+    ), r.outputRenderSurface = v.getOptimalTexture(
+      o.width,
+      o.height,
+      r.resolution,
+      r.antialias
+    ), r.backTexture = w.EMPTY, r.inputTexture = e, this.renderer.renderTarget.finishRenderPass(), this._applyFiltersToTexture(r, !0);
+    const d = r.outputRenderSurface;
+    return d.source.alphaMode = "premultiplied-alpha", d;
+  }
+  /** @internal */
+  pop() {
+    const e = this.renderer, t = this._popFilterData();
+    t.skip || (e.globalUniforms.pop(), e.renderTarget.finishRenderPass(), this._activeFilterData = t, this._applyFiltersToTexture(t, !1), t.blendRequired && v.returnTexture(t.backTexture), v.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 n = e.colorTexture.source._resolution, s = v.getOptimalTexture(
+      t.width,
+      t.height,
+      n,
+      !1
+    );
+    let i = t.minX, o = t.minY;
+    r && (i -= r.minX, o -= r.minY), i = Math.floor(i * n), o = Math.floor(o * n);
+    const u = Math.ceil(t.width * n), c = Math.ceil(t.height * n);
+    return this.renderer.renderTarget.copyToTexture(
+      e,
+      s,
+      { x: i, y: o },
+      { width: u, height: c },
+      { x: 0, y: 0 }
+    ), s;
+  }
+  /**
+   * 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, n) {
+    const s = this.renderer, i = this._activeFilterData, u = i.outputRenderSurface === r, c = s.renderTarget.rootRenderTarget.colorTexture.source._resolution, h = this._findFilterResolution(c);
+    let l = 0, d = 0;
+    if (u) {
+      const g = this._findPreviousFilterOffset();
+      l = g.x, d = g.y;
+    }
+    this._updateFilterUniforms(t, r, i, l, d, h, u, n);
+    const f = e.enabled ? e : this._getPassthroughFilter();
+    this._setupBindGroupsAndRender(f, t, s);
+  }
+  /**
+   * Multiply _input normalized coordinates_ to this matrix to get _sprite texture normalized coordinates_.
+   *
+   * 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, n = e.set(
+      r.inputTexture._source.width,
+      0,
+      0,
+      r.inputTexture._source.height,
+      r.bounds.minX,
+      r.bounds.minY
+    ), s = t.worldTransform.copyTo(P.shared), i = t.renderGroup || t.parentRenderGroup;
+    return i && i.cacheToLocalTransform && s.prepend(i.cacheToLocalTransform), s.invert(), n.prepend(s), n.scale(
+      1 / t.texture.orig.width,
+      1 / t.texture.orig.height
+    ), n.translate(t.anchor.x, t.anchor.y), n;
+  }
+  destroy() {
+    this._passthroughFilter?.destroy(!0), this._passthroughFilter = null;
+  }
+  _getPassthroughFilter() {
+    return this._passthroughFilter ?? (this._passthroughFilter = new ft()), this._passthroughFilter;
+  }
+  /**
+   * Sets up the bind groups and renders the filter.
+   * @param filter - The filter to apply
+   * @param input - The input texture
+   * @param renderer - The renderer instance
+   */
+  _setupBindGroupsAndRender(e, t, r) {
+    if (r.renderPipes.uniformBatch) {
+      const n = r.renderPipes.uniformBatch.getUboResource(this._filterGlobalUniforms);
+      this._globalFilterBindGroup.setResource(n, 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: mt,
+      shader: e,
+      state: e._state,
+      topology: "triangle-list"
+    }), r.type === $.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, n) {
+    if (e.backTexture = w.EMPTY, e.inputTexture = v.getOptimalTexture(
+      t.width,
+      t.height,
+      e.resolution,
+      e.antialias
+    ), e.blendRequired) {
+      r.renderTarget.finishRenderPass();
+      const s = r.renderTarget.getRenderTarget(e.outputRenderSurface);
+      e.backTexture = this.getBackTexture(s, t, n?.bounds);
+    }
+    r.renderTarget.bind(e.inputTexture, !0), r.globalUniforms.push({
+      offset: t
+    });
+  }
+  /**
+   * Calculates and sets the global frame for the filter.
+   * @param filterData - The filter data to update
+   * @param offsetX - The X offset
+   * @param offsetY - The Y offset
+   * @param globalResolution - The global resolution
+   * @param sourceWidth - The source texture width
+   * @param sourceHeight - The source texture height
+   */
+  _calculateGlobalFrame(e, t, r, n, s, i) {
+    const o = e.globalFrame;
+    o.x = t * n, o.y = r * n, o.width = s * n, o.height = i * n;
+  }
+  /**
+   * 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, n, s, i, o, u) {
+    const c = this._filterGlobalUniforms.uniforms, h = c.uOutputFrame, l = c.uInputSize, d = c.uInputPixel, f = c.uInputClamp, g = c.uGlobalFrame, m = c.uOutputTexture;
+    o ? (h[0] = r.bounds.minX - n, h[1] = r.bounds.minY - s) : (h[0] = 0, h[1] = 0), h[2] = e.frame.width, h[3] = e.frame.height, l[0] = e.source.width, l[1] = e.source.height, l[2] = 1 / l[0], l[3] = 1 / l[1], d[0] = e.source.pixelWidth, d[1] = e.source.pixelHeight, d[2] = 1 / d[0], d[3] = 1 / d[1], f[0] = 0.5 * d[2], f[1] = 0.5 * d[3], f[2] = e.frame.width * l[2] - 0.5 * d[2], f[3] = e.frame.height * l[3] - 0.5 * d[3];
+    const x = this.renderer.renderTarget.rootRenderTarget.colorTexture;
+    g[0] = n * i, g[1] = s * i, g[2] = x.source.width * i, g[3] = x.source.height * i, t instanceof w && (t.source.resource = null);
+    const _ = this.renderer.renderTarget.getRenderTarget(t);
+    this.renderer.renderTarget.bind(t, !!u), t instanceof w ? (m[0] = t.frame.width, m[1] = t.frame.height) : (m[0] = _.width, m[1] = _.height), m[2] = _.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 n = this._filterStack[r];
+      if (!n.skip) {
+        e = n.bounds.minX, t = n.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 ? pt(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 n = (e.container.renderGroup || e.container.parentRenderGroup).cacheToLocalTransform;
+      n && t.applyMatrix(n);
+    }
+  }
+  _applyFiltersToTexture(e, t) {
+    const r = e.inputTexture, n = e.bounds, s = e.filters, i = e.firstEnabledIndex, o = e.lastEnabledIndex;
+    if (this._globalFilterBindGroup.setResource(r.source.style, 2), this._globalFilterBindGroup.setResource(e.backTexture.source, 3), i === o)
+      s[i].apply(this, r, e.outputRenderSurface, t);
+    else {
+      let u = e.inputTexture;
+      const c = v.getOptimalTexture(
+        n.width,
+        n.height,
+        u.source._resolution,
+        !1
+      );
+      let h = c;
+      for (let l = i; l < o; l++) {
+        const d = s[l];
+        if (!d.enabled)
+          continue;
+        d.apply(this, u, h, !0);
+        const f = u;
+        u = h, h = f;
+      }
+      s[o].apply(this, u, e.outputRenderSurface, t), v.returnTexture(c);
+    }
+  }
+  _calculateFilterBounds(e, t, r, n, s) {
+    const i = this.renderer, o = e.bounds, u = e.filters;
+    let c = 1 / 0, h = 0, l = !0, d = !1, f = !1, g = !0, m = -1, x = -1;
+    for (let _ = 0; _ < u.length; _++) {
+      const y = u[_];
+      if (!y.enabled)
+        continue;
+      if (m === -1 && (m = _), x = _, c = Math.min(c, y.resolution === "inherit" ? n : y.resolution), h += y.padding, y.antialias === "off" ? l = !1 : y.antialias === "inherit" && l && (l = r), y.clipToViewport || (g = !1), !!!(y.compatibleRenderers & i.type)) {
+        f = !1;
+        break;
+      }
+      if (y.blendRequired && !(i.backBuffer?.useBackBuffer ?? !0)) {
+        Y("Blend filter requires backBuffer on WebGL renderer to be enabled. Set `useBackBuffer: true` in the renderer options."), f = !1;
+        break;
+      }
+      f = !0, d || (d = y.blendRequired);
+    }
+    if (!f) {
+      e.skip = !0;
+      return;
+    }
+    if (g && o.fitBounds(0, t.width / n, 0, t.height / n), o.scale(c).ceil().scale(1 / c).pad((h | 0) * s), !o.isPositive) {
+      e.skip = !0;
+      return;
+    }
+    e.antialias = l, e.resolution = c, e.blendRequired = d, e.firstEnabledIndex = m, e.lastEnabledIndex = x;
+  }
+  _popFilterData() {
+    return this._filterStackIndex--, this._filterStack[this._filterStackIndex];
+  }
+  _getPreviousFilterData() {
+    let e, t = this._filterStackIndex - 1;
+    for (; t > 0 && (t--, e = this._filterStack[t], !!e.skip); )
+      ;
+    return e;
+  }
+  _pushFilterData() {
+    let e = this._filterStack[this._filterStackIndex];
+    return e || (e = this._filterStack[this._filterStackIndex] = new gt()), this._filterStackIndex++, e;
+  }
+}
+Se.extension = {
+  type: [
+    p.WebGLSystem,
+    p.WebGPUSystem
+  ],
+  name: "filter"
+};
+const Fe = class Re extends N {
+  constructor(...e) {
+    let t = e[0] ?? {};
+    t instanceof Float32Array && (G(ge, "use new MeshGeometry({ positions, uvs, indices }) instead"), t = {
+      positions: t,
+      uvs: e[1],
+      indices: e[2]
+    }), t = { ...Re.defaultOptions, ...t };
+    const r = t.positions || new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]);
+    let n = t.uvs;
+    n || (t.positions ? n = new Float32Array(r.length) : n = new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]));
+    const s = t.indices || new Uint32Array([0, 1, 2, 0, 2, 3]), i = t.shrinkBuffersToFit, o = new F({
+      data: r,
+      label: "attribute-mesh-positions",
+      shrinkToFit: i,
+      usage: T.VERTEX | T.COPY_DST
+    }), u = new F({
+      data: n,
+      label: "attribute-mesh-uvs",
+      shrinkToFit: i,
+      usage: T.VERTEX | T.COPY_DST
+    }), c = new F({
+      data: s,
+      label: "index-mesh-buffer",
+      shrinkToFit: i,
+      usage: T.INDEX | T.COPY_DST
+    });
+    super({
+      attributes: {
+        aPosition: {
+          buffer: o,
+          format: "float32x2",
+          stride: 8,
+          offset: 0
+        },
+        aUV: {
+          buffer: u,
+          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;
+  }
+};
+Fe.defaultOptions = {
+  topology: "triangle-list",
+  shrinkBuffersToFit: !1
+};
+let J = Fe;
+const se = "http://www.w3.org/2000/svg", ie = "http://www.w3.org/1999/xhtml";
+class Ue {
+  constructor() {
+    this.svgRoot = document.createElementNS(se, "svg"), this.foreignObject = document.createElementNS(se, "foreignObject"), this.domElement = document.createElementNS(ie, "div"), this.styleElement = document.createElementNS(ie, "style");
+    const { foreignObject: e, svgRoot: t, styleElement: r, domElement: n } = this;
+    e.setAttribute("width", "10000"), e.setAttribute("height", "10000"), e.style.overflow = "hidden", t.appendChild(e), e.appendChild(r), e.appendChild(n), this.image = j.get().createImage();
+  }
+  destroy() {
+    this.svgRoot.remove(), this.foreignObject.remove(), this.styleElement.remove(), this.domElement.remove(), this.image.src = "", this.image.remove(), this.svgRoot = null, this.foreignObject = null, this.styleElement = null, this.domElement = null, this.image = null, this.canvasAndContext = null;
+  }
+}
+let ae;
+function xt(a, e, t, r) {
+  r || (r = ae || (ae = new Ue()));
+  const { domElement: n, styleElement: s, svgRoot: i } = r;
+  n.innerHTML = `<style>${e.cssStyle};</style><div style='padding:0'>${a}</div>`, n.setAttribute("style", "transform-origin: top left; display: inline-block"), t && (s.textContent = t), document.body.appendChild(i);
+  const o = n.getBoundingClientRect();
+  i.remove();
+  const u = e.padding * 2;
+  return {
+    width: o.width - u,
+    height: o.height - u
+  };
+}
+class _t {
+  constructor() {
+    this.batches = [], this.batched = !1;
+  }
+  destroy() {
+    this.batches.forEach((e) => {
+      M.return(e);
+    }), this.batches.length = 0;
+  }
+}
+class Be {
+  constructor(e, t) {
+    this.state = D.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, n = this.renderer.graphicsContext.updateGpuContext(t);
+    return !!(n.isBatchable || r !== n.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 n = 0; n < r.length; n++) {
+      const s = r[n];
+      s._batcher.updateElement(s);
+    }
+  }
+  execute(e) {
+    if (!e.isRenderable)
+      return;
+    const t = this.renderer, r = e.context;
+    if (!t.graphicsContext.getGpuContext(r).batches.length)
+      return;
+    const s = r.customShader || this._adaptor.shader;
+    this.state.blendMode = e.groupBlendMode;
+    const i = s.resources.localUniforms.uniforms;
+    i.uTransformMatrix = e.groupTransform, i.uRound = t._roundPixels | e._roundPixels, z(
+      e.groupColorAlpha,
+      i.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, n = this._getGpuDataForRenderable(e).batches;
+    for (let s = 0; s < n.length; s++) {
+      const i = n[s];
+      r.addToBatch(i, t);
+    }
+  }
+  _getGpuDataForRenderable(e) {
+    return e._gpuData[this.renderer.uid] || this._initGpuDataForRenderable(e);
+  }
+  _initGpuDataForRenderable(e) {
+    const t = new _t();
+    return e._gpuData[this.renderer.uid] = t, t;
+  }
+  _updateBatchesForRenderable(e, t) {
+    const r = e.context, n = this.renderer.graphicsContext.getGpuContext(r), s = this.renderer._roundPixels | e._roundPixels;
+    t.batches = n.batches.map((i) => {
+      const o = M.get(je);
+      return i.copyTo(o), o.renderable = e, o.roundPixels = s, o;
+    });
+  }
+  destroy() {
+    this.renderer = null, this._adaptor.destroy(), this._adaptor = null, this.state = null;
+  }
+}
+Be.extension = {
+  type: [
+    p.WebGLPipes,
+    p.WebGPUPipes,
+    p.CanvasPipes
+  ],
+  name: "graphics"
+};
+const Ge = class Me extends J {
+  constructor(...e) {
+    super({});
+    let t = e[0] ?? {};
+    typeof t == "number" && (G(ge, "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 = { ...Me.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 = [], n = [], s = [], i = this.verticesX - 1, o = this.verticesY - 1, u = this.width / i, c = this.height / o;
+    for (let l = 0; l < t; l++) {
+      const d = l % this.verticesX, f = l / this.verticesX | 0;
+      r.push(d * u, f * c), n.push(d / i, f / o);
+    }
+    const h = i * o;
+    for (let l = 0; l < h; l++) {
+      const d = l % i, f = l / i | 0, g = f * this.verticesX + d, m = f * this.verticesX + d + 1, x = (f + 1) * this.verticesX + d, _ = (f + 1) * this.verticesX + d + 1;
+      s.push(
+        g,
+        m,
+        x,
+        m,
+        _,
+        x
+      );
+    }
+    this.buffers[0].data = new Float32Array(r), this.buffers[1].data = new Float32Array(n), this.indexBuffer.data = new Uint32Array(s), this.buffers[0].update(), this.buffers[1].update(), this.indexBuffer.update();
+  }
+};
+Ge.defaultOptions = {
+  width: 100,
+  height: 100,
+  verticesX: 10,
+  verticesY: 10
+};
+let bt = Ge;
+class Z {
+  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 n = r;
+    const s = this.texture.textureMatrix;
+    return s.isSimple || (n = this._transformedUvs, (this._textureMatrixUpdateId !== s._updateID || this._uvUpdateId !== t._updateID) && ((!n || n.length < r.length) && (n = this._transformedUvs = new Float32Array(r.length)), this._textureMatrixUpdateId = s._updateID, this._uvUpdateId = t._updateID, s.multiplyUvs(r, n))), n;
+  }
+  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 oe {
+  destroy() {
+  }
+}
+class De {
+  constructor(e, t) {
+    this.localUniforms = new C({
+      uTransformMatrix: { value: new P(), type: "mat3x3<f32>" },
+      uColor: { value: new Float32Array([1, 1, 1, 1]), type: "vec4<f32>" },
+      uRound: { value: 0, type: "f32" }
+    }), this.localUniformsBindGroup = new pe({
+      0: this.localUniforms
+    }), this.renderer = e, this._adaptor = t, this._adaptor.init();
+  }
+  validateRenderable(e) {
+    const t = this._getMeshData(e), r = t.batched, n = e.batched;
+    if (t.batched = n, r !== n)
+      return !0;
+    if (n) {
+      const s = e._geometry;
+      if (s.indices.length !== t.indexSize || s.positions.length !== t.vertexSize)
+        return t.indexSize = s.indices.length, t.vertexSize = s.positions.length, !0;
+      const i = this._getBatchableMesh(e);
+      return i.texture.uid !== e._texture.uid && (i._textureMatrixUpdateId = -1), !i._batcher.checkAndUpdateTexture(
+        i,
+        e._texture
+      );
+    }
+    return !1;
+  }
+  addRenderable(e, t) {
+    const r = this.renderer.renderPipes.batch, n = this._getMeshData(e);
+    if (e.didViewUpdate && (n.indexSize = e._geometry.indices?.length, n.vertexSize = e._geometry.positions?.length), n.batched) {
+      const s = this._getBatchableMesh(e);
+      s.setTexture(e._texture), s.geometry = e._geometry, r.addToBatch(s, 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 = q(e.groupBlendMode, e.texture._source);
+    const t = this.localUniforms;
+    t.uniforms.uTransformMatrix = e.groupTransform, t.uniforms.uRound = this.renderer._roundPixels | e._roundPixels, t.update(), z(
+      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 oe()), 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 oe()), e._gpuData[this.renderer.uid].batchableMesh || this._initBatchableMesh(e);
+  }
+  _initBatchableMesh(e) {
+    const t = new Z();
+    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;
+  }
+}
+De.extension = {
+  type: [
+    p.WebGLPipes,
+    p.WebGPUPipes,
+    p.CanvasPipes
+  ],
+  name: "mesh"
+};
+class yt {
+  execute(e, t) {
+    const r = e.state, n = e.renderer, s = t.shader || e.defaultShader;
+    s.resources.uTexture = t.texture._source, s.resources.uniforms = e.localUniforms;
+    const i = n.gl, o = e.getBuffers(t);
+    n.shader.bind(s), n.state.set(r), n.geometry.bind(o.geometry, s.glProgram);
+    const c = o.geometry.indexBuffer.data.BYTES_PER_ELEMENT === 2 ? i.UNSIGNED_SHORT : i.UNSIGNED_INT;
+    i.drawElements(i.TRIANGLES, t.particleChildren.length * 6, c, 0);
+  }
+}
+class vt {
+  execute(e, t) {
+    const r = e.renderer, n = t.shader || e.defaultShader;
+    n.groups[0] = r.renderPipes.uniformBatch.getUniformBindGroup(e.localUniforms, !0), n.groups[1] = r.texture.getTextureBindGroup(t.texture);
+    const s = e.state, i = e.getBuffers(t);
+    r.encoder.draw({
+      geometry: i.geometry,
+      shader: t.shader || e.defaultShader,
+      state: s,
+      size: t.particleChildren.length * 6
+    });
+  }
+}
+function ue(a, e = null) {
+  const t = a * 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, n = 0; r < t; r += 6, n += 4)
+    e[r + 0] = n + 0, e[r + 1] = n + 1, e[r + 2] = n + 2, e[r + 3] = n + 0, e[r + 4] = n + 2, e[r + 5] = n + 3;
+  return e;
+}
+function Tt(a) {
+  return {
+    dynamicUpdate: le(a, !0),
+    staticUpdate: le(a, !1)
+  };
+}
+function le(a, 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 s in a) {
+    const i = a[s];
+    if (e !== i.dynamic)
+      continue;
+    t.push(`offset = index + ${r}`), t.push(i.code);
+    const o = L(i.format);
+    r += o.stride / 4;
+  }
+  t.push(`
+            index += stride * 4;
+        }
+    `), t.unshift(`
+        var stride = ${r};
+    `);
+  const n = t.join(`
+`);
+  return new Function("ps", "f32v", "u32v", n);
+}
+class Pt {
+  constructor(e) {
+    this._size = 0, this._generateParticleUpdateCache = {};
+    const t = this._size = e.size ?? 1e3, r = e.properties;
+    let n = 0, s = 0;
+    for (const h in r) {
+      const l = r[h], d = L(l.format);
+      l.dynamic ? s += d.stride : n += d.stride;
+    }
+    this._dynamicStride = s / 4, this._staticStride = n / 4, this.staticAttributeBuffer = new U(t * 4 * n), this.dynamicAttributeBuffer = new U(t * 4 * s), this.indexBuffer = ue(t);
+    const i = new N();
+    let o = 0, u = 0;
+    this._staticBuffer = new F({
+      data: new Float32Array(1),
+      label: "static-particle-buffer",
+      shrinkToFit: !1,
+      usage: T.VERTEX | T.COPY_DST
+    }), this._dynamicBuffer = new F({
+      data: new Float32Array(1),
+      label: "dynamic-particle-buffer",
+      shrinkToFit: !1,
+      usage: T.VERTEX | T.COPY_DST
+    });
+    for (const h in r) {
+      const l = r[h], d = L(l.format);
+      l.dynamic ? (i.addAttribute(l.attributeName, {
+        buffer: this._dynamicBuffer,
+        stride: this._dynamicStride * 4,
+        offset: o * 4,
+        format: l.format
+      }), o += d.size) : (i.addAttribute(l.attributeName, {
+        buffer: this._staticBuffer,
+        stride: this._staticStride * 4,
+        offset: u * 4,
+        format: l.format
+      }), u += d.size);
+    }
+    i.addIndex(this.indexBuffer);
+    const c = this.getParticleUpdate(r);
+    this._dynamicUpload = c.dynamicUpdate, this._staticUpload = c.staticUpdate, this.geometry = i;
+  }
+  getParticleUpdate(e) {
+    const t = wt(e);
+    return this._generateParticleUpdateCache[t] ? this._generateParticleUpdateCache[t] : (this._generateParticleUpdateCache[t] = this.generateParticleUpdate(e), this._generateParticleUpdateCache[t]);
+  }
+  generateParticleUpdate(e) {
+    return Tt(e);
+  }
+  update(e, t) {
+    e.length > this._size && (t = !0, this._size = Math.max(e.length, this._size * 1.5 | 0), this.staticAttributeBuffer = new U(this._size * this._staticStride * 4 * 4), this.dynamicAttributeBuffer = new U(this._size * this._dynamicStride * 4 * 4), this.indexBuffer = ue(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 n = this.staticAttributeBuffer;
+      this._staticUpload(e, n.float32View, n.uint32View), this._staticBuffer.setDataWithSize(
+        n.float32View,
+        e.length * this._staticStride * 4,
+        !0
+      );
+    }
+  }
+  destroy() {
+    this._staticBuffer.destroy(), this._dynamicBuffer.destroy(), this.geometry.destroy();
+  }
+}
+function wt(a) {
+  const e = [];
+  for (const t in a) {
+    const r = a[t];
+    e.push(t, r.code, r.dynamic ? "d" : "s");
+  }
+  return e.join("_");
+}
+var Ct = `varying vec2 vUV;
+varying vec4 vColor;
+
+uniform sampler2D uTexture;
+
+void main(void){
+    vec4 color = texture2D(uTexture, vUV) * vColor;
+    gl_FragColor = color;
+}`, St = `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;
+}
+`, ce = `
+struct ParticleUniforms {
+  uTranslationMatrix:mat3x3<f32>,
+  uColor:vec4<f32>,
+  uRound:f32,
+  uResolution:vec2<f32>,
+};
+
+fn roundPixels(position: vec2<f32>, targetSize: vec2<f32>) -> vec2<f32>
+{
+  return (floor(((position * 0.5 + 0.5) * targetSize) + 0.5) / targetSize) * 2.0 - 1.0;
+}
+
+@group(0) @binding(0) var<uniform> uniforms: ParticleUniforms;
+
+@group(1) @binding(0) var uTexture: texture_2d<f32>;
+@group(1) @binding(1) var uSampler : sampler;
+
+struct VSOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) uv : vec2<f32>,
+    @location(1) color : vec4<f32>,
+  };
+@vertex
+fn mainVertex(
+  @location(0) aVertex: vec2<f32>,
+  @location(1) aPosition: vec2<f32>,
+  @location(2) aUV: vec2<f32>,
+  @location(3) aColor: vec4<f32>,
+  @location(4) aRotation: f32,
+) -> VSOutput {
+  
+   let v = vec2(
+       aVertex.x * cos(aRotation) - aVertex.y * sin(aRotation),
+       aVertex.x * sin(aRotation) + aVertex.y * cos(aRotation)
+   ) + aPosition;
+
+   var position = vec4((uniforms.uTranslationMatrix * vec3(v, 1.0)).xy, 0.0, 1.0);
+
+   if(uniforms.uRound == 1.0) {
+       position = vec4(roundPixels(position.xy, uniforms.uResolution), position.zw);
+   }
+
+    let vColor = vec4(aColor.rgb * aColor.a, aColor.a) * uniforms.uColor;
+
+  return VSOutput(
+   position,
+   aUV,
+   vColor,
+  );
+}
+
+@fragment
+fn mainFragment(
+  @location(0) uv: vec2<f32>,
+  @location(1) color: vec4<f32>,
+  @builtin(position) position: vec4<f32>,
+) -> @location(0) vec4<f32> {
+
+    var sample = textureSample(uTexture, uSampler, uv) * color;
+   
+    return sample;
+}`;
+class Ft extends Q {
+  constructor() {
+    const e = fe.from({
+      vertex: St,
+      fragment: Ct
+    }), t = he.from({
+      fragment: {
+        source: ce,
+        entryPoint: "mainFragment"
+      },
+      vertex: {
+        source: ce,
+        entryPoint: "mainVertex"
+      }
+    });
+    super({
+      glProgram: e,
+      gpuProgram: t,
+      resources: {
+        // this will be replaced with the texture from the particle container
+        uTexture: w.WHITE.source,
+        // this will be replaced with the texture style from the particle container
+        uSampler: new X({}),
+        // this will be replaced with the local uniforms from the particle container
+        uniforms: {
+          uTranslationMatrix: { value: new P(), type: "mat3x3<f32>" },
+          uColor: { value: new qe(16777215), type: "vec4<f32>" },
+          uRound: { value: 1, type: "f32" },
+          uResolution: { value: [0, 0], type: "vec2<f32>" }
+        }
+      }
+    });
+  }
+}
+class ze {
+  /**
+   * @param renderer - The renderer this sprite batch works for.
+   * @param adaptor
+   */
+  constructor(e, t) {
+    this.state = D.for2d(), this.localUniforms = new C({
+      uTranslationMatrix: { value: new P(), 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 Ft(), this.state = D.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 Pt({
+      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, n = this.getBuffers(e);
+    e.texture || (e.texture = t[0].texture);
+    const s = this.state;
+    n.update(t, e._childrenDirty), e._childrenDirty = !1, s.blendMode = q(e.blendMode, e.texture._source);
+    const i = this.localUniforms.uniforms, o = i.uTranslationMatrix;
+    e.worldTransform.copyTo(o), o.prepend(r.globalUniforms.globalUniformData.projectionMatrix), i.uResolution = r.globalUniforms.globalUniformData.resolution, i.uRound = r._roundPixels | e._roundPixels, z(
+      e.groupColorAlpha,
+      i.uColor,
+      0
+    ), this.adaptor.execute(this, e);
+  }
+  /** Destroys the ParticleRenderer. */
+  destroy() {
+    this.renderer = null, this.defaultShader && (this.defaultShader.destroy(), this.defaultShader = null);
+  }
+}
+class Ae extends ze {
+  constructor(e) {
+    super(e, new yt());
+  }
+}
+Ae.extension = {
+  type: [
+    p.WebGLPipes
+  ],
+  name: "particle"
+};
+class ke extends ze {
+  constructor(e) {
+    super(e, new vt());
+  }
+}
+ke.extension = {
+  type: [
+    p.WebGPUPipes
+  ],
+  name: "particle"
+};
+const Oe = class Ie extends bt {
+  constructor(e = {}) {
+    e = { ...Ie.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) {
+    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 = e.anchor?.x, this._anchorY = e.anchor?.y, this.updateUvs(), this.updatePositions();
+  }
+  /** Updates the positions of the vertices. */
+  updatePositions() {
+    const e = this.positions, {
+      width: t,
+      height: r,
+      _leftWidth: n,
+      _rightWidth: s,
+      _topHeight: i,
+      _bottomHeight: o,
+      _anchorX: u,
+      _anchorY: c
+    } = this, h = n + s, l = t > h ? 1 : t / h, d = i + o, f = r > d ? 1 : r / d, g = Math.min(l, f), m = u * t, x = c * r;
+    e[0] = e[8] = e[16] = e[24] = -m, e[2] = e[10] = e[18] = e[26] = n * g - m, e[4] = e[12] = e[20] = e[28] = t - s * g - m, e[6] = e[14] = e[22] = e[30] = t - m, e[1] = e[3] = e[5] = e[7] = -x, e[9] = e[11] = e[13] = e[15] = i * g - x, e[17] = e[19] = e[21] = e[23] = r - o * g - x, e[25] = e[27] = e[29] = e[31] = r - x, 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();
+  }
+};
+Oe.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 Rt = Oe;
+class Ut extends Z {
+  constructor() {
+    super(), this.geometry = new Rt();
+  }
+  destroy() {
+    this.geometry.destroy();
+  }
+}
+class Ee {
+  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 Ut(), 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;
+  }
+}
+Ee.extension = {
+  type: [
+    p.WebGLPipes,
+    p.WebGPUPipes,
+    p.CanvasPipes
+  ],
+  name: "nineSliceSprite"
+};
+const Bt = {
+  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);
+        `
+    )
+  }
+}, Gt = {
+  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 O, I;
+class Mt extends Q {
+  constructor() {
+    O ?? (O = xe({
+      name: "tiling-sprite-shader",
+      bits: [
+        lt,
+        Bt,
+        _e
+      ]
+    })), I ?? (I = be({
+      name: "tiling-sprite-shader",
+      bits: [
+        ct,
+        Gt,
+        ye
+      ]
+    }));
+    const e = new C({
+      uMapCoord: { value: new P(), 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 P(), type: "mat3x3<f32>" },
+      uSizeAnchor: { value: new Float32Array([100, 100, 0.5, 0.5]), type: "vec4<f32>" }
+    });
+    super({
+      glProgram: I,
+      gpuProgram: O,
+      resources: {
+        localUniforms: new C({
+          uTransformMatrix: { value: new P(), type: "mat3x3<f32>" },
+          uColor: { value: new Float32Array([1, 1, 1, 1]), type: "vec4<f32>" },
+          uRound: { value: 0, type: "f32" }
+        }),
+        tilingUniforms: e,
+        uTexture: w.EMPTY.source,
+        uSampler: w.EMPTY.source.style
+      }
+    });
+  }
+  updateUniforms(e, t, r, n, s, i) {
+    const o = this.resources.tilingUniforms, u = i.width, c = i.height, h = i.textureMatrix, l = o.uniforms.uTextureTransform;
+    l.set(
+      r.a * u / e,
+      r.b * u / t,
+      r.c * c / e,
+      r.d * c / t,
+      r.tx / e,
+      r.ty / t
+    ), l.invert(), o.uniforms.uMapCoord = h.mapCoord, o.uniforms.uClampFrame = h.uClampFrame, o.uniforms.uClampOffset = h.uClampOffset, o.uniforms.uTextureTransform = l, o.uniforms.uSizeAnchor[0] = e, o.uniforms.uSizeAnchor[1] = t, o.uniforms.uSizeAnchor[2] = n, o.uniforms.uSizeAnchor[3] = s, i && (this.resources.uTexture = i.source, this.resources.uSampler = i.source.style);
+  }
+}
+class Dt extends J {
+  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 zt(a, e) {
+  const t = a.anchor.x, r = a.anchor.y;
+  e[0] = -t * a.width, e[1] = -r * a.height, e[2] = (1 - t) * a.width, e[3] = -r * a.height, e[4] = (1 - t) * a.width, e[5] = (1 - r) * a.height, e[6] = -t * a.width, e[7] = (1 - r) * a.height;
+}
+function At(a, e, t, r) {
+  let n = 0;
+  const s = a.length / e, i = r.a, o = r.b, u = r.c, c = r.d, h = r.tx, l = r.ty;
+  for (t *= e; n < s; ) {
+    const d = a[t], f = a[t + 1];
+    a[t] = i * d + u * f + h, a[t + 1] = o * d + c * f + l, t += e, n++;
+  }
+}
+function kt(a, e) {
+  const t = a.texture, r = t.frame.width, n = t.frame.height;
+  let s = 0, i = 0;
+  a.applyAnchorToTexture && (s = a.anchor.x, i = a.anchor.y), e[0] = e[6] = -s, e[2] = e[4] = 1 - s, e[1] = e[3] = -i, e[5] = e[7] = 1 - i;
+  const o = P.shared;
+  o.copyFrom(a._tileTransform.matrix), o.tx /= a.width, o.ty /= a.height, o.invert(), o.scale(a.width / r, a.height / n), At(e, 2, 0, o);
+}
+const B = new Dt();
+class Ot {
+  constructor() {
+    this.canBatch = !0, this.geometry = new J({
+      indices: B.indices.slice(),
+      positions: B.positions.slice(),
+      uvs: B.uvs.slice()
+    });
+  }
+  destroy() {
+    this.geometry.destroy(), this.shader?.destroy();
+  }
+}
+class Ve {
+  constructor(e) {
+    this._state = D.default2d, this._renderer = e;
+  }
+  validateRenderable(e) {
+    const t = this._getTilingSpriteData(e), r = t.canBatch;
+    this._updateCanBatch(e);
+    const n = t.canBatch;
+    if (n && n === r) {
+      const { batchableMesh: s } = t;
+      return !s._batcher.checkAndUpdateTexture(
+        s,
+        e.texture
+      );
+    }
+    return r !== n;
+  }
+  addRenderable(e, t) {
+    const r = this._renderer.renderPipes.batch;
+    this._updateCanBatch(e);
+    const n = this._getTilingSpriteData(e), { geometry: s, canBatch: i } = n;
+    if (i) {
+      n.batchableMesh || (n.batchableMesh = new Z());
+      const o = n.batchableMesh;
+      e.didViewUpdate && (this._updateBatchableMesh(e), o.geometry = s, o.renderable = e, o.transform = e.groupTransform, o.setTexture(e._texture)), o.roundPixels = this._renderer._roundPixels | e._roundPixels, r.addToBatch(o, t);
+    } else
+      r.break(t), n.shader || (n.shader = new Mt()), 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, z(
+      e.groupColorAlpha,
+      r.uColor,
+      0
+    ), this._state.blendMode = q(e.groupBlendMode, e.texture._source), this._renderer.encoder.draw({
+      geometry: B,
+      shader: t,
+      state: this._state
+    });
+  }
+  updateRenderable(e) {
+    const t = this._getTilingSpriteData(e), { canBatch: r } = t;
+    if (r) {
+      const { batchableMesh: n } = t;
+      e.didViewUpdate && this._updateBatchableMesh(e), n._batcher.updateElement(n);
+    } else if (e.didViewUpdate) {
+      const { shader: n } = t;
+      n.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 Ot();
+    return t.renderable = e, e._gpuData[this._renderer.uid] = t, t;
+  }
+  _updateBatchableMesh(e) {
+    const t = this._getTilingSpriteData(e), { geometry: r } = t, n = e.texture.source.style;
+    n.addressMode !== "repeat" && (n.addressMode = "repeat", n.update()), kt(e, r.uvs), zt(e, r.positions);
+  }
+  destroy() {
+    this._renderer = null;
+  }
+  _updateCanBatch(e) {
+    const t = this._getTilingSpriteData(e), r = e.texture;
+    let n = !0;
+    return this._renderer.type === $.WEBGL && (n = this._renderer.context.supports.nonPowOf2wrapping), t.canBatch = r.textureMatrix.isSimple && (n || r.source.isPowerOfTwo), t.canBatch;
+  }
+}
+Ve.extension = {
+  type: [
+    p.WebGLPipes,
+    p.WebGPUPipes,
+    p.CanvasPipes
+  ],
+  name: "tilingSprite"
+};
+const It = {
+  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));
+        `
+    )
+  }
+}, Et = {
+  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));
+        `
+    )
+  }
+}, Vt = {
+  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;
+
+            }
+        `
+    )
+  }
+}, Wt = {
+  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 E, V;
+class Yt extends Q {
+  constructor(e) {
+    const t = new C({
+      uColor: { value: new Float32Array([1, 1, 1, 1]), type: "vec4<f32>" },
+      uTransformMatrix: { value: new P(), type: "mat3x3<f32>" },
+      uDistance: { value: 4, type: "f32" },
+      uRound: { value: 0, type: "f32" }
+    });
+    E ?? (E = xe({
+      name: "sdf-shader",
+      bits: [
+        Qe,
+        Je(e),
+        It,
+        Vt,
+        _e
+      ]
+    })), V ?? (V = be({
+      name: "sdf-shader",
+      bits: [
+        Ze,
+        et(e),
+        Et,
+        Wt,
+        ye
+      ]
+    })), super({
+      glProgram: V,
+      gpuProgram: E,
+      resources: {
+        localUniforms: t,
+        batchSamplers: tt(e)
+      }
+    });
+  }
+}
+class Lt extends it {
+  destroy() {
+    this.context.customShader && this.context.customShader.destroy(), super.destroy();
+  }
+}
+class We {
+  constructor(e) {
+    this._renderer = e;
+  }
+  validateRenderable(e) {
+    const t = this._getGpuBitmapText(e);
+    return this._renderer.renderPipes.graphics.validateRenderable(t);
+  }
+  addRenderable(e, t) {
+    const r = this._getGpuBitmapText(e);
+    de(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);
+    de(e, t), this._renderer.renderPipes.graphics.updateRenderable(t), t.context.customShader && this._updateDistanceField(e);
+  }
+  _updateContext(e, t) {
+    const { context: r } = t, n = rt.getFont(e.text, e._style);
+    r.clear(), n.distanceField.type !== "none" && (r.customShader || (r.customShader = new Yt(this._renderer.limits.maxBatchableTextures)));
+    const s = nt.graphemeSegmenter(e.text), i = e._style;
+    let o = n.baseLineOffset;
+    const u = st(s, i, n, !0), c = i.padding, h = u.scale;
+    let l = u.width, d = u.height + u.offsetY;
+    i._stroke && (l += i._stroke.width / h, d += i._stroke.width / h), r.translate(-e._anchor._x * l - c, -e._anchor._y * d - c).scale(h, h);
+    const f = n.applyFillAsTint ? i._fill.color : 16777215;
+    let g = n.fontMetrics.fontSize, m = n.lineHeight;
+    i.lineHeight && (g = i.fontSize / h, m = i.lineHeight / h);
+    let x = (m - g) / 2;
+    x - n.baseLineOffset < 0 && (x = 0);
+    for (let _ = 0; _ < u.lines.length; _++) {
+      const y = u.lines[_];
+      for (let S = 0; S < y.charPositions.length; S++) {
+        const Ne = y.chars[S], R = n.chars[Ne];
+        if (R?.texture) {
+          const A = R.texture;
+          r.texture(
+            A,
+            f || "black",
+            Math.round(y.charPositions[S] + R.xOffset),
+            Math.round(o + R.yOffset + x),
+            A.orig.width,
+            A.orig.height
+          );
+        }
+      }
+      o += m;
+    }
+  }
+  _getGpuBitmapText(e) {
+    return e._gpuData[this._renderer.uid] || this.initGpuText(e);
+  }
+  initGpuText(e) {
+    const t = new Lt();
+    return e._gpuData[this._renderer.uid] = t, this._updateContext(e, t), t;
+  }
+  _updateDistanceField(e) {
+    const t = this._getGpuBitmapText(e).context, r = e._style.fontFamily, n = H.get(`${r}-bitmap`), { a: s, b: i, c: o, d: u } = e.groupTransform, c = Math.sqrt(s * s + i * i), h = Math.sqrt(o * o + u * u), l = (Math.abs(c) + Math.abs(h)) / 2, d = n.baseRenderedFontSize / e._style.fontSize, f = l * n.distanceField.range * (1 / d);
+    t.customShader.resources.localUniforms.uniforms.uDistance = f;
+  }
+  destroy() {
+    this._renderer = null;
+  }
+}
+We.extension = {
+  type: [
+    p.WebGLPipes,
+    p.WebGPUPipes,
+    p.CanvasPipes
+  ],
+  name: "bitmapText"
+};
+function de(a, e) {
+  e.groupTransform = a.groupTransform, e.groupColorAlpha = a.groupColorAlpha, e.groupColor = a.groupColor, e.groupBlendMode = a.groupBlendMode, e.globalDisplayStatus = a.globalDisplayStatus, e.groupTransform = a.groupTransform, e.localDisplayStatus = a.localDisplayStatus, e.groupAlpha = a.groupAlpha, e._roundPixels = a._roundPixels;
+}
+class Xt extends Te {
+  /**
+   * Creates an instance of BatchableHTMLText.
+   * @param renderer - The renderer instance to be used.
+   */
+  constructor(e) {
+    super(), this.generatingTexture = !1, this.currentKey = "--", this._renderer = e, e.runners.resolutionChange.add(this);
+  }
+  /** Handles resolution changes for the HTML text. If the text has auto resolution enabled, it triggers a view update. */
+  resolutionChange() {
+    const e = this.renderable;
+    e._autoResolution && e.onViewUpdate();
+  }
+  /** Destroys the BatchableHTMLText instance. Returns the texture promise to the renderer and cleans up references. */
+  destroy() {
+    const { htmlText: e } = this._renderer;
+    e.getReferenceCount(this.currentKey) === null ? e.returnTexturePromise(this.texturePromise) : e.decreaseReferenceCount(this.currentKey), this._renderer.runners.resolutionChange.remove(this), this.texturePromise = null, this._renderer = null;
+  }
+}
+function K(a, e) {
+  const { texture: t, bounds: r } = a, n = e._style._getFinalPadding();
+  at(r, e._anchor, t);
+  const s = e._anchor._x * n * 2, i = e._anchor._y * n * 2;
+  r.minX -= n - s, r.minY -= n - i, r.maxX -= n - s, r.maxY -= n - i;
+}
+class Ye {
+  constructor(e) {
+    this._renderer = e;
+  }
+  validateRenderable(e) {
+    const t = this._getGpuText(e), r = e.styleKey;
+    return t.currentKey !== r;
+  }
+  addRenderable(e, t) {
+    const r = this._getGpuText(e);
+    if (e._didTextUpdate) {
+      const n = e._autoResolution ? this._renderer.resolution : e.resolution;
+      (r.currentKey !== e.styleKey || e.resolution !== n) && this._updateGpuText(e).catch((s) => {
+        console.error(s);
+      }), e._didTextUpdate = !1, K(r, e);
+    }
+    this._renderer.renderPipes.batch.addToBatch(r, t);
+  }
+  updateRenderable(e) {
+    const t = this._getGpuText(e);
+    t._batcher.updateElement(t);
+  }
+  async _updateGpuText(e) {
+    e._didTextUpdate = !1;
+    const t = this._getGpuText(e);
+    if (t.generatingTexture)
+      return;
+    const r = t.texturePromise;
+    t.texturePromise = null, t.generatingTexture = !0, e._resolution = e._autoResolution ? this._renderer.resolution : e.resolution;
+    let n = this._renderer.htmlText.getTexturePromise(e);
+    r && (n = n.finally(() => {
+      this._renderer.htmlText.decreaseReferenceCount(t.currentKey), this._renderer.htmlText.returnTexturePromise(r);
+    })), t.texturePromise = n, t.currentKey = e.styleKey, t.texture = await n;
+    const s = e.renderGroup || e.parentRenderGroup;
+    s && (s.structureDidChange = !0), t.generatingTexture = !1, K(t, e);
+  }
+  _getGpuText(e) {
+    return e._gpuData[this._renderer.uid] || this.initGpuText(e);
+  }
+  initGpuText(e) {
+    const t = new Xt(this._renderer);
+    return t.renderable = e, t.transform = e.groupTransform, t.texture = w.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;
+  }
+}
+Ye.extension = {
+  type: [
+    p.WebGLPipes,
+    p.WebGPUPipes,
+    p.CanvasPipes
+  ],
+  name: "htmlText"
+};
+function Ht() {
+  const { userAgent: a } = j.get().getNavigator();
+  return /^((?!chrome|android).)*safari/i.test(a);
+}
+const Kt = new me();
+function Le(a, e, t, r) {
+  const n = Kt;
+  n.minX = 0, n.minY = 0, n.maxX = a.width / r | 0, n.maxY = a.height / r | 0;
+  const s = v.getOptimalTexture(
+    n.width,
+    n.height,
+    r,
+    !1
+  );
+  return s.source.uploadMethodId = "image", s.source.resource = a, s.source.alphaMode = "premultiply-alpha-on-upload", s.frame.width = e / r, s.frame.height = t / r, s.source.emit("update", s.source), s.updateUvs(), s;
+}
+function Nt(a, e) {
+  const t = e.fontFamily, r = [], n = {}, s = /font-family:([^;"\s]+)/g, i = a.match(s);
+  function o(u) {
+    n[u] || (r.push(u), n[u] = !0);
+  }
+  if (Array.isArray(t))
+    for (let u = 0; u < t.length; u++)
+      o(t[u]);
+  else
+    o(t);
+  i && i.forEach((u) => {
+    const c = u.split(":")[1].trim();
+    o(c);
+  });
+  for (const u in e.tagStyles) {
+    const c = e.tagStyles[u].fontFamily;
+    o(c);
+  }
+  return r;
+}
+async function $t(a) {
+  const t = await (await j.get().fetch(a)).blob(), r = new FileReader();
+  return await new Promise((s, i) => {
+    r.onloadend = () => s(r.result), r.onerror = i, r.readAsDataURL(t);
+  });
+}
+async function jt(a, e) {
+  const t = await $t(e);
+  return `@font-face {
+        font-family: "${a.fontFamily}";
+        font-weight: ${a.fontWeight};
+        font-style: ${a.fontStyle};
+        src: url('${t}');
+    }`;
+}
+const W = /* @__PURE__ */ new Map();
+async function qt(a) {
+  const e = a.filter((t) => H.has(`${t}-and-url`)).map((t) => {
+    if (!W.has(t)) {
+      const { entries: r } = H.get(`${t}-and-url`), n = [];
+      r.forEach((s) => {
+        const i = s.url, u = s.faces.map((c) => ({ weight: c.weight, style: c.style }));
+        n.push(
+          ...u.map(
+            (c) => jt(
+              {
+                fontWeight: c.weight,
+                fontStyle: c.style,
+                fontFamily: t
+              },
+              i
+            )
+          )
+        );
+      }), W.set(
+        t,
+        Promise.all(n).then((s) => s.join(`
+`))
+      );
+    }
+    return W.get(t);
+  });
+  return (await Promise.all(e)).join(`
+`);
+}
+function Qt(a, e, t, r, n) {
+  const { domElement: s, styleElement: i, svgRoot: o } = n;
+  s.innerHTML = `<style>${e.cssStyle}</style><div style='padding:0;'>${a}</div>`, s.setAttribute("style", `transform: scale(${t});transform-origin: top left; display: inline-block`), i.textContent = r;
+  const { width: u, height: c } = n.image;
+  return o.setAttribute("width", u.toString()), o.setAttribute("height", c.toString()), new XMLSerializer().serializeToString(o);
+}
+function Jt(a, e) {
+  const t = ve.getOptimalCanvasAndContext(
+    a.width,
+    a.height,
+    e
+  ), { context: r } = t;
+  return r.clearRect(0, 0, a.width, a.height), r.drawImage(a, 0, 0), t;
+}
+function Zt(a, e, t) {
+  return new Promise(async (r) => {
+    t && await new Promise((n) => setTimeout(n, 100)), a.onload = () => {
+      r();
+    }, a.src = `data:image/svg+xml;charset=utf8,${encodeURIComponent(e)}`, a.crossOrigin = "anonymous";
+  });
+}
+class Xe {
+  constructor(e) {
+    this._activeTextures = {}, this._renderer = e, this._createCanvas = e.type === $.WEBGPU;
+  }
+  /**
+   * @param options
+   * @deprecated Use getTexturePromise instead
+   */
+  getTexture(e) {
+    return this.getTexturePromise(e);
+  }
+  /**
+   * Increases the reference count for a texture.
+   * @param text - The HTMLText instance associated with the texture.
+   */
+  getManagedTexture(e) {
+    const t = e.styleKey;
+    if (this._activeTextures[t])
+      return this._increaseReferenceCount(t), this._activeTextures[t].promise;
+    const r = this._buildTexturePromise(e).then((n) => (this._activeTextures[t].texture = n, n));
+    return this._activeTextures[t] = {
+      texture: null,
+      promise: r,
+      usageCount: 1
+    }, r;
+  }
+  /**
+   * Gets the current reference count for a texture associated with a text key.
+   * @param textKey - The unique key identifying the text style configuration
+   * @returns The number of Text instances currently using this texture
+   */
+  getReferenceCount(e) {
+    return this._activeTextures[e]?.usageCount ?? null;
+  }
+  _increaseReferenceCount(e) {
+    this._activeTextures[e].usageCount++;
+  }
+  /**
+   * Decreases the reference count for a texture.
+   * If the count reaches zero, the texture is cleaned up.
+   * @param textKey - The key associated with the HTMLText instance.
+   */
+  decreaseReferenceCount(e) {
+    const t = this._activeTextures[e];
+    t && (t.usageCount--, t.usageCount === 0 && (t.texture ? this._cleanUp(t.texture) : t.promise.then((r) => {
+      t.texture = r, this._cleanUp(t.texture);
+    }).catch(() => {
+      Y("HTMLTextSystem: Failed to clean texture");
+    }), this._activeTextures[e] = null));
+  }
+  /**
+   * Returns a promise that resolves to a texture for the given HTMLText options.
+   * @param options - The options for the HTMLText.
+   * @returns A promise that resolves to a Texture.
+   */
+  getTexturePromise(e) {
+    return this._buildTexturePromise(e);
+  }
+  async _buildTexturePromise(e) {
+    const { text: t, style: r, resolution: n, textureStyle: s } = e, i = M.get(Ue), o = Nt(t, r), u = await qt(o), c = xt(t, r, u, i), h = Math.ceil(Math.ceil(Math.max(1, c.width) + r.padding * 2) * n), l = Math.ceil(Math.ceil(Math.max(1, c.height) + r.padding * 2) * n), d = i.image, f = 2;
+    d.width = (h | 0) + f, d.height = (l | 0) + f;
+    const g = Qt(t, r, n, u, i);
+    await Zt(d, g, Ht() && o.length > 0);
+    const m = d;
+    let x;
+    this._createCanvas && (x = Jt(d, n));
+    const _ = Le(
+      x ? x.canvas : m,
+      d.width - f,
+      d.height - f,
+      n
+    );
+    return s && (_.source.style = s), this._createCanvas && (this._renderer.texture.initSource(_.source), ve.returnCanvasAndContext(x)), M.return(i), _;
+  }
+  returnTexturePromise(e) {
+    e.then((t) => {
+      this._cleanUp(t);
+    }).catch(() => {
+      Y("HTMLTextSystem: Failed to clean texture");
+    });
+  }
+  _cleanUp(e) {
+    v.returnTexture(e, !0), e.source.resource = null, e.source.uploadMethodId = "unknown";
+  }
+  destroy() {
+    this._renderer = null;
+    for (const e in this._activeTextures)
+      this._activeTextures[e] && this.returnTexturePromise(this._activeTextures[e].promise);
+    this._activeTextures = null;
+  }
+}
+Xe.extension = {
+  type: [
+    p.WebGLSystem,
+    p.WebGPUSystem,
+    p.CanvasSystem
+  ],
+  name: "htmlText"
+};
+class er extends Te {
+  constructor(e) {
+    super(), this._renderer = e, e.runners.resolutionChange.add(this);
+  }
+  resolutionChange() {
+    const e = this.renderable;
+    e._autoResolution && e.onViewUpdate();
+  }
+  destroy() {
+    const { canvasText: e } = this._renderer;
+    e.getReferenceCount(this.currentKey) > 0 ? e.decreaseReferenceCount(this.currentKey) : this.texture && e.returnTexture(this.texture), this._renderer.runners.resolutionChange.remove(this), this._renderer = null;
+  }
+}
+class He {
+  constructor(e) {
+    this._renderer = e;
+  }
+  validateRenderable(e) {
+    const t = this._getGpuText(e), r = e.styleKey;
+    return t.currentKey !== r ? !0 : e._didTextUpdate;
+  }
+  addRenderable(e, t) {
+    const r = this._getGpuText(e);
+    if (e._didTextUpdate) {
+      const n = e._autoResolution ? this._renderer.resolution : e.resolution;
+      (r.currentKey !== e.styleKey || e.resolution !== n) && this._updateGpuText(e), e._didTextUpdate = !1, K(r, e);
+    }
+    this._renderer.renderPipes.batch.addToBatch(r, t);
+  }
+  updateRenderable(e) {
+    const t = this._getGpuText(e);
+    t._batcher.updateElement(t);
+  }
+  _updateGpuText(e) {
+    const t = this._getGpuText(e);
+    t.texture && this._renderer.canvasText.decreaseReferenceCount(t.currentKey), e._resolution = e._autoResolution ? this._renderer.resolution : e.resolution, t.texture = this._renderer.canvasText.getManagedTexture(e), t.currentKey = e.styleKey;
+  }
+  _getGpuText(e) {
+    return e._gpuData[this._renderer.uid] || this.initGpuText(e);
+  }
+  initGpuText(e) {
+    const t = new er(this._renderer);
+    return t.currentKey = "--", t.renderable = e, t.transform = e.groupTransform, t.bounds = { minX: 0, maxX: 1, minY: 0, maxY: 0 }, t.roundPixels = this._renderer._roundPixels | e._roundPixels, e._gpuData[this._renderer.uid] = t, t;
+  }
+  destroy() {
+    this._renderer = null;
+  }
+}
+He.extension = {
+  type: [
+    p.WebGLPipes,
+    p.WebGPUPipes,
+    p.CanvasPipes
+  ],
+  name: "text"
+};
+class Ke {
+  constructor(e) {
+    this._activeTextures = {}, this._renderer = e;
+  }
+  getTexture(e, t, r, n) {
+    typeof e == "string" && (G("8.0.0", "CanvasTextSystem.getTexture: Use object TextOptions instead of separate arguments"), e = {
+      text: e,
+      style: r,
+      resolution: t
+    }), e.style instanceof te || (e.style = new te(e.style)), e.textureStyle instanceof X || (e.textureStyle = new X(e.textureStyle)), typeof e.text != "string" && (e.text = e.text.toString());
+    const { text: s, style: i, textureStyle: o } = e, u = e.resolution ?? this._renderer.resolution, { frame: c, canvasAndContext: h } = k.getCanvasAndContext({
+      text: s,
+      style: i,
+      resolution: u
+    }), l = Le(h.canvas, c.width, c.height, u);
+    if (o && (l.source.style = o), i.trim && (c.pad(i.padding), l.frame.copyFrom(c), l.frame.scale(1 / u), l.updateUvs()), i.filters) {
+      const d = this._applyFilters(l, i.filters);
+      return this.returnTexture(l), k.returnCanvasAndContext(h), d;
+    }
+    return this._renderer.texture.initSource(l._source), k.returnCanvasAndContext(h), l;
+  }
+  /**
+   * 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", v.returnTexture(e, !0);
+  }
+  /**
+   * Renders text to its canvas, and updates its texture.
+   * @deprecated since 8.10.0
+   */
+  renderTextToCanvas() {
+    G(
+      "8.10.0",
+      "CanvasTextSystem.renderTextToCanvas: no longer supported, use CanvasTextSystem.getTexture instead"
+    );
+  }
+  /**
+   * Gets or creates a managed texture for a Text object. This method handles texture reuse and reference counting.
+   * @param text - The Text object that needs a texture
+   * @returns A Texture instance that represents the rendered text
+   * @remarks
+   * This method performs the following:
+   * 1. Sets the appropriate resolution based on auto-resolution settings
+   * 2. Checks if a texture already exists for the text's style
+   * 3. Creates a new texture if needed or returns an existing one
+   * 4. Manages reference counting for texture reuse
+   */
+  getManagedTexture(e) {
+    e._resolution = e._autoResolution ? this._renderer.resolution : e.resolution;
+    const t = e.styleKey;
+    if (this._activeTextures[t])
+      return this._increaseReferenceCount(t), this._activeTextures[t].texture;
+    const r = this.getTexture({
+      text: e.text,
+      style: e.style,
+      resolution: e._resolution,
+      textureStyle: e.textureStyle
+    });
+    return this._activeTextures[t] = {
+      texture: r,
+      usageCount: 1
+    }, r;
+  }
+  /**
+   * Decreases the reference count for a texture associated with a text key.
+   * When the reference count reaches zero, the texture is returned to the pool.
+   * @param textKey - The unique key identifying the text style configuration
+   * @remarks
+   * This method is crucial for memory management, ensuring textures are properly
+   * cleaned up when they are no longer needed by any Text instances.
+   */
+  decreaseReferenceCount(e) {
+    const t = this._activeTextures[e];
+    t.usageCount--, t.usageCount === 0 && (this.returnTexture(t.texture), this._activeTextures[e] = null);
+  }
+  /**
+   * Gets the current reference count for a texture associated with a text key.
+   * @param textKey - The unique key identifying the text style configuration
+   * @returns The number of Text instances currently using this texture
+   */
+  getReferenceCount(e) {
+    return this._activeTextures[e]?.usageCount ?? 0;
+  }
+  _increaseReferenceCount(e) {
+    this._activeTextures[e].usageCount++;
+  }
+  /**
+   * Applies the specified filters to the given texture.
+   *
+   * This method takes a texture and a list of filters, applies the filters to the texture,
+   * and returns the resulting texture. It also ensures that the alpha mode of the resulting
+   * texture is set to 'premultiplied-alpha'.
+   * @param {Texture} texture - The texture to which the filters will be applied.
+   * @param {Filter[]} filters - The filters to apply to the texture.
+   * @returns {Texture} The resulting texture after all filters have been applied.
+   */
+  _applyFilters(e, t) {
+    const r = this._renderer.renderTarget.renderTarget, n = this._renderer.filter.generateFilteredTexture({
+      texture: e,
+      filters: t
+    });
+    return this._renderer.renderTarget.bind(r, !1), n;
+  }
+  destroy() {
+    this._renderer = null;
+    for (const e in this._activeTextures)
+      this._activeTextures[e] && this.returnTexture(this._activeTextures[e].texture);
+    this._activeTextures = null;
+  }
+}
+Ke.extension = {
+  type: [
+    p.WebGLSystem,
+    p.WebGPUSystem,
+    p.CanvasSystem
+  ],
+  name: "canvasText"
+};
+b.add(Pe);
+b.add(we);
+b.add(Be);
+b.add(ot);
+b.add(De);
+b.add(Ae);
+b.add(ke);
+b.add(Ke);
+b.add(He);
+b.add(We);
+b.add(Xe);
+b.add(Ye);
+b.add(Ve);
+b.add(Ee);
+b.add(Se);
+b.add(Ce);