@vivi2d/web 0.1.0-alpha.0

package/dist/RenderTargetSystem-BCowAg_f.js

@@ -0,0 +1,3493 @@
+import { ac as Ct, al as De, a5 as T, Y as xe, a7 as ge, o as Le, G as St, c as _e, e as D, ao as te, k as He, p as Oe, V as re, v as kt, i as u, F as Mt, z as Pt, M, x as Bt, a6 as se, B as H, aa as Rt, b as ne, H as A, u as ae, j as Fe, w as wt, T as S, S as B, C as Y, s as be, ah as We, Q as $e, N as Ve, U as je, h as O, K as Ut, g as K, D as ie, J as I, R as F, ab as Gt, P as At, a0 as It, a as Et, L as ve, W as ye, f as X, am as zt, t as Dt, y as Lt } from "./index-CW8mx7yF.js";
+function Te(n, e, t, r) {
+  if (t ?? (t = 0), r ?? (r = Math.min(n.byteLength - t, e.byteLength)), !(t & 7) && !(r & 7)) {
+    const s = r / 8;
+    new Float64Array(e, 0, s).set(new Float64Array(n, t, s));
+  } else if (!(t & 3) && !(r & 3)) {
+    const s = r / 4;
+    new Float32Array(e, 0, s).set(new Float32Array(n, t, s));
+  } else
+    new Uint8Array(e).set(new Uint8Array(n, t, r));
+}
+const Ht = [
+  "precision mediump float;",
+  "void main(void){",
+  "float test = 0.1;",
+  "%forloop%",
+  "gl_FragColor = vec4(0.0);",
+  "}"
+].join(`
+`);
+function Ot(n) {
+  let e = "";
+  for (let t = 0; t < n; ++t)
+    t > 0 && (e += `
+else `), t < n - 1 && (e += `if(test == ${t}.0){}`);
+  return e;
+}
+function Ft(n, e) {
+  if (n === 0)
+    throw new Error("Invalid value of `0` passed to `checkMaxIfStatementsInShader`");
+  const t = e.createShader(e.FRAGMENT_SHADER);
+  try {
+    for (; ; ) {
+      const r = Ht.replace(/%forloop%/gi, Ot(n));
+      if (e.shaderSource(t, r), e.compileShader(t), !e.getShaderParameter(t, e.COMPILE_STATUS))
+        n = n / 2 | 0;
+      else
+        break;
+    }
+  } finally {
+    e.deleteShader(t);
+  }
+  return n;
+}
+let R = null;
+function Wt() {
+  var e;
+  if (R) return R;
+  const n = Ct();
+  return R = n.getParameter(n.MAX_TEXTURE_IMAGE_UNITS), R = Ft(
+    R,
+    n
+  ), (e = n.getExtension("WEBGL_lose_context")) == null || e.loseContext(), R;
+}
+class $t {
+  constructor() {
+    this.ids = /* @__PURE__ */ Object.create(null), this.textures = [], this.count = 0;
+  }
+  /** Clear the textures and their locations. */
+  clear() {
+    for (let e = 0; e < this.count; e++) {
+      const t = this.textures[e];
+      this.textures[e] = null, this.ids[t.uid] = null;
+    }
+    this.count = 0;
+  }
+}
+class Vt {
+  constructor() {
+    this.renderPipeId = "batch", this.action = "startBatch", this.start = 0, this.size = 0, this.textures = new $t(), this.blendMode = "normal", this.topology = "triangle-strip", this.canBundle = !0;
+  }
+  destroy() {
+    this.textures = null, this.gpuBindGroup = null, this.bindGroup = null, this.batcher = null, this.elements = null;
+  }
+}
+const E = [];
+let W = 0;
+Le.register({
+  clear: () => {
+    if (E.length > 0)
+      for (const n of E)
+        n && n.destroy();
+    E.length = 0, W = 0;
+  }
+});
+function Ce() {
+  return W > 0 ? E[--W] : new Vt();
+}
+function Se(n) {
+  n.elements = null, E[W++] = n;
+}
+let U = 0;
+const Ne = class qe {
+  constructor(e) {
+    this.uid = De("batcher"), this.dirty = !0, this.batchIndex = 0, this.batches = [], this._elements = [], e = { ...qe.defaultOptions, ...e }, e.maxTextures || (T("v8.8.0", "maxTextures is a required option for Batcher now, please pass it in the options"), e.maxTextures = Wt());
+    const { maxTextures: t, attributesInitialSize: r, indicesInitialSize: s } = e;
+    this.attributeBuffer = new xe(r * 4), this.indexBuffer = new Uint16Array(s), this.maxTextures = t;
+  }
+  begin() {
+    this.elementSize = 0, this.elementStart = 0, this.indexSize = 0, this.attributeSize = 0;
+    for (let e = 0; e < this.batchIndex; e++)
+      Se(this.batches[e]);
+    this.batchIndex = 0, this._batchIndexStart = 0, this._batchIndexSize = 0, this.dirty = !0;
+  }
+  add(e) {
+    this._elements[this.elementSize++] = e, e._indexStart = this.indexSize, e._attributeStart = this.attributeSize, e._batcher = this, this.indexSize += e.indexSize, this.attributeSize += e.attributeSize * this.vertexSize;
+  }
+  checkAndUpdateTexture(e, t) {
+    const r = e._batch.textures.ids[t._source.uid];
+    return !r && r !== 0 ? !1 : (e._textureId = r, e.texture = t, !0);
+  }
+  updateElement(e) {
+    this.dirty = !0;
+    const t = this.attributeBuffer;
+    e.packAsQuad ? this.packQuadAttributes(
+      e,
+      t.float32View,
+      t.uint32View,
+      e._attributeStart,
+      e._textureId
+    ) : this.packAttributes(
+      e,
+      t.float32View,
+      t.uint32View,
+      e._attributeStart,
+      e._textureId
+    );
+  }
+  /**
+   * breaks the batcher. This happens when a batch gets too big,
+   * or we need to switch to a different type of rendering (a filter for example)
+   * @param instructionSet
+   */
+  break(e) {
+    const t = this._elements;
+    if (!t[this.elementStart]) return;
+    let r = Ce(), s = r.textures;
+    s.clear();
+    const a = t[this.elementStart];
+    let i = ge(a.blendMode, a.texture._source), o = a.topology;
+    this.attributeSize * 4 > this.attributeBuffer.size && this._resizeAttributeBuffer(this.attributeSize * 4), this.indexSize > this.indexBuffer.length && this._resizeIndexBuffer(this.indexSize);
+    const l = this.attributeBuffer.float32View, d = this.attributeBuffer.uint32View, f = this.indexBuffer;
+    let c = this._batchIndexSize, x = this._batchIndexStart, g = "startBatch", m = [];
+    const v = this.maxTextures;
+    for (let _ = this.elementStart; _ < this.elementSize; ++_) {
+      const h = t[_];
+      t[_] = null;
+      const p = h.texture._source, y = ge(h.blendMode, p), b = i !== y || o !== h.topology;
+      if (p._batchTick === U && !b) {
+        h._textureId = p._textureBindLocation, c += h.indexSize, h.packAsQuad ? (this.packQuadAttributes(
+          h,
+          l,
+          d,
+          h._attributeStart,
+          h._textureId
+        ), this.packQuadIndex(
+          f,
+          h._indexStart,
+          h._attributeStart / this.vertexSize
+        )) : (this.packAttributes(
+          h,
+          l,
+          d,
+          h._attributeStart,
+          h._textureId
+        ), this.packIndex(
+          h,
+          f,
+          h._indexStart,
+          h._attributeStart / this.vertexSize
+        )), h._batch = r, m.push(h);
+        continue;
+      }
+      p._batchTick = U, (s.count >= v || b) && (this._finishBatch(
+        r,
+        x,
+        c - x,
+        s,
+        i,
+        o,
+        e,
+        g,
+        m
+      ), g = "renderBatch", x = c, i = y, o = h.topology, r = Ce(), s = r.textures, s.clear(), m = [], ++U), h._textureId = p._textureBindLocation = s.count, s.ids[p.uid] = s.count, s.textures[s.count++] = p, h._batch = r, m.push(h), c += h.indexSize, h.packAsQuad ? (this.packQuadAttributes(
+        h,
+        l,
+        d,
+        h._attributeStart,
+        h._textureId
+      ), this.packQuadIndex(
+        f,
+        h._indexStart,
+        h._attributeStart / this.vertexSize
+      )) : (this.packAttributes(
+        h,
+        l,
+        d,
+        h._attributeStart,
+        h._textureId
+      ), this.packIndex(
+        h,
+        f,
+        h._indexStart,
+        h._attributeStart / this.vertexSize
+      ));
+    }
+    s.count > 0 && (this._finishBatch(
+      r,
+      x,
+      c - x,
+      s,
+      i,
+      o,
+      e,
+      g,
+      m
+    ), x = c, ++U), this.elementStart = this.elementSize, this._batchIndexStart = x, this._batchIndexSize = c;
+  }
+  _finishBatch(e, t, r, s, a, i, o, l, d) {
+    e.gpuBindGroup = null, e.bindGroup = null, e.action = l, e.batcher = this, e.textures = s, e.blendMode = a, e.topology = i, e.start = t, e.size = r, e.elements = d, ++U, this.batches[this.batchIndex++] = e, o.add(e);
+  }
+  finish(e) {
+    this.break(e);
+  }
+  /**
+   * Resizes the attribute buffer to the given size (1 = 1 float32)
+   * @param size - the size in vertices to ensure (not bytes!)
+   */
+  ensureAttributeBuffer(e) {
+    e * 4 <= this.attributeBuffer.size || this._resizeAttributeBuffer(e * 4);
+  }
+  /**
+   * Resizes the index buffer to the given size (1 = 1 float32)
+   * @param size - the size in vertices to ensure (not bytes!)
+   */
+  ensureIndexBuffer(e) {
+    e <= this.indexBuffer.length || this._resizeIndexBuffer(e);
+  }
+  _resizeAttributeBuffer(e) {
+    const t = Math.max(e, this.attributeBuffer.size * 2), r = new xe(t);
+    Te(this.attributeBuffer.rawBinaryData, r.rawBinaryData), this.attributeBuffer = r;
+  }
+  _resizeIndexBuffer(e) {
+    const t = this.indexBuffer;
+    let r = Math.max(e, t.length * 1.5);
+    r += r % 2;
+    const s = r > 65535 ? new Uint32Array(r) : new Uint16Array(r);
+    if (s.BYTES_PER_ELEMENT !== t.BYTES_PER_ELEMENT)
+      for (let a = 0; a < t.length; a++)
+        s[a] = t[a];
+    else
+      Te(t.buffer, s.buffer);
+    this.indexBuffer = s;
+  }
+  packQuadIndex(e, t, r) {
+    e[t] = r + 0, e[t + 1] = r + 1, e[t + 2] = r + 2, e[t + 3] = r + 0, e[t + 4] = r + 2, e[t + 5] = r + 3;
+  }
+  packIndex(e, t, r, s) {
+    const a = e.indices, i = e.indexSize, o = e.indexOffset, l = e.attributeOffset;
+    for (let d = 0; d < i; d++)
+      t[r++] = s + a[d + o] - l;
+  }
+  /**
+   * Destroys the batch and its resources.
+   * @param options - destruction options
+   * @param options.shader - whether to destroy the associated shader
+   */
+  destroy(e = {}) {
+    var t;
+    if (this.batches !== null) {
+      for (let r = 0; r < this.batchIndex; r++)
+        Se(this.batches[r]);
+      this.batches = null, this.geometry.destroy(!0), this.geometry = null, e.shader && ((t = this.shader) == null || t.destroy(), this.shader = null);
+      for (let r = 0; r < this._elements.length; r++)
+        this._elements[r] && (this._elements[r]._batch = null);
+      this._elements = null, this.indexBuffer = null, this.attributeBuffer.destroy(), this.attributeBuffer = null;
+    }
+  }
+};
+Ne.defaultOptions = {
+  maxTextures: null,
+  attributesInitialSize: 4,
+  indicesInitialSize: 6
+};
+let jt = Ne;
+const Nt = new Float32Array(1), qt = new Uint32Array(1);
+class Qt extends St {
+  constructor() {
+    const t = new _e({
+      data: Nt,
+      label: "attribute-batch-buffer",
+      usage: D.VERTEX | D.COPY_DST,
+      shrinkToFit: !1
+    }), r = new _e({
+      data: qt,
+      label: "index-batch-buffer",
+      usage: D.INDEX | D.COPY_DST,
+      // | BufferUsage.STATIC,
+      shrinkToFit: !1
+    }), s = 24;
+    super({
+      attributes: {
+        aPosition: {
+          buffer: t,
+          format: "float32x2",
+          stride: s,
+          offset: 0
+        },
+        aUV: {
+          buffer: t,
+          format: "float32x2",
+          stride: s,
+          offset: 8
+        },
+        aColor: {
+          buffer: t,
+          format: "unorm8x4",
+          stride: s,
+          offset: 16
+        },
+        aTextureIdAndRound: {
+          buffer: t,
+          format: "uint16x2",
+          stride: s,
+          offset: 20
+        }
+      },
+      indexBuffer: r
+    });
+  }
+}
+function ke(n, e, t) {
+  if (n)
+    for (const r in n) {
+      const s = r.toLocaleLowerCase(), a = e[s];
+      if (a) {
+        let i = n[r];
+        r === "header" && (i = i.replace(/@in\s+[^;]+;\s*/g, "").replace(/@out\s+[^;]+;\s*/g, "")), t && a.push(`//----${t}----//`), a.push(i);
+      } else
+        te(`${r} placement hook does not exist in shader`);
+    }
+}
+const Yt = /\{\{(.*?)\}\}/g;
+function Me(n) {
+  var r;
+  const e = {};
+  return (((r = n.match(Yt)) == null ? void 0 : r.map((s) => s.replace(/[{()}]/g, ""))) ?? []).forEach((s) => {
+    e[s] = [];
+  }), e;
+}
+function Pe(n, e) {
+  let t;
+  const r = /@in\s+([^;]+);/g;
+  for (; (t = r.exec(n)) !== null; )
+    e.push(t[1]);
+}
+function Be(n, e, t = !1) {
+  const r = [];
+  Pe(e, r), n.forEach((o) => {
+    o.header && Pe(o.header, r);
+  });
+  const s = r;
+  t && s.sort();
+  const a = s.map((o, l) => `       @location(${l}) ${o},`).join(`
+`);
+  let i = e.replace(/@in\s+[^;]+;\s*/g, "");
+  return i = i.replace("{{in}}", `
+${a}
+`), i;
+}
+function Re(n, e) {
+  let t;
+  const r = /@out\s+([^;]+);/g;
+  for (; (t = r.exec(n)) !== null; )
+    e.push(t[1]);
+}
+function Kt(n) {
+  const t = /\b(\w+)\s*:/g.exec(n);
+  return t ? t[1] : "";
+}
+function Xt(n) {
+  const e = /@.*?\s+/g;
+  return n.replace(e, "");
+}
+function Jt(n, e) {
+  const t = [];
+  Re(e, t), n.forEach((l) => {
+    l.header && Re(l.header, t);
+  });
+  let r = 0;
+  const s = t.sort().map((l) => l.indexOf("builtin") > -1 ? l : `@location(${r++}) ${l}`).join(`,
+`), a = t.sort().map((l) => `       var ${Xt(l)};`).join(`
+`), i = `return VSOutput(
+            ${t.sort().map((l) => ` ${Kt(l)}`).join(`,
+`)});`;
+  let o = e.replace(/@out\s+[^;]+;\s*/g, "");
+  return o = o.replace("{{struct}}", `
+${s}
+`), o = o.replace("{{start}}", `
+${a}
+`), o = o.replace("{{return}}", `
+${i}
+`), o;
+}
+function we(n, e) {
+  let t = n;
+  for (const r in e) {
+    const s = e[r];
+    s.join(`
+`).length ? t = t.replace(`{{${r}}}`, `//-----${r} START-----//
+${s.join(`
+`)}
+//----${r} FINISH----//`) : t = t.replace(`{{${r}}}`, "");
+  }
+  return t;
+}
+const k = /* @__PURE__ */ Object.create(null), j = /* @__PURE__ */ new Map();
+let Zt = 0;
+function er({
+  template: n,
+  bits: e
+}) {
+  const t = Qe(n, e);
+  if (k[t]) return k[t];
+  const { vertex: r, fragment: s } = rr(n, e);
+  return k[t] = Ye(r, s, e), k[t];
+}
+function tr({
+  template: n,
+  bits: e
+}) {
+  const t = Qe(n, e);
+  return k[t] || (k[t] = Ye(n.vertex, n.fragment, e)), k[t];
+}
+function rr(n, e) {
+  const t = e.map((i) => i.vertex).filter((i) => !!i), r = e.map((i) => i.fragment).filter((i) => !!i);
+  let s = Be(t, n.vertex, !0);
+  s = Jt(t, s);
+  const a = Be(r, n.fragment, !0);
+  return {
+    vertex: s,
+    fragment: a
+  };
+}
+function Qe(n, e) {
+  return e.map((t) => (j.has(t) || j.set(t, Zt++), j.get(t))).sort((t, r) => t - r).join("-") + n.vertex + n.fragment;
+}
+function Ye(n, e, t) {
+  const r = Me(n), s = Me(e);
+  return t.forEach((a) => {
+    ke(a.vertex, r, a.name), ke(a.fragment, s, a.name);
+  }), {
+    vertex: we(n, r),
+    fragment: we(e, s)
+  };
+}
+const sr = (
+  /* wgsl */
+  `
+    @in aPosition: vec2<f32>;
+    @in aUV: vec2<f32>;
+
+    @out @builtin(position) vPosition: vec4<f32>;
+    @out vUV : vec2<f32>;
+    @out vColor : vec4<f32>;
+
+    {{header}}
+
+    struct VSOutput {
+        {{struct}}
+    };
+
+    @vertex
+    fn main( {{in}} ) -> VSOutput {
+
+        var worldTransformMatrix = globalUniforms.uWorldTransformMatrix;
+        var modelMatrix = mat3x3<f32>(
+            1.0, 0.0, 0.0,
+            0.0, 1.0, 0.0,
+            0.0, 0.0, 1.0
+          );
+        var position = aPosition;
+        var uv = aUV;
+
+        {{start}}
+
+        vColor = vec4<f32>(1., 1., 1., 1.);
+
+        {{main}}
+
+        vUV = uv;
+
+        var modelViewProjectionMatrix = globalUniforms.uProjectionMatrix * worldTransformMatrix * modelMatrix;
+
+        vPosition =  vec4<f32>((modelViewProjectionMatrix *  vec3<f32>(position, 1.0)).xy, 0.0, 1.0);
+
+        vColor *= globalUniforms.uWorldColorAlpha;
+
+        {{end}}
+
+        {{return}}
+    };
+`
+), nr = (
+  /* wgsl */
+  `
+    @in vUV : vec2<f32>;
+    @in vColor : vec4<f32>;
+
+    {{header}}
+
+    @fragment
+    fn main(
+        {{in}}
+      ) -> @location(0) vec4<f32> {
+
+        {{start}}
+
+        var outColor:vec4<f32>;
+
+        {{main}}
+
+        var finalColor:vec4<f32> = outColor * vColor;
+
+        {{end}}
+
+        return finalColor;
+      };
+`
+), ar = (
+  /* glsl */
+  `
+    in vec2 aPosition;
+    in vec2 aUV;
+
+    out vec4 vColor;
+    out vec2 vUV;
+
+    {{header}}
+
+    void main(void){
+
+        mat3 worldTransformMatrix = uWorldTransformMatrix;
+        mat3 modelMatrix = mat3(
+            1.0, 0.0, 0.0,
+            0.0, 1.0, 0.0,
+            0.0, 0.0, 1.0
+          );
+        vec2 position = aPosition;
+        vec2 uv = aUV;
+
+        {{start}}
+
+        vColor = vec4(1.);
+
+        {{main}}
+
+        vUV = uv;
+
+        mat3 modelViewProjectionMatrix = uProjectionMatrix * worldTransformMatrix * modelMatrix;
+
+        gl_Position = vec4((modelViewProjectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);
+
+        vColor *= uWorldColorAlpha;
+
+        {{end}}
+    }
+`
+), ir = (
+  /* glsl */
+  `
+
+    in vec4 vColor;
+    in vec2 vUV;
+
+    out vec4 finalColor;
+
+    {{header}}
+
+    void main(void) {
+
+        {{start}}
+
+        vec4 outColor;
+
+        {{main}}
+
+        finalColor = outColor * vColor;
+
+        {{end}}
+    }
+`
+), or = {
+  name: "global-uniforms-bit",
+  vertex: {
+    header: (
+      /* wgsl */
+      `
+        struct GlobalUniforms {
+            uProjectionMatrix:mat3x3<f32>,
+            uWorldTransformMatrix:mat3x3<f32>,
+            uWorldColorAlpha: vec4<f32>,
+            uResolution: vec2<f32>,
+        }
+
+        @group(0) @binding(0) var<uniform> globalUniforms : GlobalUniforms;
+        `
+    )
+  }
+}, lr = {
+  name: "global-uniforms-bit",
+  vertex: {
+    header: (
+      /* glsl */
+      `
+          uniform mat3 uProjectionMatrix;
+          uniform mat3 uWorldTransformMatrix;
+          uniform vec4 uWorldColorAlpha;
+          uniform vec2 uResolution;
+        `
+    )
+  }
+};
+function ur({ bits: n, name: e }) {
+  const t = er({
+    template: {
+      fragment: nr,
+      vertex: sr
+    },
+    bits: [
+      or,
+      ...n
+    ]
+  });
+  return Oe.from({
+    name: e,
+    vertex: {
+      source: t.vertex,
+      entryPoint: "main"
+    },
+    fragment: {
+      source: t.fragment,
+      entryPoint: "main"
+    }
+  });
+}
+function cr({ bits: n, name: e }) {
+  return new He({
+    name: e,
+    ...tr({
+      template: {
+        vertex: ar,
+        fragment: ir
+      },
+      bits: [
+        lr,
+        ...n
+      ]
+    })
+  });
+}
+const dr = {
+  name: "color-bit",
+  vertex: {
+    header: (
+      /* wgsl */
+      `
+            @in aColor: vec4<f32>;
+        `
+    ),
+    main: (
+      /* wgsl */
+      `
+            vColor *= vec4<f32>(aColor.rgb * aColor.a, aColor.a);
+        `
+    )
+  }
+}, hr = {
+  name: "color-bit",
+  vertex: {
+    header: (
+      /* glsl */
+      `
+            in vec4 aColor;
+        `
+    ),
+    main: (
+      /* glsl */
+      `
+            vColor *= vec4(aColor.rgb * aColor.a, aColor.a);
+        `
+    )
+  }
+}, N = {};
+function fr(n) {
+  const e = [];
+  if (n === 1)
+    e.push("@group(1) @binding(0) var textureSource1: texture_2d<f32>;"), e.push("@group(1) @binding(1) var textureSampler1: sampler;");
+  else {
+    let t = 0;
+    for (let r = 0; r < n; r++)
+      e.push(`@group(1) @binding(${t++}) var textureSource${r + 1}: texture_2d<f32>;`), e.push(`@group(1) @binding(${t++}) var textureSampler${r + 1}: sampler;`);
+  }
+  return e.join(`
+`);
+}
+function pr(n) {
+  const e = [];
+  if (n === 1)
+    e.push("outColor = textureSampleGrad(textureSource1, textureSampler1, vUV, uvDx, uvDy);");
+  else {
+    e.push("switch vTextureId {");
+    for (let t = 0; t < n; t++)
+      t === n - 1 ? e.push("  default:{") : e.push(`  case ${t}:{`), e.push(`      outColor = textureSampleGrad(textureSource${t + 1}, textureSampler${t + 1}, vUV, uvDx, uvDy);`), e.push("      break;}");
+    e.push("}");
+  }
+  return e.join(`
+`);
+}
+function mr(n) {
+  return N[n] || (N[n] = {
+    name: "texture-batch-bit",
+    vertex: {
+      header: `
+                @in aTextureIdAndRound: vec2<u32>;
+                @out @interpolate(flat) vTextureId : u32;
+            `,
+      main: `
+                vTextureId = aTextureIdAndRound.y;
+            `,
+      end: `
+                if(aTextureIdAndRound.x == 1)
+                {
+                    vPosition = vec4<f32>(roundPixels(vPosition.xy, globalUniforms.uResolution), vPosition.zw);
+                }
+            `
+    },
+    fragment: {
+      header: `
+                @in @interpolate(flat) vTextureId: u32;
+
+                ${fr(n)}
+            `,
+      main: `
+                var uvDx = dpdx(vUV);
+                var uvDy = dpdy(vUV);
+
+                ${pr(n)}
+            `
+    }
+  }), N[n];
+}
+const q = {};
+function xr(n) {
+  const e = [];
+  for (let t = 0; t < n; t++)
+    t > 0 && e.push("else"), t < n - 1 && e.push(`if(vTextureId < ${t}.5)`), e.push("{"), e.push(`	outColor = texture(uTextures[${t}], vUV);`), e.push("}");
+  return e.join(`
+`);
+}
+function gr(n) {
+  return q[n] || (q[n] = {
+    name: "texture-batch-bit",
+    vertex: {
+      header: `
+                in vec2 aTextureIdAndRound;
+                out float vTextureId;
+
+            `,
+      main: `
+                vTextureId = aTextureIdAndRound.y;
+            `,
+      end: `
+                if(aTextureIdAndRound.x == 1.)
+                {
+                    gl_Position.xy = roundPixels(gl_Position.xy, uResolution);
+                }
+            `
+    },
+    fragment: {
+      header: `
+                in float vTextureId;
+
+                uniform sampler2D uTextures[${n}];
+
+            `,
+      main: `
+
+                ${xr(n)}
+            `
+    }
+  }), q[n];
+}
+const _r = {
+  name: "round-pixels-bit",
+  vertex: {
+    header: (
+      /* wgsl */
+      `
+            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;
+            }
+        `
+    )
+  }
+}, br = {
+  name: "round-pixels-bit",
+  vertex: {
+    header: (
+      /* glsl */
+      `
+            vec2 roundPixels(vec2 position, vec2 targetSize)
+            {
+                return (floor(((position * 0.5 + 0.5) * targetSize) + 0.5) / targetSize) * 2.0 - 1.0;
+            }
+        `
+    )
+  }
+}, Ue = {};
+function vr(n) {
+  let e = Ue[n];
+  if (e) return e;
+  const t = new Int32Array(n);
+  for (let r = 0; r < n; r++)
+    t[r] = r;
+  return e = Ue[n] = new re({
+    uTextures: { value: t, type: "i32", size: n }
+  }, { isStatic: !0 }), e;
+}
+class Ge extends kt {
+  constructor(e) {
+    const t = cr({
+      name: "batch",
+      bits: [
+        hr,
+        gr(e),
+        br
+      ]
+    }), r = ur({
+      name: "batch",
+      bits: [
+        dr,
+        mr(e),
+        _r
+      ]
+    });
+    super({
+      glProgram: t,
+      gpuProgram: r,
+      resources: {
+        batchSamplers: vr(e)
+      }
+    }), this.maxTextures = e;
+  }
+}
+let G = null;
+const Ke = class Xe extends jt {
+  constructor(e) {
+    super(e), this.geometry = new Qt(), this.name = Xe.extension.name, this.vertexSize = 6, G ?? (G = new Ge(e.maxTextures)), this.shader = G;
+  }
+  /**
+   * Packs the attributes of a DefaultBatchableMeshElement into the provided views.
+   * @param element - The DefaultBatchableMeshElement to pack.
+   * @param float32View - The Float32Array view to pack into.
+   * @param uint32View - The Uint32Array view to pack into.
+   * @param index - The starting index in the views.
+   * @param textureId - The texture ID to use.
+   */
+  packAttributes(e, t, r, s, a) {
+    const i = a << 16 | e.roundPixels & 65535, o = e.transform, l = o.a, d = o.b, f = o.c, c = o.d, x = o.tx, g = o.ty, { positions: m, uvs: v } = e, _ = e.color, h = e.attributeOffset, C = h + e.attributeSize;
+    for (let p = h; p < C; p++) {
+      const y = p * 2, b = m[y], P = m[y + 1];
+      t[s++] = l * b + f * P + x, t[s++] = c * P + d * b + g, t[s++] = v[y], t[s++] = v[y + 1], r[s++] = _, r[s++] = i;
+    }
+  }
+  /**
+   * Packs the attributes of a DefaultBatchableQuadElement into the provided views.
+   * @param element - The DefaultBatchableQuadElement to pack.
+   * @param float32View - The Float32Array view to pack into.
+   * @param uint32View - The Uint32Array view to pack into.
+   * @param index - The starting index in the views.
+   * @param textureId - The texture ID to use.
+   */
+  packQuadAttributes(e, t, r, s, a) {
+    const i = e.texture, o = e.transform, l = o.a, d = o.b, f = o.c, c = o.d, x = o.tx, g = o.ty, m = e.bounds, v = m.maxX, _ = m.minX, h = m.maxY, C = m.minY, p = i.uvs, y = e.color, b = a << 16 | e.roundPixels & 65535;
+    t[s + 0] = l * _ + f * C + x, t[s + 1] = c * C + d * _ + g, t[s + 2] = p.x0, t[s + 3] = p.y0, r[s + 4] = y, r[s + 5] = b, t[s + 6] = l * v + f * C + x, t[s + 7] = c * C + d * v + g, t[s + 8] = p.x1, t[s + 9] = p.y1, r[s + 10] = y, r[s + 11] = b, t[s + 12] = l * v + f * h + x, t[s + 13] = c * h + d * v + g, t[s + 14] = p.x2, t[s + 15] = p.y2, r[s + 16] = y, r[s + 17] = b, t[s + 18] = l * _ + f * h + x, t[s + 19] = c * h + d * _ + g, t[s + 20] = p.x3, t[s + 21] = p.y3, r[s + 22] = y, r[s + 23] = b;
+  }
+  /**
+   * Updates the maximum number of textures that can be used in the shader.
+   * @param maxTextures - The maximum number of textures that can be used in the shader.
+   * @internal
+   */
+  _updateMaxTextures(e) {
+    this.shader.maxTextures !== e && (G = new Ge(e), this.shader = G);
+  }
+  destroy() {
+    this.shader = null, super.destroy();
+  }
+};
+Ke.extension = {
+  type: [
+    u.Batcher
+  ],
+  name: "default"
+};
+let Je = Ke;
+class Nr {
+  constructor(e) {
+    this.items = /* @__PURE__ */ Object.create(null);
+    const { renderer: t, type: r, onUnload: s, priority: a, name: i } = e;
+    this._renderer = t, t.gc.addResourceHash(this, "items", r, a ?? 0), this._onUnload = s, this.name = i;
+  }
+  /**
+   * Add an item to the hash. No-op if already added.
+   * @param item
+   * @returns true if the item was added, false if it was already in the hash
+   */
+  add(e) {
+    return this.items[e.uid] ? !1 : (this.items[e.uid] = e, e.once("unload", this.remove, this), e._gcLastUsed = this._renderer.gc.now, !0);
+  }
+  remove(e, ...t) {
+    var s;
+    if (!this.items[e.uid]) return;
+    const r = e._gpuData[this._renderer.uid];
+    r && ((s = this._onUnload) == null || s.call(this, e, ...t), r.destroy(), e._gpuData[this._renderer.uid] = null, this.items[e.uid] = null);
+  }
+  removeAll(...e) {
+    Object.values(this.items).forEach((t) => t && this.remove(t, ...e));
+  }
+  destroy(...e) {
+    this.removeAll(...e), this.items = /* @__PURE__ */ Object.create(null), this._renderer = null, this._onUnload = null;
+  }
+}
+var yr = `in vec2 vMaskCoord;
+in vec2 vTextureCoord;
+
+uniform sampler2D uTexture;
+uniform sampler2D uMaskTexture;
+
+uniform float uAlpha;
+uniform vec4 uMaskClamp;
+uniform float uInverse;
+uniform float uChannel;
+
+out vec4 finalColor;
+
+void main(void)
+{
+    float clip = step(3.5,
+        step(uMaskClamp.x, vMaskCoord.x) +
+        step(uMaskClamp.y, vMaskCoord.y) +
+        step(vMaskCoord.x, uMaskClamp.z) +
+        step(vMaskCoord.y, uMaskClamp.w));
+
+    // TODO look into why this is needed
+    float npmAlpha = uAlpha;
+    vec4 original = texture(uTexture, vTextureCoord);
+    vec4 masky = texture(uMaskTexture, vMaskCoord);
+
+    float a;
+    if (uChannel == 1.0) {
+        a = masky.a * npmAlpha * clip;
+    } else {
+        float alphaMul = 1.0 - npmAlpha * (1.0 - masky.a);
+        a = alphaMul * masky.r * npmAlpha * clip;
+    }
+
+    if (uInverse == 1.0) {
+        a = 1.0 - a;
+    }
+
+    finalColor = original * a;
+}
+`, Tr = `in vec2 aPosition;
+
+out vec2 vTextureCoord;
+out vec2 vMaskCoord;
+
+
+uniform vec4 uInputSize;
+uniform vec4 uOutputFrame;
+uniform vec4 uOutputTexture;
+uniform mat3 uFilterMatrix;
+
+vec4 filterVertexPosition(  vec2 aPosition )
+{
+    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(  vec2 aPosition )
+{
+    return aPosition * (uOutputFrame.zw * uInputSize.zw);
+}
+
+vec2 getFilterCoord( vec2 aPosition )
+{
+    return  ( uFilterMatrix * vec3( filterTextureCoord(aPosition), 1.0)  ).xy;
+}   
+
+void main(void)
+{
+    gl_Position = filterVertexPosition(aPosition);
+    vTextureCoord = filterTextureCoord(aPosition);
+    vMaskCoord = getFilterCoord(aPosition);
+}
+`, Ae = `struct GlobalFilterUniforms {
+  uInputSize:vec4<f32>,
+  uInputPixel:vec4<f32>,
+  uInputClamp:vec4<f32>,
+  uOutputFrame:vec4<f32>,
+  uGlobalFrame:vec4<f32>,
+  uOutputTexture:vec4<f32>,
+};
+
+struct MaskUniforms {
+  uFilterMatrix:mat3x3<f32>,
+  uMaskClamp:vec4<f32>,
+  uAlpha:f32,
+  uInverse:f32,
+  uChannel: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;
+
+@group(1) @binding(0) var<uniform> filterUniforms : MaskUniforms;
+@group(1) @binding(1) var uMaskTexture: texture_2d<f32>;
+
+struct VSOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) uv : vec2<f32>,
+    @location(1) filterUv : 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);
+}
+
+fn globalTextureCoord( aPosition:vec2<f32> ) -> vec2<f32>
+{
+  return  (aPosition.xy / gfu.uGlobalFrame.zw) + (gfu.uGlobalFrame.xy / gfu.uGlobalFrame.zw);
+}
+
+fn getFilterCoord(aPosition:vec2<f32> ) -> vec2<f32>
+{
+  return ( filterUniforms.uFilterMatrix * vec3( filterTextureCoord(aPosition), 1.0)  ).xy;
+}
+
+fn getSize() -> vec2<f32>
+{
+  return gfu.uGlobalFrame.zw;
+}
+
+@vertex
+fn mainVertex(
+  @location(0) aPosition : vec2<f32>,
+) -> VSOutput {
+  return VSOutput(
+   filterVertexPosition(aPosition),
+   filterTextureCoord(aPosition),
+   getFilterCoord(aPosition)
+  );
+}
+
+@fragment
+fn mainFragment(
+  @location(0) uv: vec2<f32>,
+  @location(1) filterUv: vec2<f32>,
+  @builtin(position) position: vec4<f32>
+) -> @location(0) vec4<f32> {
+
+    var maskClamp = filterUniforms.uMaskClamp;
+    var uAlpha = filterUniforms.uAlpha;
+
+    var clip = step(3.5,
+      step(maskClamp.x, filterUv.x) +
+      step(maskClamp.y, filterUv.y) +
+      step(filterUv.x, maskClamp.z) +
+      step(filterUv.y, maskClamp.w));
+
+    var mask = textureSample(uMaskTexture, uSampler, filterUv);
+    var source = textureSample(uTexture, uSampler, uv);
+
+    var a: f32;
+    if (filterUniforms.uChannel == 1.0) {
+        a = mask.a * uAlpha * clip;
+    } else {
+        var alphaMul = 1.0 - uAlpha * (1.0 - mask.a);
+        a = alphaMul * mask.r * uAlpha * clip;
+    }
+
+    if (filterUniforms.uInverse == 1.0) {
+        a = 1.0 - a;
+    }
+
+    return source * a;
+}
+`;
+class Cr extends Mt {
+  constructor(e) {
+    const { sprite: t, ...r } = e, s = new Pt(t.texture), a = new re({
+      uFilterMatrix: { value: new M(), type: "mat3x3<f32>" },
+      uMaskClamp: { value: s.uClampFrame, type: "vec4<f32>" },
+      uAlpha: { value: 1, type: "f32" },
+      uInverse: { value: e.inverse ? 1 : 0, type: "f32" },
+      uChannel: { value: e.channel === "alpha" ? 1 : 0, type: "f32" }
+    }), i = Oe.from({
+      vertex: {
+        source: Ae,
+        entryPoint: "mainVertex"
+      },
+      fragment: {
+        source: Ae,
+        entryPoint: "mainFragment"
+      }
+    }), o = He.from({
+      vertex: Tr,
+      fragment: yr,
+      name: "mask-filter"
+    });
+    super({
+      ...r,
+      gpuProgram: i,
+      glProgram: o,
+      clipToViewport: !1,
+      resources: {
+        filterUniforms: a,
+        uMaskTexture: t.texture.source
+      }
+    }), this.sprite = t, this._textureMatrix = s;
+  }
+  set inverse(e) {
+    this.resources.filterUniforms.uniforms.uInverse = e ? 1 : 0;
+  }
+  get inverse() {
+    return this.resources.filterUniforms.uniforms.uInverse === 1;
+  }
+  set channel(e) {
+    this.resources.filterUniforms.uniforms.uChannel = e === "alpha" ? 1 : 0;
+  }
+  get channel() {
+    return this.resources.filterUniforms.uniforms.uChannel === 1 ? "alpha" : "red";
+  }
+  apply(e, t, r, s) {
+    this._textureMatrix.texture = this.sprite.texture, e.calculateSpriteMatrix(
+      this.resources.filterUniforms.uniforms.uFilterMatrix,
+      this.sprite
+    ).prepend(this._textureMatrix.mapCoord), this.resources.uMaskTexture = this.sprite.texture.source, e.applyFilter(this, t, r, s);
+  }
+}
+class Ze {
+  constructor() {
+    this.batcherName = "default", this.topology = "triangle-list", this.attributeSize = 4, this.indexSize = 6, this.packAsQuad = !0, this.roundPixels = 0, this._attributeStart = 0, this._batcher = null, this._batch = null;
+  }
+  get blendMode() {
+    return this.renderable.groupBlendMode;
+  }
+  get color() {
+    return this.renderable.groupColorAlpha;
+  }
+  reset() {
+    this.renderable = null, this.texture = null, this._batcher = null, this._batch = null, this.bounds = null;
+  }
+  destroy() {
+    this.reset();
+  }
+}
+const oe = class et {
+  constructor(e, t) {
+    var r, s;
+    this.state = Bt.for2d(), this._batchersByInstructionSet = /* @__PURE__ */ Object.create(null), this._activeBatches = /* @__PURE__ */ Object.create(null), this.renderer = e, this._adaptor = t, (s = (r = this._adaptor).init) == null || s.call(r, this);
+  }
+  static getBatcher(e) {
+    return new this._availableBatchers[e]();
+  }
+  buildStart(e) {
+    let t = this._batchersByInstructionSet[e.uid];
+    t || (t = this._batchersByInstructionSet[e.uid] = /* @__PURE__ */ Object.create(null), t.default || (t.default = new Je({
+      maxTextures: this.renderer.limits.maxBatchableTextures
+    }))), this._activeBatches = t, this._activeBatch = this._activeBatches.default;
+    for (const r in this._activeBatches)
+      this._activeBatches[r].begin();
+  }
+  addToBatch(e, t) {
+    if (this._activeBatch.name !== e.batcherName) {
+      this._activeBatch.break(t);
+      let r = this._activeBatches[e.batcherName];
+      r || (r = this._activeBatches[e.batcherName] = et.getBatcher(e.batcherName), r.begin()), this._activeBatch = r;
+    }
+    this._activeBatch.add(e);
+  }
+  break(e) {
+    this._activeBatch.break(e);
+  }
+  buildEnd(e) {
+    this._activeBatch.break(e);
+    const t = this._activeBatches;
+    for (const r in t) {
+      const s = t[r], a = s.geometry;
+      a.indexBuffer.setDataWithSize(s.indexBuffer, s.indexSize, !0), a.buffers[0].setDataWithSize(s.attributeBuffer.float32View, s.attributeSize, !1);
+    }
+  }
+  upload(e) {
+    const t = this._batchersByInstructionSet[e.uid];
+    for (const r in t) {
+      const s = t[r], a = s.geometry;
+      s.dirty && (s.dirty = !1, a.buffers[0].update(s.attributeSize * 4));
+    }
+  }
+  execute(e) {
+    if (e.action === "startBatch") {
+      const t = e.batcher, r = t.geometry, s = t.shader;
+      this._adaptor.start(this, r, s);
+    }
+    this._adaptor.execute(this, e);
+  }
+  destroy() {
+    this.state = null, this.renderer = null, this._adaptor = null;
+    for (const e in this._activeBatches)
+      this._activeBatches[e].destroy();
+    this._activeBatches = null;
+  }
+};
+oe.extension = {
+  type: [
+    u.WebGLPipes,
+    u.WebGPUPipes,
+    u.CanvasPipes
+  ],
+  name: "batch"
+};
+oe._availableBatchers = /* @__PURE__ */ Object.create(null);
+let tt = oe;
+se.handleByMap(u.Batcher, tt._availableBatchers);
+se.add(Je);
+const Sr = new ne();
+class kr extends Fe {
+  constructor() {
+    super(), this.filters = [new Cr({
+      sprite: new wt(S.EMPTY),
+      inverse: !1,
+      resolution: "inherit",
+      antialias: "inherit"
+    })];
+  }
+  get sprite() {
+    return this.filters[0].sprite;
+  }
+  set sprite(e) {
+    this.filters[0].sprite = e;
+  }
+  get inverse() {
+    return this.filters[0].inverse;
+  }
+  set inverse(e) {
+    this.filters[0].inverse = e;
+  }
+  get channel() {
+    return this.filters[0].channel;
+  }
+  set channel(e) {
+    this.filters[0].channel = e;
+  }
+}
+class rt {
+  constructor(e) {
+    this._activeMaskStage = [], this._renderer = e;
+  }
+  push(e, t, r) {
+    const s = this._renderer;
+    if (s.renderPipes.batch.break(r), r.add({
+      renderPipeId: "alphaMask",
+      action: "pushMaskBegin",
+      mask: e,
+      inverse: t._maskOptions.inverse,
+      canBundle: !1,
+      maskedContainer: t
+    }), e.inverse = t._maskOptions.inverse, e.channel = t._maskOptions.channel ?? "red", e.renderMaskToTexture) {
+      const a = e.mask;
+      a.includeInBuild = !0, a.collectRenderables(
+        r,
+        s,
+        null
+      ), a.includeInBuild = !1;
+    }
+    s.renderPipes.batch.break(r), r.add({
+      renderPipeId: "alphaMask",
+      action: "pushMaskEnd",
+      mask: e,
+      maskedContainer: t,
+      inverse: t._maskOptions.inverse,
+      canBundle: !1
+    });
+  }
+  pop(e, t, r) {
+    this._renderer.renderPipes.batch.break(r), r.add({
+      renderPipeId: "alphaMask",
+      action: "popMaskEnd",
+      mask: e,
+      inverse: t._maskOptions.inverse,
+      canBundle: !1
+    });
+  }
+  execute(e) {
+    const t = this._renderer, r = e.mask.renderMaskToTexture;
+    if (e.action === "pushMaskBegin") {
+      const s = H.get(kr);
+      if (s.inverse = e.inverse, s.channel = e.mask.channel, r) {
+        e.mask.mask.measurable = !0;
+        const a = Rt(e.mask.mask, !0, Sr);
+        e.mask.mask.measurable = !1, a.ceil();
+        const i = t.renderTarget.renderTarget.colorTexture.source, o = A.getOptimalTexture(
+          a.width,
+          a.height,
+          i._resolution,
+          i.antialias
+        );
+        t.renderTarget.push(o, !0), t.globalUniforms.push({
+          offset: a,
+          worldColor: 4294967295
+        });
+        const l = s.sprite;
+        l.texture = o, l.worldTransform.tx = a.minX, l.worldTransform.ty = a.minY, this._activeMaskStage.push({
+          filterEffect: s,
+          maskedContainer: e.maskedContainer,
+          filterTexture: o
+        });
+      } else
+        s.sprite = e.mask.mask, this._activeMaskStage.push({
+          filterEffect: s,
+          maskedContainer: e.maskedContainer
+        });
+    } else if (e.action === "pushMaskEnd") {
+      const s = this._activeMaskStage[this._activeMaskStage.length - 1];
+      r && (t.type === ae.WEBGL && t.renderTarget.finishRenderPass(), t.renderTarget.pop(), t.globalUniforms.pop()), t.filter.push({
+        renderPipeId: "filter",
+        action: "pushFilter",
+        container: s.maskedContainer,
+        filterEffect: s.filterEffect,
+        canBundle: !1
+      });
+    } else if (e.action === "popMaskEnd") {
+      t.filter.pop();
+      const s = this._activeMaskStage.pop();
+      r && A.returnTexture(s.filterTexture), H.return(s.filterEffect);
+    }
+  }
+  destroy() {
+    this._renderer = null, this._activeMaskStage = null;
+  }
+}
+rt.extension = {
+  type: [
+    u.WebGLPipes,
+    u.WebGPUPipes,
+    u.CanvasPipes
+  ],
+  name: "alphaMask"
+};
+class st {
+  constructor(e) {
+    this._colorStack = [], this._colorStackIndex = 0, this._currentColor = 0, this._renderer = e;
+  }
+  buildStart() {
+    this._colorStack[0] = 15, this._colorStackIndex = 1, this._currentColor = 15;
+  }
+  push(e, t, r) {
+    this._renderer.renderPipes.batch.break(r);
+    const a = this._colorStack;
+    a[this._colorStackIndex] = a[this._colorStackIndex - 1] & e.mask;
+    const i = this._colorStack[this._colorStackIndex];
+    i !== this._currentColor && (this._currentColor = i, r.add({
+      renderPipeId: "colorMask",
+      colorMask: i,
+      canBundle: !1
+    })), this._colorStackIndex++;
+  }
+  pop(e, t, r) {
+    this._renderer.renderPipes.batch.break(r);
+    const a = this._colorStack;
+    this._colorStackIndex--;
+    const i = a[this._colorStackIndex - 1];
+    i !== this._currentColor && (this._currentColor = i, r.add({
+      renderPipeId: "colorMask",
+      colorMask: i,
+      canBundle: !1
+    }));
+  }
+  execute(e) {
+    this._renderer.colorMask.setMask(e.colorMask);
+  }
+  destroy() {
+    this._renderer = null, this._colorStack = null;
+  }
+}
+st.extension = {
+  type: [
+    u.WebGLPipes,
+    u.WebGPUPipes
+  ],
+  name: "colorMask"
+};
+class nt {
+  constructor(e) {
+    this._maskStackHash = {}, this._maskHash = /* @__PURE__ */ new WeakMap(), this._renderer = e;
+  }
+  push(e, t, r) {
+    var s;
+    const a = e, i = this._renderer;
+    i.renderPipes.batch.break(r), i.renderPipes.blendMode.setBlendMode(a.mask, "none", r), r.add({
+      renderPipeId: "stencilMask",
+      action: "pushMaskBegin",
+      mask: e,
+      inverse: t._maskOptions.inverse,
+      canBundle: !1
+    });
+    const o = a.mask;
+    o.includeInBuild = !0, this._maskHash.has(a) || this._maskHash.set(a, {
+      instructionsStart: 0,
+      instructionsLength: 0
+    });
+    const l = this._maskHash.get(a);
+    l.instructionsStart = r.instructionSize, o.collectRenderables(
+      r,
+      i,
+      null
+    ), o.includeInBuild = !1, i.renderPipes.batch.break(r), r.add({
+      renderPipeId: "stencilMask",
+      action: "pushMaskEnd",
+      mask: e,
+      inverse: t._maskOptions.inverse,
+      canBundle: !1
+    });
+    const d = r.instructionSize - l.instructionsStart - 1;
+    l.instructionsLength = d;
+    const f = i.renderTarget.renderTarget.uid;
+    (s = this._maskStackHash)[f] ?? (s[f] = 0);
+  }
+  pop(e, t, r) {
+    const s = e, a = this._renderer;
+    a.renderPipes.batch.break(r), a.renderPipes.blendMode.setBlendMode(s.mask, "none", r), r.add({
+      renderPipeId: "stencilMask",
+      action: "popMaskBegin",
+      inverse: t._maskOptions.inverse,
+      canBundle: !1
+    });
+    const i = this._maskHash.get(e);
+    for (let o = 0; o < i.instructionsLength; o++)
+      r.instructions[r.instructionSize++] = r.instructions[i.instructionsStart++];
+    r.add({
+      renderPipeId: "stencilMask",
+      action: "popMaskEnd",
+      canBundle: !1
+    });
+  }
+  execute(e) {
+    var t;
+    const r = this._renderer, s = r, a = r.renderTarget.renderTarget.uid;
+    let i = (t = this._maskStackHash)[a] ?? (t[a] = 0);
+    e.action === "pushMaskBegin" ? (s.renderTarget.ensureDepthStencil(), s.stencil.setStencilMode(B.RENDERING_MASK_ADD, i), i++, s.colorMask.setMask(0)) : e.action === "pushMaskEnd" ? (e.inverse ? s.stencil.setStencilMode(B.INVERSE_MASK_ACTIVE, i) : s.stencil.setStencilMode(B.MASK_ACTIVE, i), s.colorMask.setMask(15)) : e.action === "popMaskBegin" ? (s.colorMask.setMask(0), i !== 0 ? s.stencil.setStencilMode(B.RENDERING_MASK_REMOVE, i) : (s.renderTarget.clear(null, Y.STENCIL), s.stencil.setStencilMode(B.DISABLED, i)), i--) : e.action === "popMaskEnd" && (e.inverse ? s.stencil.setStencilMode(B.INVERSE_MASK_ACTIVE, i) : s.stencil.setStencilMode(B.MASK_ACTIVE, i), s.colorMask.setMask(15)), this._maskStackHash[a] = i;
+  }
+  destroy() {
+    this._renderer = null, this._maskStackHash = null, this._maskHash = null;
+  }
+}
+nt.extension = {
+  type: [
+    u.WebGLPipes,
+    u.WebGPUPipes
+  ],
+  name: "stencilMask"
+};
+class at {
+  constructor(e) {
+    this._renderer = e;
+  }
+  updateRenderable() {
+  }
+  destroyRenderable() {
+  }
+  validateRenderable() {
+    return !1;
+  }
+  addRenderable(e, t) {
+    this._renderer.renderPipes.batch.break(t), t.add(e);
+  }
+  execute(e) {
+    e.isRenderable && e.render(this._renderer);
+  }
+  destroy() {
+    this._renderer = null;
+  }
+}
+at.extension = {
+  type: [
+    u.WebGLPipes,
+    u.WebGPUPipes,
+    u.CanvasPipes
+  ],
+  name: "customRender"
+};
+function J(n, e) {
+  const t = n.instructionSet, r = t.instructions;
+  for (let s = 0; s < t.instructionSize; s++) {
+    const a = r[s];
+    e[a.renderPipeId].execute(a);
+  }
+}
+class it {
+  constructor(e) {
+    this._renderer = e;
+  }
+  addRenderGroup(e, t) {
+    e.isCachedAsTexture ? this._addRenderableCacheAsTexture(e, t) : this._addRenderableDirect(e, t);
+  }
+  execute(e) {
+    e.isRenderable && (e.isCachedAsTexture ? this._executeCacheAsTexture(e) : this._executeDirect(e));
+  }
+  destroy() {
+    this._renderer = null;
+  }
+  _addRenderableDirect(e, t) {
+    this._renderer.renderPipes.batch.break(t), e._batchableRenderGroup && (H.return(e._batchableRenderGroup), e._batchableRenderGroup = null), t.add(e);
+  }
+  _addRenderableCacheAsTexture(e, t) {
+    const r = e._batchableRenderGroup ?? (e._batchableRenderGroup = H.get(Ze));
+    r.renderable = e.root, r.transform = e.root.relativeGroupTransform, r.texture = e.texture, r.bounds = e._textureBounds, t.add(e), this._renderer.renderPipes.blendMode.pushBlendMode(e, e.root.groupBlendMode, t), this._renderer.renderPipes.batch.addToBatch(r, t), this._renderer.renderPipes.blendMode.popBlendMode(t);
+  }
+  _executeCacheAsTexture(e) {
+    if (e.textureNeedsUpdate) {
+      e.textureNeedsUpdate = !1;
+      const t = new M().translate(
+        -e._textureBounds.x,
+        -e._textureBounds.y
+      );
+      this._renderer.renderTarget.push(e.texture, !0, null, e.texture.frame), this._renderer.globalUniforms.push({
+        worldTransformMatrix: t,
+        worldColor: 4294967295,
+        offset: { x: 0, y: 0 }
+      }), J(e, this._renderer.renderPipes), this._renderer.renderTarget.finishRenderPass(), this._renderer.renderTarget.pop(), this._renderer.globalUniforms.pop();
+    }
+    e._batchableRenderGroup._batcher.updateElement(e._batchableRenderGroup), e._batchableRenderGroup._batcher.geometry.buffers[0].update();
+  }
+  _executeDirect(e) {
+    this._renderer.globalUniforms.push({
+      worldTransformMatrix: e.inverseParentTextureTransform,
+      worldColor: e.worldColorAlpha
+    }), J(e, this._renderer.renderPipes), this._renderer.globalUniforms.pop();
+  }
+}
+it.extension = {
+  type: [
+    u.WebGLPipes,
+    u.WebGPUPipes,
+    u.CanvasPipes
+  ],
+  name: "renderGroup"
+};
+class ot {
+  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.bounds = e.visualBounds, t.texture = e._texture;
+  }
+  _getGpuSprite(e) {
+    return e._gpuData[this._renderer.uid] || this._initGPUSprite(e);
+  }
+  _initGPUSprite(e) {
+    const t = new Ze();
+    return t.renderable = e, t.transform = e.groupTransform, t.texture = e._texture, t.bounds = e.visualBounds, t.roundPixels = this._renderer._roundPixels | e._roundPixels, e._gpuData[this._renderer.uid] = t, t;
+  }
+  destroy() {
+    this._renderer = null;
+  }
+}
+ot.extension = {
+  type: [
+    u.WebGLPipes,
+    u.WebGPUPipes,
+    u.CanvasPipes
+  ],
+  name: "sprite"
+};
+const z = {};
+se.handle(u.BlendMode, (n) => {
+  if (!n.name)
+    throw new Error("BlendMode extension must have a name property");
+  z[n.name] = n.ref;
+}, (n) => {
+  delete z[n.name];
+});
+class lt {
+  constructor(e) {
+    this._blendModeStack = [], this._isAdvanced = !1, this._filterHash = /* @__PURE__ */ Object.create(null), this._renderer = e, this._renderer.runners.prerender.add(this);
+  }
+  prerender() {
+    this._activeBlendMode = "normal", this._isAdvanced = !1;
+  }
+  /**
+   * Push a blend mode onto the internal stack and apply it to the instruction set if needed.
+   * @param renderable - The renderable or {@link RenderGroup} associated with the change.
+   * @param blendMode - The blend mode to activate.
+   * @param instructionSet - The instruction set being built.
+   */
+  pushBlendMode(e, t, r) {
+    this._blendModeStack.push(t), this.setBlendMode(e, t, r);
+  }
+  /**
+   * Pop the last blend mode from the stack and apply the new top-of-stack mode.
+   * @param instructionSet - The instruction set being built.
+   */
+  popBlendMode(e) {
+    this._blendModeStack.pop();
+    const t = this._blendModeStack[this._activeBlendMode.length - 1] ?? "normal";
+    this.setBlendMode(null, t, e);
+  }
+  /**
+   * Ensure a blend mode switch is added to the instruction set when the mode changes.
+   * If an advanced blend mode is active, subsequent renderables will be collected so they can be
+   * rendered within a single filter pass.
+   * @param renderable - The renderable or {@link RenderGroup} to associate with the change, or null when unwinding.
+   * @param blendMode - The target blend mode.
+   * @param instructionSet - The instruction set being built.
+   */
+  setBlendMode(e, t, r) {
+    var a;
+    const s = e instanceof be;
+    if (this._activeBlendMode === t) {
+      this._isAdvanced && e && !s && ((a = this._renderableList) == null || a.push(e));
+      return;
+    }
+    this._isAdvanced && this._endAdvancedBlendMode(r), this._activeBlendMode = t, e && (this._isAdvanced = !!z[t], this._isAdvanced && this._beginAdvancedBlendMode(e, r));
+  }
+  _beginAdvancedBlendMode(e, t) {
+    this._renderer.renderPipes.batch.break(t);
+    const r = this._activeBlendMode;
+    if (!z[r]) {
+      te(`Unable to assign BlendMode: '${r}'. You may want to include: import 'pixi.js/advanced-blend-modes'`);
+      return;
+    }
+    const s = this._ensureFilterEffect(r), a = e instanceof be, i = {
+      renderPipeId: "filter",
+      action: "pushFilter",
+      filterEffect: s,
+      renderables: a ? null : [e],
+      container: a ? e.root : null,
+      canBundle: !1
+    };
+    this._renderableList = i.renderables, t.add(i);
+  }
+  _ensureFilterEffect(e) {
+    let t = this._filterHash[e];
+    return t || (t = this._filterHash[e] = new Fe(), t.filters = [new z[e]()]), t;
+  }
+  _endAdvancedBlendMode(e) {
+    this._isAdvanced = !1, this._renderableList = null, this._renderer.renderPipes.batch.break(e), e.add({
+      renderPipeId: "filter",
+      action: "popFilter",
+      canBundle: !1
+    });
+  }
+  /**
+   * called when the instruction build process is starting this will reset internally to the default blend mode
+   * @internal
+   */
+  buildStart() {
+    this._isAdvanced = !1;
+  }
+  /**
+   * called when the instruction build process is finished, ensuring that if there is an advanced blend mode
+   * active, we add the final render instructions added to the instruction set
+   * @param instructionSet - The instruction set we are adding to
+   * @internal
+   */
+  buildEnd(e) {
+    this._isAdvanced && this._endAdvancedBlendMode(e);
+  }
+  /** @internal */
+  destroy() {
+    this._renderer = null, this._renderableList = null;
+    for (const e in this._filterHash)
+      this._filterHash[e].destroy();
+    this._filterHash = null;
+  }
+}
+lt.extension = {
+  type: [
+    u.WebGLPipes,
+    u.WebGPUPipes,
+    u.CanvasPipes
+  ],
+  name: "blendMode"
+};
+function Z(n, e) {
+  e || (e = 0);
+  for (let t = e; t < n.length && n[t]; t++)
+    n[t] = null;
+}
+const Mr = new O(), Ie = $e | Ve | je;
+function ut(n, e = !1) {
+  Pr(n);
+  const t = n.childrenToUpdate, r = n.updateTick++;
+  for (const s in t) {
+    const a = Number(s), i = t[s], o = i.list, l = i.index;
+    for (let d = 0; d < l; d++) {
+      const f = o[d];
+      f.parentRenderGroup === n && f.relativeRenderGroupDepth === a && ct(f, r, 0);
+    }
+    Z(o, l), i.index = 0;
+  }
+  if (e)
+    for (let s = 0; s < n.renderGroupChildren.length; s++)
+      ut(n.renderGroupChildren[s], e);
+}
+function Pr(n) {
+  const e = n.root;
+  let t;
+  if (n.renderGroupParent) {
+    const r = n.renderGroupParent;
+    n.worldTransform.appendFrom(
+      e.relativeGroupTransform,
+      r.worldTransform
+    ), n.worldColor = We(
+      e.groupColor,
+      r.worldColor
+    ), t = e.groupAlpha * r.worldAlpha;
+  } else
+    n.worldTransform.copyFrom(e.localTransform), n.worldColor = e.localColor, t = e.localAlpha;
+  t = t < 0 ? 0 : t > 1 ? 1 : t, n.worldAlpha = t, n.worldColorAlpha = n.worldColor + ((t * 255 | 0) << 24);
+}
+function ct(n, e, t) {
+  if (e === n.updateTick) return;
+  n.updateTick = e, n.didChange = !1;
+  const r = n.localTransform;
+  n.updateLocalTransform();
+  const s = n.parent;
+  if (s && !s.renderGroup ? (t |= n._updateFlags, n.relativeGroupTransform.appendFrom(
+    r,
+    s.relativeGroupTransform
+  ), t & Ie && Ee(n, s, t)) : (t = n._updateFlags, n.relativeGroupTransform.copyFrom(r), t & Ie && Ee(n, Mr, t)), !n.renderGroup) {
+    const a = n.children, i = a.length;
+    for (let d = 0; d < i; d++)
+      ct(a[d], e, t);
+    const o = n.parentRenderGroup, l = n;
+    l.renderPipeId && !o.structureDidChange && o.updateRenderable(l);
+  }
+}
+function Ee(n, e, t) {
+  if (t & Ve) {
+    n.groupColor = We(
+      n.localColor,
+      e.groupColor
+    );
+    let r = n.localAlpha * e.groupAlpha;
+    r = r < 0 ? 0 : r > 1 ? 1 : r, n.groupAlpha = r, n.groupColorAlpha = n.groupColor + ((r * 255 | 0) << 24);
+  }
+  t & je && (n.groupBlendMode = n.localBlendMode === "inherit" ? e.groupBlendMode : n.localBlendMode), t & $e && (n.globalDisplayStatus = n.localDisplayStatus & e.globalDisplayStatus), n._updateFlags = 0;
+}
+function Br(n, e) {
+  const { list: t } = n.childrenRenderablesToUpdate;
+  let r = !1;
+  for (let s = 0; s < n.childrenRenderablesToUpdate.index; s++) {
+    const a = t[s];
+    if (r = e[a.renderPipeId].validateRenderable(a), r)
+      break;
+  }
+  return n.structureDidChange = r, r;
+}
+const Rr = new M();
+class dt {
+  constructor(e) {
+    this._renderer = e;
+  }
+  render({ container: e, transform: t }) {
+    const r = e.parent, s = e.renderGroup.renderGroupParent;
+    e.parent = null, e.renderGroup.renderGroupParent = null;
+    const a = this._renderer, i = Rr;
+    t && (i.copyFrom(e.renderGroup.localTransform), e.renderGroup.localTransform.copyFrom(t));
+    const o = a.renderPipes;
+    this._updateCachedRenderGroups(e.renderGroup, null), this._updateRenderGroups(e.renderGroup), a.globalUniforms.start({
+      worldTransformMatrix: t ? e.renderGroup.localTransform : e.renderGroup.worldTransform,
+      worldColor: e.renderGroup.worldColorAlpha
+    }), J(e.renderGroup, o), o.uniformBatch && o.uniformBatch.renderEnd(), t && e.renderGroup.localTransform.copyFrom(i), e.parent = r, e.renderGroup.renderGroupParent = s;
+  }
+  destroy() {
+    this._renderer = null;
+  }
+  _updateCachedRenderGroups(e, t) {
+    if (e._parentCacheAsTextureRenderGroup = t, e.isCachedAsTexture) {
+      if (!e.textureNeedsUpdate) return;
+      t = e;
+    }
+    for (let r = e.renderGroupChildren.length - 1; r >= 0; r--)
+      this._updateCachedRenderGroups(e.renderGroupChildren[r], t);
+    if (e.invalidateMatrices(), e.isCachedAsTexture) {
+      if (e.textureNeedsUpdate) {
+        const r = e.root.getLocalBounds(), s = this._renderer, a = e.textureOptions.resolution || s.view.resolution, i = e.textureOptions.antialias ?? s.view.antialias, o = e.textureOptions.scaleMode ?? "linear", l = e.texture;
+        r.ceil(), e.texture && A.returnTexture(e.texture, !0);
+        const d = A.getOptimalTexture(
+          r.width,
+          r.height,
+          a,
+          i
+        );
+        d._source.style = new Ut({ scaleMode: o }), e.texture = d, e._textureBounds || (e._textureBounds = new ne()), e._textureBounds.copyFrom(r), l !== e.texture && e.renderGroupParent && (e.renderGroupParent.structureDidChange = !0);
+      }
+    } else e.texture && (A.returnTexture(e.texture, !0), e.texture = null);
+  }
+  _updateRenderGroups(e) {
+    const t = this._renderer, r = t.renderPipes;
+    if (e.runOnRender(t), e.instructionSet.renderPipes = r, e.structureDidChange ? Z(e.childrenRenderablesToUpdate.list, 0) : Br(e, r), ut(e), e.structureDidChange ? (e.structureDidChange = !1, this._buildInstructions(e, t)) : this._updateRenderables(e), e.childrenRenderablesToUpdate.index = 0, t.renderPipes.batch.upload(e.instructionSet), !(e.isCachedAsTexture && !e.textureNeedsUpdate))
+      for (let s = 0; s < e.renderGroupChildren.length; s++)
+        this._updateRenderGroups(e.renderGroupChildren[s]);
+  }
+  _updateRenderables(e) {
+    const { list: t, index: r } = e.childrenRenderablesToUpdate;
+    for (let s = 0; s < r; s++) {
+      const a = t[s];
+      a.didViewUpdate && e.updateRenderable(a);
+    }
+    Z(t, r);
+  }
+  _buildInstructions(e, t) {
+    const r = e.root, s = e.instructionSet;
+    s.reset();
+    const a = t.renderPipes ? t : t.batch.renderer, i = a.renderPipes;
+    i.batch.buildStart(s), i.blendMode.buildStart(), i.colorMask.buildStart(), r.sortableChildren && r.sortChildren(), r.collectRenderablesWithEffects(s, a, null), i.batch.buildEnd(s), i.blendMode.buildEnd(s);
+  }
+}
+dt.extension = {
+  type: [
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
+  ],
+  name: "renderGroup"
+};
+const le = class ht {
+  constructor() {
+    this.clearBeforeRender = !0, this._backgroundColor = new K(0), this.color = this._backgroundColor, this.alpha = 1;
+  }
+  /**
+   * initiates the background system
+   * @param options - the options for the background colors
+   */
+  init(e) {
+    e = { ...ht.defaultOptions, ...e }, this.clearBeforeRender = e.clearBeforeRender, this.color = e.background || e.backgroundColor || this._backgroundColor, this.alpha = e.backgroundAlpha, this._backgroundColor.setAlpha(e.backgroundAlpha);
+  }
+  /** The background color to fill if not transparent */
+  get color() {
+    return this._backgroundColor;
+  }
+  set color(e) {
+    K.shared.setValue(e).alpha < 1 && this._backgroundColor.alpha === 1 && te(
+      "Cannot set a transparent background on an opaque canvas. To enable transparency, set backgroundAlpha < 1 when initializing your Application."
+    ), this._backgroundColor.setValue(e);
+  }
+  /** The background color alpha. Setting this to 0 will make the canvas transparent. */
+  get alpha() {
+    return this._backgroundColor.alpha;
+  }
+  set alpha(e) {
+    this._backgroundColor.setAlpha(e);
+  }
+  /** The background color as an [R, G, B, A] array. */
+  get colorRgba() {
+    return this._backgroundColor.toArray();
+  }
+  /**
+   * destroys the background system
+   * @internal
+   */
+  destroy() {
+  }
+};
+le.extension = {
+  type: [
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
+  ],
+  name: "background",
+  priority: 0
+};
+le.defaultOptions = {
+  /**
+   * {@link WebGLOptions.backgroundAlpha}
+   * @default 1
+   */
+  backgroundAlpha: 1,
+  /**
+   * {@link WebGLOptions.backgroundColor}
+   * @default 0x000000
+   */
+  backgroundColor: 0,
+  /**
+   * {@link WebGLOptions.clearBeforeRender}
+   * @default true
+   */
+  clearBeforeRender: !0
+};
+let wr = le;
+const Q = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  webp: "image/webp"
+}, ue = class ft {
+  /** @param renderer - The renderer this System works for. */
+  constructor(e) {
+    this._renderer = e;
+  }
+  _normalizeOptions(e, t = {}) {
+    return e instanceof O || e instanceof S ? {
+      target: e,
+      ...t
+    } : {
+      ...t,
+      ...e
+    };
+  }
+  /**
+   * Creates an IImage from a display object or texture.
+   * @param options - Options for creating the image, or the target to extract
+   * @returns Promise that resolves with the generated IImage
+   * @example
+   * ```ts
+   * // Basic usage with a sprite
+   * const sprite = new Sprite(texture);
+   * const image = await renderer.extract.image(sprite);
+   * document.body.appendChild(image);
+   *
+   * // Advanced usage with options
+   * const image = await renderer.extract.image({
+   *     target: container,
+   *     format: 'webp',
+   *     quality: 0.8,
+   *     frame: new Rectangle(0, 0, 100, 100),
+   *     resolution: 2,
+   *     clearColor: '#ff0000',
+   *     antialias: true
+   * });
+   *
+   * // Extract directly from a texture
+   * const texture = Texture.from('myTexture.png');
+   * const image = await renderer.extract.image(texture);
+   * ```
+   * @see {@link ExtractImageOptions} For detailed options
+   * @see {@link ExtractSystem.base64} For base64 string output
+   * @see {@link ExtractSystem.canvas} For canvas output
+   * @see {@link ImageLike} For the image interface
+   * @category rendering
+   */
+  async image(e) {
+    const t = ie.get().createImage();
+    return t.src = await this.base64(e), t;
+  }
+  /**
+   * Converts the target into a base64 encoded string.
+   *
+   * This method works by first creating
+   * a canvas using `Extract.canvas` and then converting it to a base64 string.
+   * @param options - The options for creating the base64 string, or the target to extract
+   * @returns Promise that resolves with the base64 encoded string
+   * @example
+   * ```ts
+   * // Basic usage with a sprite
+   * const sprite = new Sprite(texture);
+   * const base64 = await renderer.extract.base64(sprite);
+   * console.log(base64); // data:image/png;base64,...
+   *
+   * // Advanced usage with options
+   * const base64 = await renderer.extract.base64({
+   *     target: container,
+   *     format: 'webp',
+   *     quality: 0.8,
+   *     frame: new Rectangle(0, 0, 100, 100),
+   *     resolution: 2
+   * });
+   * ```
+   * @throws Will throw an error if the platform doesn't support any of:
+   * - ICanvas.toDataURL
+   * - ICanvas.toBlob
+   * - ICanvas.convertToBlob
+   * @see {@link ExtractImageOptions} For detailed options
+   * @see {@link ExtractSystem.canvas} For canvas output
+   * @see {@link ExtractSystem.image} For HTMLImage output
+   * @category rendering
+   */
+  async base64(e) {
+    e = this._normalizeOptions(
+      e,
+      ft.defaultImageOptions
+    );
+    const { format: t, quality: r } = e, s = this.canvas(e);
+    if (s.toBlob !== void 0)
+      return new Promise((a, i) => {
+        s.toBlob((o) => {
+          if (!o) {
+            i(new Error("ICanvas.toBlob failed!"));
+            return;
+          }
+          const l = new FileReader();
+          l.onload = () => a(l.result), l.onerror = i, l.readAsDataURL(o);
+        }, Q[t], r);
+      });
+    if (s.toDataURL !== void 0)
+      return s.toDataURL(Q[t], r);
+    if (s.convertToBlob !== void 0) {
+      const a = await s.convertToBlob({ type: Q[t], quality: r });
+      return new Promise((i, o) => {
+        const l = new FileReader();
+        l.onload = () => i(l.result), l.onerror = o, l.readAsDataURL(a);
+      });
+    }
+    throw new Error("Extract.base64() requires ICanvas.toDataURL, ICanvas.toBlob, or ICanvas.convertToBlob to be implemented");
+  }
+  /**
+   * Creates a Canvas element, renders the target to it and returns it.
+   * This method is useful for creating static images or when you need direct canvas access.
+   * @param options - The options for creating the canvas, or the target to extract
+   * @returns A Canvas element with the texture rendered on
+   * @example
+   * ```ts
+   * // Basic canvas extraction from a sprite
+   * const sprite = new Sprite(texture);
+   * const canvas = renderer.extract.canvas(sprite);
+   * document.body.appendChild(canvas);
+   *
+   * // Extract with custom region
+   * const canvas = renderer.extract.canvas({
+   *     target: container,
+   *     frame: new Rectangle(0, 0, 100, 100)
+   * });
+   *
+   * // Extract with high resolution
+   * const canvas = renderer.extract.canvas({
+   *     target: sprite,
+   *     resolution: 2,
+   *     clearColor: '#ff0000'
+   * });
+   *
+   * // Extract directly from a texture
+   * const texture = Texture.from('myTexture.png');
+   * const canvas = renderer.extract.canvas(texture);
+   *
+   * // Extract with anti-aliasing
+   * const canvas = renderer.extract.canvas({
+   *     target: graphics,
+   *     antialias: true
+   * });
+   * ```
+   * @see {@link ExtractOptions} For detailed options
+   * @see {@link ExtractSystem.image} For HTMLImage output
+   * @see {@link ExtractSystem.pixels} For raw pixel data
+   * @category rendering
+   */
+  canvas(e) {
+    e = this._normalizeOptions(e);
+    const t = e.target, r = this._renderer;
+    if (t instanceof S)
+      return r.texture.generateCanvas(t);
+    const s = r.textureGenerator.generateTexture(e), a = r.texture.generateCanvas(s);
+    return s.destroy(!0), a;
+  }
+  /**
+   * Returns a one-dimensional array containing the pixel data of the entire texture in RGBA order,
+   * with integer values between 0 and 255 (inclusive).
+   * > [!NOE] The returned array is a flat Uint8Array where every 4 values represent RGBA
+   * @param options - The options for extracting the image, or the target to extract
+   * @returns One-dimensional Uint8Array containing the pixel data in RGBA format
+   * @example
+   * ```ts
+   * // Basic pixel extraction
+   * const sprite = new Sprite(texture);
+   * const pixels = renderer.extract.pixels(sprite);
+   * console.log(pixels[0], pixels[1], pixels[2], pixels[3]); // R,G,B,A values
+   *
+   * // Extract with custom region
+   * const pixels = renderer.extract.pixels({
+   *     target: sprite,
+   *     frame: new Rectangle(0, 0, 100, 100)
+   * });
+   *
+   * // Extract with high resolution
+   * const pixels = renderer.extract.pixels({
+   *     target: sprite,
+   *     resolution: 2
+   * });
+   * ```
+   * @see {@link ExtractOptions} For detailed options
+   * @see {@link ExtractSystem.canvas} For canvas output
+   * @see {@link ExtractSystem.image} For image output
+   * @category rendering
+   */
+  pixels(e) {
+    e = this._normalizeOptions(e);
+    const t = e.target, r = this._renderer, s = t instanceof S ? t : r.textureGenerator.generateTexture(e), a = r.texture.getPixels(s);
+    return t instanceof O && s.destroy(!0), a;
+  }
+  /**
+   * Creates a texture from a display object or existing texture.
+   *
+   * This is useful for creating
+   * reusable textures from rendered content or making copies of existing textures.
+   * > [!NOTE] The returned texture should be destroyed when no longer needed
+   * @param options - The options for creating the texture, or the target to extract
+   * @returns A new texture containing the extracted content
+   * @example
+   * ```ts
+   * // Basic texture extraction from a sprite
+   * const sprite = new Sprite(texture);
+   * const extractedTexture = renderer.extract.texture(sprite);
+   *
+   * // Extract with custom region
+   * const regionTexture = renderer.extract.texture({
+   *     target: container,
+   *     frame: new Rectangle(0, 0, 100, 100)
+   * });
+   *
+   * // Extract with high resolution
+   * const hiResTexture = renderer.extract.texture({
+   *     target: sprite,
+   *     resolution: 2,
+   *     clearColor: '#ff0000'
+   * });
+   *
+   * // Create a new sprite from extracted texture
+   * const newSprite = new Sprite(
+   *     renderer.extract.texture({
+   *         target: graphics,
+   *         antialias: true
+   *     })
+   * );
+   *
+   * // Clean up when done
+   * extractedTexture.destroy(true);
+   * ```
+   * @see {@link ExtractOptions} For detailed options
+   * @see {@link Texture} For texture management
+   * @see {@link GenerateTextureSystem} For texture generation
+   * @category rendering
+   */
+  texture(e) {
+    return e = this._normalizeOptions(e), e.target instanceof S ? e.target : this._renderer.textureGenerator.generateTexture(e);
+  }
+  /**
+   * Extracts and downloads content from the renderer as an image file.
+   * This is a convenient way to save screenshots or export rendered content.
+   * > [!NOTE] The download will use PNG format regardless of the filename extension
+   * @param options - The options for downloading and extracting the image, or the target to extract
+   * @example
+   * ```ts
+   * // Basic download with default filename
+   * const sprite = new Sprite(texture);
+   * renderer.extract.download(sprite); // Downloads as 'image.png'
+   *
+   * // Download with custom filename
+   * renderer.extract.download({
+   *     target: sprite,
+   *     filename: 'screenshot.png'
+   * });
+   *
+   * // Download with custom region
+   * renderer.extract.download({
+   *     target: container,
+   *     filename: 'region.png',
+   *     frame: new Rectangle(0, 0, 100, 100)
+   * });
+   *
+   * // Download with high resolution and background
+   * renderer.extract.download({
+   *     target: stage,
+   *     filename: 'hd-screenshot.png',
+   *     resolution: 2,
+   *     clearColor: '#ff0000'
+   * });
+   *
+   * // Download with anti-aliasing
+   * renderer.extract.download({
+   *     target: graphics,
+   *     filename: 'smooth.png',
+   *     antialias: true
+   * });
+   * ```
+   * @see {@link ExtractDownloadOptions} For detailed options
+   * @see {@link ExtractSystem.image} For creating images without download
+   * @see {@link ExtractSystem.canvas} For canvas output
+   * @category rendering
+   */
+  download(e) {
+    e = this._normalizeOptions(e);
+    const t = this.canvas(e), r = document.createElement("a");
+    r.download = e.filename ?? "image.png", r.href = t.toDataURL("image/png"), document.body.appendChild(r), r.click(), document.body.removeChild(r);
+  }
+  /**
+   * Logs the target to the console as an image. This is a useful way to debug what's happening in the renderer.
+   * The image will be displayed in the browser's console using CSS background images.
+   * @param options - The options for logging the image, or the target to log
+   * @param options.width - The width of the logged image preview in the console (in pixels)
+   * @example
+   * ```ts
+   * // Basic usage
+   * const sprite = new Sprite(texture);
+   * renderer.extract.log(sprite);
+   * ```
+   * @see {@link ExtractSystem.canvas} For getting raw canvas output
+   * @see {@link ExtractSystem.pixels} For raw pixel data
+   * @category rendering
+   * @advanced
+   */
+  log(e) {
+    const t = e.width ?? 200;
+    e = this._normalizeOptions(e);
+    const r = this.canvas(e), s = r.toDataURL();
+    console.log(`[Pixi Texture] ${r.width}px ${r.height}px`);
+    const a = [
+      "font-size: 1px;",
+      `padding: ${t}px 300px;`,
+      `background: url(${s}) no-repeat;`,
+      "background-size: contain;"
+    ].join(" ");
+    console.log("%c ", a);
+  }
+  destroy() {
+    this._renderer = null;
+  }
+};
+ue.extension = {
+  type: [
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
+  ],
+  name: "extract"
+};
+ue.defaultImageOptions = {
+  format: "png",
+  quality: 1
+};
+let Ur = ue;
+class ce extends S {
+  /**
+   * Creates a RenderTexture. Pass `dynamic: true` in options to allow resizing after creation.
+   * @param options - Options for the RenderTexture, including width, height, textureOptions, and dynamic.
+   * @returns A new RenderTexture instance.
+   * @example
+   * const textureOptions = { defaultAnchor: { x: 0.5, y: 0.5 } };
+   * const rt = RenderTexture.create({ width: 100, height: 100, dynamic: true, textureOptions });
+   * rt.resize(500, 500);
+   */
+  static create(e) {
+    const { dynamic: t, textureOptions: r, ...s } = e;
+    return new ce({
+      ...r,
+      source: new I(s),
+      dynamic: t ?? !1
+    });
+  }
+  /**
+   * Resizes the render texture.
+   * @param width - The new width of the render texture.
+   * @param height - The new height of the render texture.
+   * @param resolution - The new resolution of the render texture.
+   * @returns This texture.
+   */
+  resize(e, t, r) {
+    return this.source.resize(e, t, r), this;
+  }
+}
+const Gr = new F(), Ar = new ne(), Ir = [0, 0, 0, 0];
+class pt {
+  constructor(e) {
+    this._renderer = e;
+  }
+  /**
+   * Creates a texture from a display object that can be used for creating sprites and other textures.
+   * This is particularly useful for optimizing performance when a complex container needs to be reused.
+   * @param options - Generate texture options or a container to convert to texture
+   * @returns A new RenderTexture containing the rendered display object
+   * @example
+   * ```ts
+   * // Basic usage with a container
+   * const container = new Container();
+   * container.addChild(
+   *     new Graphics()
+   *         .circle(0, 0, 50)
+   *         .fill('red')
+   * );
+   *
+   * const texture = renderer.textureGenerator.generateTexture(container);
+   *
+   * // Advanced usage with options
+   * const texture = renderer.textureGenerator.generateTexture({
+   *     target: container,
+   *     frame: new Rectangle(0, 0, 100, 100), // Specific region
+   *     resolution: 2,                        // High DPI
+   *     clearColor: '#ff0000',               // Red background
+   *     antialias: true                      // Smooth edges
+   * });
+   *
+   * // Create a sprite from the generated texture
+   * const sprite = new Sprite(texture);
+   *
+   * // Clean up when done
+   * texture.destroy(true);
+   * ```
+   * @see {@link GenerateTextureOptions} For detailed texture generation options
+   * @see {@link RenderTexture} For the type of texture created
+   * @category rendering
+   */
+  generateTexture(e) {
+    var f;
+    e instanceof O && (e = {
+      target: e,
+      frame: void 0,
+      textureSourceOptions: {},
+      resolution: void 0
+    });
+    const t = e.resolution || this._renderer.resolution, r = e.antialias || this._renderer.view.antialias, s = e.target;
+    let a = e.clearColor;
+    a ? a = Array.isArray(a) && a.length === 4 ? a : K.shared.setValue(a).toArray() : a = Ir;
+    const i = ((f = e.frame) == null ? void 0 : f.copyTo(Gr)) || Gt(s, Ar).rectangle, o = e.defaultAnchor && {
+      defaultAnchor: e.defaultAnchor
+    };
+    i.width = Math.max(i.width, 1 / t) | 0, i.height = Math.max(i.height, 1 / t) | 0;
+    const l = ce.create({
+      ...e.textureSourceOptions,
+      width: i.width,
+      height: i.height,
+      resolution: t,
+      antialias: r,
+      textureOptions: o
+    }), d = M.shared.translate(-i.x, -i.y);
+    return this._renderer.render({
+      container: s,
+      transform: d,
+      target: l,
+      clearColor: a
+    }), l.source.updateMipmaps(), l;
+  }
+  destroy() {
+    this._renderer = null;
+  }
+}
+pt.extension = {
+  type: [
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
+  ],
+  name: "textureGenerator"
+};
+function Er(n) {
+  let e = !1;
+  for (const r in n)
+    if (n[r] == null) {
+      e = !0;
+      break;
+    }
+  if (!e) return n;
+  const t = /* @__PURE__ */ Object.create(null);
+  for (const r in n) {
+    const s = n[r];
+    s && (t[r] = s);
+  }
+  return t;
+}
+function zr(n) {
+  let e = 0;
+  for (let t = 0; t < n.length; t++)
+    n[t] == null ? e++ : n[t - e] = n[t];
+  return n.length -= e, n;
+}
+const de = class mt {
+  /**
+   * Creates a new GCSystem instance.
+   * @param renderer - The renderer this garbage collection system works for
+   */
+  constructor(e) {
+    this._managedResources = [], this._managedResourceHashes = [], this._managedCollections = [], this._ready = !1, this._renderer = e;
+  }
+  /**
+   * Initializes the garbage collection system with the provided options.
+   * @param options - Configuration options
+   */
+  init(e) {
+    e = { ...mt.defaultOptions, ...e }, this.maxUnusedTime = e.gcMaxUnusedTime, this._frequency = e.gcFrequency, this.enabled = e.gcActive, this.now = performance.now();
+  }
+  /**
+   * Gets whether the garbage collection system is currently enabled.
+   * @returns True if GC is enabled, false otherwise
+   */
+  get enabled() {
+    return !!this._handler;
+  }
+  /**
+   * Enables or disables the garbage collection system.
+   * When enabled, schedules periodic cleanup of resources.
+   * When disabled, cancels all scheduled cleanups.
+   */
+  set enabled(e) {
+    this.enabled !== e && (e ? (this._handler = this._renderer.scheduler.repeat(
+      () => {
+        this._ready = !0;
+      },
+      this._frequency,
+      !1
+    ), this._collectionsHandler = this._renderer.scheduler.repeat(
+      () => {
+        for (const t of this._managedCollections) {
+          const { context: r, collection: s, type: a } = t;
+          a === "hash" ? r[s] = Er(r[s]) : r[s] = zr(r[s]);
+        }
+      },
+      this._frequency
+    )) : (this._renderer.scheduler.cancel(this._handler), this._renderer.scheduler.cancel(this._collectionsHandler), this._handler = 0, this._collectionsHandler = 0));
+  }
+  /**
+   * Called before rendering. Updates the current timestamp.
+   * @param options - The render options
+   * @param options.container - The container to render
+   */
+  prerender({ container: e }) {
+    this.now = performance.now(), e.renderGroup.gcTick = this._renderer.tick++, this._updateInstructionGCTick(e.renderGroup, e.renderGroup.gcTick);
+  }
+  /** Performs garbage collection after rendering. */
+  postrender() {
+    !this._ready || !this.enabled || (this.run(), this._ready = !1);
+  }
+  /**
+   * Updates the GC tick counter for a render group and its children.
+   * @param renderGroup - The render group to update
+   * @param gcTick - The new tick value
+   */
+  _updateInstructionGCTick(e, t) {
+    e.instructionSet.gcTick = t, e.gcTick = t;
+    for (const r of e.renderGroupChildren)
+      this._updateInstructionGCTick(r, t);
+  }
+  /**
+   * Registers a collection for garbage collection tracking.
+   * @param context - The object containing the collection
+   * @param collection - The property name on context that holds the collection
+   * @param type - The type of collection to track ('hash' or 'array')
+   */
+  addCollection(e, t, r) {
+    this._managedCollections.push({
+      context: e,
+      collection: t,
+      type: r
+    });
+  }
+  /**
+   * Registers a resource for garbage collection tracking.
+   * @param resource - The resource to track
+   * @param type - The type of resource to track
+   */
+  addResource(e, t) {
+    var s, a;
+    if (e._gcLastUsed !== -1) {
+      e._gcLastUsed = this.now, (s = e._onTouch) == null || s.call(e, this.now);
+      return;
+    }
+    const r = this._managedResources.length;
+    e._gcData = {
+      index: r,
+      type: t
+    }, e._gcLastUsed = this.now, (a = e._onTouch) == null || a.call(e, this.now), e.once("unload", this.removeResource, this), this._managedResources.push(e);
+  }
+  /**
+   * Removes a resource from garbage collection tracking.
+   * Call this when manually destroying a resource.
+   * @param resource - The resource to stop tracking
+   */
+  removeResource(e) {
+    const t = e._gcData;
+    if (!t) return;
+    const r = t.index, s = this._managedResources.length - 1;
+    if (r !== s) {
+      const a = this._managedResources[s];
+      this._managedResources[r] = a, a._gcData.index = r;
+    }
+    this._managedResources.length--, e._gcData = null, e._gcLastUsed = -1;
+  }
+  /**
+   * Registers a hash-based resource collection for garbage collection tracking.
+   * Resources in the hash will be automatically tracked and cleaned up when unused.
+   * @param context - The object containing the hash property
+   * @param hash - The property name on context that holds the resource hash
+   * @param type - The type of resources in the hash ('resource' or 'renderable')
+   * @param priority - Processing priority (lower values are processed first)
+   */
+  addResourceHash(e, t, r, s = 0) {
+    this._managedResourceHashes.push({
+      context: e,
+      hash: t,
+      type: r,
+      priority: s
+    }), this._managedResourceHashes.sort((a, i) => a.priority - i.priority);
+  }
+  /**
+   * Performs garbage collection by cleaning up unused resources.
+   * Removes resources that haven't been used for longer than maxUnusedTime.
+   */
+  run() {
+    const e = performance.now(), t = this._managedResourceHashes;
+    for (const s of t)
+      this.runOnHash(s, e);
+    let r = 0;
+    for (let s = 0; s < this._managedResources.length; s++) {
+      const a = this._managedResources[s];
+      r = this.runOnResource(a, e, r);
+    }
+    this._managedResources.length = r;
+  }
+  updateRenderableGCTick(e, t) {
+    var a, i;
+    const r = e.renderGroup ?? e.parentRenderGroup, s = ((a = r == null ? void 0 : r.instructionSet) == null ? void 0 : a.gcTick) ?? -1;
+    ((r == null ? void 0 : r.gcTick) ?? 0) === s && (e._gcLastUsed = t, (i = e._onTouch) == null || i.call(e, t));
+  }
+  runOnResource(e, t, r) {
+    const s = e._gcData;
+    return s.type === "renderable" && this.updateRenderableGCTick(e, t), t - e._gcLastUsed < this.maxUnusedTime || !e.autoGarbageCollect ? (this._managedResources[r] = e, s.index = r, r++) : (e.unload(), e._gcData = null, e._gcLastUsed = -1, e.off("unload", this.removeResource, this)), r;
+  }
+  /**
+   * Creates a clone of the hash, copying all non-null entries up to (but not including) the stop key.
+   * @param hashValue - The original hash to clone from
+   * @param stopKey - The key to stop at (exclusive)
+   * @returns A new hash object with copied entries
+   */
+  _createHashClone(e, t) {
+    const r = /* @__PURE__ */ Object.create(null);
+    for (const s in e) {
+      if (s === t) break;
+      e[s] !== null && (r[s] = e[s]);
+    }
+    return r;
+  }
+  runOnHash(e, t) {
+    var d;
+    const { context: r, hash: s, type: a } = e, i = r[s];
+    let o = null, l = 0;
+    for (const f in i) {
+      const c = i[f];
+      if (c === null) {
+        l++, l === 1e4 && !o && (o = this._createHashClone(i, f));
+        continue;
+      }
+      if (c._gcLastUsed === -1) {
+        c._gcLastUsed = t, (d = c._onTouch) == null || d.call(c, t), o && (o[f] = c);
+        continue;
+      }
+      if (a === "renderable" && this.updateRenderableGCTick(c, t), !(t - c._gcLastUsed < this.maxUnusedTime) && c.autoGarbageCollect) {
+        if (o || (l + 1 !== 1e4 ? (i[f] = null, l++) : o = this._createHashClone(i, f)), a === "renderable") {
+          const g = c, m = g.renderGroup ?? g.parentRenderGroup;
+          m && (m.structureDidChange = !0);
+        }
+        c.unload(), c._gcData = null, c._gcLastUsed = -1;
+      } else o && (o[f] = c);
+    }
+    o && (r[s] = o);
+  }
+  /** Cleans up the garbage collection system. Disables GC and removes all tracked resources. */
+  destroy() {
+    this.enabled = !1, this._managedResources.forEach((e) => {
+      e.off("unload", this.removeResource, this);
+    }), this._managedResources.length = 0, this._managedResourceHashes.length = 0, this._managedCollections.length = 0, this._renderer = null;
+  }
+};
+de.extension = {
+  type: [
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
+  ],
+  name: "gc",
+  priority: 0
+};
+de.defaultOptions = {
+  /** Enable/disable the garbage collector */
+  gcActive: !0,
+  /** Time in ms before an unused resource is collected (default 1 minute) */
+  gcMaxUnusedTime: 6e4,
+  /** How often to run garbage collection in ms (default 30 seconds) */
+  gcFrequency: 3e4
+};
+let Dr = de;
+class xt {
+  constructor(e) {
+    this._stackIndex = 0, this._globalUniformDataStack = [], this._uniformsPool = [], this._activeUniforms = [], this._bindGroupPool = [], this._activeBindGroups = [], this._renderer = e;
+  }
+  reset() {
+    this._stackIndex = 0;
+    for (let e = 0; e < this._activeUniforms.length; e++)
+      this._uniformsPool.push(this._activeUniforms[e]);
+    for (let e = 0; e < this._activeBindGroups.length; e++)
+      this._bindGroupPool.push(this._activeBindGroups[e]);
+    this._activeUniforms.length = 0, this._activeBindGroups.length = 0;
+  }
+  start(e) {
+    this.reset(), this.push(e);
+  }
+  bind({
+    size: e,
+    projectionMatrix: t,
+    worldTransformMatrix: r,
+    worldColor: s,
+    offset: a
+  }) {
+    const i = this._renderer.renderTarget.renderTarget, o = this._stackIndex ? this._globalUniformDataStack[this._stackIndex - 1] : {
+      worldTransformMatrix: new M(),
+      worldColor: 4294967295,
+      offset: new At()
+    }, l = {
+      projectionMatrix: t || this._renderer.renderTarget.projectionMatrix,
+      resolution: e || i.size,
+      worldTransformMatrix: r || o.worldTransformMatrix,
+      worldColor: s || o.worldColor,
+      offset: a || o.offset,
+      bindGroup: null
+    }, d = this._uniformsPool.pop() || this._createUniforms();
+    this._activeUniforms.push(d);
+    const f = d.uniforms;
+    f.uProjectionMatrix = l.projectionMatrix, f.uResolution = l.resolution, f.uWorldTransformMatrix.copyFrom(l.worldTransformMatrix), f.uWorldTransformMatrix.tx -= l.offset.x, f.uWorldTransformMatrix.ty -= l.offset.y, It(
+      l.worldColor,
+      f.uWorldColorAlpha,
+      0
+    ), d.update();
+    let c;
+    this._renderer.renderPipes.uniformBatch ? c = this._renderer.renderPipes.uniformBatch.getUniformBindGroup(d, !1) : (c = this._bindGroupPool.pop() || new Et(), this._activeBindGroups.push(c), c.setResource(d, 0)), l.bindGroup = c, this._currentGlobalUniformData = l;
+  }
+  push(e) {
+    this.bind(e), this._globalUniformDataStack[this._stackIndex++] = this._currentGlobalUniformData;
+  }
+  pop() {
+    this._currentGlobalUniformData = this._globalUniformDataStack[--this._stackIndex - 1], this._renderer.type === ae.WEBGL && this._currentGlobalUniformData.bindGroup.resources[0].update();
+  }
+  get bindGroup() {
+    return this._currentGlobalUniformData.bindGroup;
+  }
+  get globalUniformData() {
+    return this._currentGlobalUniformData;
+  }
+  get uniformGroup() {
+    return this._currentGlobalUniformData.bindGroup.resources[0];
+  }
+  _createUniforms() {
+    return new re({
+      uProjectionMatrix: { value: new M(), type: "mat3x3<f32>" },
+      uWorldTransformMatrix: { value: new M(), type: "mat3x3<f32>" },
+      // TODO - someone smart - set this to be a unorm8x4 rather than a vec4<f32>
+      uWorldColorAlpha: { value: new Float32Array(4), type: "vec4<f32>" },
+      uResolution: { value: [0, 0], type: "vec2<f32>" }
+    }, {
+      isStatic: !0
+    });
+  }
+  destroy() {
+    this._renderer = null, this._globalUniformDataStack.length = 0, this._uniformsPool.length = 0, this._activeUniforms.length = 0, this._bindGroupPool.length = 0, this._activeBindGroups.length = 0, this._currentGlobalUniformData = null;
+  }
+}
+xt.extension = {
+  type: [
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
+  ],
+  name: "globalUniforms"
+};
+let Lr = 1;
+class gt {
+  constructor() {
+    this._tasks = [], this._offset = 0;
+  }
+  /** Initializes the scheduler system and starts the ticker. */
+  init() {
+    ve.system.add(this._update, this);
+  }
+  /**
+   * Schedules a repeating task.
+   * @param func - The function to execute.
+   * @param duration - The interval duration in milliseconds.
+   * @param useOffset - this will spread out tasks so that they do not all run at the same time
+   * @returns The unique identifier for the scheduled task.
+   */
+  repeat(e, t, r = !0) {
+    const s = Lr++;
+    let a = 0;
+    return r && (this._offset += 1e3, a = this._offset), this._tasks.push({
+      func: e,
+      duration: t,
+      start: performance.now(),
+      offset: a,
+      last: performance.now(),
+      repeat: !0,
+      id: s
+    }), s;
+  }
+  /**
+   * Cancels a scheduled task.
+   * @param id - The unique identifier of the task to cancel.
+   */
+  cancel(e) {
+    for (let t = 0; t < this._tasks.length; t++)
+      if (this._tasks[t].id === e) {
+        this._tasks.splice(t, 1);
+        return;
+      }
+  }
+  /**
+   * Updates and executes the scheduled tasks.
+   * @private
+   */
+  _update() {
+    const e = performance.now();
+    for (let t = 0; t < this._tasks.length; t++) {
+      const r = this._tasks[t];
+      if (e - r.offset - r.last >= r.duration) {
+        const s = e - r.start;
+        r.func(s), r.last = e;
+      }
+    }
+  }
+  /**
+   * Destroys the scheduler system and removes all tasks.
+   * @internal
+   */
+  destroy() {
+    ve.system.remove(this._update, this), this._tasks.length = 0;
+  }
+}
+gt.extension = {
+  type: [
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
+  ],
+  name: "scheduler",
+  priority: 0
+};
+let ze = !1;
+function Hr(n) {
+  if (!ze) {
+    if (ie.get().getNavigator().userAgent.toLowerCase().indexOf("chrome") > -1) {
+      const e = [
+        `%c  %c  %c  %c  %c PixiJS %c v${ye} (${n}) http://www.pixijs.com/
+
+`,
+        "background: #E72264; padding:5px 0;",
+        "background: #6CA2EA; padding:5px 0;",
+        "background: #B5D33D; padding:5px 0;",
+        "background: #FED23F; padding:5px 0;",
+        "color: #FFFFFF; background: #E72264; padding:5px 0;",
+        "color: #E72264; background: #FFFFFF; padding:5px 0;"
+      ];
+      globalThis.console.log(...e);
+    } else globalThis.console && globalThis.console.log(`PixiJS ${ye} - ${n} - http://www.pixijs.com/`);
+    ze = !0;
+  }
+}
+class he {
+  constructor(e) {
+    this._renderer = e;
+  }
+  /**
+   * It all starts here! This initiates every system, passing in the options for any system by name.
+   * @param options - the config for the renderer and all its systems
+   */
+  init(e) {
+    if (e.hello) {
+      let t = this._renderer.name;
+      this._renderer.type === ae.WEBGL && (t += ` ${this._renderer.context.webGLVersion}`), Hr(t);
+    }
+  }
+}
+he.extension = {
+  type: [
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
+  ],
+  name: "hello",
+  priority: -2
+};
+he.defaultOptions = {
+  /** {@link WebGLOptions.hello} */
+  hello: !1
+};
+const fe = class _t {
+  /**
+   * Creates a new RenderableGCSystem instance.
+   * @param renderer - The renderer this garbage collection system works for
+   */
+  constructor(e) {
+    this._renderer = e;
+  }
+  /**
+   * Initializes the garbage collection system with the provided options.
+   * @param options - Configuration options for the renderer
+   */
+  init(e) {
+    e = { ..._t.defaultOptions, ...e }, this.maxUnusedTime = e.renderableGCMaxUnusedTime;
+  }
+  /**
+   * Gets whether the garbage collection system is currently enabled.
+   * @returns True if GC is enabled, false otherwise
+   */
+  get enabled() {
+    return T("8.15.0", "RenderableGCSystem.enabled is deprecated, please use the GCSystem.enabled instead."), this._renderer.gc.enabled;
+  }
+  /**
+   * Enables or disables the garbage collection system.
+   * When enabled, schedules periodic cleanup of resources.
+   * When disabled, cancels all scheduled cleanups.
+   */
+  set enabled(e) {
+    T("8.15.0", "RenderableGCSystem.enabled is deprecated, please use the GCSystem.enabled instead."), this._renderer.gc.enabled = e;
+  }
+  /**
+   * Adds a hash table to be managed by the garbage collector.
+   * @param context - The object containing the hash table
+   * @param hash - The property name of the hash table
+   */
+  addManagedHash(e, t) {
+    T("8.15.0", "RenderableGCSystem.addManagedHash is deprecated, please use the GCSystem.addCollection instead."), this._renderer.gc.addCollection(e, t, "hash");
+  }
+  /**
+   * Adds an array to be managed by the garbage collector.
+   * @param context - The object containing the array
+   * @param hash - The property name of the array
+   */
+  addManagedArray(e, t) {
+    T("8.15.0", "RenderableGCSystem.addManagedArray is deprecated, please use the GCSystem.addCollection instead."), this._renderer.gc.addCollection(e, t, "array");
+  }
+  /**
+   * Starts tracking a renderable for garbage collection.
+   * @param _renderable - The renderable to track
+   * @deprecated since 8.15.0
+   */
+  addRenderable(e) {
+    T("8.15.0", "RenderableGCSystem.addRenderable is deprecated, please use the GCSystem instead."), this._renderer.gc.addResource(e, "renderable");
+  }
+  /**
+   * Performs garbage collection by cleaning up unused renderables.
+   * Removes renderables that haven't been used for longer than maxUnusedTime.
+   */
+  run() {
+    T("8.15.0", "RenderableGCSystem.run is deprecated, please use the GCSystem instead."), this._renderer.gc.run();
+  }
+  /** Cleans up the garbage collection system. Disables GC and removes all tracked resources. */
+  destroy() {
+    this._renderer = null;
+  }
+};
+fe.extension = {
+  type: [
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
+  ],
+  name: "renderableGC",
+  priority: 0
+};
+fe.defaultOptions = {
+  /** Enable/disable the garbage collector */
+  renderableGCActive: !0,
+  /** Time in ms before an unused resource is collected (default 1 minute) */
+  renderableGCMaxUnusedTime: 6e4,
+  /** How often to run garbage collection in ms (default 30 seconds) */
+  renderableGCFrequency: 3e4
+};
+let Or = fe;
+const pe = class L {
+  /**
+   * Frame count since started.
+   * @readonly
+   * @deprecated since 8.15.0
+   */
+  get count() {
+    return this._renderer.tick;
+  }
+  /**
+   * Frame count since last garbage collection.
+   * @readonly
+   * @deprecated since 8.15.0
+   */
+  get checkCount() {
+    return this._checkCount;
+  }
+  set checkCount(e) {
+    T("8.15.0", "TextureGCSystem.run is deprecated, please use the GCSystem instead."), this._checkCount = e;
+  }
+  /**
+   * Maximum idle frames before a texture is destroyed by garbage collection.
+   * @see TextureGCSystem.defaultMaxIdle
+   * @deprecated since 8.15.0
+   */
+  get maxIdle() {
+    return this._renderer.gc.maxUnusedTime / 1e3 * 60;
+  }
+  set maxIdle(e) {
+    T("8.15.0", "TextureGCSystem.run is deprecated, please use the GCSystem instead."), this._renderer.gc.maxUnusedTime = e / 60 * 1e3;
+  }
+  /**
+   * Frames between two garbage collections.
+   * @see TextureGCSystem.defaultCheckCountMax
+   * @deprecated since 8.15.0
+   */
+  // eslint-disable-next-line dot-notation
+  get checkCountMax() {
+    return Math.floor(this._renderer.gc._frequency / 1e3);
+  }
+  set checkCountMax(e) {
+    T("8.15.0", "TextureGCSystem.run is deprecated, please use the GCSystem instead.");
+  }
+  /**
+   * Current garbage collection mode.
+   * @see TextureGCSystem.defaultMode
+   * @deprecated since 8.15.0
+   */
+  get active() {
+    return this._renderer.gc.enabled;
+  }
+  set active(e) {
+    T("8.15.0", "TextureGCSystem.run is deprecated, please use the GCSystem instead."), this._renderer.gc.enabled = e;
+  }
+  /** @param renderer - The renderer this System works for. */
+  constructor(e) {
+    this._renderer = e, this._checkCount = 0;
+  }
+  init(e) {
+    e.textureGCActive !== L.defaultOptions.textureGCActive && (this.active = e.textureGCActive), e.textureGCMaxIdle !== L.defaultOptions.textureGCMaxIdle && (this.maxIdle = e.textureGCMaxIdle), e.textureGCCheckCountMax !== L.defaultOptions.textureGCCheckCountMax && (this.checkCountMax = e.textureGCCheckCountMax);
+  }
+  /**
+   * Checks to see when the last time a texture was used.
+   * If the texture has not been used for a specified amount of time, it will be removed from the GPU.
+   * @deprecated since 8.15.0
+   */
+  run() {
+    T("8.15.0", "TextureGCSystem.run is deprecated, please use the GCSystem instead."), this._renderer.gc.run();
+  }
+  destroy() {
+    this._renderer = null;
+  }
+};
+pe.extension = {
+  type: [
+    u.WebGLSystem,
+    u.WebGPUSystem
+  ],
+  name: "textureGC"
+};
+pe.defaultOptions = {
+  /**
+   * If set to true, this will enable the garbage collector on the GPU.
+   * @default true
+   */
+  textureGCActive: !0,
+  /**
+   * @deprecated since 8.3.0
+   * @see {@link TextureGCSystemOptions.textureGCMaxIdle}
+   */
+  textureGCAMaxIdle: null,
+  /**
+   * The maximum idle frames before a texture is destroyed by garbage collection.
+   * @default 60 * 60
+   */
+  textureGCMaxIdle: 3600,
+  /**
+   * Frames between two garbage collections.
+   * @default 600
+   */
+  textureGCCheckCountMax: 600
+};
+let Fr = pe;
+const bt = class vt {
+  /**
+   * @param [descriptor] - Options for creating a render target.
+   */
+  constructor(e = {}) {
+    if (this.uid = De("renderTarget"), this.colorTextures = [], this.dirtyId = 0, this.isRoot = !1, this._size = new Float32Array(2), this._managedColorTextures = !1, e = { ...vt.defaultOptions, ...e }, this.stencil = e.stencil, this.depth = e.depth, this.isRoot = e.isRoot, typeof e.colorTextures == "number") {
+      this._managedColorTextures = !0;
+      for (let t = 0; t < e.colorTextures; t++)
+        this.colorTextures.push(
+          new I({
+            width: e.width,
+            height: e.height,
+            resolution: e.resolution,
+            antialias: e.antialias
+          })
+        );
+    } else {
+      this.colorTextures = [...e.colorTextures.map((r) => r.source)];
+      const t = this.colorTexture.source;
+      this.resize(t.width, t.height, t._resolution);
+    }
+    this.colorTexture.source.on("resize", this.onSourceResize, this), (e.depthStencilTexture || this.stencil) && (e.depthStencilTexture instanceof S || e.depthStencilTexture instanceof I ? this.depthStencilTexture = e.depthStencilTexture.source : this.ensureDepthStencilTexture());
+  }
+  get size() {
+    const e = this._size;
+    return e[0] = this.pixelWidth, e[1] = this.pixelHeight, e;
+  }
+  get width() {
+    return this.colorTexture.source.width;
+  }
+  get height() {
+    return this.colorTexture.source.height;
+  }
+  get pixelWidth() {
+    return this.colorTexture.source.pixelWidth;
+  }
+  get pixelHeight() {
+    return this.colorTexture.source.pixelHeight;
+  }
+  get resolution() {
+    return this.colorTexture.source._resolution;
+  }
+  get colorTexture() {
+    return this.colorTextures[0];
+  }
+  onSourceResize(e) {
+    this.resize(e.width, e.height, e._resolution, !0);
+  }
+  /**
+   * This will ensure a depthStencil texture is created for this render target.
+   * Most likely called by the mask system to make sure we have stencil buffer added.
+   * @internal
+   */
+  ensureDepthStencilTexture() {
+    this.depthStencilTexture || (this.depthStencilTexture = new I({
+      width: this.width,
+      height: this.height,
+      resolution: this.resolution,
+      format: "depth24plus-stencil8",
+      autoGenerateMipmaps: !1,
+      antialias: !1,
+      mipLevelCount: 1
+      // sampleCount: handled by the render target system..
+    }));
+  }
+  resize(e, t, r = this.resolution, s = !1) {
+    this.dirtyId++, this.colorTextures.forEach((a, i) => {
+      s && i === 0 || a.source.resize(e, t, r);
+    }), this.depthStencilTexture && this.depthStencilTexture.source.resize(e, t, r);
+  }
+  destroy() {
+    this.colorTexture.source.off("resize", this.onSourceResize, this), this._managedColorTextures && this.colorTextures.forEach((e) => {
+      e.destroy();
+    }), this.depthStencilTexture && (this.depthStencilTexture.destroy(), delete this.depthStencilTexture);
+  }
+};
+bt.defaultOptions = {
+  /** the width of the RenderTarget */
+  width: 0,
+  /** the height of the RenderTarget */
+  height: 0,
+  /** the resolution of the RenderTarget */
+  resolution: 1,
+  /** an array of textures, or a number indicating how many color textures there should be */
+  colorTextures: 1,
+  /** should this render target have a stencil buffer? */
+  stencil: !1,
+  /** should this render target have a depth buffer? */
+  depth: !1,
+  /** should this render target be antialiased? */
+  antialias: !1,
+  // save on perf by default!
+  /** is this a root element, true if this is gl context owners render target */
+  isRoot: !1
+};
+let ee = bt;
+const w = /* @__PURE__ */ new Map();
+Le.register(w);
+function yt(n, e) {
+  if (!w.has(n)) {
+    const t = new S({
+      source: new X({
+        resource: n,
+        ...e
+      })
+    }), r = () => {
+      w.get(n) === t && w.delete(n);
+    };
+    t.once("destroy", r), t.source.once("destroy", r), w.set(n, t);
+  }
+  return w.get(n);
+}
+const me = class Tt {
+  /**
+   * Whether CSS dimensions of canvas view should be resized to screen dimensions automatically.
+   * This is only supported for HTMLCanvasElement and will be ignored if the canvas is an OffscreenCanvas.
+   * @type {boolean}
+   */
+  get autoDensity() {
+    return this.texture.source.autoDensity;
+  }
+  set autoDensity(e) {
+    this.texture.source.autoDensity = e;
+  }
+  /** The resolution / device pixel ratio of the renderer. */
+  get resolution() {
+    return this.texture.source._resolution;
+  }
+  set resolution(e) {
+    this.texture.source.resize(
+      this.texture.source.width,
+      this.texture.source.height,
+      e
+    );
+  }
+  /**
+   * initiates the view system
+   * @param options - the options for the view
+   */
+  init(e) {
+    e = {
+      ...Tt.defaultOptions,
+      ...e
+    }, e.view && (T(zt, "ViewSystem.view has been renamed to ViewSystem.canvas"), e.canvas = e.view), this.screen = new F(0, 0, e.width, e.height), this.canvas = e.canvas || ie.get().createCanvas(), this.antialias = !!e.antialias, this.texture = yt(this.canvas, e), this.renderTarget = new ee({
+      colorTextures: [this.texture],
+      depth: !!e.depth,
+      isRoot: !0
+    }), this.texture.source.transparent = e.backgroundAlpha < 1, this.resolution = e.resolution;
+  }
+  /**
+   * Resizes the screen and canvas to the specified dimensions.
+   * @param desiredScreenWidth - The new width of the screen.
+   * @param desiredScreenHeight - The new height of the screen.
+   * @param resolution
+   */
+  resize(e, t, r) {
+    this.texture.source.resize(e, t, r), this.screen.width = this.texture.frame.width, this.screen.height = this.texture.frame.height;
+  }
+  /**
+   * Destroys this System and optionally removes the canvas from the dom.
+   * @param {options | false} options - The options for destroying the view, or "false".
+   * @example
+   * viewSystem.destroy();
+   * viewSystem.destroy(true);
+   * viewSystem.destroy({ removeView: true });
+   */
+  destroy(e = !1) {
+    (typeof e == "boolean" ? e : !!(e != null && e.removeView)) && this.canvas.parentNode && this.canvas.parentNode.removeChild(this.canvas), this.texture.destroy();
+  }
+};
+me.extension = {
+  type: [
+    u.WebGLSystem,
+    u.WebGPUSystem,
+    u.CanvasSystem
+  ],
+  name: "view",
+  priority: 0
+};
+me.defaultOptions = {
+  /**
+   * {@link WebGLOptions.width}
+   * @default 800
+   */
+  width: 800,
+  /**
+   * {@link WebGLOptions.height}
+   * @default 600
+   */
+  height: 600,
+  /**
+   * {@link WebGLOptions.autoDensity}
+   * @default false
+   */
+  autoDensity: !1,
+  /**
+   * {@link WebGLOptions.antialias}
+   * @default false
+   */
+  antialias: !1
+};
+let Wr = me;
+const qr = [
+  wr,
+  xt,
+  he,
+  Wr,
+  dt,
+  Dr,
+  Fr,
+  pt,
+  Ur,
+  Dt,
+  Or,
+  gt
+], Qr = [
+  lt,
+  tt,
+  ot,
+  it,
+  rt,
+  nt,
+  st,
+  at
+];
+function $r(n, e, t, r, s, a) {
+  const i = a ? 1 : -1;
+  return n.identity(), n.a = 1 / r * 2, n.d = i * (1 / s * 2), n.tx = -1 - e * n.a, n.ty = -i - t * n.d, n;
+}
+function Vr(n) {
+  const e = n.colorTexture.source.resource;
+  return globalThis.HTMLCanvasElement && e instanceof HTMLCanvasElement && document.body.contains(e);
+}
+class Yr {
+  constructor(e) {
+    this.rootViewPort = new F(), this.viewport = new F(), this.mipLevel = 0, this.layer = 0, this.onRenderTargetChange = new Lt("onRenderTargetChange"), this.projectionMatrix = new M(), this.defaultClearColor = [0, 0, 0, 0], this._renderSurfaceToRenderTargetHash = /* @__PURE__ */ new Map(), this._gpuRenderTargetHash = /* @__PURE__ */ Object.create(null), this._renderTargetStack = [], this._renderer = e, e.gc.addCollection(this, "_gpuRenderTargetHash", "hash");
+  }
+  /** called when dev wants to finish a render pass */
+  finishRenderPass() {
+    this.adaptor.finishRenderPass(this.renderTarget);
+  }
+  /**
+   * called when the renderer starts to render a scene.
+   * @param options
+   * @param options.target - the render target to render to
+   * @param options.clear - the clear mode to use. Can be true or a CLEAR number 'COLOR | DEPTH | STENCIL' 0b111
+   * @param options.clearColor - the color to clear to
+   * @param options.frame - the frame to render to
+   * @param options.mipLevel - the mip level to render to
+   * @param options.layer - The layer of the render target to render to. Used for array or 3D textures, or when rendering
+   * to a specific layer of a layered render target. Optional.
+   */
+  renderStart({
+    target: e,
+    clear: t,
+    clearColor: r,
+    frame: s,
+    mipLevel: a,
+    layer: i
+  }) {
+    var o, l;
+    this._renderTargetStack.length = 0, this.push(
+      e,
+      t,
+      r,
+      s,
+      a ?? 0,
+      i ?? 0
+    ), this.rootViewPort.copyFrom(this.viewport), this.rootRenderTarget = this.renderTarget, this.renderingToScreen = Vr(this.rootRenderTarget), (l = (o = this.adaptor).prerender) == null || l.call(o, this.rootRenderTarget);
+  }
+  postrender() {
+    var e, t;
+    (t = (e = this.adaptor).postrender) == null || t.call(e, this.rootRenderTarget);
+  }
+  /**
+   * Binding a render surface! This is the main function of the render target system.
+   * It will take the RenderSurface (which can be a texture, canvas, or render target) and bind it to the renderer.
+   * Once bound all draw calls will be rendered to the render surface.
+   *
+   * If a frame is not provided and the render surface is a {@link Texture}, the frame of the texture will be used.
+   *
+   * IMPORTANT:
+   * - `frame` is treated as **base mip (mip 0) pixel space**.
+   * - When `mipLevel > 0`, the viewport derived from `frame` is scaled by \(2^{mipLevel}\) and clamped to the
+   *   mip dimensions. This keeps "render the same region" semantics consistent across mip levels.
+   * - When `renderSurface` is a {@link Texture}, `renderer.render({ container, target: texture, mipLevel })` will
+   *   render into
+   *   the underlying {@link TextureSource} (Pixi will create/use a {@link RenderTarget} for the source) using the
+   *   texture's frame to define the region (in mip 0 space).
+   * @param renderSurface - the render surface to bind
+   * @param clear - the clear mode to use. Can be true or a CLEAR number 'COLOR | DEPTH | STENCIL' 0b111
+   * @param clearColor - the color to clear to
+   * @param frame - the frame to render to
+   * @param mipLevel - the mip level to render to
+   * @param layer - the layer (or slice) of the render surface to render to. For array textures,
+   * 3D textures, or cubemaps, this specifies the target layer or face. Defaults to 0 (the first layer/face).
+   * Ignored for surfaces that do not support layers.
+   * @returns the render target that was bound
+   */
+  bind(e, t = !0, r, s, a = 0, i = 0) {
+    const o = this.getRenderTarget(e), l = this.renderTarget !== o;
+    this.renderTarget = o, this.renderSurface = e;
+    const d = this.getGpuRenderTarget(o);
+    (o.pixelWidth !== d.width || o.pixelHeight !== d.height) && (this.adaptor.resizeGpuRenderTarget(o), d.width = o.pixelWidth, d.height = o.pixelHeight);
+    const f = o.colorTexture, c = this.viewport, x = f.arrayLayerCount || 1;
+    if ((i | 0) !== i && (i |= 0), i < 0 || i >= x)
+      throw new Error(`[RenderTargetSystem] layer ${i} is out of bounds (arrayLayerCount=${x}).`);
+    this.mipLevel = a | 0, this.layer = i | 0;
+    const g = Math.max(f.pixelWidth >> a, 1), m = Math.max(f.pixelHeight >> a, 1);
+    if (!s && e instanceof S && (s = e.frame), s) {
+      const v = f._resolution, _ = 1 << Math.max(a | 0, 0), h = s.x * v + 0.5 | 0, C = s.y * v + 0.5 | 0, p = s.width * v + 0.5 | 0, y = s.height * v + 0.5 | 0;
+      let b = Math.floor(h / _), P = Math.floor(C / _), $ = Math.ceil(p / _), V = Math.ceil(y / _);
+      b = Math.min(Math.max(b, 0), g - 1), P = Math.min(Math.max(P, 0), m - 1), $ = Math.min(Math.max($, 1), g - b), V = Math.min(Math.max(V, 1), m - P), c.x = b, c.y = P, c.width = $, c.height = V;
+    } else
+      c.x = 0, c.y = 0, c.width = g, c.height = m;
+    return $r(
+      this.projectionMatrix,
+      0,
+      0,
+      c.width / f.resolution,
+      c.height / f.resolution,
+      !o.isRoot
+    ), this.adaptor.startRenderPass(o, t, r, c, a, i), l && this.onRenderTargetChange.emit(o), o;
+  }
+  clear(e, t = Y.ALL, r, s = this.mipLevel, a = this.layer) {
+    t && (e && (e = this.getRenderTarget(e)), this.adaptor.clear(
+      e || this.renderTarget,
+      t,
+      r,
+      this.viewport,
+      s,
+      a
+    ));
+  }
+  contextChange() {
+    this._gpuRenderTargetHash = /* @__PURE__ */ Object.create(null);
+  }
+  /**
+   * Push a render surface to the renderer. This will bind the render surface to the renderer,
+   * @param renderSurface - the render surface to push
+   * @param clear - the clear mode to use. Can be true or a CLEAR number 'COLOR | DEPTH | STENCIL' 0b111
+   * @param clearColor - the color to clear to
+   * @param frame - the frame to use when rendering to the render surface
+   * @param mipLevel - the mip level to render to
+   * @param layer - The layer of the render surface to render to. For array textures or cube maps, this specifies
+   * which layer or face to target. Defaults to 0 (the first layer).
+   */
+  push(e, t = Y.ALL, r, s, a = 0, i = 0) {
+    const o = this.bind(e, t, r, s, a, i);
+    return this._renderTargetStack.push({
+      renderTarget: o,
+      frame: s,
+      mipLevel: a,
+      layer: i
+    }), o;
+  }
+  /** Pops the current render target from the renderer and restores the previous render target. */
+  pop() {
+    this._renderTargetStack.pop();
+    const e = this._renderTargetStack[this._renderTargetStack.length - 1];
+    this.bind(
+      e.renderTarget,
+      !1,
+      null,
+      e.frame,
+      e.mipLevel,
+      e.layer
+    );
+  }
+  /**
+   * Gets the render target from the provide render surface. Eg if its a texture,
+   * it will return the render target for the texture.
+   * If its a render target, it will return the same render target.
+   * @param renderSurface - the render surface to get the render target for
+   * @returns the render target for the render surface
+   */
+  getRenderTarget(e) {
+    return e.isTexture && (e = e.source), this._renderSurfaceToRenderTargetHash.get(e) ?? this._initRenderTarget(e);
+  }
+  /**
+   * Copies a render surface to another texture.
+   *
+   * NOTE:
+   * for sourceRenderSurfaceTexture, The render target must be something that is written too by the renderer
+   *
+   * The following is not valid:
+   * @example
+   * const canvas = document.createElement('canvas')
+   * canvas.width = 200;
+   * canvas.height = 200;
+   *
+   * const ctx = canvas2.getContext('2d')!
+   * ctx.fillStyle = 'red'
+   * ctx.fillRect(0, 0, 200, 200);
+   *
+   * const texture = RenderTexture.create({
+   *   width: 200,
+   *   height: 200,
+   * })
+   * const renderTarget = renderer.renderTarget.getRenderTarget(canvas2);
+   *
+   * renderer.renderTarget.copyToTexture(renderTarget,texture, {x:0,y:0},{width:200,height:200},{x:0,y:0});
+   *
+   * The best way to copy a canvas is to create a texture from it. Then render with that.
+   *
+   * Parsing in a RenderTarget canvas context (with a 2d context)
+   * @param sourceRenderSurfaceTexture - the render surface to copy from
+   * @param {Texture} destinationTexture - the texture to copy to
+   * @param {object} originSrc - the origin of the copy
+   * @param {number} originSrc.x - the x origin of the copy
+   * @param {number} originSrc.y - the y origin of the copy
+   * @param {object} size - the size of the copy
+   * @param {number} size.width - the width of the copy
+   * @param {number} size.height - the height of the copy
+   * @param {object} originDest - the destination origin (top left to paste from!)
+   * @param {number} originDest.x - the x origin of the paste
+   * @param {number} originDest.y - the y origin of the paste
+   */
+  copyToTexture(e, t, r, s, a) {
+    r.x < 0 && (s.width += r.x, a.x -= r.x, r.x = 0), r.y < 0 && (s.height += r.y, a.y -= r.y, r.y = 0);
+    const { pixelWidth: i, pixelHeight: o } = e;
+    return s.width = Math.min(s.width, i - r.x), s.height = Math.min(s.height, o - r.y), this.adaptor.copyToTexture(
+      e,
+      t,
+      r,
+      s,
+      a
+    );
+  }
+  /**
+   * ensures that we have a depth stencil buffer available to render to
+   * This is used by the mask system to make sure we have a stencil buffer.
+   */
+  ensureDepthStencil() {
+    this.renderTarget.stencil || (this.renderTarget.stencil = !0, this.adaptor.startRenderPass(this.renderTarget, !1, null, this.viewport, 0, this.layer));
+  }
+  /** nukes the render target system */
+  destroy() {
+    this._renderer = null, this._renderSurfaceToRenderTargetHash.forEach((e, t) => {
+      e !== t && e.destroy();
+    }), this._renderSurfaceToRenderTargetHash.clear(), this._gpuRenderTargetHash = /* @__PURE__ */ Object.create(null);
+  }
+  _initRenderTarget(e) {
+    let t = null;
+    return X.test(e) && (e = yt(e).source), e instanceof ee ? t = e : e instanceof I && (t = new ee({
+      colorTextures: [e]
+    }), e.source instanceof X && (t.isRoot = !0), e.once("destroy", () => {
+      t.destroy(), this._renderSurfaceToRenderTargetHash.delete(e);
+      const r = this._gpuRenderTargetHash[t.uid];
+      r && (this._gpuRenderTargetHash[t.uid] = null, this.adaptor.destroyGpuRenderTarget(r));
+    })), this._renderSurfaceToRenderTargetHash.set(e, t), t;
+  }
+  getGpuRenderTarget(e) {
+    return this._gpuRenderTargetHash[e.uid] || (this._gpuRenderTargetHash[e.uid] = this.adaptor.initGpuRenderTarget(e));
+  }
+  resetState() {
+    this.renderTarget = null, this.renderSurface = null;
+  }
+}
+export {
+  rt as A,
+  tt as B,
+  at as C,
+  Je as D,
+  Nr as G,
+  it as R,
+  Qr as S,
+  lt as a,
+  Yr as b,
+  qr as c,
+  ot as d,
+  Ft as e,
+  dr as f,
+  hr as g,
+  cr as h,
+  ur as i,
+  Te as j,
+  mr as k,
+  gr as l,
+  vr as m,
+  br as n,
+  _r as r
+};
+//# sourceMappingURL=RenderTargetSystem-BCowAg_f.js.map