holostaff-widget 3.0.2 → 3.0.4

package/dist/Filter-BZ0p_cLc.js

@@ -0,0 +1,670 @@
+import { D as I, c as L, g as X, b as z, u as Z, d as Y } from "./index-BbQvHSpa.js";
+let p;
+function J() {
+  return (!p || p != null && p.isContextLost()) && (p = I.get().createCanvas().getContext("webgl", {})), p;
+}
+let _;
+function Q() {
+  if (!_) {
+    _ = "mediump";
+    const r = J();
+    r && r.getShaderPrecisionFormat && (_ = r.getShaderPrecisionFormat(r.FRAGMENT_SHADER, r.HIGH_FLOAT).precision ? "highp" : "mediump");
+  }
+  return _;
+}
+function tt(r, t, e) {
+  return t ? r : e ? (r = r.replace("out vec4 finalColor;", ""), `
+
+        #ifdef GL_ES // This checks if it is WebGL1
+        #define in varying
+        #define finalColor gl_FragColor
+        #define texture texture2D
+        #endif
+        ${r}
+        `) : `
+
+        #ifdef GL_ES // This checks if it is WebGL1
+        #define in attribute
+        #define out varying
+        #endif
+        ${r}
+        `;
+}
+function et(r, t, e) {
+  const s = e ? t.maxSupportedFragmentPrecision : t.maxSupportedVertexPrecision;
+  if (r.substring(0, 9) !== "precision") {
+    let i = e ? t.requestedFragmentPrecision : t.requestedVertexPrecision;
+    return i === "highp" && s !== "highp" && (i = "mediump"), `precision ${i} float;
+${r}`;
+  } else if (s !== "highp" && r.substring(0, 15) === "precision highp")
+    return r.replace("precision highp", "precision mediump");
+  return r;
+}
+function st(r, t) {
+  return t ? `#version 300 es
+${r}` : r;
+}
+const rt = {}, it = {};
+function nt(r, { name: t = "pixi-program" }, e = !0) {
+  t = t.replace(/\s+/g, "-"), t += e ? "-fragment" : "-vertex";
+  const s = e ? rt : it;
+  return s[t] ? (s[t]++, t += `-${s[t]}`) : s[t] = 1, r.indexOf("#define SHADER_NAME") !== -1 ? r : `${`#define SHADER_NAME ${t}`}
+${r}`;
+}
+function ot(r, t) {
+  return t ? r.replace("#version 300 es", "") : r;
+}
+const P = {
+  // strips any version headers..
+  stripVersion: ot,
+  // adds precision string if not already present
+  ensurePrecision: et,
+  // add some defines if WebGL1 to make it more compatible with WebGL2 shaders
+  addProgramDefines: tt,
+  // add the program name to the shader
+  setProgramName: nt,
+  // add the version string to the shader header
+  insertVersion: st
+}, m = /* @__PURE__ */ Object.create(null), V = class O {
+  /**
+   * Creates a shiny new GlProgram. Used by WebGL renderer.
+   * @param options - The options for the program.
+   */
+  constructor(t) {
+    t = { ...O.defaultOptions, ...t };
+    const e = t.fragment.indexOf("#version 300 es") !== -1, s = {
+      stripVersion: e,
+      ensurePrecision: {
+        requestedFragmentPrecision: t.preferredFragmentPrecision,
+        requestedVertexPrecision: t.preferredVertexPrecision,
+        maxSupportedVertexPrecision: "highp",
+        maxSupportedFragmentPrecision: Q()
+      },
+      setProgramName: {
+        name: t.name
+      },
+      addProgramDefines: e,
+      insertVersion: e
+    };
+    let i = t.fragment, n = t.vertex;
+    Object.keys(P).forEach((a) => {
+      const o = s[a];
+      i = P[a](i, o, !0), n = P[a](n, o, !1);
+    }), this.fragment = i, 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, m[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 m[e] || (m[e] = new O(t), m[e]._cacheKey = e), m[e];
+  }
+};
+V.defaultOptions = {
+  preferredVertexPrecision: "highp",
+  preferredFragmentPrecision: "mediump"
+};
+let U = V;
+const at = {
+  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"
+}, B = /@location\((\d+)\)\s+([a-zA-Z0-9_]+)\s*:\s*([a-zA-Z0-9_<>]+)(?:,|\s|\)|$)/g;
+function C(r, t) {
+  let e;
+  for (; (e = B.exec(r)) !== null; ) {
+    const s = at[e[3]] ?? "float32";
+    t[e[2]] = {
+      location: parseInt(e[1], 10),
+      format: s,
+      stride: X(s).stride,
+      offset: 0,
+      instance: !1,
+      start: 0
+    };
+  }
+  B.lastIndex = 0;
+}
+function ut(r) {
+  return r.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+}
+function ct({ source: r, entryPoint: t }) {
+  const e = {}, s = ut(r), i = s.indexOf(`fn ${t}(`);
+  if (i === -1)
+    return e;
+  const n = s.indexOf("->", i);
+  if (n === -1)
+    return e;
+  const a = s.substring(i, n);
+  if (C(a, e), Object.keys(e).length === 0) {
+    const o = a.match(/\(\s*\w+\s*:\s*(\w+)/);
+    if (o) {
+      const d = o[1], c = new RegExp(`struct\\s+${d}\\s*\\{([^}]+)\\}`, "s"), u = s.match(c);
+      u && C(u[1], e);
+    }
+  }
+  return e;
+}
+function v(r) {
+  var f, h;
+  const t = /(^|[^/])@(group|binding)\(\d+\)[^;]+;/g, e = /@group\((\d+)\)/, s = /@binding\((\d+)\)/, i = /var(<[^>]+>)? (\w+)/, n = /:\s*([\w<>]+)/, a = /struct\s+(\w+)\s*{([^}]+)}/g, o = /(\w+)\s*:\s*([\w\<\>]+)/g, d = /struct\s+(\w+)/, c = (f = r.match(t)) == null ? void 0 : f.map((l) => ({
+    group: parseInt(l.match(e)[1], 10),
+    binding: parseInt(l.match(s)[1], 10),
+    name: l.match(i)[2],
+    isUniform: l.match(i)[1] === "<uniform>",
+    type: l.match(n)[1]
+  }));
+  if (!c)
+    return {
+      groups: [],
+      structs: []
+    };
+  const u = ((h = r.match(a)) == null ? void 0 : h.map((l) => {
+    const y = l.match(d)[1], N = l.match(o).reduce((D, j) => {
+      const [H, q] = j.split(":");
+      return D[H.trim()] = q.trim(), D;
+    }, {});
+    return N ? { name: y, members: N } : null;
+  }).filter(({ name: l }) => c.some(
+    (y) => (
+      // Handle both direct type matches and generic types like array<StructName>
+      y.type === l || y.type.includes(`<${l}>`)
+    )
+  ))) ?? [];
+  return {
+    groups: c,
+    structs: u
+  };
+}
+var g = /* @__PURE__ */ ((r) => (r[r.VERTEX = 1] = "VERTEX", r[r.FRAGMENT = 2] = "FRAGMENT", r[r.COMPUTE = 4] = "COMPUTE", r))(g || {});
+function lt({ groups: r }) {
+  const t = [];
+  for (let e = 0; e < r.length; e++) {
+    const s = r[e];
+    t[s.group] || (t[s.group] = []), s.isUniform ? t[s.group].push({
+      binding: s.binding,
+      visibility: g.VERTEX | g.FRAGMENT,
+      buffer: {
+        type: "uniform"
+      }
+    }) : s.type === "sampler" ? t[s.group].push({
+      binding: s.binding,
+      visibility: g.FRAGMENT,
+      sampler: {
+        type: "filtering"
+      }
+    }) : s.type === "texture_2d" || s.type.startsWith("texture_2d<") ? t[s.group].push({
+      binding: s.binding,
+      visibility: g.FRAGMENT,
+      texture: {
+        sampleType: "float",
+        viewDimension: "2d",
+        multisampled: !1
+      }
+    }) : s.type === "texture_2d_array" || s.type.startsWith("texture_2d_array<") ? t[s.group].push({
+      binding: s.binding,
+      visibility: g.FRAGMENT,
+      texture: {
+        sampleType: "float",
+        viewDimension: "2d-array",
+        multisampled: !1
+      }
+    }) : (s.type === "texture_cube" || s.type.startsWith("texture_cube<")) && t[s.group].push({
+      binding: s.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 ft({ groups: r }) {
+  const t = [];
+  for (let e = 0; e < r.length; e++) {
+    const s = r[e];
+    t[s.group] || (t[s.group] = {}), t[s.group][s.name] = s.binding;
+  }
+  return t;
+}
+function dt(r, t) {
+  const e = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), i = [...r.structs, ...t.structs].filter((a) => e.has(a.name) ? !1 : (e.add(a.name), !0)), n = [...r.groups, ...t.groups].filter((a) => {
+    const o = `${a.name}-${a.binding}`;
+    return s.has(o) ? !1 : (s.add(o), !0);
+  });
+  return { structs: i, groups: n };
+}
+const b = /* @__PURE__ */ Object.create(null);
+class x {
+  /**
+   * 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: s, layout: i, gpuLayout: n, name: a } = t;
+    if (this.name = a, this.fragment = e, this.vertex = s, e.source === s.source) {
+      const c = v(e.source);
+      this.structsAndGroups = c;
+    } else {
+      const c = v(s.source), u = v(e.source);
+      this.structsAndGroups = dt(c, u);
+    }
+    this.layout = i ?? ft(this.structsAndGroups), this.gpuLayout = n ?? lt(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, s = t.source + e.source + t.entryPoint + e.entryPoint;
+    this._layoutKey = L(s, "program");
+  }
+  get attributeData() {
+    return this._attributeData ?? (this._attributeData = ct(this.vertex)), this._attributeData;
+  }
+  /** destroys the program */
+  destroy() {
+    this.gpuLayout = null, this.layout = null, this.structsAndGroups = null, this.fragment = null, this.vertex = null, b[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 b[e] || (b[e] = new x(t), b[e]._cacheKey = e), b[e];
+  }
+}
+class G {
+  /**
+   * 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 s in t) {
+      const i = t[s];
+      this.setResource(i, 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 s in this.resources)
+      t[e++] = this.resources[s]._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 i, n;
+    const s = this.resources[e];
+    t !== s && ((i = s == null ? void 0 : s.off) == null || i.call(s, "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 s = this.resources;
+    for (const i in s)
+      s[i]._gcLastUsed = t, s[i]._touched = e;
+  }
+  /** Destroys this bind group and removes all listeners. */
+  destroy() {
+    var e;
+    const t = this.resources;
+    for (const s in t) {
+      const i = t[s];
+      (e = i == null ? void 0 : i.off) == null || e.call(i, "change", this.onResourceChange, this);
+    }
+    this.resources = null;
+  }
+  onResourceChange(t) {
+    this._dirty = !0, t.destroyed ? this.destroy() : this._updateKey();
+  }
+}
+var T = /* @__PURE__ */ ((r) => (r[r.WEBGL = 1] = "WEBGL", r[r.WEBGPU = 2] = "WEBGPU", r[r.CANVAS = 4] = "CANVAS", r[r.BOTH = 3] = "BOTH", r))(T || {});
+class k extends z {
+  constructor(t) {
+    super(), this.uid = Z("shader"), this._uniformBindMap = /* @__PURE__ */ Object.create(null), this._ownedBindGroups = [], this._destroyed = !1;
+    let {
+      gpuProgram: e,
+      glProgram: s,
+      groups: i,
+      resources: n,
+      compatibleRenderers: a,
+      groupMap: o
+    } = t;
+    this.gpuProgram = e, this.glProgram = s, a === void 0 && (a = 0, e && (a |= T.WEBGPU), s && (a |= T.WEBGL)), this.compatibleRenderers = a;
+    const d = {};
+    if (!n && !i && (n = {}), n && i)
+      throw new Error("[Shader] Cannot have both resources and groups");
+    if (!e && i && !o)
+      throw new Error("[Shader] No group map or WebGPU shader provided - consider using resources instead.");
+    if (!e && i && o)
+      for (const c in o)
+        for (const u in o[c]) {
+          const f = o[c][u];
+          d[f] = {
+            group: c,
+            binding: u,
+            name: f
+          };
+        }
+    else if (e && i && !o) {
+      const c = e.structsAndGroups.groups;
+      o = {}, c.forEach((u) => {
+        o[u.group] = o[u.group] || {}, o[u.group][u.binding] = u.name, d[u.name] = u;
+      });
+    } else if (n) {
+      i = {}, o = {}, e && e.structsAndGroups.groups.forEach((f) => {
+        o[f.group] = o[f.group] || {}, o[f.group][f.binding] = f.name, d[f.name] = f;
+      });
+      let c = 0;
+      for (const u in n)
+        d[u] || (i[99] || (i[99] = new G(), this._ownedBindGroups.push(i[99])), d[u] = { group: 99, binding: c, name: u }, o[99] = o[99] || {}, o[99][c] = u, c++);
+      for (const u in n) {
+        const f = u;
+        let h = n[u];
+        !h.source && !h._resourceType && (h = new Y(h));
+        const l = d[f];
+        l && (i[l.group] || (i[l.group] = new G(), this._ownedBindGroups.push(i[l.group])), i[l.group].setResource(h, l.binding));
+      }
+    }
+    this.groups = i, this._uniformBindMap = o, this.resources = this._buildResourceAccessor(i, 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, s) {
+    var i, n;
+    (i = this._uniformBindMap)[e] || (i[e] = {}), (n = this._uniformBindMap[e])[s] || (n[s] = t), this.groups[e] || (this.groups[e] = new G(), this._ownedBindGroups.push(this.groups[e]));
+  }
+  _buildResourceAccessor(t, e) {
+    const s = {};
+    for (const i in e) {
+      const n = e[i];
+      Object.defineProperty(s, n.name, {
+        get() {
+          return t[n.group].getResource(n.binding);
+        },
+        set(a) {
+          t[n.group].setResource(a, n.binding);
+        }
+      });
+    }
+    return s;
+  }
+  /**
+   * 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, s;
+    this._destroyed || (this._destroyed = !0, this.emit("destroy", this), t && ((e = this.gpuProgram) == null || e.destroy(), (s = this.glProgram) == null || s.destroy()), this.gpuProgram = null, this.glProgram = null, this.removeAllListeners(), this._uniformBindMap = null, this._ownedBindGroups.forEach((i) => {
+      i.destroy();
+    }), this._ownedBindGroups = null, this.resources = null, this.groups = null);
+  }
+  static from(t) {
+    const { gpu: e, gl: s, ...i } = t;
+    let n, a;
+    return e && (n = x.from(e)), s && (a = U.from(s)), new k({
+      gpuProgram: n,
+      glProgram: a,
+      ...i
+    });
+  }
+}
+const ht = {
+  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
+}, E = 0, F = 1, M = 2, w = 3, A = 4, $ = 5, R = class W {
+  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 << E);
+  }
+  set blend(t) {
+    !!(this.data & 1 << E) !== t && (this.data ^= 1 << E);
+  }
+  /**
+   * Activates adding an offset to depth values of polygon's fragments
+   * @default false
+   */
+  get offsets() {
+    return !!(this.data & 1 << F);
+  }
+  set offsets(t) {
+    !!(this.data & 1 << F) !== t && (this.data ^= 1 << F);
+  }
+  /** 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 << M);
+  }
+  set culling(t) {
+    !!(this.data & 1 << M) !== t && (this.data ^= 1 << M);
+  }
+  /**
+   * Activates depth comparisons and updates to the depth buffer.
+   * @default false
+   */
+  get depthTest() {
+    return !!(this.data & 1 << w);
+  }
+  set depthTest(t) {
+    !!(this.data & 1 << w) !== t && (this.data ^= 1 << w);
+  }
+  /**
+   * Enables or disables writing to the depth buffer.
+   * @default true
+   */
+  get depthMask() {
+    return !!(this.data & 1 << $);
+  }
+  set depthMask(t) {
+    !!(this.data & 1 << $) !== t && (this.data ^= 1 << $);
+  }
+  /**
+   * Specifies whether or not front or back-facing polygons can be culled.
+   * @default false
+   */
+  get clockwiseFrontFace() {
+    return !!(this.data & 1 << A);
+  }
+  set clockwiseFrontFace(t) {
+    !!(this.data & 1 << A) !== t && (this.data ^= 1 << A);
+  }
+  /**
+   * 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 = ht[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 W();
+    return t.depthTest = !1, t.blend = !0, t;
+  }
+};
+R.default2d = R.for2d();
+let gt = R;
+const K = class S extends k {
+  /**
+   * @param options - The optional parameters of this filter.
+   */
+  constructor(t) {
+    t = { ...S.defaultOptions, ...t }, super(t), this.enabled = !0, this._state = gt.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, s, i) {
+    t.applyFilter(this, e, s, i);
+  }
+  /**
+   * 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: s, ...i } = t;
+    let n, a;
+    return e && (n = x.from(e)), s && (a = U.from(s)), new S({
+      gpuProgram: n,
+      glProgram: a,
+      ...i
+    });
+  }
+};
+K.defaultOptions = {
+  blendMode: "normal",
+  resolution: 1,
+  padding: 0,
+  antialias: "off",
+  blendRequired: !1,
+  clipToViewport: !0
+};
+let mt = K;
+export {
+  G as B,
+  mt as F,
+  U as G,
+  T as R,
+  gt as S,
+  k as a,
+  x as b,
+  J as g
+};
+//# sourceMappingURL=Filter-BZ0p_cLc.js.map