holostaff-widget 3.0.0-alpha.9 → 3.0.0

package/dist/Geometry-Bdq2tsB3.js

@@ -0,0 +1,1017 @@
+import { D as rt, a as y, E as N, B as nt } from "./index-C1ZbqCjI.js";
+const P = /* @__PURE__ */ Object.create(null), Y = /* @__PURE__ */ Object.create(null);
+function L(s, t) {
+  let e = Y[s];
+  return e === void 0 && (P[t] === void 0 && (P[t] = 1), Y[s] = e = P[t]++), e;
+}
+let b;
+function ot() {
+  return (!b || b != null && b.isContextLost()) && (b = rt.get().createCanvas().getContext("webgl", {})), b;
+}
+let E;
+function at() {
+  if (!E) {
+    E = "mediump";
+    const s = ot();
+    s && s.getShaderPrecisionFormat && (E = s.getShaderPrecisionFormat(s.FRAGMENT_SHADER, s.HIGH_FLOAT).precision ? "highp" : "mediump");
+  }
+  return E;
+}
+function ut(s, t, e) {
+  return t ? s : e ? (s = s.replace("out vec4 finalColor;", ""), `
+
+        #ifdef GL_ES // This checks if it is WebGL1
+        #define in varying
+        #define finalColor gl_FragColor
+        #define texture texture2D
+        #endif
+        ${s}
+        `) : `
+
+        #ifdef GL_ES // This checks if it is WebGL1
+        #define in attribute
+        #define out varying
+        #endif
+        ${s}
+        `;
+}
+function ct(s, t, e) {
+  const i = e ? t.maxSupportedFragmentPrecision : t.maxSupportedVertexPrecision;
+  if (s.substring(0, 9) !== "precision") {
+    let r = e ? t.requestedFragmentPrecision : t.requestedVertexPrecision;
+    return r === "highp" && i !== "highp" && (r = "mediump"), `precision ${r} float;
+${s}`;
+  } else if (i !== "highp" && s.substring(0, 15) === "precision highp")
+    return s.replace("precision highp", "precision mediump");
+  return s;
+}
+function lt(s, t) {
+  return t ? `#version 300 es
+${s}` : s;
+}
+const dt = {}, ht = {};
+function ft(s, { name: t = "pixi-program" }, e = !0) {
+  t = t.replace(/\s+/g, "-"), t += e ? "-fragment" : "-vertex";
+  const i = e ? dt : ht;
+  return i[t] ? (i[t]++, t += `-${i[t]}`) : i[t] = 1, s.indexOf("#define SHADER_NAME") !== -1 ? s : `${`#define SHADER_NAME ${t}`}
+${s}`;
+}
+function mt(s, t) {
+  return t ? s.replace("#version 300 es", "") : s;
+}
+const v = {
+  // strips any version headers..
+  stripVersion: mt,
+  // adds precision string if not already present
+  ensurePrecision: ct,
+  // add some defines if WebGL1 to make it more compatible with WebGL2 shaders
+  addProgramDefines: ut,
+  // add the program name to the shader
+  setProgramName: ft,
+  // add the version string to the shader header
+  insertVersion: lt
+}, _ = /* @__PURE__ */ Object.create(null), K = class R {
+  /**
+   * Creates a shiny new GlProgram. Used by WebGL renderer.
+   * @param options - The options for the program.
+   */
+  constructor(t) {
+    t = { ...R.defaultOptions, ...t };
+    const e = t.fragment.indexOf("#version 300 es") !== -1, i = {
+      stripVersion: e,
+      ensurePrecision: {
+        requestedFragmentPrecision: t.preferredFragmentPrecision,
+        requestedVertexPrecision: t.preferredVertexPrecision,
+        maxSupportedVertexPrecision: "highp",
+        maxSupportedFragmentPrecision: at()
+      },
+      setProgramName: {
+        name: t.name
+      },
+      addProgramDefines: e,
+      insertVersion: e
+    };
+    let r = t.fragment, n = t.vertex;
+    Object.keys(v).forEach((a) => {
+      const o = i[a];
+      r = v[a](r, o, !0), n = v[a](n, o, !1);
+    }), this.fragment = r, this.vertex = n, this.transformFeedbackVaryings = t.transformFeedbackVaryings, this._key = L(`${this.vertex}:${this.fragment}`, "gl-program");
+  }
+  /** destroys the program */
+  destroy() {
+    this.fragment = null, this.vertex = null, this._attributeData = null, this._uniformData = null, this._uniformBlockData = null, this.transformFeedbackVaryings = null, _[this._cacheKey] = null;
+  }
+  /**
+   * Helper function that creates a program for a given source.
+   * It will check the program cache if the program has already been created.
+   * If it has that one will be returned, if not a new one will be created and cached.
+   * @param options - The options for the program.
+   * @returns A program using the same source
+   */
+  static from(t) {
+    const e = `${t.vertex}:${t.fragment}`;
+    return _[e] || (_[e] = new R(t), _[e]._cacheKey = e), _[e];
+  }
+};
+K.defaultOptions = {
+  preferredVertexPrecision: "highp",
+  preferredFragmentPrecision: "mediump"
+};
+let U = K;
+const j = {
+  uint8x2: { size: 2, stride: 2, normalised: !1 },
+  uint8x4: { size: 4, stride: 4, normalised: !1 },
+  sint8x2: { size: 2, stride: 2, normalised: !1 },
+  sint8x4: { size: 4, stride: 4, normalised: !1 },
+  unorm8x2: { size: 2, stride: 2, normalised: !0 },
+  unorm8x4: { size: 4, stride: 4, normalised: !0 },
+  snorm8x2: { size: 2, stride: 2, normalised: !0 },
+  snorm8x4: { size: 4, stride: 4, normalised: !0 },
+  uint16x2: { size: 2, stride: 4, normalised: !1 },
+  uint16x4: { size: 4, stride: 8, normalised: !1 },
+  sint16x2: { size: 2, stride: 4, normalised: !1 },
+  sint16x4: { size: 4, stride: 8, normalised: !1 },
+  unorm16x2: { size: 2, stride: 4, normalised: !0 },
+  unorm16x4: { size: 4, stride: 8, normalised: !0 },
+  snorm16x2: { size: 2, stride: 4, normalised: !0 },
+  snorm16x4: { size: 4, stride: 8, normalised: !0 },
+  float16x2: { size: 2, stride: 4, normalised: !1 },
+  float16x4: { size: 4, stride: 8, normalised: !1 },
+  float32: { size: 1, stride: 4, normalised: !1 },
+  float32x2: { size: 2, stride: 8, normalised: !1 },
+  float32x3: { size: 3, stride: 12, normalised: !1 },
+  float32x4: { size: 4, stride: 16, normalised: !1 },
+  uint32: { size: 1, stride: 4, normalised: !1 },
+  uint32x2: { size: 2, stride: 8, normalised: !1 },
+  uint32x3: { size: 3, stride: 12, normalised: !1 },
+  uint32x4: { size: 4, stride: 16, normalised: !1 },
+  sint32: { size: 1, stride: 4, normalised: !1 },
+  sint32x2: { size: 2, stride: 8, normalised: !1 },
+  sint32x3: { size: 3, stride: 12, normalised: !1 },
+  sint32x4: { size: 4, stride: 16, normalised: !1 }
+};
+function pt(s) {
+  return j[s] ?? j.float32;
+}
+const gt = {
+  f32: "float32",
+  "vec2<f32>": "float32x2",
+  "vec3<f32>": "float32x3",
+  "vec4<f32>": "float32x4",
+  vec2f: "float32x2",
+  vec3f: "float32x3",
+  vec4f: "float32x4",
+  i32: "sint32",
+  "vec2<i32>": "sint32x2",
+  "vec3<i32>": "sint32x3",
+  "vec4<i32>": "sint32x4",
+  vec2i: "sint32x2",
+  vec3i: "sint32x3",
+  vec4i: "sint32x4",
+  u32: "uint32",
+  "vec2<u32>": "uint32x2",
+  "vec3<u32>": "uint32x3",
+  "vec4<u32>": "uint32x4",
+  vec2u: "uint32x2",
+  vec3u: "uint32x3",
+  vec4u: "uint32x4",
+  bool: "uint32",
+  "vec2<bool>": "uint32x2",
+  "vec3<bool>": "uint32x3",
+  "vec4<bool>": "uint32x4"
+}, X = /@location\((\d+)\)\s+([a-zA-Z0-9_]+)\s*:\s*([a-zA-Z0-9_<>]+)(?:,|\s|\)|$)/g;
+function W(s, t) {
+  let e;
+  for (; (e = X.exec(s)) !== null; ) {
+    const i = gt[e[3]] ?? "float32";
+    t[e[2]] = {
+      location: parseInt(e[1], 10),
+      format: i,
+      stride: pt(i).stride,
+      offset: 0,
+      instance: !1,
+      start: 0
+    };
+  }
+  X.lastIndex = 0;
+}
+function yt(s) {
+  return s.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+}
+function bt({ source: s, entryPoint: t }) {
+  const e = {}, i = yt(s), r = i.indexOf(`fn ${t}(`);
+  if (r === -1)
+    return e;
+  const n = i.indexOf("->", r);
+  if (n === -1)
+    return e;
+  const a = i.substring(r, n);
+  if (W(a, e), Object.keys(e).length === 0) {
+    const o = a.match(/\(\s*\w+\s*:\s*(\w+)/);
+    if (o) {
+      const d = o[1], l = new RegExp(`struct\\s+${d}\\s*\\{([^}]+)\\}`, "s"), u = i.match(l);
+      u && W(u[1], e);
+    }
+  }
+  return e;
+}
+function T(s) {
+  var h, f;
+  const t = /(^|[^/])@(group|binding)\(\d+\)[^;]+;/g, e = /@group\((\d+)\)/, i = /@binding\((\d+)\)/, r = /var(<[^>]+>)? (\w+)/, n = /:\s*([\w<>]+)/, a = /struct\s+(\w+)\s*{([^}]+)}/g, o = /(\w+)\s*:\s*([\w\<\>]+)/g, d = /struct\s+(\w+)/, l = (h = s.match(t)) == null ? void 0 : h.map((c) => ({
+    group: parseInt(c.match(e)[1], 10),
+    binding: parseInt(c.match(i)[1], 10),
+    name: c.match(r)[2],
+    isUniform: c.match(r)[1] === "<uniform>",
+    type: c.match(n)[1]
+  }));
+  if (!l)
+    return {
+      groups: [],
+      structs: []
+    };
+  const u = ((f = s.match(a)) == null ? void 0 : f.map((c) => {
+    const p = c.match(d)[1], V = c.match(o).reduce((B, et) => {
+      const [st, it] = et.split(":");
+      return B[st.trim()] = it.trim(), B;
+    }, {});
+    return V ? { name: p, members: V } : null;
+  }).filter(({ name: c }) => l.some(
+    (p) => (
+      // Handle both direct type matches and generic types like array<StructName>
+      p.type === c || p.type.includes(`<${c}>`)
+    )
+  ))) ?? [];
+  return {
+    groups: l,
+    structs: u
+  };
+}
+var g = /* @__PURE__ */ ((s) => (s[s.VERTEX = 1] = "VERTEX", s[s.FRAGMENT = 2] = "FRAGMENT", s[s.COMPUTE = 4] = "COMPUTE", s))(g || {});
+function _t({ groups: s }) {
+  const t = [];
+  for (let e = 0; e < s.length; e++) {
+    const i = s[e];
+    t[i.group] || (t[i.group] = []), i.isUniform ? t[i.group].push({
+      binding: i.binding,
+      visibility: g.VERTEX | g.FRAGMENT,
+      buffer: {
+        type: "uniform"
+      }
+    }) : i.type === "sampler" ? t[i.group].push({
+      binding: i.binding,
+      visibility: g.FRAGMENT,
+      sampler: {
+        type: "filtering"
+      }
+    }) : i.type === "texture_2d" || i.type.startsWith("texture_2d<") ? t[i.group].push({
+      binding: i.binding,
+      visibility: g.FRAGMENT,
+      texture: {
+        sampleType: "float",
+        viewDimension: "2d",
+        multisampled: !1
+      }
+    }) : i.type === "texture_2d_array" || i.type.startsWith("texture_2d_array<") ? t[i.group].push({
+      binding: i.binding,
+      visibility: g.FRAGMENT,
+      texture: {
+        sampleType: "float",
+        viewDimension: "2d-array",
+        multisampled: !1
+      }
+    }) : (i.type === "texture_cube" || i.type.startsWith("texture_cube<")) && t[i.group].push({
+      binding: i.binding,
+      visibility: g.FRAGMENT,
+      texture: {
+        sampleType: "float",
+        viewDimension: "cube",
+        multisampled: !1
+      }
+    });
+  }
+  for (let e = 0; e < t.length; e++)
+    t[e] || (t[e] = []);
+  return t;
+}
+function xt({ groups: s }) {
+  const t = [];
+  for (let e = 0; e < s.length; e++) {
+    const i = s[e];
+    t[i.group] || (t[i.group] = {}), t[i.group][i.name] = i.binding;
+  }
+  return t;
+}
+function Et(s, t) {
+  const e = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set(), r = [...s.structs, ...t.structs].filter((a) => e.has(a.name) ? !1 : (e.add(a.name), !0)), n = [...s.groups, ...t.groups].filter((a) => {
+    const o = `${a.name}-${a.binding}`;
+    return i.has(o) ? !1 : (i.add(o), !0);
+  });
+  return { structs: r, groups: n };
+}
+const x = /* @__PURE__ */ Object.create(null);
+class A {
+  /**
+   * Create a new GpuProgram
+   * @param options - The options for the gpu program
+   */
+  constructor(t) {
+    var o, d;
+    this._layoutKey = 0, this._attributeLocationsKey = 0;
+    const { fragment: e, vertex: i, layout: r, gpuLayout: n, name: a } = t;
+    if (this.name = a, this.fragment = e, this.vertex = i, e.source === i.source) {
+      const l = T(e.source);
+      this.structsAndGroups = l;
+    } else {
+      const l = T(i.source), u = T(e.source);
+      this.structsAndGroups = Et(l, u);
+    }
+    this.layout = r ?? xt(this.structsAndGroups), this.gpuLayout = n ?? _t(this.structsAndGroups), this.autoAssignGlobalUniforms = ((o = this.layout[0]) == null ? void 0 : o.globalUniforms) !== void 0, this.autoAssignLocalUniforms = ((d = this.layout[1]) == null ? void 0 : d.localUniforms) !== void 0, this._generateProgramKey();
+  }
+  // TODO maker this pure
+  _generateProgramKey() {
+    const { vertex: t, fragment: e } = this, i = t.source + e.source + t.entryPoint + e.entryPoint;
+    this._layoutKey = L(i, "program");
+  }
+  get attributeData() {
+    return this._attributeData ?? (this._attributeData = bt(this.vertex)), this._attributeData;
+  }
+  /** destroys the program */
+  destroy() {
+    this.gpuLayout = null, this.layout = null, this.structsAndGroups = null, this.fragment = null, this.vertex = null, x[this._cacheKey] = null;
+  }
+  /**
+   * Helper function that creates a program for a given source.
+   * It will check the program cache if the program has already been created.
+   * If it has that one will be returned, if not a new one will be created and cached.
+   * @param options - The options for the program.
+   * @returns A program using the same source
+   */
+  static from(t) {
+    const e = `${t.vertex.source}:${t.fragment.source}:${t.fragment.entryPoint}:${t.vertex.entryPoint}`;
+    return x[e] || (x[e] = new A(t), x[e]._cacheKey = e), x[e];
+  }
+}
+const H = [
+  "f32",
+  "i32",
+  "vec2<f32>",
+  "vec3<f32>",
+  "vec4<f32>",
+  "mat2x2<f32>",
+  "mat3x3<f32>",
+  "mat4x4<f32>",
+  "mat3x2<f32>",
+  "mat4x2<f32>",
+  "mat2x3<f32>",
+  "mat4x3<f32>",
+  "mat2x4<f32>",
+  "mat3x4<f32>",
+  "vec2<i32>",
+  "vec3<i32>",
+  "vec4<i32>"
+], At = H.reduce((s, t) => (s[t] = !0, s), {});
+function Pt(s, t) {
+  switch (s) {
+    case "f32":
+      return 0;
+    case "vec2<f32>":
+      return new Float32Array(2 * t);
+    case "vec3<f32>":
+      return new Float32Array(3 * t);
+    case "vec4<f32>":
+      return new Float32Array(4 * t);
+    case "mat2x2<f32>":
+      return new Float32Array([
+        1,
+        0,
+        0,
+        1
+      ]);
+    case "mat3x3<f32>":
+      return new Float32Array([
+        1,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        1
+      ]);
+    case "mat4x4<f32>":
+      return new Float32Array([
+        1,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        1
+      ]);
+  }
+  return null;
+}
+const q = class Q {
+  /**
+   * Create a new Uniform group
+   * @param uniformStructures - The structures of the uniform group
+   * @param options - The optional parameters of this uniform group
+   */
+  constructor(t, e) {
+    this._touched = 0, this.uid = y("uniform"), this._resourceType = "uniformGroup", this._resourceId = y("resource"), this.isUniformGroup = !0, this._dirtyId = 0, this.destroyed = !1, e = { ...Q.defaultOptions, ...e }, this.uniformStructures = t;
+    const i = {};
+    for (const r in t) {
+      const n = t[r];
+      if (n.name = r, n.size = n.size ?? 1, !At[n.type]) {
+        const a = n.type.match(/^array<(\w+(?:<\w+>)?),\s*(\d+)>$/);
+        if (a) {
+          const [, o, d] = a;
+          throw new Error(
+            `Uniform type ${n.type} is not supported. Use type: '${o}', size: ${d} instead.`
+          );
+        }
+        throw new Error(`Uniform type ${n.type} is not supported. Supported uniform types are: ${H.join(", ")}`);
+      }
+      n.value ?? (n.value = Pt(n.type, n.size)), i[r] = n.value;
+    }
+    this.uniforms = i, this._dirtyId = 1, this.ubo = e.ubo, this.isStatic = e.isStatic, this._signature = L(Object.keys(i).map(
+      (r) => `${r}-${t[r].type}`
+    ).join("-"), "uniform-group");
+  }
+  /** Call this if you want the uniform groups data to be uploaded to the GPU only useful if `isStatic` is true. */
+  update() {
+    this._dirtyId++;
+  }
+};
+q.defaultOptions = {
+  /** if true the UniformGroup is handled as an Uniform buffer object. */
+  ubo: !1,
+  /** if true, then you are responsible for when the data is uploaded to the GPU by calling `update()` */
+  isStatic: !1
+};
+let vt = q;
+class F {
+  /**
+   * Create a new instance eof the Bind Group.
+   * @param resources - The resources that are bound together for use by a shader.
+   */
+  constructor(t) {
+    this.resources = /* @__PURE__ */ Object.create(null), this._dirty = !0;
+    let e = 0;
+    for (const i in t) {
+      const r = t[i];
+      this.setResource(r, e++);
+    }
+    this._updateKey();
+  }
+  /**
+   * Updates the key if its flagged as dirty. This is used internally to
+   * match this bind group to a WebGPU BindGroup.
+   * @internal
+   */
+  _updateKey() {
+    if (!this._dirty) return;
+    this._dirty = !1;
+    const t = [];
+    let e = 0;
+    for (const i in this.resources)
+      t[e++] = this.resources[i]._resourceId;
+    this._key = t.join("|");
+  }
+  /**
+   * Set a resource at a given index. this function will
+   * ensure that listeners will be removed from the current resource
+   * and added to the new resource.
+   * @param resource - The resource to set.
+   * @param index - The index to set the resource at.
+   */
+  setResource(t, e) {
+    var r, n;
+    const i = this.resources[e];
+    t !== i && ((r = i == null ? void 0 : i.off) == null || r.call(i, "change", this.onResourceChange, this), (n = t.on) == null || n.call(t, "change", this.onResourceChange, this), this.resources[e] = t, this._dirty = !0);
+  }
+  /**
+   * Returns the resource at the current specified index.
+   * @param index - The index of the resource to get.
+   * @returns - The resource at the specified index.
+   */
+  getResource(t) {
+    return this.resources[t];
+  }
+  /**
+   * Used internally to 'touch' each resource, to ensure that the GC
+   * knows that all resources in this bind group are still being used.
+   * @param now - The current time in milliseconds.
+   * @param tick - The current tick.
+   * @internal
+   */
+  _touch(t, e) {
+    const i = this.resources;
+    for (const r in i)
+      i[r]._gcLastUsed = t, i[r]._touched = e;
+  }
+  /** Destroys this bind group and removes all listeners. */
+  destroy() {
+    var e;
+    const t = this.resources;
+    for (const i in t) {
+      const r = t[i];
+      (e = r == null ? void 0 : r.off) == null || e.call(r, "change", this.onResourceChange, this);
+    }
+    this.resources = null;
+  }
+  onResourceChange(t) {
+    this._dirty = !0, t.destroyed ? this.destroy() : this._updateKey();
+  }
+}
+var I = /* @__PURE__ */ ((s) => (s[s.WEBGL = 1] = "WEBGL", s[s.WEBGPU = 2] = "WEBGPU", s[s.CANVAS = 4] = "CANVAS", s[s.BOTH = 3] = "BOTH", s))(I || {});
+class k extends N {
+  constructor(t) {
+    super(), this.uid = y("shader"), this._uniformBindMap = /* @__PURE__ */ Object.create(null), this._ownedBindGroups = [], this._destroyed = !1;
+    let {
+      gpuProgram: e,
+      glProgram: i,
+      groups: r,
+      resources: n,
+      compatibleRenderers: a,
+      groupMap: o
+    } = t;
+    this.gpuProgram = e, this.glProgram = i, a === void 0 && (a = 0, e && (a |= I.WEBGPU), i && (a |= I.WEBGL)), this.compatibleRenderers = a;
+    const d = {};
+    if (!n && !r && (n = {}), n && r)
+      throw new Error("[Shader] Cannot have both resources and groups");
+    if (!e && r && !o)
+      throw new Error("[Shader] No group map or WebGPU shader provided - consider using resources instead.");
+    if (!e && r && o)
+      for (const l in o)
+        for (const u in o[l]) {
+          const h = o[l][u];
+          d[h] = {
+            group: l,
+            binding: u,
+            name: h
+          };
+        }
+    else if (e && r && !o) {
+      const l = e.structsAndGroups.groups;
+      o = {}, l.forEach((u) => {
+        o[u.group] = o[u.group] || {}, o[u.group][u.binding] = u.name, d[u.name] = u;
+      });
+    } else if (n) {
+      r = {}, o = {}, e && e.structsAndGroups.groups.forEach((h) => {
+        o[h.group] = o[h.group] || {}, o[h.group][h.binding] = h.name, d[h.name] = h;
+      });
+      let l = 0;
+      for (const u in n)
+        d[u] || (r[99] || (r[99] = new F(), this._ownedBindGroups.push(r[99])), d[u] = { group: 99, binding: l, name: u }, o[99] = o[99] || {}, o[99][l] = u, l++);
+      for (const u in n) {
+        const h = u;
+        let f = n[u];
+        !f.source && !f._resourceType && (f = new vt(f));
+        const c = d[h];
+        c && (r[c.group] || (r[c.group] = new F(), this._ownedBindGroups.push(r[c.group])), r[c.group].setResource(f, c.binding));
+      }
+    }
+    this.groups = r, this._uniformBindMap = o, this.resources = this._buildResourceAccessor(r, d);
+  }
+  /**
+   * Sometimes a resource group will be provided later (for example global uniforms)
+   * In such cases, this method can be used to let the shader know about the group.
+   * @param name - the name of the resource group
+   * @param groupIndex - the index of the group (should match the webGPU shader group location)
+   * @param bindIndex - the index of the bind point (should match the webGPU shader bind point)
+   */
+  addResource(t, e, i) {
+    var r, n;
+    (r = this._uniformBindMap)[e] || (r[e] = {}), (n = this._uniformBindMap[e])[i] || (n[i] = t), this.groups[e] || (this.groups[e] = new F(), this._ownedBindGroups.push(this.groups[e]));
+  }
+  _buildResourceAccessor(t, e) {
+    const i = {};
+    for (const r in e) {
+      const n = e[r];
+      Object.defineProperty(i, n.name, {
+        get() {
+          return t[n.group].getResource(n.binding);
+        },
+        set(a) {
+          t[n.group].setResource(a, n.binding);
+        }
+      });
+    }
+    return i;
+  }
+  /**
+   * Use to destroy the shader when its not longer needed.
+   * It will destroy the resources and remove listeners.
+   * @param destroyPrograms - if the programs should be destroyed as well.
+   * Make sure its not being used by other shaders!
+   */
+  destroy(t = !1) {
+    var e, i;
+    this._destroyed || (this._destroyed = !0, this.emit("destroy", this), t && ((e = this.gpuProgram) == null || e.destroy(), (i = this.glProgram) == null || i.destroy()), this.gpuProgram = null, this.glProgram = null, this.removeAllListeners(), this._uniformBindMap = null, this._ownedBindGroups.forEach((r) => {
+      r.destroy();
+    }), this._ownedBindGroups = null, this.resources = null, this.groups = null);
+  }
+  static from(t) {
+    const { gpu: e, gl: i, ...r } = t;
+    let n, a;
+    return e && (n = A.from(e)), i && (a = U.from(i)), new k({
+      gpuProgram: n,
+      glProgram: a,
+      ...r
+    });
+  }
+}
+const Tt = {
+  normal: 0,
+  add: 1,
+  multiply: 2,
+  screen: 3,
+  overlay: 4,
+  erase: 5,
+  "normal-npm": 6,
+  "add-npm": 7,
+  "screen-npm": 8,
+  min: 9,
+  max: 10
+}, w = 0, S = 1, D = 2, G = 3, M = 4, O = 5, C = class Z {
+  constructor() {
+    this.data = 0, this.blendMode = "normal", this.polygonOffset = 0, this.blend = !0, this.depthMask = !0;
+  }
+  /**
+   * Activates blending of the computed fragment color values.
+   * @default true
+   */
+  get blend() {
+    return !!(this.data & 1 << w);
+  }
+  set blend(t) {
+    !!(this.data & 1 << w) !== t && (this.data ^= 1 << w);
+  }
+  /**
+   * Activates adding an offset to depth values of polygon's fragments
+   * @default false
+   */
+  get offsets() {
+    return !!(this.data & 1 << S);
+  }
+  set offsets(t) {
+    !!(this.data & 1 << S) !== t && (this.data ^= 1 << S);
+  }
+  /** The culling settings for this state none - No culling back - Back face culling front - Front face culling */
+  set cullMode(t) {
+    if (t === "none") {
+      this.culling = !1;
+      return;
+    }
+    this.culling = !0, this.clockwiseFrontFace = t === "front";
+  }
+  get cullMode() {
+    return this.culling ? this.clockwiseFrontFace ? "front" : "back" : "none";
+  }
+  /**
+   * Activates culling of polygons.
+   * @default false
+   */
+  get culling() {
+    return !!(this.data & 1 << D);
+  }
+  set culling(t) {
+    !!(this.data & 1 << D) !== t && (this.data ^= 1 << D);
+  }
+  /**
+   * Activates depth comparisons and updates to the depth buffer.
+   * @default false
+   */
+  get depthTest() {
+    return !!(this.data & 1 << G);
+  }
+  set depthTest(t) {
+    !!(this.data & 1 << G) !== t && (this.data ^= 1 << G);
+  }
+  /**
+   * Enables or disables writing to the depth buffer.
+   * @default true
+   */
+  get depthMask() {
+    return !!(this.data & 1 << O);
+  }
+  set depthMask(t) {
+    !!(this.data & 1 << O) !== t && (this.data ^= 1 << O);
+  }
+  /**
+   * Specifies whether or not front or back-facing polygons can be culled.
+   * @default false
+   */
+  get clockwiseFrontFace() {
+    return !!(this.data & 1 << M);
+  }
+  set clockwiseFrontFace(t) {
+    !!(this.data & 1 << M) !== t && (this.data ^= 1 << M);
+  }
+  /**
+   * The blend mode to be applied when this state is set. Apply a value of `normal` to reset the blend mode.
+   * Setting this mode to anything other than NO_BLEND will automatically switch blending on.
+   * @default 'normal'
+   */
+  get blendMode() {
+    return this._blendMode;
+  }
+  set blendMode(t) {
+    this.blend = t !== "none", this._blendMode = t, this._blendModeId = Tt[t] || 0;
+  }
+  /**
+   * The polygon offset. Setting this property to anything other than 0 will automatically enable polygon offset fill.
+   * @default 0
+   */
+  get polygonOffset() {
+    return this._polygonOffset;
+  }
+  set polygonOffset(t) {
+    this.offsets = !!t, this._polygonOffset = t;
+  }
+  toString() {
+    return `[pixi.js/core:State blendMode=${this.blendMode} clockwiseFrontFace=${this.clockwiseFrontFace} culling=${this.culling} depthMask=${this.depthMask} polygonOffset=${this.polygonOffset}]`;
+  }
+  /**
+   * A quickly getting an instance of a State that is configured for 2d rendering.
+   * @returns a new State with values set for 2d rendering
+   */
+  static for2d() {
+    const t = new Z();
+    return t.depthTest = !1, t.blend = !0, t;
+  }
+};
+C.default2d = C.for2d();
+let Ft = C;
+const J = class z extends k {
+  /**
+   * @param options - The optional parameters of this filter.
+   */
+  constructor(t) {
+    t = { ...z.defaultOptions, ...t }, super(t), this.enabled = !0, this._state = Ft.for2d(), this.blendMode = t.blendMode, this.padding = t.padding, typeof t.antialias == "boolean" ? this.antialias = t.antialias ? "on" : "off" : this.antialias = t.antialias, this.resolution = t.resolution, this.blendRequired = t.blendRequired, this.clipToViewport = t.clipToViewport, this.addResource("uTexture", 0, 1), t.blendRequired && this.addResource("uBackTexture", 0, 3);
+  }
+  /**
+   * Applies the filter
+   * @param filterManager - The renderer to retrieve the filter from
+   * @param input - The input render target.
+   * @param output - The target to output to.
+   * @param clearMode - Should the output be cleared before rendering to it
+   */
+  apply(t, e, i, r) {
+    t.applyFilter(this, e, i, r);
+  }
+  /**
+   * Get the blend mode of the filter.
+   * @default "normal"
+   */
+  get blendMode() {
+    return this._state.blendMode;
+  }
+  /** Sets the blend mode of the filter. */
+  set blendMode(t) {
+    this._state.blendMode = t;
+  }
+  /**
+   * A short hand function to create a filter based of a vertex and fragment shader src.
+   * @param options
+   * @returns A shiny new PixiJS filter!
+   */
+  static from(t) {
+    const { gpu: e, gl: i, ...r } = t;
+    let n, a;
+    return e && (n = A.from(e)), i && (a = U.from(i)), new z({
+      gpuProgram: n,
+      glProgram: a,
+      ...r
+    });
+  }
+};
+J.defaultOptions = {
+  blendMode: "normal",
+  resolution: 1,
+  padding: 0,
+  antialias: "off",
+  blendRequired: !1,
+  clipToViewport: !0
+};
+let Gt = J;
+var m = /* @__PURE__ */ ((s) => (s[s.MAP_READ = 1] = "MAP_READ", s[s.MAP_WRITE = 2] = "MAP_WRITE", s[s.COPY_SRC = 4] = "COPY_SRC", s[s.COPY_DST = 8] = "COPY_DST", s[s.INDEX = 16] = "INDEX", s[s.VERTEX = 32] = "VERTEX", s[s.UNIFORM = 64] = "UNIFORM", s[s.STORAGE = 128] = "STORAGE", s[s.INDIRECT = 256] = "INDIRECT", s[s.QUERY_RESOLVE = 512] = "QUERY_RESOLVE", s[s.STATIC = 1024] = "STATIC", s))(m || {});
+let $ = class extends N {
+  /**
+   * Creates a new Buffer with the given options
+   * @param options - the options for the buffer
+   */
+  constructor(t) {
+    let { data: e, size: i } = t;
+    const { usage: r, label: n, shrinkToFit: a } = t;
+    super(), this._gpuData = /* @__PURE__ */ Object.create(null), this._gcLastUsed = -1, this.autoGarbageCollect = !0, this.uid = y("buffer"), this._resourceType = "buffer", this._resourceId = y("resource"), this._touched = 0, this._updateID = 1, this._dataInt32 = null, this.shrinkToFit = !0, this.destroyed = !1, e instanceof Array && (e = new Float32Array(e)), this._data = e, i ?? (i = e == null ? void 0 : e.byteLength);
+    const o = !!e;
+    this.descriptor = {
+      size: i,
+      usage: r,
+      mappedAtCreation: o,
+      label: n
+    }, this.shrinkToFit = a ?? !0;
+  }
+  /** the data in the buffer */
+  get data() {
+    return this._data;
+  }
+  set data(t) {
+    this.setDataWithSize(t, t.length, !0);
+  }
+  get dataInt32() {
+    return this._dataInt32 || (this._dataInt32 = new Int32Array(this.data.buffer)), this._dataInt32;
+  }
+  /** whether the buffer is static or not */
+  get static() {
+    return !!(this.descriptor.usage & m.STATIC);
+  }
+  set static(t) {
+    t ? this.descriptor.usage |= m.STATIC : this.descriptor.usage &= ~m.STATIC;
+  }
+  /**
+   * Sets the data in the buffer to the given value. This will immediately update the buffer on the GPU.
+   * If you only want to update a subset of the buffer, you can pass in the size of the data.
+   * @param value - the data to set
+   * @param size - the size of the data in bytes
+   * @param syncGPU - should the buffer be updated on the GPU immediately?
+   */
+  setDataWithSize(t, e, i) {
+    if (this._updateID++, this._updateSize = e * t.BYTES_PER_ELEMENT, this._data === t) {
+      i && this.emit("update", this);
+      return;
+    }
+    const r = this._data;
+    if (this._data = t, this._dataInt32 = null, !r || r.length !== t.length) {
+      !this.shrinkToFit && r && t.byteLength < r.byteLength ? i && this.emit("update", this) : (this.descriptor.size = t.byteLength, this._resourceId = y("resource"), this.emit("change", this));
+      return;
+    }
+    i && this.emit("update", this);
+  }
+  /**
+   * updates the buffer on the GPU to reflect the data in the buffer.
+   * By default it will update the entire buffer. If you only want to update a subset of the buffer,
+   * you can pass in the size of the buffer to update.
+   * @param sizeInBytes - the new size of the buffer in bytes
+   */
+  update(t) {
+    this._updateSize = t ?? this._updateSize, this._updateID++, this.emit("update", this);
+  }
+  /** Unloads the buffer from the GPU */
+  unload() {
+    var t;
+    this.emit("unload", this);
+    for (const e in this._gpuData)
+      (t = this._gpuData[e]) == null || t.destroy();
+    this._gpuData = /* @__PURE__ */ Object.create(null);
+  }
+  /** Destroys the buffer */
+  destroy() {
+    this.destroyed = !0, this.unload(), this.emit("destroy", this), this.emit("change", this), this._data = null, this.descriptor = null, this.removeAllListeners();
+  }
+};
+function tt(s, t) {
+  if (!(s instanceof $)) {
+    let e = t ? m.INDEX : m.VERTEX;
+    s instanceof Array && (t ? (s = new Uint32Array(s), e = m.INDEX | m.COPY_DST) : (s = new Float32Array(s), e = m.VERTEX | m.COPY_DST)), s = new $({
+      data: s,
+      label: t ? "index-mesh-buffer" : "vertex-mesh-buffer",
+      usage: e
+    });
+  }
+  return s;
+}
+function wt(s, t, e) {
+  const i = s.getAttribute(t);
+  if (!i)
+    return e.minX = 0, e.minY = 0, e.maxX = 0, e.maxY = 0, e;
+  const r = i.buffer.data;
+  let n = 1 / 0, a = 1 / 0, o = -1 / 0, d = -1 / 0;
+  const l = r.BYTES_PER_ELEMENT, u = (i.offset || 0) / l, h = (i.stride || 8) / l;
+  for (let f = u; f < r.length; f += h) {
+    const c = r[f], p = r[f + 1];
+    c > o && (o = c), p > d && (d = p), c < n && (n = c), p < a && (a = p);
+  }
+  return e.minX = n, e.minY = a, e.maxX = o, e.maxY = d, e;
+}
+function St(s) {
+  return (s instanceof $ || Array.isArray(s) || s.BYTES_PER_ELEMENT) && (s = {
+    buffer: s
+  }), s.buffer = tt(s.buffer, !1), s;
+}
+class Ot extends N {
+  /**
+   * Create a new instance of a geometry
+   * @param options - The options for the geometry.
+   */
+  constructor(t = {}) {
+    super(), this._gpuData = /* @__PURE__ */ Object.create(null), this.autoGarbageCollect = !0, this._gcLastUsed = -1, this.uid = y("geometry"), this._layoutKey = 0, this.instanceCount = 1, this._bounds = new nt(), this._boundsDirty = !0;
+    const { attributes: e, indexBuffer: i, topology: r } = t;
+    if (this.buffers = [], this.attributes = {}, e)
+      for (const n in e)
+        this.addAttribute(n, e[n]);
+    this.instanceCount = t.instanceCount ?? 1, i && this.addIndex(i), this.topology = r || "triangle-list";
+  }
+  onBufferUpdate() {
+    this._boundsDirty = !0, this.emit("update", this);
+  }
+  /**
+   * Returns the requested attribute.
+   * @param id - The name of the attribute required
+   * @returns - The attribute requested.
+   */
+  getAttribute(t) {
+    return this.attributes[t];
+  }
+  /**
+   * Returns the index buffer
+   * @returns - The index buffer.
+   */
+  getIndex() {
+    return this.indexBuffer;
+  }
+  /**
+   * Returns the requested buffer.
+   * @param id - The name of the buffer required.
+   * @returns - The buffer requested.
+   */
+  getBuffer(t) {
+    return this.getAttribute(t).buffer;
+  }
+  /**
+   * Used to figure out how many vertices there are in this geometry
+   * @returns the number of vertices in the geometry
+   */
+  getSize() {
+    for (const t in this.attributes) {
+      const e = this.attributes[t];
+      return e.buffer.data.length / (e.stride / 4 || e.size);
+    }
+    return 0;
+  }
+  /**
+   * Adds an attribute to the geometry.
+   * @param name - The name of the attribute to add.
+   * @param attributeOption - The attribute option to add.
+   */
+  addAttribute(t, e) {
+    const i = St(e);
+    this.buffers.indexOf(i.buffer) === -1 && (this.buffers.push(i.buffer), i.buffer.on("update", this.onBufferUpdate, this), i.buffer.on("change", this.onBufferUpdate, this)), this.attributes[t] = i;
+  }
+  /**
+   * Adds an index buffer to the geometry.
+   * @param indexBuffer - The index buffer to add. Can be a Buffer, TypedArray, or an array of numbers.
+   */
+  addIndex(t) {
+    this.indexBuffer = tt(t, !0), this.buffers.push(this.indexBuffer);
+  }
+  /** Returns the bounds of the geometry. */
+  get bounds() {
+    return this._boundsDirty ? (this._boundsDirty = !1, wt(this, "aPosition", this._bounds)) : this._bounds;
+  }
+  /** Unloads the geometry from the GPU. */
+  unload() {
+    var t;
+    this.emit("unload", this);
+    for (const e in this._gpuData)
+      (t = this._gpuData[e]) == null || t.destroy();
+    this._gpuData = /* @__PURE__ */ Object.create(null);
+  }
+  /**
+   * destroys the geometry.
+   * @param destroyBuffers - destroy the buffers associated with this geometry
+   */
+  destroy(t = !1) {
+    var e;
+    this.emit("destroy", this), this.removeAllListeners(), t && this.buffers.forEach((i) => i.destroy()), this.unload(), (e = this.indexBuffer) == null || e.destroy(), this.attributes = null, this.buffers = null, this.indexBuffer = null, this._bounds = null;
+  }
+}
+export {
+  F as B,
+  Gt as F,
+  U as G,
+  I as R,
+  Ft as S,
+  vt as U,
+  $ as a,
+  m as b,
+  L as c,
+  k as d,
+  Ot as e,
+  ot as f,
+  pt as g,
+  A as h
+};
+//# sourceMappingURL=Geometry-Bdq2tsB3.js.map