code:
/*!
 * pixi-filters - v5.3.0
 * Compiled Thu, 15 Feb 2024 16:39:05 UTC
 *
 * pixi-filters is licensed under the MIT License.
 * http://www.opensource.org/licenses/mit-license
 */ var __filters = (function (f, a, Pe, I) {
  "use strict";
  var Me = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    De = `varying vec2 vTextureCoord;
uniform sampler2D uSampler;

uniform float gamma;
uniform float contrast;
uniform float saturation;
uniform float brightness;
uniform float red;
uniform float green;
uniform float blue;
uniform float alpha;

void main(void)
{
    vec4 c = texture2D(uSampler, vTextureCoord);

    if (c.a > 0.0) {
        c.rgb /= c.a;

        vec3 rgb = pow(c.rgb, vec3(1. / gamma));
        rgb = mix(vec3(.5), mix(vec3(dot(vec3(.2125, .7154, .0721), rgb)), rgb, saturation), contrast);
        rgb.r *= red;
        rgb.g *= green;
        rgb.b *= blue;
        c.rgb = rgb * brightness;

        c.rgb *= c.a;
    }

    gl_FragColor = c * alpha;
}
`;
  class ke extends a.Filter {
    constructor(e) {
      super(Me, De),
        (this.gamma = 1),
        (this.saturation = 1),
        (this.contrast = 1),
        (this.brightness = 1),
        (this.red = 1),
        (this.green = 1),
        (this.blue = 1),
        (this.alpha = 1),
        Object.assign(this, e);
    }
    apply(e, r, i, o) {
      (this.uniforms.gamma = Math.max(this.gamma, 1e-4)),
        (this.uniforms.saturation = this.saturation),
        (this.uniforms.contrast = this.contrast),
        (this.uniforms.brightness = this.brightness),
        (this.uniforms.red = this.red),
        (this.uniforms.green = this.green),
        (this.uniforms.blue = this.blue),
        (this.uniforms.alpha = this.alpha),
        e.applyFilter(this, r, i, o);
    }
  }
  var Oe = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    Re = `
varying vec2 vTextureCoord;
uniform sampler2D uSampler;

uniform vec2 uOffset;

void main(void)
{
    vec4 color = vec4(0.0);

    // Sample top left pixel
    color += texture2D(uSampler, vec2(vTextureCoord.x - uOffset.x, vTextureCoord.y + uOffset.y));

    // Sample top right pixel
    color += texture2D(uSampler, vec2(vTextureCoord.x + uOffset.x, vTextureCoord.y + uOffset.y));

    // Sample bottom right pixel
    color += texture2D(uSampler, vec2(vTextureCoord.x + uOffset.x, vTextureCoord.y - uOffset.y));

    // Sample bottom left pixel
    color += texture2D(uSampler, vec2(vTextureCoord.x - uOffset.x, vTextureCoord.y - uOffset.y));

    // Average
    color *= 0.25;

    gl_FragColor = color;
}`,
    $e = `
varying vec2 vTextureCoord;
uniform sampler2D uSampler;

uniform vec2 uOffset;
uniform vec4 filterClamp;

void main(void)
{
    vec4 color = vec4(0.0);

    // Sample top left pixel
    color += texture2D(uSampler, clamp(vec2(vTextureCoord.x - uOffset.x, vTextureCoord.y + uOffset.y), filterClamp.xy, filterClamp.zw));

    // Sample top right pixel
    color += texture2D(uSampler, clamp(vec2(vTextureCoord.x + uOffset.x, vTextureCoord.y + uOffset.y), filterClamp.xy, filterClamp.zw));

    // Sample bottom right pixel
    color += texture2D(uSampler, clamp(vec2(vTextureCoord.x + uOffset.x, vTextureCoord.y - uOffset.y), filterClamp.xy, filterClamp.zw));

    // Sample bottom left pixel
    color += texture2D(uSampler, clamp(vec2(vTextureCoord.x - uOffset.x, vTextureCoord.y - uOffset.y), filterClamp.xy, filterClamp.zw));

    // Average
    color *= 0.25;

    gl_FragColor = color;
}
`;
  class T extends a.Filter {
    constructor(e = 4, r = 3, i = !1) {
      super(Oe, i ? $e : Re),
        (this._kernels = []),
        (this._blur = 4),
        (this._quality = 3),
        (this.uniforms.uOffset = new Float32Array(2)),
        (this._pixelSize = new a.Point()),
        (this.pixelSize = 1),
        (this._clamp = i),
        Array.isArray(e)
          ? (this.kernels = e)
          : ((this._blur = e), (this.quality = r));
    }
    apply(e, r, i, o) {
      const s = this._pixelSize.x / r._frame.width,
        n = this._pixelSize.y / r._frame.height;
      let l;
      if (this._quality === 1 || this._blur === 0)
        (l = this._kernels[0] + 0.5),
          (this.uniforms.uOffset[0] = l * s),
          (this.uniforms.uOffset[1] = l * n),
          e.applyFilter(this, r, i, o);
      else {
        const u = e.getFilterTexture();
        let h = r,
          p = u,
          S;
        const g = this._quality - 1;
        for (let x = 0; x < g; x++)
          (l = this._kernels[x] + 0.5),
            (this.uniforms.uOffset[0] = l * s),
            (this.uniforms.uOffset[1] = l * n),
            e.applyFilter(this, h, p, 1),
            (S = h),
            (h = p),
            (p = S);
        (l = this._kernels[g] + 0.5),
          (this.uniforms.uOffset[0] = l * s),
          (this.uniforms.uOffset[1] = l * n),
          e.applyFilter(this, h, i, o),
          e.returnFilterTexture(u);
      }
    }
    _updatePadding() {
      this.padding = Math.ceil(this._kernels.reduce((e, r) => e + r + 0.5, 0));
    }
    _generateKernels() {
      const e = this._blur,
        r = this._quality,
        i = [e];
      if (e > 0) {
        let o = e;
        const s = e / r;
        for (let n = 1; n < r; n++) (o -= s), i.push(o);
      }
      (this._kernels = i), this._updatePadding();
    }
    get kernels() {
      return this._kernels;
    }
    set kernels(e) {
      Array.isArray(e) && e.length > 0
        ? ((this._kernels = e),
          (this._quality = e.length),
          (this._blur = Math.max(...e)))
        : ((this._kernels = [0]), (this._quality = 1));
    }
    get clamp() {
      return this._clamp;
    }
    set pixelSize(e) {
      typeof e == "number"
        ? ((this._pixelSize.x = e), (this._pixelSize.y = e))
        : Array.isArray(e)
        ? ((this._pixelSize.x = e[0]), (this._pixelSize.y = e[1]))
        : e instanceof a.Point
        ? ((this._pixelSize.x = e.x), (this._pixelSize.y = e.y))
        : ((this._pixelSize.x = 1), (this._pixelSize.y = 1));
    }
    get pixelSize() {
      return this._pixelSize;
    }
    get quality() {
      return this._quality;
    }
    set quality(e) {
      (this._quality = Math.max(1, Math.round(e))), this._generateKernels();
    }
    get blur() {
      return this._blur;
    }
    set blur(e) {
      (this._blur = e), this._generateKernels();
    }
  }
  var L = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    Ee = `
uniform sampler2D uSampler;
varying vec2 vTextureCoord;

uniform float threshold;

void main() {
    vec4 color = texture2D(uSampler, vTextureCoord);

    // A simple & fast algorithm for getting brightness.
    // It's inaccuracy , but good enought for this feature.
    float _max = max(max(color.r, color.g), color.b);
    float _min = min(min(color.r, color.g), color.b);
    float brightness = (_max + _min) * 0.5;

    if(brightness > threshold) {
        gl_FragColor = color;
    } else {
        gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
    }
}
`;
  class je extends a.Filter {
    constructor(e = 0.5) {
      super(L, Ee), (this.threshold = e);
    }
    get threshold() {
      return this.uniforms.threshold;
    }
    set threshold(e) {
      this.uniforms.threshold = e;
    }
  }
  var Ie = `uniform sampler2D uSampler;
varying vec2 vTextureCoord;

uniform sampler2D bloomTexture;
uniform float bloomScale;
uniform float brightness;

void main() {
    vec4 color = texture2D(uSampler, vTextureCoord);
    color.rgb *= brightness;
    vec4 bloomColor = vec4(texture2D(bloomTexture, vTextureCoord).rgb, 0.0);
    bloomColor.rgb *= bloomScale;
    gl_FragColor = color + bloomColor;
}
`;
  const V = class extends a.Filter {
    constructor(t) {
      super(L, Ie),
        (this.bloomScale = 1),
        (this.brightness = 1),
        (this._resolution = a.settings.FILTER_RESOLUTION),
        typeof t == "number" && (t = { threshold: t });
      const e = Object.assign(V.defaults, t);
      (this.bloomScale = e.bloomScale), (this.brightness = e.brightness);
      const {
        kernels: r,
        blur: i,
        quality: o,
        pixelSize: s,
        resolution: n,
      } = e;
      (this._extractFilter = new je(e.threshold)),
        (this._extractFilter.resolution = n),
        (this._blurFilter = r ? new T(r) : new T(i, o)),
        (this.pixelSize = s),
        (this.resolution = n);
    }
    apply(t, e, r, i, o) {
      const s = t.getFilterTexture();
      this._extractFilter.apply(t, e, s, 1, o);
      const n = t.getFilterTexture();
      this._blurFilter.apply(t, s, n, 1),
        (this.uniforms.bloomScale = this.bloomScale),
        (this.uniforms.brightness = this.brightness),
        (this.uniforms.bloomTexture = n),
        t.applyFilter(this, e, r, i),
        t.returnFilterTexture(n),
        t.returnFilterTexture(s);
    }
    get resolution() {
      return this._resolution;
    }
    set resolution(t) {
      (this._resolution = t),
        this._extractFilter && (this._extractFilter.resolution = t),
        this._blurFilter && (this._blurFilter.resolution = t);
    }
    get threshold() {
      return this._extractFilter.threshold;
    }
    set threshold(t) {
      this._extractFilter.threshold = t;
    }
    get kernels() {
      return this._blurFilter.kernels;
    }
    set kernels(t) {
      this._blurFilter.kernels = t;
    }
    get blur() {
      return this._blurFilter.blur;
    }
    set blur(t) {
      this._blurFilter.blur = t;
    }
    get quality() {
      return this._blurFilter.quality;
    }
    set quality(t) {
      this._blurFilter.quality = t;
    }
    get pixelSize() {
      return this._blurFilter.pixelSize;
    }
    set pixelSize(t) {
      this._blurFilter.pixelSize = t;
    }
  };
  let N = V;
  N.defaults = {
    threshold: 0.5,
    bloomScale: 1,
    brightness: 1,
    kernels: null,
    blur: 8,
    quality: 4,
    pixelSize: 1,
    resolution: a.settings.FILTER_RESOLUTION,
  };
  var Le = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    Ve = `varying vec2 vTextureCoord;

uniform vec4 filterArea;
uniform float pixelSize;
uniform sampler2D uSampler;

vec2 mapCoord( vec2 coord )
{
    coord *= filterArea.xy;
    coord += filterArea.zw;

    return coord;
}

vec2 unmapCoord( vec2 coord )
{
    coord -= filterArea.zw;
    coord /= filterArea.xy;

    return coord;
}

vec2 pixelate(vec2 coord, vec2 size)
{
    return floor(coord / size) * size;
}

vec2 getMod(vec2 coord, vec2 size)
{
    return mod(coord, size) / size;
}

float character(float n, vec2 p)
{
    p = floor(p*vec2(4.0, 4.0) + 2.5);

    if (clamp(p.x, 0.0, 4.0) == p.x)
    {
        if (clamp(p.y, 0.0, 4.0) == p.y)
        {
            if (int(mod(n/exp2(p.x + 5.0*p.y), 2.0)) == 1) return 1.0;
        }
    }
    return 0.0;
}

void main()
{
    vec2 coord = mapCoord(vTextureCoord);

    // get the grid position
    vec2 pixCoord = pixelate(coord, vec2(pixelSize));
    pixCoord = unmapCoord(pixCoord);

    // sample the color at grid position
    vec4 color = texture2D(uSampler, pixCoord);

    // brightness of the color as it's perceived by the human eye
    float gray = 0.3 * color.r + 0.59 * color.g + 0.11 * color.b;

    // determine the character to use
    float n =  65536.0;             // .
    if (gray > 0.2) n = 65600.0;    // :
    if (gray > 0.3) n = 332772.0;   // *
    if (gray > 0.4) n = 15255086.0; // o
    if (gray > 0.5) n = 23385164.0; // &
    if (gray > 0.6) n = 15252014.0; // 8
    if (gray > 0.7) n = 13199452.0; // @
    if (gray > 0.8) n = 11512810.0; // #

    // get the mod..
    vec2 modd = getMod(coord, vec2(pixelSize));

    gl_FragColor = color * character( n, vec2(-1.0) + modd * 2.0);

}
`;
  class Ne extends a.Filter {
    constructor(e = 8) {
      super(Le, Ve), (this.size = e);
    }
    get size() {
      return this.uniforms.pixelSize;
    }
    set size(e) {
      this.uniforms.pixelSize = e;
    }
  }
  var Ge = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    Be = `precision mediump float;

varying vec2 vTextureCoord;
uniform sampler2D uSampler;
uniform vec4 filterArea;

uniform float transformX;
uniform float transformY;
uniform vec3 lightColor;
uniform float lightAlpha;
uniform vec3 shadowColor;
uniform float shadowAlpha;

void main(void) {
    vec2 transform = vec2(1.0 / filterArea) * vec2(transformX, transformY);
    vec4 color = texture2D(uSampler, vTextureCoord);
    float light = texture2D(uSampler, vTextureCoord - transform).a;
    float shadow = texture2D(uSampler, vTextureCoord + transform).a;

    color.rgb = mix(color.rgb, lightColor, clamp((color.a - light) * lightAlpha, 0.0, 1.0));
    color.rgb = mix(color.rgb, shadowColor, clamp((color.a - shadow) * shadowAlpha, 0.0, 1.0));
    gl_FragColor = vec4(color.rgb * color.a, color.a);
}
`;
  class Xe extends a.Filter {
    constructor(e) {
      super(Ge, Be),
        (this._thickness = 2),
        (this._angle = 0),
        (this.uniforms.lightColor = new Float32Array(3)),
        (this.uniforms.shadowColor = new Float32Array(3)),
        Object.assign(
          this,
          {
            rotation: 45,
            thickness: 2,
            lightColor: 16777215,
            lightAlpha: 0.7,
            shadowColor: 0,
            shadowAlpha: 0.7,
          },
          e
        ),
        (this.padding = 1);
    }
    _updateTransform() {
      (this.uniforms.transformX = this._thickness * Math.cos(this._angle)),
        (this.uniforms.transformY = this._thickness * Math.sin(this._angle));
    }
    get rotation() {
      return this._angle / a.DEG_TO_RAD;
    }
    set rotation(e) {
      (this._angle = e * a.DEG_TO_RAD), this._updateTransform();
    }
    get thickness() {
      return this._thickness;
    }
    set thickness(e) {
      (this._thickness = e), this._updateTransform();
    }
    get lightColor() {
      return a.utils.rgb2hex(this.uniforms.lightColor);
    }
    set lightColor(e) {
      a.utils.hex2rgb(e, this.uniforms.lightColor);
    }
    get lightAlpha() {
      return this.uniforms.lightAlpha;
    }
    set lightAlpha(e) {
      this.uniforms.lightAlpha = e;
    }
    get shadowColor() {
      return a.utils.rgb2hex(this.uniforms.shadowColor);
    }
    set shadowColor(e) {
      a.utils.hex2rgb(e, this.uniforms.shadowColor);
    }
    get shadowAlpha() {
      return this.uniforms.shadowAlpha;
    }
    set shadowAlpha(e) {
      this.uniforms.shadowAlpha = e;
    }
  }
  class qe extends a.Filter {
    constructor(e = 2, r = 4, i = a.settings.FILTER_RESOLUTION, o = 5) {
      super();
      let s, n;
      typeof e == "number"
        ? ((s = e), (n = e))
        : e instanceof a.Point
        ? ((s = e.x), (n = e.y))
        : Array.isArray(e) && ((s = e[0]), (n = e[1])),
        (this.blurXFilter = new I.BlurFilterPass(!0, s, r, i, o)),
        (this.blurYFilter = new I.BlurFilterPass(!1, n, r, i, o)),
        (this.blurYFilter.blendMode = a.BLEND_MODES.SCREEN),
        (this.defaultFilter = new Pe.AlphaFilter());
    }
    apply(e, r, i, o) {
      const s = e.getFilterTexture();
      this.defaultFilter.apply(e, r, i, o),
        this.blurXFilter.apply(e, r, s, 1),
        this.blurYFilter.apply(e, s, i, 0),
        e.returnFilterTexture(s);
    }
    get blur() {
      return this.blurXFilter.blur;
    }
    set blur(e) {
      this.blurXFilter.blur = this.blurYFilter.blur = e;
    }
    get blurX() {
      return this.blurXFilter.blur;
    }
    set blurX(e) {
      this.blurXFilter.blur = e;
    }
    get blurY() {
      return this.blurYFilter.blur;
    }
    set blurY(e) {
      this.blurYFilter.blur = e;
    }
  }
  var Ke = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    We = `uniform float radius;
uniform float strength;
uniform vec2 center;
uniform sampler2D uSampler;
varying vec2 vTextureCoord;

uniform vec4 filterArea;
uniform vec4 filterClamp;
uniform vec2 dimensions;

void main()
{
    vec2 coord = vTextureCoord * filterArea.xy;
    coord -= center * dimensions.xy;
    float distance = length(coord);
    if (distance < radius) {
        float percent = distance / radius;
        if (strength > 0.0) {
            coord *= mix(1.0, smoothstep(0.0, radius / distance, percent), strength * 0.75);
        } else {
            coord *= mix(1.0, pow(percent, 1.0 + strength * 0.75) * radius / distance, 1.0 - percent);
        }
    }
    coord += center * dimensions.xy;
    coord /= filterArea.xy;
    vec2 clampedCoord = clamp(coord, filterClamp.xy, filterClamp.zw);
    vec4 color = texture2D(uSampler, clampedCoord);
    if (coord != clampedCoord) {
        color *= max(0.0, 1.0 - length(coord - clampedCoord));
    }

    gl_FragColor = color;
}
`;
  const G = class extends a.Filter {
    constructor(t) {
      super(Ke, We),
        (this.uniforms.dimensions = new Float32Array(2)),
        Object.assign(this, G.defaults, t);
    }
    apply(t, e, r, i) {
      const { width: o, height: s } = e.filterFrame;
      (this.uniforms.dimensions[0] = o),
        (this.uniforms.dimensions[1] = s),
        t.applyFilter(this, e, r, i);
    }
    get radius() {
      return this.uniforms.radius;
    }
    set radius(t) {
      this.uniforms.radius = t;
    }
    get strength() {
      return this.uniforms.strength;
    }
    set strength(t) {
      this.uniforms.strength = t;
    }
    get center() {
      return this.uniforms.center;
    }
    set center(t) {
      this.uniforms.center = t;
    }
  };
  let B = G;
  B.defaults = { center: [0.5, 0.5], radius: 100, strength: 1 };
  var Ye = `const float PI = 3.1415926538;
const float PI_2 = PI*2.;

varying vec2 vTextureCoord;
varying vec2 vFilterCoord;
uniform sampler2D uSampler;

const int TYPE_LINEAR = 0;
const int TYPE_RADIAL = 1;
const int TYPE_CONIC = 2;
const int MAX_STOPS = 32;

uniform int uNumStops;
uniform float uAlphas[3*MAX_STOPS];
uniform vec3 uColors[MAX_STOPS];
uniform float uOffsets[MAX_STOPS];
uniform int uType;
uniform float uAngle;
uniform float uAlpha;
uniform int uMaxColors;
uniform bool uReplace;

struct ColorStop {
    float offset;
    vec3 color;
    float alpha;
};

mat2 rotate2d(float angle){
    return mat2(cos(angle), -sin(angle),
    sin(angle), cos(angle));
}

float projectLinearPosition(vec2 pos, float angle){
    vec2 center = vec2(0.5);
    vec2 result = pos - center;
    result = rotate2d(angle) * result;
    result = result + center;
    return clamp(result.x, 0., 1.);
}

float projectRadialPosition(vec2 pos) {
    float r = distance(vFilterCoord, vec2(0.5));
    return clamp(2.*r, 0., 1.);
}

float projectAnglePosition(vec2 pos, float angle) {
    vec2 center = pos - vec2(0.5);
    float polarAngle=atan(-center.y, center.x);
    return mod(polarAngle + angle, PI_2) / PI_2;
}

float projectPosition(vec2 pos, int type, float angle) {
    if (type == TYPE_LINEAR) {
        return projectLinearPosition(pos, angle);
    } else if (type == TYPE_RADIAL) {
        return projectRadialPosition(pos);
    } else if (type == TYPE_CONIC) {
        return projectAnglePosition(pos, angle);
    }

    return pos.y;
}

void main(void) {
    // current/original color
    vec4 currentColor = texture2D(uSampler, vTextureCoord);

    // skip calculations if gradient alpha is 0
    if (0.0 == uAlpha) {
        gl_FragColor = currentColor;
        return;
    }

    // project position
    float y = projectPosition(vFilterCoord, uType, radians(uAngle));

    // check gradient bounds
    float offsetMin = uOffsets[0];
    float offsetMax = 0.0;

    for (int i = 0; i < MAX_STOPS; i++) {
        if (i == uNumStops-1){ // last index
            offsetMax = uOffsets[i];
        }
    }

    if (y  < offsetMin || y > offsetMax) {
        gl_FragColor = currentColor;
        return;
    }

    // limit colors
    if (uMaxColors > 0) {
        float stepSize = 1./float(uMaxColors);
        float stepNumber = float(floor(y/stepSize));
        y = stepSize * (stepNumber + 0.5);// offset by 0.5 to use color from middle of segment
    }

    // find color stops
    ColorStop from;
    ColorStop to;

    for (int i = 0; i < MAX_STOPS; i++) {
        if (y >= uOffsets[i]) {
            from = ColorStop(uOffsets[i], uColors[i], uAlphas[i]);
            to = ColorStop(uOffsets[i+1], uColors[i+1], uAlphas[i+1]);
        }

        if (i == uNumStops-1){ // last index
            break;
        }
    }

    // mix colors from stops
    vec4 colorFrom = vec4(from.color * from.alpha, from.alpha);
    vec4 colorTo = vec4(to.color * to.alpha, to.alpha);

    float segmentHeight = to.offset - from.offset;
    float relativePos = y - from.offset;// position from 0 to [segmentHeight]
    float relativePercent = relativePos / segmentHeight;// position in percent between [from.offset] and [to.offset].

    float gradientAlpha = uAlpha * currentColor.a;
    vec4 gradientColor = mix(colorFrom, colorTo, relativePercent) * gradientAlpha;

    if (uReplace == false) {
        // mix resulting color with current color
        gl_FragColor = gradientColor + currentColor*(1.-gradientColor.a);
    } else {
        // replace with gradient color
        gl_FragColor = gradientColor;
    }
}
`,
    Ue = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;
uniform vec4 inputSize;
uniform vec4 outputFrame;

varying vec2 vTextureCoord;
varying vec2 vFilterCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
    vFilterCoord = vTextureCoord * inputSize.xy / outputFrame.zw;
}
`,
    _ = _ || {};
  _.stringify = (function () {
    var t = {
      "visit_linear-gradient": function (e) {
        return t.visit_gradient(e);
      },
      "visit_repeating-linear-gradient": function (e) {
        return t.visit_gradient(e);
      },
      "visit_radial-gradient": function (e) {
        return t.visit_gradient(e);
      },
      "visit_repeating-radial-gradient": function (e) {
        return t.visit_gradient(e);
      },
      visit_gradient: function (e) {
        var r = t.visit(e.orientation);
        return r && (r += ", "), e.type + "(" + r + t.visit(e.colorStops) + ")";
      },
      visit_shape: function (e) {
        var r = e.value,
          i = t.visit(e.at),
          o = t.visit(e.style);
        return o && (r += " " + o), i && (r += " at " + i), r;
      },
      "visit_default-radial": function (e) {
        var r = "",
          i = t.visit(e.at);
        return i && (r += i), r;
      },
      "visit_extent-keyword": function (e) {
        var r = e.value,
          i = t.visit(e.at);
        return i && (r += " at " + i), r;
      },
      "visit_position-keyword": function (e) {
        return e.value;
      },
      visit_position: function (e) {
        return t.visit(e.value.x) + " " + t.visit(e.value.y);
      },
      "visit_%": function (e) {
        return e.value + "%";
      },
      visit_em: function (e) {
        return e.value + "em";
      },
      visit_px: function (e) {
        return e.value + "px";
      },
      visit_literal: function (e) {
        return t.visit_color(e.value, e);
      },
      visit_hex: function (e) {
        return t.visit_color("#" + e.value, e);
      },
      visit_rgb: function (e) {
        return t.visit_color("rgb(" + e.value.join(", ") + ")", e);
      },
      visit_rgba: function (e) {
        return t.visit_color("rgba(" + e.value.join(", ") + ")", e);
      },
      visit_color: function (e, r) {
        var i = e,
          o = t.visit(r.length);
        return o && (i += " " + o), i;
      },
      visit_angular: function (e) {
        return e.value + "deg";
      },
      visit_directional: function (e) {
        return "to " + e.value;
      },
      visit_array: function (e) {
        var r = "",
          i = e.length;
        return (
          e.forEach(function (o, s) {
            (r += t.visit(o)), s < i - 1 && (r += ", ");
          }),
          r
        );
      },
      visit: function (e) {
        if (!e) return "";
        var r = "";
        if (e instanceof Array) return t.visit_array(e, r);
        if (e.type) {
          var i = t["visit_" + e.type];
          if (i) return i(e);
          throw Error("Missing visitor visit_" + e.type);
        } else throw Error("Invalid node.");
      },
    };
    return function (e) {
      return t.visit(e);
    };
  })();
  var _ = _ || {};
  _.parse = (function () {
    var t = {
        linearGradient: /^(\-(webkit|o|ms|moz)\-)?(linear\-gradient)/i,
        repeatingLinearGradient:
          /^(\-(webkit|o|ms|moz)\-)?(repeating\-linear\-gradient)/i,
        radialGradient: /^(\-(webkit|o|ms|moz)\-)?(radial\-gradient)/i,
        repeatingRadialGradient:
          /^(\-(webkit|o|ms|moz)\-)?(repeating\-radial\-gradient)/i,
        sideOrCorner:
          /^to (left (top|bottom)|right (top|bottom)|left|right|top|bottom)/i,
        extentKeywords:
          /^(closest\-side|closest\-corner|farthest\-side|farthest\-corner|contain|cover)/,
        positionKeywords: /^(left|center|right|top|bottom)/i,
        pixelValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))px/,
        percentageValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))\%/,
        emValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))em/,
        angleValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))deg/,
        startCall: /^\(/,
        endCall: /^\)/,
        comma: /^,/,
        hexColor: /^\#([0-9a-fA-F]+)/,
        literalColor: /^([a-zA-Z]+)/,
        rgbColor: /^rgb/i,
        rgbaColor: /^rgba/i,
        number: /^(([0-9]*\.[0-9]+)|([0-9]+\.?))/,
      },
      e = "";
    function r(c) {
      var d = new Error(e + ": " + c);
      throw ((d.source = e), d);
    }
    function i() {
      var c = o();
      return e.length > 0 && r("Invalid input not EOF"), c;
    }
    function o() {
      return w(s);
    }
    function s() {
      return (
        n("linear-gradient", t.linearGradient, u) ||
        n("repeating-linear-gradient", t.repeatingLinearGradient, u) ||
        n("radial-gradient", t.radialGradient, S) ||
        n("repeating-radial-gradient", t.repeatingRadialGradient, S)
      );
    }
    function n(c, d, m) {
      return l(d, function (C) {
        var we = m();
        return (
          we && (y(t.comma) || r("Missing comma before color stops")),
          { type: c, orientation: we, colorStops: w(Vr) }
        );
      });
    }
    function l(c, d) {
      var m = y(c);
      if (m) {
        y(t.startCall) || r("Missing (");
        var C = d(m);
        return y(t.endCall) || r("Missing )"), C;
      }
    }
    function u() {
      return h() || p();
    }
    function h() {
      return v("directional", t.sideOrCorner, 1);
    }
    function p() {
      return v("angular", t.angleValue, 1);
    }
    function S() {
      var c,
        d = g(),
        m;
      return (
        d &&
          ((c = []),
          c.push(d),
          (m = e),
          y(t.comma) && ((d = g()), d ? c.push(d) : (e = m))),
        c
      );
    }
    function g() {
      var c = x() || Ir();
      if (c) c.at = Se();
      else {
        var d = j();
        if (d) {
          c = d;
          var m = Se();
          m && (c.at = m);
        } else {
          var C = Te();
          C && (c = { type: "default-radial", at: C });
        }
      }
      return c;
    }
    function x() {
      var c = v("shape", /^(circle)/i, 0);
      return c && (c.style = Ae() || j()), c;
    }
    function Ir() {
      var c = v("shape", /^(ellipse)/i, 0);
      return c && (c.style = P() || j()), c;
    }
    function j() {
      return v("extent-keyword", t.extentKeywords, 1);
    }
    function Se() {
      if (v("position", /^at/, 0)) {
        var c = Te();
        return c || r("Missing positioning value"), c;
      }
    }
    function Te() {
      var c = Lr();
      if (c.x || c.y) return { type: "position", value: c };
    }
    function Lr() {
      return { x: P(), y: P() };
    }
    function w(c) {
      var d = c(),
        m = [];
      if (d)
        for (m.push(d); y(t.comma); )
          (d = c()), d ? m.push(d) : r("One extra comma");
      return m;
    }
    function Vr() {
      var c = Nr();
      return c || r("Expected color definition"), (c.length = P()), c;
    }
    function Nr() {
      return Br() || qr() || Xr() || Gr();
    }
    function Gr() {
      return v("literal", t.literalColor, 0);
    }
    function Br() {
      return v("hex", t.hexColor, 1);
    }
    function Xr() {
      return l(t.rgbColor, function () {
        return { type: "rgb", value: w(Fe) };
      });
    }
    function qr() {
      return l(t.rgbaColor, function () {
        return { type: "rgba", value: w(Fe) };
      });
    }
    function Fe() {
      return y(t.number)[1];
    }
    function P() {
      return v("%", t.percentageValue, 1) || Kr() || Ae();
    }
    function Kr() {
      return v("position-keyword", t.positionKeywords, 1);
    }
    function Ae() {
      return v("px", t.pixelValue, 1) || v("em", t.emValue, 1);
    }
    function v(c, d, m) {
      var C = y(d);
      if (C) return { type: c, value: C[m] };
    }
    function y(c) {
      var d, m;
      return (
        (m = /^[\n\r\t\s]+/.exec(e)),
        m && ze(m[0].length),
        (d = c.exec(e)),
        d && ze(d[0].length),
        d
      );
    }
    function ze(c) {
      e = e.substr(c);
    }
    return function (c) {
      return (e = c.toString()), i();
    };
  })();
  var Ze = _.parse;
  _.stringify;
  var X = {
      aliceblue: [240, 248, 255],
      antiquewhite: [250, 235, 215],
      aqua: [0, 255, 255],
      aquamarine: [127, 255, 212],
      azure: [240, 255, 255],
      beige: [245, 245, 220],
      bisque: [255, 228, 196],
      black: [0, 0, 0],
      blanchedalmond: [255, 235, 205],
      blue: [0, 0, 255],
      blueviolet: [138, 43, 226],
      brown: [165, 42, 42],
      burlywood: [222, 184, 135],
      cadetblue: [95, 158, 160],
      chartreuse: [127, 255, 0],
      chocolate: [210, 105, 30],
      coral: [255, 127, 80],
      cornflowerblue: [100, 149, 237],
      cornsilk: [255, 248, 220],
      crimson: [220, 20, 60],
      cyan: [0, 255, 255],
      darkblue: [0, 0, 139],
      darkcyan: [0, 139, 139],
      darkgoldenrod: [184, 134, 11],
      darkgray: [169, 169, 169],
      darkgreen: [0, 100, 0],
      darkgrey: [169, 169, 169],
      darkkhaki: [189, 183, 107],
      darkmagenta: [139, 0, 139],
      darkolivegreen: [85, 107, 47],
      darkorange: [255, 140, 0],
      darkorchid: [153, 50, 204],
      darkred: [139, 0, 0],
      darksalmon: [233, 150, 122],
      darkseagreen: [143, 188, 143],
      darkslateblue: [72, 61, 139],
      darkslategray: [47, 79, 79],
      darkslategrey: [47, 79, 79],
      darkturquoise: [0, 206, 209],
      darkviolet: [148, 0, 211],
      deeppink: [255, 20, 147],
      deepskyblue: [0, 191, 255],
      dimgray: [105, 105, 105],
      dimgrey: [105, 105, 105],
      dodgerblue: [30, 144, 255],
      firebrick: [178, 34, 34],
      floralwhite: [255, 250, 240],
      forestgreen: [34, 139, 34],
      fuchsia: [255, 0, 255],
      gainsboro: [220, 220, 220],
      ghostwhite: [248, 248, 255],
      gold: [255, 215, 0],
      goldenrod: [218, 165, 32],
      gray: [128, 128, 128],
      green: [0, 128, 0],
      greenyellow: [173, 255, 47],
      grey: [128, 128, 128],
      honeydew: [240, 255, 240],
      hotpink: [255, 105, 180],
      indianred: [205, 92, 92],
      indigo: [75, 0, 130],
      ivory: [255, 255, 240],
      khaki: [240, 230, 140],
      lavender: [230, 230, 250],
      lavenderblush: [255, 240, 245],
      lawngreen: [124, 252, 0],
      lemonchiffon: [255, 250, 205],
      lightblue: [173, 216, 230],
      lightcoral: [240, 128, 128],
      lightcyan: [224, 255, 255],
      lightgoldenrodyellow: [250, 250, 210],
      lightgray: [211, 211, 211],
      lightgreen: [144, 238, 144],
      lightgrey: [211, 211, 211],
      lightpink: [255, 182, 193],
      lightsalmon: [255, 160, 122],
      lightseagreen: [32, 178, 170],
      lightskyblue: [135, 206, 250],
      lightslategray: [119, 136, 153],
      lightslategrey: [119, 136, 153],
      lightsteelblue: [176, 196, 222],
      lightyellow: [255, 255, 224],
      lime: [0, 255, 0],
      limegreen: [50, 205, 50],
      linen: [250, 240, 230],
      magenta: [255, 0, 255],
      maroon: [128, 0, 0],
      mediumaquamarine: [102, 205, 170],
      mediumblue: [0, 0, 205],
      mediumorchid: [186, 85, 211],
      mediumpurple: [147, 112, 219],
      mediumseagreen: [60, 179, 113],
      mediumslateblue: [123, 104, 238],
      mediumspringgreen: [0, 250, 154],
      mediumturquoise: [72, 209, 204],
      mediumvioletred: [199, 21, 133],
      midnightblue: [25, 25, 112],
      mintcream: [245, 255, 250],
      mistyrose: [255, 228, 225],
      moccasin: [255, 228, 181],
      navajowhite: [255, 222, 173],
      navy: [0, 0, 128],
      oldlace: [253, 245, 230],
      olive: [128, 128, 0],
      olivedrab: [107, 142, 35],
      orange: [255, 165, 0],
      orangered: [255, 69, 0],
      orchid: [218, 112, 214],
      palegoldenrod: [238, 232, 170],
      palegreen: [152, 251, 152],
      paleturquoise: [175, 238, 238],
      palevioletred: [219, 112, 147],
      papayawhip: [255, 239, 213],
      peachpuff: [255, 218, 185],
      peru: [205, 133, 63],
      pink: [255, 192, 203],
      plum: [221, 160, 221],
      powderblue: [176, 224, 230],
      purple: [128, 0, 128],
      rebeccapurple: [102, 51, 153],
      red: [255, 0, 0],
      rosybrown: [188, 143, 143],
      royalblue: [65, 105, 225],
      saddlebrown: [139, 69, 19],
      salmon: [250, 128, 114],
      sandybrown: [244, 164, 96],
      seagreen: [46, 139, 87],
      seashell: [255, 245, 238],
      sienna: [160, 82, 45],
      silver: [192, 192, 192],
      skyblue: [135, 206, 235],
      slateblue: [106, 90, 205],
      slategray: [112, 128, 144],
      slategrey: [112, 128, 144],
      snow: [255, 250, 250],
      springgreen: [0, 255, 127],
      steelblue: [70, 130, 180],
      tan: [210, 180, 140],
      teal: [0, 128, 128],
      thistle: [216, 191, 216],
      tomato: [255, 99, 71],
      turquoise: [64, 224, 208],
      violet: [238, 130, 238],
      wheat: [245, 222, 179],
      white: [255, 255, 255],
      whitesmoke: [245, 245, 245],
      yellow: [255, 255, 0],
      yellowgreen: [154, 205, 50],
    },
    q = { red: 0, orange: 60, yellow: 120, green: 180, blue: 240, purple: 300 };
  function He(t) {
    var e,
      r = [],
      i = 1,
      o;
    if (typeof t == "string")
      if (X[t]) (r = X[t].slice()), (o = "rgb");
      else if (t === "transparent") (i = 0), (o = "rgb"), (r = [0, 0, 0]);
      else if (/^#[A-Fa-f0-9]+$/.test(t)) {
        var s = t.slice(1),
          n = s.length,
          l = n <= 4;
        (i = 1),
          l
            ? ((r = [
                parseInt(s[0] + s[0], 16),
                parseInt(s[1] + s[1], 16),
                parseInt(s[2] + s[2], 16),
              ]),
              n === 4 && (i = parseInt(s[3] + s[3], 16) / 255))
            : ((r = [
                parseInt(s[0] + s[1], 16),
                parseInt(s[2] + s[3], 16),
                parseInt(s[4] + s[5], 16),
              ]),
              n === 8 && (i = parseInt(s[6] + s[7], 16) / 255)),
          r[0] || (r[0] = 0),
          r[1] || (r[1] = 0),
          r[2] || (r[2] = 0),
          (o = "rgb");
      } else if (
        (e =
          /^((?:rgb|hs[lvb]|hwb|cmyk?|xy[zy]|gray|lab|lchu?v?|[ly]uv|lms)a?)\s*\(([^\)]*)\)/.exec(
            t
          ))
      ) {
        var u = e[1],
          h = u === "rgb",
          s = u.replace(/a$/, "");
        o = s;
        var n = s === "cmyk" ? 4 : s === "gray" ? 1 : 3;
        (r = e[2]
          .trim()
          .split(/\s*[,\/]\s*|\s+/)
          .map(function (g, x) {
            if (/%$/.test(g))
              return x === n
                ? parseFloat(g) / 100
                : s === "rgb"
                ? (parseFloat(g) * 255) / 100
                : parseFloat(g);
            if (s[x] === "h") {
              if (/deg$/.test(g)) return parseFloat(g);
              if (q[g] !== void 0) return q[g];
            }
            return parseFloat(g);
          })),
          u === s && r.push(1),
          (i = h || r[n] === void 0 ? 1 : r[n]),
          (r = r.slice(0, n));
      } else
        t.length > 10 &&
          /[0-9](?:\s|\/)/.test(t) &&
          ((r = t.match(/([0-9]+)/g).map(function (p) {
            return parseFloat(p);
          })),
          (o = t
            .match(/([a-z])/gi)
            .join("")
            .toLowerCase()));
    else
      isNaN(t)
        ? Array.isArray(t) || t.length
          ? ((r = [t[0], t[1], t[2]]),
            (o = "rgb"),
            (i = t.length === 4 ? t[3] : 1))
          : t instanceof Object &&
            (t.r != null || t.red != null || t.R != null
              ? ((o = "rgb"),
                (r = [
                  t.r || t.red || t.R || 0,
                  t.g || t.green || t.G || 0,
                  t.b || t.blue || t.B || 0,
                ]))
              : ((o = "hsl"),
                (r = [
                  t.h || t.hue || t.H || 0,
                  t.s || t.saturation || t.S || 0,
                  t.l || t.lightness || t.L || t.b || t.brightness,
                ])),
            (i = t.a || t.alpha || t.opacity || 1),
            t.opacity != null && (i /= 100))
        : ((o = "rgb"), (r = [t >>> 16, (t & 65280) >>> 8, t & 255]));
    return { space: o, values: r, alpha: i };
  }
  var M = {
      name: "rgb",
      min: [0, 0, 0],
      max: [255, 255, 255],
      channel: ["red", "green", "blue"],
      alias: ["RGB"],
    },
    D = {
      name: "hsl",
      min: [0, 0, 0],
      max: [360, 100, 100],
      channel: ["hue", "saturation", "lightness"],
      alias: ["HSL"],
      rgb: function (t) {
        var e = t[0] / 360,
          r = t[1] / 100,
          i = t[2] / 100,
          o,
          s,
          n,
          l,
          u;
        if (r === 0) return (u = i * 255), [u, u, u];
        i < 0.5 ? (s = i * (1 + r)) : (s = i + r - i * r),
          (o = 2 * i - s),
          (l = [0, 0, 0]);
        for (var h = 0; h < 3; h++)
          (n = e + (1 / 3) * -(h - 1)),
            n < 0 ? n++ : n > 1 && n--,
            6 * n < 1
              ? (u = o + (s - o) * 6 * n)
              : 2 * n < 1
              ? (u = s)
              : 3 * n < 2
              ? (u = o + (s - o) * (2 / 3 - n) * 6)
              : (u = o),
            (l[h] = u * 255);
        return l;
      },
    };
  M.hsl = function (t) {
    var e = t[0] / 255,
      r = t[1] / 255,
      i = t[2] / 255,
      o = Math.min(e, r, i),
      s = Math.max(e, r, i),
      n = s - o,
      l,
      u,
      h;
    return (
      s === o
        ? (l = 0)
        : e === s
        ? (l = (r - i) / n)
        : r === s
        ? (l = 2 + (i - e) / n)
        : i === s && (l = 4 + (e - r) / n),
      (l = Math.min(l * 60, 360)),
      l < 0 && (l += 360),
      (h = (o + s) / 2),
      s === o ? (u = 0) : h <= 0.5 ? (u = n / (s + o)) : (u = n / (2 - s - o)),
      [l, u * 100, h * 100]
    );
  };
  function Qe(t) {
    Array.isArray(t) && t.raw && (t = String.raw(...arguments));
    var e,
      r = He(t);
    if (!r.space) return [];
    const i = r.space[0] === "h" ? D.min : M.min,
      o = r.space[0] === "h" ? D.max : M.max;
    return (
      (e = Array(3)),
      (e[0] = Math.min(Math.max(r.values[0], i[0]), o[0])),
      (e[1] = Math.min(Math.max(r.values[1], i[1]), o[1])),
      (e[2] = Math.min(Math.max(r.values[2], i[2]), o[2])),
      r.space[0] === "h" && (e = D.rgb(e)),
      e.push(Math.min(Math.max(r.alpha, 0), 1)),
      e
    );
  }
  function K(t) {
    switch (typeof t) {
      case "string":
        return Je(t);
      case "number":
        return a.utils.hex2rgb(t);
      default:
        return t;
    }
  }
  function Je(t) {
    const e = Qe(t);
    if (!e) throw new Error(`Unable to parse color "${t}" as RGBA.`);
    return [e[0] / 255, e[1] / 255, e[2] / 255, e[3]];
  }
  function et(t) {
    const e = Ze(ut(t));
    if (e.length === 0) throw new Error("Invalid CSS gradient.");
    if (e.length !== 1)
      throw new Error(
        "Unsupported CSS gradient (multiple gradients is not supported)."
      );
    const r = e[0],
      i = tt(r.type),
      o = rt(r.colorStops),
      s = nt(r.orientation);
    return { type: i, stops: o, angle: s };
  }
  function tt(t) {
    const e = { "linear-gradient": 0, "radial-gradient": 1 };
    if (!(t in e)) throw new Error(`Unsupported gradient type "${t}"`);
    return e[t];
  }
  function rt(t) {
    const e = st(t),
      r = [];
    for (let i = 0; i < t.length; i++) {
      const o = it(t[i]);
      r.push({ offset: e[i], color: o.slice(0, 3), alpha: o[3] });
    }
    return r;
  }
  function it(t) {
    return K(ot(t));
  }
  function ot(t) {
    switch (t.type) {
      case "hex":
        return `#${t.value}`;
      case "literal":
        return t.value;
      default:
        return `${t.type}(${t.value.join(",")})`;
    }
  }
  function st(t) {
    const e = [];
    for (let o = 0; o < t.length; o++) {
      const s = t[o];
      let n = -1;
      s.type === "literal" &&
        s.length &&
        "type" in s.length &&
        s.length.type === "%" &&
        "value" in s.length &&
        (n = parseFloat(s.length.value) / 100),
        e.push(n);
    }
    const r = (o) => {
      for (let s = o; s < e.length; s++)
        if (e[s] !== -1) return { indexDelta: s - o, offset: e[s] };
      return { indexDelta: e.length - 1 - o, offset: 1 };
    };
    let i = 0;
    for (let o = 0; o < e.length; o++) {
      const s = e[o];
      if (s !== -1) i = s;
      else if (o === 0) e[o] = 0;
      else if (o + 1 === e.length) e[o] = 1;
      else {
        const n = r(o),
          l = (n.offset - i) / (1 + n.indexDelta);
        for (let u = 0; u <= n.indexDelta; u++) e[o + u] = i + (u + 1) * l;
        (o += n.indexDelta), (i = e[o]);
      }
    }
    return e.map(at);
  }
  function at(t) {
    return t.toString().length > 6
      ? parseFloat(t.toString().substring(0, 6))
      : t;
  }
  function nt(t) {
    if (typeof t == "undefined") return 0;
    if ("type" in t && "value" in t)
      switch (t.type) {
        case "angular":
          return parseFloat(t.value);
        case "directional":
          return lt(t.value);
      }
    return 0;
  }
  function lt(t) {
    const e = {
      left: 270,
      top: 0,
      bottom: 180,
      right: 90,
      "left top": 315,
      "top left": 315,
      "left bottom": 225,
      "bottom left": 225,
      "right top": 45,
      "top right": 45,
      "right bottom": 135,
      "bottom right": 135,
    };
    if (!(t in e)) throw new Error(`Unsupported directional value "${t}"`);
    return e[t];
  }
  function ut(t) {
    let e = t.replace(/\s{2,}/gu, " ");
    return (
      (e = e.replace(/;/g, "")),
      (e = e.replace(/ ,/g, ",")),
      (e = e.replace(/\( /g, "(")),
      (e = e.replace(/ \)/g, ")")),
      e.trim()
    );
  }
  var ct = Object.defineProperty,
    ft = Object.defineProperties,
    dt = Object.getOwnPropertyDescriptors,
    W = Object.getOwnPropertySymbols,
    ht = Object.prototype.hasOwnProperty,
    mt = Object.prototype.propertyIsEnumerable,
    Y = (t, e, r) =>
      e in t
        ? ct(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r })
        : (t[e] = r),
    k = (t, e) => {
      for (var r in e || (e = {})) ht.call(e, r) && Y(t, r, e[r]);
      if (W) for (var r of W(e)) mt.call(e, r) && Y(t, r, e[r]);
      return t;
    },
    gt = (t, e) => ft(t, dt(e));
  const U = 90;
  function vt(t) {
    return [...t].sort((e, r) => e.offset - r.offset);
  }
  const F = class extends a.Filter {
    constructor(t) {
      var e, r;
      let i;
      if (
        (t && "css" in t
          ? (i = gt(k({}, et(t.css || "")), {
              alpha: (e = t.alpha) != null ? e : F.defaults.alpha,
              maxColors: (r = t.maxColors) != null ? r : F.defaults.maxColors,
            }))
          : (i = k(k({}, F.defaults), t)),
        !i.stops || i.stops.length < 2)
      )
        throw new Error("ColorGradientFilter requires at least 2 color stops.");
      super(Ue, Ye),
        (this._stops = []),
        (this.autoFit = !1),
        Object.assign(this, i);
    }
    get stops() {
      return this._stops;
    }
    set stops(t) {
      const e = vt(t),
        r = new Float32Array(e.length * 3),
        i = 0,
        o = 1,
        s = 2;
      for (let n = 0; n < e.length; n++) {
        const l = K(e[n].color),
          u = n * 3;
        (r[u + i] = l[i]), (r[u + o] = l[o]), (r[u + s] = l[s]);
      }
      (this.uniforms.uColors = r),
        (this.uniforms.uOffsets = e.map((n) => n.offset)),
        (this.uniforms.uAlphas = e.map((n) => n.alpha)),
        (this.uniforms.uNumStops = e.length),
        (this._stops = e);
    }
    set type(t) {
      this.uniforms.uType = t;
    }
    get type() {
      return this.uniforms.uType;
    }
    set angle(t) {
      this.uniforms.uAngle = t - U;
    }
    get angle() {
      return this.uniforms.uAngle + U;
    }
    set alpha(t) {
      this.uniforms.uAlpha = t;
    }
    get alpha() {
      return this.uniforms.uAlpha;
    }
    set maxColors(t) {
      this.uniforms.uMaxColors = t;
    }
    get maxColors() {
      return this.uniforms.uMaxColors;
    }
    set replace(t) {
      this.uniforms.uReplace = t;
    }
    get replace() {
      return this.uniforms.uReplace;
    }
  };
  let A = F;
  (A.LINEAR = 0),
    (A.RADIAL = 1),
    (A.CONIC = 2),
    (A.defaults = {
      type: F.LINEAR,
      stops: [
        { offset: 0, color: 16711680, alpha: 1 },
        { offset: 1, color: 255, alpha: 1 },
      ],
      alpha: 1,
      angle: 90,
      maxColors: 0,
      replace: !1,
    });
  var pt = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    xt = `varying vec2 vTextureCoord;
uniform sampler2D uSampler;
uniform sampler2D colorMap;
uniform float _mix;
uniform float _size;
uniform float _sliceSize;
uniform float _slicePixelSize;
uniform float _sliceInnerSize;
void main() {
    vec4 color = texture2D(uSampler, vTextureCoord.xy);

    vec4 adjusted;
    if (color.a > 0.0) {
        color.rgb /= color.a;
        float innerWidth = _size - 1.0;
        float zSlice0 = min(floor(color.b * innerWidth), innerWidth);
        float zSlice1 = min(zSlice0 + 1.0, innerWidth);
        float xOffset = _slicePixelSize * 0.5 + color.r * _sliceInnerSize;
        float s0 = xOffset + (zSlice0 * _sliceSize);
        float s1 = xOffset + (zSlice1 * _sliceSize);
        float yOffset = _sliceSize * 0.5 + color.g * (1.0 - _sliceSize);
        vec4 slice0Color = texture2D(colorMap, vec2(s0,yOffset));
        vec4 slice1Color = texture2D(colorMap, vec2(s1,yOffset));
        float zOffset = fract(color.b * innerWidth);
        adjusted = mix(slice0Color, slice1Color, zOffset);

        color.rgb *= color.a;
    }
    gl_FragColor = vec4(mix(color, adjusted, _mix).rgb, color.a);

}`;
  class yt extends a.Filter {
    constructor(e, r = !1, i = 1) {
      super(pt, xt),
        (this.mix = 1),
        (this._size = 0),
        (this._sliceSize = 0),
        (this._slicePixelSize = 0),
        (this._sliceInnerSize = 0),
        (this._nearest = !1),
        (this._scaleMode = null),
        (this._colorMap = null),
        (this._scaleMode = null),
        (this.nearest = r),
        (this.mix = i),
        (this.colorMap = e);
    }
    apply(e, r, i, o) {
      (this.uniforms._mix = this.mix), e.applyFilter(this, r, i, o);
    }
    get colorSize() {
      return this._size;
    }
    get colorMap() {
      return this._colorMap;
    }
    set colorMap(e) {
      !e ||
        (e instanceof a.Texture || (e = a.Texture.from(e)),
        e != null &&
          e.baseTexture &&
          ((e.baseTexture.scaleMode = this._scaleMode),
          (e.baseTexture.mipmap = a.MIPMAP_MODES.OFF),
          (this._size = e.height),
          (this._sliceSize = 1 / this._size),
          (this._slicePixelSize = this._sliceSize / this._size),
          (this._sliceInnerSize = this._slicePixelSize * (this._size - 1)),
          (this.uniforms._size = this._size),
          (this.uniforms._sliceSize = this._sliceSize),
          (this.uniforms._slicePixelSize = this._slicePixelSize),
          (this.uniforms._sliceInnerSize = this._sliceInnerSize),
          (this.uniforms.colorMap = e)),
        (this._colorMap = e));
    }
    get nearest() {
      return this._nearest;
    }
    set nearest(e) {
      (this._nearest = e),
        (this._scaleMode = e ? a.SCALE_MODES.NEAREST : a.SCALE_MODES.LINEAR);
      const r = this._colorMap;
      r &&
        r.baseTexture &&
        ((r.baseTexture._glTextures = {}),
        (r.baseTexture.scaleMode = this._scaleMode),
        (r.baseTexture.mipmap = a.MIPMAP_MODES.OFF),
        r._updateID++,
        r.baseTexture.emit("update", r.baseTexture));
    }
    updateColorMap() {
      const e = this._colorMap;
      e &&
        e.baseTexture &&
        (e._updateID++,
        e.baseTexture.emit("update", e.baseTexture),
        (this.colorMap = e));
    }
    destroy(e = !1) {
      this._colorMap && this._colorMap.destroy(e), super.destroy();
    }
  }
  var Ct = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    _t = `varying vec2 vTextureCoord;
uniform sampler2D uSampler;
uniform vec3 color;
uniform float alpha;

void main(void) {
    vec4 currentColor = texture2D(uSampler, vTextureCoord);
    gl_FragColor = vec4(mix(currentColor.rgb, color.rgb, currentColor.a * alpha), currentColor.a);
}
`;
  class bt extends a.Filter {
    constructor(e = 0, r = 1) {
      super(Ct, _t),
        (this._color = 0),
        (this._alpha = 1),
        (this.uniforms.color = new Float32Array(3)),
        (this.color = e),
        (this.alpha = r);
    }
    set color(e) {
      const r = this.uniforms.color;
      typeof e == "number"
        ? (a.utils.hex2rgb(e, r), (this._color = e))
        : ((r[0] = e[0]),
          (r[1] = e[1]),
          (r[2] = e[2]),
          (this._color = a.utils.rgb2hex(r)));
    }
    get color() {
      return this._color;
    }
    set alpha(e) {
      (this.uniforms.alpha = e), (this._alpha = e);
    }
    get alpha() {
      return this._alpha;
    }
  }
  var St = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    Tt = `varying vec2 vTextureCoord;
uniform sampler2D uSampler;
uniform vec3 originalColor;
uniform vec3 newColor;
uniform float epsilon;
void main(void) {
    vec4 currentColor = texture2D(uSampler, vTextureCoord);
    vec3 colorDiff = originalColor - (currentColor.rgb / max(currentColor.a, 0.0000000001));
    float colorDistance = length(colorDiff);
    float doReplace = step(colorDistance, epsilon);
    gl_FragColor = vec4(mix(currentColor.rgb, (newColor + colorDiff) * currentColor.a, doReplace), currentColor.a);
}
`;
  class Ft extends a.Filter {
    constructor(e = 16711680, r = 0, i = 0.4) {
      super(St, Tt),
        (this._originalColor = 16711680),
        (this._newColor = 0),
        (this.uniforms.originalColor = new Float32Array(3)),
        (this.uniforms.newColor = new Float32Array(3)),
        (this.originalColor = e),
        (this.newColor = r),
        (this.epsilon = i);
    }
    set originalColor(e) {
      const r = this.uniforms.originalColor;
      typeof e == "number"
        ? (a.utils.hex2rgb(e, r), (this._originalColor = e))
        : ((r[0] = e[0]),
          (r[1] = e[1]),
          (r[2] = e[2]),
          (this._originalColor = a.utils.rgb2hex(r)));
    }
    get originalColor() {
      return this._originalColor;
    }
    set newColor(e) {
      const r = this.uniforms.newColor;
      typeof e == "number"
        ? (a.utils.hex2rgb(e, r), (this._newColor = e))
        : ((r[0] = e[0]),
          (r[1] = e[1]),
          (r[2] = e[2]),
          (this._newColor = a.utils.rgb2hex(r)));
    }
    get newColor() {
      return this._newColor;
    }
    set epsilon(e) {
      this.uniforms.epsilon = e;
    }
    get epsilon() {
      return this.uniforms.epsilon;
    }
  }
  var At = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    zt = `precision mediump float;

varying mediump vec2 vTextureCoord;

uniform sampler2D uSampler;
uniform vec2 texelSize;
uniform float matrix[9];

void main(void)
{
   vec4 c11 = texture2D(uSampler, vTextureCoord - texelSize); // top left
   vec4 c12 = texture2D(uSampler, vec2(vTextureCoord.x, vTextureCoord.y - texelSize.y)); // top center
   vec4 c13 = texture2D(uSampler, vec2(vTextureCoord.x + texelSize.x, vTextureCoord.y - texelSize.y)); // top right

   vec4 c21 = texture2D(uSampler, vec2(vTextureCoord.x - texelSize.x, vTextureCoord.y)); // mid left
   vec4 c22 = texture2D(uSampler, vTextureCoord); // mid center
   vec4 c23 = texture2D(uSampler, vec2(vTextureCoord.x + texelSize.x, vTextureCoord.y)); // mid right

   vec4 c31 = texture2D(uSampler, vec2(vTextureCoord.x - texelSize.x, vTextureCoord.y + texelSize.y)); // bottom left
   vec4 c32 = texture2D(uSampler, vec2(vTextureCoord.x, vTextureCoord.y + texelSize.y)); // bottom center
   vec4 c33 = texture2D(uSampler, vTextureCoord + texelSize); // bottom right

   gl_FragColor =
       c11 * matrix[0] + c12 * matrix[1] + c13 * matrix[2] +
       c21 * matrix[3] + c22 * matrix[4] + c23 * matrix[5] +
       c31 * matrix[6] + c32 * matrix[7] + c33 * matrix[8];

   gl_FragColor.a = c22.a;
}
`;
  class wt extends a.Filter {
    constructor(e, r = 200, i = 200) {
      super(At, zt),
        (this.uniforms.texelSize = new Float32Array(2)),
        (this.uniforms.matrix = new Float32Array(9)),
        e !== void 0 && (this.matrix = e),
        (this.width = r),
        (this.height = i);
    }
    get matrix() {
      return this.uniforms.matrix;
    }
    set matrix(e) {
      e.forEach((r, i) => {
        this.uniforms.matrix[i] = r;
      });
    }
    get width() {
      return 1 / this.uniforms.texelSize[0];
    }
    set width(e) {
      this.uniforms.texelSize[0] = 1 / e;
    }
    get height() {
      return 1 / this.uniforms.texelSize[1];
    }
    set height(e) {
      this.uniforms.texelSize[1] = 1 / e;
    }
  }
  var Pt = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    Mt = `precision mediump float;

varying vec2 vTextureCoord;

uniform sampler2D uSampler;

void main(void)
{
    float lum = length(texture2D(uSampler, vTextureCoord.xy).rgb);

    gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);

    if (lum < 1.00)
    {
        if (mod(gl_FragCoord.x + gl_FragCoord.y, 10.0) == 0.0)
        {
            gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
        }
    }

    if (lum < 0.75)
    {
        if (mod(gl_FragCoord.x - gl_FragCoord.y, 10.0) == 0.0)
        {
            gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
        }
    }

    if (lum < 0.50)
    {
        if (mod(gl_FragCoord.x + gl_FragCoord.y - 5.0, 10.0) == 0.0)
        {
            gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
        }
    }

    if (lum < 0.3)
    {
        if (mod(gl_FragCoord.x - gl_FragCoord.y - 5.0, 10.0) == 0.0)
        {
            gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
        }
    }
}
`;
  class Dt extends a.Filter {
    constructor() {
      super(Pt, Mt);
    }
  }
  var kt = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    Ot = `varying vec2 vTextureCoord;
uniform sampler2D uSampler;

uniform vec4 filterArea;
uniform vec2 dimensions;

const float SQRT_2 = 1.414213;

const float light = 1.0;

uniform float curvature;
uniform float lineWidth;
uniform float lineContrast;
uniform bool verticalLine;
uniform float noise;
uniform float noiseSize;

uniform float vignetting;
uniform float vignettingAlpha;
uniform float vignettingBlur;

uniform float seed;
uniform float time;

float rand(vec2 co) {
    return fract(sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453);
}

void main(void)
{
    vec2 pixelCoord = vTextureCoord.xy * filterArea.xy;
    vec2 dir = vec2(vTextureCoord.xy * filterArea.xy / dimensions - vec2(0.5, 0.5));

    gl_FragColor = texture2D(uSampler, vTextureCoord);
    vec3 rgb = gl_FragColor.rgb;

    if (noise > 0.0 && noiseSize > 0.0)
    {
        pixelCoord.x = floor(pixelCoord.x / noiseSize);
        pixelCoord.y = floor(pixelCoord.y / noiseSize);
        float _noise = rand(pixelCoord * noiseSize * seed) - 0.5;
        rgb += _noise * noise;
    }

    if (lineWidth > 0.0)
    {
        float _c = curvature > 0. ? curvature : 1.;
        float k = curvature > 0. ?(length(dir * dir) * 0.25 * _c * _c + 0.935 * _c) : 1.;
        vec2 uv = dir * k;

        float v = (verticalLine ? uv.x * dimensions.x : uv.y * dimensions.y) * min(1.0, 2.0 / lineWidth ) / _c;
        float j = 1. + cos(v * 1.2 - time) * 0.5 * lineContrast;
        rgb *= j;
        float segment = verticalLine ? mod((dir.x + .5) * dimensions.x, 4.) : mod((dir.y + .5) * dimensions.y, 4.);
        rgb *= 0.99 + ceil(segment) * 0.015;
    }

    if (vignetting > 0.0)
    {
        float outter = SQRT_2 - vignetting * SQRT_2;
        float darker = clamp((outter - length(dir) * SQRT_2) / ( 0.00001 + vignettingBlur * SQRT_2), 0.0, 1.0);
        rgb *= darker + (1.0 - darker) * (1.0 - vignettingAlpha);
    }

    gl_FragColor.rgb = rgb;
}
`;
  const Z = class extends a.Filter {
    constructor(t) {
      super(kt, Ot),
        (this.time = 0),
        (this.seed = 0),
        (this.uniforms.dimensions = new Float32Array(2)),
        Object.assign(this, Z.defaults, t);
    }
    apply(t, e, r, i) {
      const { width: o, height: s } = e.filterFrame;
      (this.uniforms.dimensions[0] = o),
        (this.uniforms.dimensions[1] = s),
        (this.uniforms.seed = this.seed),
        (this.uniforms.time = this.time),
        t.applyFilter(this, e, r, i);
    }
    set curvature(t) {
      this.uniforms.curvature = t;
    }
    get curvature() {
      return this.uniforms.curvature;
    }
    set lineWidth(t) {
      this.uniforms.lineWidth = t;
    }
    get lineWidth() {
      return this.uniforms.lineWidth;
    }
    set lineContrast(t) {
      this.uniforms.lineContrast = t;
    }
    get lineContrast() {
      return this.uniforms.lineContrast;
    }
    set verticalLine(t) {
      this.uniforms.verticalLine = t;
    }
    get verticalLine() {
      return this.uniforms.verticalLine;
    }
    set noise(t) {
      this.uniforms.noise = t;
    }
    get noise() {
      return this.uniforms.noise;
    }
    set noiseSize(t) {
      this.uniforms.noiseSize = t;
    }
    get noiseSize() {
      return this.uniforms.noiseSize;
    }
    set vignetting(t) {
      this.uniforms.vignetting = t;
    }
    get vignetting() {
      return this.uniforms.vignetting;
    }
    set vignettingAlpha(t) {
      this.uniforms.vignettingAlpha = t;
    }
    get vignettingAlpha() {
      return this.uniforms.vignettingAlpha;
    }
    set vignettingBlur(t) {
      this.uniforms.vignettingBlur = t;
    }
    get vignettingBlur() {
      return this.uniforms.vignettingBlur;
    }
  };
  let H = Z;
  H.defaults = {
    curvature: 1,
    lineWidth: 1,
    lineContrast: 0.25,
    verticalLine: !1,
    noise: 0,
    noiseSize: 1,
    seed: 0,
    vignetting: 0.3,
    vignettingAlpha: 1,
    vignettingBlur: 0.3,
    time: 0,
  };
  var Rt = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    $t = `precision mediump float;

varying vec2 vTextureCoord;
varying vec4 vColor;

uniform vec4 filterArea;
uniform sampler2D uSampler;

uniform float angle;
uniform float scale;
uniform bool grayscale;

float pattern()
{
   float s = sin(angle), c = cos(angle);
   vec2 tex = vTextureCoord * filterArea.xy;
   vec2 point = vec2(
       c * tex.x - s * tex.y,
       s * tex.x + c * tex.y
   ) * scale;
   return (sin(point.x) * sin(point.y)) * 4.0;
}

void main()
{
   vec4 color = texture2D(uSampler, vTextureCoord);
   vec3 colorRGB = vec3(color);

   if (grayscale)
   {
       colorRGB = vec3(color.r + color.g + color.b) / 3.0;
   }

   gl_FragColor = vec4(colorRGB * 10.0 - 5.0 + pattern(), color.a);
}
`;
  class Et extends a.Filter {
    constructor(e = 1, r = 5, i = !0) {
      super(Rt, $t), (this.scale = e), (this.angle = r), (this.grayscale = i);
    }
    get scale() {
      return this.uniforms.scale;
    }
    set scale(e) {
      this.uniforms.scale = e;
    }
    get angle() {
      return this.uniforms.angle;
    }
    set angle(e) {
      this.uniforms.angle = e;
    }
    get grayscale() {
      return this.uniforms.grayscale;
    }
    set grayscale(e) {
      this.uniforms.grayscale = e;
    }
  }
  var jt = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    It = `varying vec2 vTextureCoord;
uniform sampler2D uSampler;
uniform float alpha;
uniform vec3 color;

uniform vec2 shift;
uniform vec4 inputSize;

void main(void){
    vec4 sample = texture2D(uSampler, vTextureCoord - shift * inputSize.zw);

    // Premultiply alpha
    sample.rgb = color.rgb * sample.a;

    // alpha user alpha
    sample *= alpha;

    gl_FragColor = sample;
}`,
    Lt = Object.defineProperty,
    Q = Object.getOwnPropertySymbols,
    Vt = Object.prototype.hasOwnProperty,
    Nt = Object.prototype.propertyIsEnumerable,
    J = (t, e, r) =>
      e in t
        ? Lt(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r })
        : (t[e] = r),
    ee = (t, e) => {
      for (var r in e || (e = {})) Vt.call(e, r) && J(t, r, e[r]);
      if (Q) for (var r of Q(e)) Nt.call(e, r) && J(t, r, e[r]);
      return t;
    };
  const O = class extends a.Filter {
    constructor(t) {
      super(),
        (this.angle = 45),
        (this._distance = 5),
        (this._resolution = a.settings.FILTER_RESOLUTION);
      const e = t ? ee(ee({}, O.defaults), t) : O.defaults,
        { kernels: r, blur: i, quality: o, pixelSize: s, resolution: n } = e;
      (this._offset = new a.ObservablePoint(this._updatePadding, this)),
        (this._tintFilter = new a.Filter(jt, It)),
        (this._tintFilter.uniforms.color = new Float32Array(4)),
        (this._tintFilter.uniforms.shift = this._offset),
        (this._tintFilter.resolution = n),
        (this._blurFilter = r ? new T(r) : new T(i, o)),
        (this.pixelSize = s),
        (this.resolution = n);
      const {
        shadowOnly: l,
        rotation: u,
        distance: h,
        offset: p,
        alpha: S,
        color: g,
      } = e;
      (this.shadowOnly = l),
        u !== void 0 && h !== void 0
          ? ((this.rotation = u), (this.distance = h))
          : (this.offset = p),
        (this.alpha = S),
        (this.color = g);
    }
    apply(t, e, r, i) {
      const o = t.getFilterTexture();
      this._tintFilter.apply(t, e, o, 1),
        this._blurFilter.apply(t, o, r, i),
        this.shadowOnly !== !0 && t.applyFilter(this, e, r, 0),
        t.returnFilterTexture(o);
    }
    _updatePadding() {
      const t = Math.max(Math.abs(this._offset.x), Math.abs(this._offset.y));
      this.padding = t + this.blur * 2;
    }
    _updateShift() {
      this._tintFilter.uniforms.shift.set(
        this.distance * Math.cos(this.angle),
        this.distance * Math.sin(this.angle)
      );
    }
    set offset(t) {
      this._offset.copyFrom(t), this._updatePadding();
    }
    get offset() {
      return this._offset;
    }
    get resolution() {
      return this._resolution;
    }
    set resolution(t) {
      (this._resolution = t),
        this._tintFilter && (this._tintFilter.resolution = t),
        this._blurFilter && (this._blurFilter.resolution = t);
    }
    get distance() {
      return this._distance;
    }
    set distance(t) {
      a.utils.deprecation(
        "5.3.0",
        "DropShadowFilter distance is deprecated, use offset"
      ),
        (this._distance = t),
        this._updatePadding(),
        this._updateShift();
    }
    get rotation() {
      return this.angle / a.DEG_TO_RAD;
    }
    set rotation(t) {
      a.utils.deprecation(
        "5.3.0",
        "DropShadowFilter rotation is deprecated, use offset"
      ),
        (this.angle = t * a.DEG_TO_RAD),
        this._updateShift();
    }
    get alpha() {
      return this._tintFilter.uniforms.alpha;
    }
    set alpha(t) {
      this._tintFilter.uniforms.alpha = t;
    }
    get color() {
      return a.utils.rgb2hex(this._tintFilter.uniforms.color);
    }
    set color(t) {
      a.utils.hex2rgb(t, this._tintFilter.uniforms.color);
    }
    get kernels() {
      return this._blurFilter.kernels;
    }
    set kernels(t) {
      this._blurFilter.kernels = t;
    }
    get blur() {
      return this._blurFilter.blur;
    }
    set blur(t) {
      (this._blurFilter.blur = t), this._updatePadding();
    }
    get quality() {
      return this._blurFilter.quality;
    }
    set quality(t) {
      this._blurFilter.quality = t;
    }
    get pixelSize() {
      return this._blurFilter.pixelSize;
    }
    set pixelSize(t) {
      this._blurFilter.pixelSize = t;
    }
  };
  let te = O;
  te.defaults = {
    offset: { x: 4, y: 4 },
    color: 0,
    alpha: 0.5,
    shadowOnly: !1,
    kernels: null,
    blur: 2,
    quality: 3,
    pixelSize: 1,
    resolution: a.settings.FILTER_RESOLUTION,
  };
  var Gt = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    Bt = `precision mediump float;

varying vec2 vTextureCoord;

uniform sampler2D uSampler;
uniform float strength;
uniform vec4 filterArea;

void main(void)
{
	vec2 onePixel = vec2(1.0 / filterArea);

	vec4 color;

	color.rgb = vec3(0.5);

	color -= texture2D(uSampler, vTextureCoord - onePixel) * strength;
	color += texture2D(uSampler, vTextureCoord + onePixel) * strength;

	color.rgb = vec3((color.r + color.g + color.b) / 3.0);

	float alpha = texture2D(uSampler, vTextureCoord).a;

	gl_FragColor = vec4(color.rgb * alpha, alpha);
}
`;
  class Xt extends a.Filter {
    constructor(e = 5) {
      super(Gt, Bt), (this.strength = e);
    }
    get strength() {
      return this.uniforms.strength;
    }
    set strength(e) {
      this.uniforms.strength = e;
    }
  }
  var qt = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    Kt = `// precision highp float;

varying vec2 vTextureCoord;
uniform sampler2D uSampler;

uniform vec4 filterArea;
uniform vec4 filterClamp;
uniform vec2 dimensions;
uniform float aspect;

uniform sampler2D displacementMap;
uniform float offset;
uniform float sinDir;
uniform float cosDir;
uniform int fillMode;

uniform float seed;
uniform vec2 red;
uniform vec2 green;
uniform vec2 blue;

const int TRANSPARENT = 0;
const int ORIGINAL = 1;
const int LOOP = 2;
const int CLAMP = 3;
const int MIRROR = 4;

void main(void)
{
    vec2 coord = (vTextureCoord * filterArea.xy) / dimensions;

    if (coord.x > 1.0 || coord.y > 1.0) {
        return;
    }

    float cx = coord.x - 0.5;
    float cy = (coord.y - 0.5) * aspect;
    float ny = (-sinDir * cx + cosDir * cy) / aspect + 0.5;

    // displacementMap: repeat
    // ny = ny > 1.0 ? ny - 1.0 : (ny < 0.0 ? 1.0 + ny : ny);

    // displacementMap: mirror
    ny = ny > 1.0 ? 2.0 - ny : (ny < 0.0 ? -ny : ny);

    vec4 dc = texture2D(displacementMap, vec2(0.5, ny));

    float displacement = (dc.r - dc.g) * (offset / filterArea.x);

    coord = vTextureCoord + vec2(cosDir * displacement, sinDir * displacement * aspect);

    if (fillMode == CLAMP) {
        coord = clamp(coord, filterClamp.xy, filterClamp.zw);
    } else {
        if( coord.x > filterClamp.z ) {
            if (fillMode == TRANSPARENT) {
                discard;
            } else if (fillMode == LOOP) {
                coord.x -= filterClamp.z;
            } else if (fillMode == MIRROR) {
                coord.x = filterClamp.z * 2.0 - coord.x;
            }
        } else if( coord.x < filterClamp.x ) {
            if (fillMode == TRANSPARENT) {
                discard;
            } else if (fillMode == LOOP) {
                coord.x += filterClamp.z;
            } else if (fillMode == MIRROR) {
                coord.x *= -filterClamp.z;
            }
        }

        if( coord.y > filterClamp.w ) {
            if (fillMode == TRANSPARENT) {
                discard;
            } else if (fillMode == LOOP) {
                coord.y -= filterClamp.w;
            } else if (fillMode == MIRROR) {
                coord.y = filterClamp.w * 2.0 - coord.y;
            }
        } else if( coord.y < filterClamp.y ) {
            if (fillMode == TRANSPARENT) {
                discard;
            } else if (fillMode == LOOP) {
                coord.y += filterClamp.w;
            } else if (fillMode == MIRROR) {
                coord.y *= -filterClamp.w;
            }
        }
    }

    gl_FragColor.r = texture2D(uSampler, coord + red * (1.0 - seed * 0.4) / filterArea.xy).r;
    gl_FragColor.g = texture2D(uSampler, coord + green * (1.0 - seed * 0.3) / filterArea.xy).g;
    gl_FragColor.b = texture2D(uSampler, coord + blue * (1.0 - seed * 0.2) / filterArea.xy).b;
    gl_FragColor.a = texture2D(uSampler, coord).a;
}
`;
  const R = class extends a.Filter {
    constructor(t) {
      super(qt, Kt),
        (this.offset = 100),
        (this.fillMode = R.TRANSPARENT),
        (this.average = !1),
        (this.seed = 0),
        (this.minSize = 8),
        (this.sampleSize = 512),
        (this._slices = 0),
        (this._offsets = new Float32Array(1)),
        (this._sizes = new Float32Array(1)),
        (this._direction = -1),
        (this.uniforms.dimensions = new Float32Array(2)),
        (this._canvas = document.createElement("canvas")),
        (this._canvas.width = 4),
        (this._canvas.height = this.sampleSize),
        (this.texture = a.Texture.from(this._canvas, {
          scaleMode: a.SCALE_MODES.NEAREST,
        })),
        Object.assign(this, R.defaults, t);
    }
    apply(t, e, r, i) {
      const { width: o, height: s } = e.filterFrame;
      (this.uniforms.dimensions[0] = o),
        (this.uniforms.dimensions[1] = s),
        (this.uniforms.aspect = s / o),
        (this.uniforms.seed = this.seed),
        (this.uniforms.offset = this.offset),
        (this.uniforms.fillMode = this.fillMode),
        t.applyFilter(this, e, r, i);
    }
    _randomizeSizes() {
      const t = this._sizes,
        e = this._slices - 1,
        r = this.sampleSize,
        i = Math.min(this.minSize / r, 0.9 / this._slices);
      if (this.average) {
        const o = this._slices;
        let s = 1;
        for (let n = 0; n < e; n++) {
          const l = s / (o - n),
            u = Math.max(l * (1 - Math.random() * 0.6), i);
          (t[n] = u), (s -= u);
        }
        t[e] = s;
      } else {
        let o = 1;
        const s = Math.sqrt(1 / this._slices);
        for (let n = 0; n < e; n++) {
          const l = Math.max(s * o * Math.random(), i);
          (t[n] = l), (o -= l);
        }
        t[e] = o;
      }
      this.shuffle();
    }
    shuffle() {
      const t = this._sizes,
        e = this._slices - 1;
      for (let r = e; r > 0; r--) {
        const i = (Math.random() * r) >> 0,
          o = t[r];
        (t[r] = t[i]), (t[i] = o);
      }
    }
    _randomizeOffsets() {
      for (let t = 0; t < this._slices; t++)
        this._offsets[t] = Math.random() * (Math.random() < 0.5 ? -1 : 1);
    }
    refresh() {
      this._randomizeSizes(), this._randomizeOffsets(), this.redraw();
    }
    redraw() {
      const t = this.sampleSize,
        e = this.texture,
        r = this._canvas.getContext("2d");
      r.clearRect(0, 0, 8, t);
      let i,
        o = 0;
      for (let s = 0; s < this._slices; s++) {
        i = Math.floor(this._offsets[s] * 256);
        const n = this._sizes[s] * t,
          l = i > 0 ? i : 0,
          u = i < 0 ? -i : 0;
        (r.fillStyle = `rgba(${l}, ${u}, 0, 1)`),
          r.fillRect(0, o >> 0, t, (n + 1) >> 0),
          (o += n);
      }
      e.baseTexture.update(), (this.uniforms.displacementMap = e);
    }
    set sizes(t) {
      const e = Math.min(this._slices, t.length);
      for (let r = 0; r < e; r++) this._sizes[r] = t[r];
    }
    get sizes() {
      return this._sizes;
    }
    set offsets(t) {
      const e = Math.min(this._slices, t.length);
      for (let r = 0; r < e; r++) this._offsets[r] = t[r];
    }
    get offsets() {
      return this._offsets;
    }
    get slices() {
      return this._slices;
    }
    set slices(t) {
      this._slices !== t &&
        ((this._slices = t),
        (this.uniforms.slices = t),
        (this._sizes = this.uniforms.slicesWidth = new Float32Array(t)),
        (this._offsets = this.uniforms.slicesOffset = new Float32Array(t)),
        this.refresh());
    }
    get direction() {
      return this._direction;
    }
    set direction(t) {
      if (this._direction === t) return;
      this._direction = t;
      const e = t * a.DEG_TO_RAD;
      (this.uniforms.sinDir = Math.sin(e)),
        (this.uniforms.cosDir = Math.cos(e));
    }
    get red() {
      return this.uniforms.red;
    }
    set red(t) {
      this.uniforms.red = t;
    }
    get green() {
      return this.uniforms.green;
    }
    set green(t) {
      this.uniforms.green = t;
    }
    get blue() {
      return this.uniforms.blue;
    }
    set blue(t) {
      this.uniforms.blue = t;
    }
    destroy() {
      var t;
      (t = this.texture) == null || t.destroy(!0),
        (this.texture =
          this._canvas =
          this.red =
          this.green =
          this.blue =
          this._sizes =
          this._offsets =
            null);
    }
  };
  let b = R;
  (b.defaults = {
    slices: 5,
    offset: 100,
    direction: 0,
    fillMode: 0,
    average: !1,
    seed: 0,
    red: [0, 0],
    green: [0, 0],
    blue: [0, 0],
    minSize: 8,
    sampleSize: 512,
  }),
    (b.TRANSPARENT = 0),
    (b.ORIGINAL = 1),
    (b.LOOP = 2),
    (b.CLAMP = 3),
    (b.MIRROR = 4);
  var Wt = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    Yt = `varying vec2 vTextureCoord;
varying vec4 vColor;

uniform sampler2D uSampler;

uniform float outerStrength;
uniform float innerStrength;

uniform vec4 glowColor;

uniform vec4 filterArea;
uniform vec4 filterClamp;
uniform bool knockout;
uniform float alpha;

const float PI = 3.14159265358979323846264;

const float DIST = __DIST__;
const float ANGLE_STEP_SIZE = min(__ANGLE_STEP_SIZE__, PI * 2.0);
const float ANGLE_STEP_NUM = ceil(PI * 2.0 / ANGLE_STEP_SIZE);

const float MAX_TOTAL_ALPHA = ANGLE_STEP_NUM * DIST * (DIST + 1.0) / 2.0;

void main(void) {
    vec2 px = vec2(1.0 / filterArea.x, 1.0 / filterArea.y);

    float totalAlpha = 0.0;

    vec2 direction;
    vec2 displaced;
    vec4 curColor;

    for (float angle = 0.0; angle < PI * 2.0; angle += ANGLE_STEP_SIZE) {
       direction = vec2(cos(angle), sin(angle)) * px;

       for (float curDistance = 0.0; curDistance < DIST; curDistance++) {
           displaced = clamp(vTextureCoord + direction *
                   (curDistance + 1.0), filterClamp.xy, filterClamp.zw);

           curColor = texture2D(uSampler, displaced);

           totalAlpha += (DIST - curDistance) * curColor.a;
       }
    }

    curColor = texture2D(uSampler, vTextureCoord);

    float alphaRatio = (totalAlpha / MAX_TOTAL_ALPHA);

    float innerGlowAlpha = (1.0 - alphaRatio) * innerStrength * curColor.a;
    float innerGlowStrength = min(1.0, innerGlowAlpha);

    vec4 innerColor = mix(curColor, glowColor, innerGlowStrength);

    float outerGlowAlpha = alphaRatio * outerStrength * (1. - curColor.a);
    float outerGlowStrength = min(1.0 - innerColor.a, outerGlowAlpha);

    if (knockout) {
      float resultAlpha = (outerGlowAlpha + innerGlowAlpha) * alpha;
      gl_FragColor = vec4(glowColor.rgb * resultAlpha, resultAlpha);
    }
    else {
      vec4 outerGlowColor = outerGlowStrength * glowColor.rgba * alpha;
      gl_FragColor = innerColor + outerGlowColor;
    }
}
`;
  const re = class extends a.Filter {
    constructor(t) {
      const e = Object.assign({}, re.defaults, t),
        {
          outerStrength: r,
          innerStrength: i,
          color: o,
          knockout: s,
          quality: n,
          alpha: l,
        } = e,
        u = Math.round(e.distance);
      super(
        Wt,
        Yt.replace(
          /__ANGLE_STEP_SIZE__/gi,
          `${(1 / n / u).toFixed(7)}`
        ).replace(/__DIST__/gi, `${u.toFixed(0)}.0`)
      ),
        (this.uniforms.glowColor = new Float32Array([0, 0, 0, 1])),
        (this.uniforms.alpha = 1),
        Object.assign(this, {
          color: o,
          outerStrength: r,
          innerStrength: i,
          padding: u,
          knockout: s,
          alpha: l,
        });
    }
    get color() {
      return a.utils.rgb2hex(this.uniforms.glowColor);
    }
    set color(t) {
      a.utils.hex2rgb(t, this.uniforms.glowColor);
    }
    get outerStrength() {
      return this.uniforms.outerStrength;
    }
    set outerStrength(t) {
      this.uniforms.outerStrength = t;
    }
    get innerStrength() {
      return this.uniforms.innerStrength;
    }
    set innerStrength(t) {
      this.uniforms.innerStrength = t;
    }
    get knockout() {
      return this.uniforms.knockout;
    }
    set knockout(t) {
      this.uniforms.knockout = t;
    }
    get alpha() {
      return this.uniforms.alpha;
    }
    set alpha(t) {
      this.uniforms.alpha = t;
    }
  };
  let ie = re;
  ie.defaults = {
    distance: 10,
    outerStrength: 4,
    innerStrength: 0,
    color: 16777215,
    quality: 0.1,
    knockout: !1,
    alpha: 1,
  };
  var Ut = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    Zt = `vec3 mod289(vec3 x)
{
    return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec4 mod289(vec4 x)
{
    return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec4 permute(vec4 x)
{
    return mod289(((x * 34.0) + 1.0) * x);
}
vec4 taylorInvSqrt(vec4 r)
{
    return 1.79284291400159 - 0.85373472095314 * r;
}
vec3 fade(vec3 t)
{
    return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
}
// Classic Perlin noise, periodic variant
float pnoise(vec3 P, vec3 rep)
{
    vec3 Pi0 = mod(floor(P), rep); // Integer part, modulo period
    vec3 Pi1 = mod(Pi0 + vec3(1.0), rep); // Integer part + 1, mod period
    Pi0 = mod289(Pi0);
    Pi1 = mod289(Pi1);
    vec3 Pf0 = fract(P); // Fractional part for interpolation
    vec3 Pf1 = Pf0 - vec3(1.0); // Fractional part - 1.0
    vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
    vec4 iy = vec4(Pi0.yy, Pi1.yy);
    vec4 iz0 = Pi0.zzzz;
    vec4 iz1 = Pi1.zzzz;
    vec4 ixy = permute(permute(ix) + iy);
    vec4 ixy0 = permute(ixy + iz0);
    vec4 ixy1 = permute(ixy + iz1);
    vec4 gx0 = ixy0 * (1.0 / 7.0);
    vec4 gy0 = fract(floor(gx0) * (1.0 / 7.0)) - 0.5;
    gx0 = fract(gx0);
    vec4 gz0 = vec4(0.5) - abs(gx0) - abs(gy0);
    vec4 sz0 = step(gz0, vec4(0.0));
    gx0 -= sz0 * (step(0.0, gx0) - 0.5);
    gy0 -= sz0 * (step(0.0, gy0) - 0.5);
    vec4 gx1 = ixy1 * (1.0 / 7.0);
    vec4 gy1 = fract(floor(gx1) * (1.0 / 7.0)) - 0.5;
    gx1 = fract(gx1);
    vec4 gz1 = vec4(0.5) - abs(gx1) - abs(gy1);
    vec4 sz1 = step(gz1, vec4(0.0));
    gx1 -= sz1 * (step(0.0, gx1) - 0.5);
    gy1 -= sz1 * (step(0.0, gy1) - 0.5);
    vec3 g000 = vec3(gx0.x, gy0.x, gz0.x);
    vec3 g100 = vec3(gx0.y, gy0.y, gz0.y);
    vec3 g010 = vec3(gx0.z, gy0.z, gz0.z);
    vec3 g110 = vec3(gx0.w, gy0.w, gz0.w);
    vec3 g001 = vec3(gx1.x, gy1.x, gz1.x);
    vec3 g101 = vec3(gx1.y, gy1.y, gz1.y);
    vec3 g011 = vec3(gx1.z, gy1.z, gz1.z);
    vec3 g111 = vec3(gx1.w, gy1.w, gz1.w);
    vec4 norm0 = taylorInvSqrt(vec4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
    g000 *= norm0.x;
    g010 *= norm0.y;
    g100 *= norm0.z;
    g110 *= norm0.w;
    vec4 norm1 = taylorInvSqrt(vec4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
    g001 *= norm1.x;
    g011 *= norm1.y;
    g101 *= norm1.z;
    g111 *= norm1.w;
    float n000 = dot(g000, Pf0);
    float n100 = dot(g100, vec3(Pf1.x, Pf0.yz));
    float n010 = dot(g010, vec3(Pf0.x, Pf1.y, Pf0.z));
    float n110 = dot(g110, vec3(Pf1.xy, Pf0.z));
    float n001 = dot(g001, vec3(Pf0.xy, Pf1.z));
    float n101 = dot(g101, vec3(Pf1.x, Pf0.y, Pf1.z));
    float n011 = dot(g011, vec3(Pf0.x, Pf1.yz));
    float n111 = dot(g111, Pf1);
    vec3 fade_xyz = fade(Pf0);
    vec4 n_z = mix(vec4(n000, n100, n010, n110), vec4(n001, n101, n011, n111), fade_xyz.z);
    vec2 n_yz = mix(n_z.xy, n_z.zw, fade_xyz.y);
    float n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);
    return 2.2 * n_xyz;
}
float turb(vec3 P, vec3 rep, float lacunarity, float gain)
{
    float sum = 0.0;
    float sc = 1.0;
    float totalgain = 1.0;
    for (float i = 0.0; i < 6.0; i++)
    {
        sum += totalgain * pnoise(P * sc, rep);
        sc *= lacunarity;
        totalgain *= gain;
    }
    return abs(sum);
}
`,
    Ht = `varying vec2 vTextureCoord;
uniform sampler2D uSampler;
uniform vec4 filterArea;
uniform vec2 dimensions;

uniform vec2 light;
uniform bool parallel;
uniform float aspect;

uniform float gain;
uniform float lacunarity;
uniform float time;
uniform float alpha;

\${perlin}

void main(void) {
    vec2 coord = vTextureCoord * filterArea.xy / dimensions.xy;

    float d;

    if (parallel) {
        float _cos = light.x;
        float _sin = light.y;
        d = (_cos * coord.x) + (_sin * coord.y * aspect);
    } else {
        float dx = coord.x - light.x / dimensions.x;
        float dy = (coord.y - light.y / dimensions.y) * aspect;
        float dis = sqrt(dx * dx + dy * dy) + 0.00001;
        d = dy / dis;
    }

    vec3 dir = vec3(d, d, 0.0);

    float noise = turb(dir + vec3(time, 0.0, 62.1 + time) * 0.05, vec3(480.0, 320.0, 480.0), lacunarity, gain);
    noise = mix(noise, 0.0, 0.3);
    //fade vertically.
    vec4 mist = vec4(noise, noise, noise, 1.0) * (1.0 - coord.y);
    mist.a = 1.0;
    // apply user alpha
    mist *= alpha;

    gl_FragColor = texture2D(uSampler, vTextureCoord) + mist;

}
`;
  const oe = class extends a.Filter {
    constructor(t) {
      super(Ut, Ht.replace("${perlin}", Zt)),
        (this.parallel = !0),
        (this.time = 0),
        (this._angle = 0),
        (this.uniforms.dimensions = new Float32Array(2));
      const e = Object.assign(oe.defaults, t);
      (this._angleLight = new a.Point()),
        (this.angle = e.angle),
        (this.gain = e.gain),
        (this.lacunarity = e.lacunarity),
        (this.alpha = e.alpha),
        (this.parallel = e.parallel),
        (this.center = e.center),
        (this.time = e.time);
    }
    apply(t, e, r, i) {
      const { width: o, height: s } = e.filterFrame;
      (this.uniforms.light = this.parallel ? this._angleLight : this.center),
        (this.uniforms.parallel = this.parallel),
        (this.uniforms.dimensions[0] = o),
        (this.uniforms.dimensions[1] = s),
        (this.uniforms.aspect = s / o),
        (this.uniforms.time = this.time),
        (this.uniforms.alpha = this.alpha),
        t.applyFilter(this, e, r, i);
    }
    get angle() {
      return this._angle;
    }
    set angle(t) {
      this._angle = t;
      const e = t * a.DEG_TO_RAD;
      (this._angleLight.x = Math.cos(e)), (this._angleLight.y = Math.sin(e));
    }
    get gain() {
      return this.uniforms.gain;
    }
    set gain(t) {
      this.uniforms.gain = t;
    }
    get lacunarity() {
      return this.uniforms.lacunarity;
    }
    set lacunarity(t) {
      this.uniforms.lacunarity = t;
    }
    get alpha() {
      return this.uniforms.alpha;
    }
    set alpha(t) {
      this.uniforms.alpha = t;
    }
  };
  let se = oe;
  se.defaults = {
    angle: 30,
    gain: 0.5,
    lacunarity: 2.5,
    time: 0,
    parallel: !0,
    center: [0, 0],
    alpha: 1,
  };
  var Qt = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    Jt = `precision mediump float;

varying vec2 vTextureCoord;
uniform sampler2D uSampler;

// https://en.wikipedia.org/wiki/Luma_(video)
const vec3 weight = vec3(0.299, 0.587, 0.114);

void main()
{
    vec4 color = texture2D(uSampler, vTextureCoord);
    gl_FragColor = vec4(
        vec3(color.r * weight.r + color.g * weight.g  + color.b * weight.b),
        color.a
    );
}
`;
  class er extends a.Filter {
    constructor() {
      super(Qt, Jt);
    }
  }
  var tr = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    rr = `precision mediump float;

varying vec2 vTextureCoord;
uniform sampler2D uSampler;
uniform float uHue;
uniform float uAlpha;
uniform bool uColorize;
uniform float uSaturation;
uniform float uLightness;

// https://en.wikipedia.org/wiki/Luma_(video)
const vec3 weight = vec3(0.299, 0.587, 0.114);

float getWeightedAverage(vec3 rgb) {
    return rgb.r * weight.r + rgb.g * weight.g + rgb.b * weight.b;
}

// https://gist.github.com/mairod/a75e7b44f68110e1576d77419d608786?permalink_comment_id=3195243#gistcomment-3195243
const vec3 k = vec3(0.57735, 0.57735, 0.57735);

vec3 hueShift(vec3 color, float angle) {
    float cosAngle = cos(angle);
    return vec3(
    color * cosAngle +
    cross(k, color) * sin(angle) +
    k * dot(k, color) * (1.0 - cosAngle)
    );
}

void main()
{
    vec4 color = texture2D(uSampler, vTextureCoord);
    vec4 result = color;

    // colorize
    if (uColorize) {
        result.rgb = vec3(getWeightedAverage(result.rgb), 0., 0.);
    }

    // hue
    result.rgb = hueShift(result.rgb, uHue);

    // saturation
    // https://github.com/evanw/glfx.js/blob/master/src/filters/adjust/huesaturation.js
    float average = (result.r + result.g + result.b) / 3.0;

    if (uSaturation > 0.) {
        result.rgb += (average - result.rgb) * (1. - 1. / (1.001 - uSaturation));
    } else {
        result.rgb -= (average - result.rgb) * uSaturation;
    }

    // lightness
    result.rgb = mix(result.rgb, vec3(ceil(uLightness)) * color.a, abs(uLightness));

    // alpha
    gl_FragColor = mix(color, result, uAlpha);
}
`;
  const ae = class extends a.Filter {
    constructor(t) {
      super(tr, rr), (this._hue = 0);
      const e = Object.assign({}, ae.defaults, t);
      Object.assign(this, e);
    }
    get hue() {
      return this._hue;
    }
    set hue(t) {
      (this._hue = t), (this.uniforms.uHue = this._hue * (Math.PI / 180));
    }
    get alpha() {
      return this.uniforms.uAlpha;
    }
    set alpha(t) {
      this.uniforms.uAlpha = t;
    }
    get colorize() {
      return this.uniforms.uColorize;
    }
    set colorize(t) {
      this.uniforms.uColorize = t;
    }
    get lightness() {
      return this.uniforms.uLightness;
    }
    set lightness(t) {
      this.uniforms.uLightness = t;
    }
    get saturation() {
      return this.uniforms.uSaturation;
    }
    set saturation(t) {
      this.uniforms.uSaturation = t;
    }
  };
  let ne = ae;
  ne.defaults = { hue: 0, saturation: 0, lightness: 0, colorize: !1, alpha: 1 };
  var ir = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    or = `varying vec2 vTextureCoord;
uniform sampler2D uSampler;
uniform vec4 filterArea;

uniform vec2 uVelocity;
uniform int uKernelSize;
uniform float uOffset;

const int MAX_KERNEL_SIZE = 2048;

// Notice:
// the perfect way:
//    int kernelSize = min(uKernelSize, MAX_KERNELSIZE);
// BUT in real use-case , uKernelSize < MAX_KERNELSIZE almost always.
// So use uKernelSize directly.

void main(void)
{
    vec4 color = texture2D(uSampler, vTextureCoord);

    if (uKernelSize == 0)
    {
        gl_FragColor = color;
        return;
    }

    vec2 velocity = uVelocity / filterArea.xy;
    float offset = -uOffset / length(uVelocity) - 0.5;
    int k = uKernelSize - 1;

    for(int i = 0; i < MAX_KERNEL_SIZE - 1; i++) {
        if (i == k) {
            break;
        }
        vec2 bias = velocity * (float(i) / float(k) + offset);
        color += texture2D(uSampler, vTextureCoord + bias);
    }
    gl_FragColor = color / float(uKernelSize);
}
`;
  class sr extends a.Filter {
    constructor(e = [0, 0], r = 5, i = 0) {
      super(ir, or),
        (this.kernelSize = 5),
        (this.uniforms.uVelocity = new Float32Array(2)),
        (this._velocity = new a.ObservablePoint(this.velocityChanged, this)),
        this.setVelocity(e),
        (this.kernelSize = r),
        (this.offset = i);
    }
    apply(e, r, i, o) {
      const { x: s, y: n } = this.velocity;
      (this.uniforms.uKernelSize = s !== 0 || n !== 0 ? this.kernelSize : 0),
        e.applyFilter(this, r, i, o);
    }
    set velocity(e) {
      this.setVelocity(e);
    }
    get velocity() {
      return this._velocity;
    }
    setVelocity(e) {
      if (Array.isArray(e)) {
        const [r, i] = e;
        this._velocity.set(r, i);
      } else this._velocity.copyFrom(e);
    }
    velocityChanged() {
      (this.uniforms.uVelocity[0] = this._velocity.x),
        (this.uniforms.uVelocity[1] = this._velocity.y),
        (this.padding =
          (Math.max(Math.abs(this._velocity.x), Math.abs(this._velocity.y)) >>
            0) +
          1);
    }
    set offset(e) {
      this.uniforms.uOffset = e;
    }
    get offset() {
      return this.uniforms.uOffset;
    }
  }
  var ar = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    nr = `varying vec2 vTextureCoord;
uniform sampler2D uSampler;

uniform float epsilon;

const int MAX_COLORS = %maxColors%;

uniform vec3 originalColors[MAX_COLORS];
uniform vec3 targetColors[MAX_COLORS];

void main(void)
{
    gl_FragColor = texture2D(uSampler, vTextureCoord);

    float alpha = gl_FragColor.a;
    if (alpha < 0.0001)
    {
      return;
    }

    vec3 color = gl_FragColor.rgb / alpha;

    for(int i = 0; i < MAX_COLORS; i++)
    {
      vec3 origColor = originalColors[i];
      if (origColor.r < 0.0)
      {
        break;
      }
      vec3 colorDiff = origColor - color;
      if (length(colorDiff) < epsilon)
      {
        vec3 targetColor = targetColors[i];
        gl_FragColor = vec4((targetColor + colorDiff) * alpha, alpha);
        return;
      }
    }
}
`;
  class lr extends a.Filter {
    constructor(e, r = 0.05, i = e.length) {
      super(ar, nr.replace(/%maxColors%/g, i.toFixed(0))),
        (this._replacements = []),
        (this._maxColors = 0),
        (this.epsilon = r),
        (this._maxColors = i),
        (this.uniforms.originalColors = new Float32Array(i * 3)),
        (this.uniforms.targetColors = new Float32Array(i * 3)),
        (this.replacements = e);
    }
    set replacements(e) {
      const r = this.uniforms.originalColors,
        i = this.uniforms.targetColors,
        o = e.length;
      if (o > this._maxColors)
        throw new Error(
          `Length of replacements (${o}) exceeds the maximum colors length (${this._maxColors})`
        );
      r[o * 3] = -1;
      for (let s = 0; s < o; s++) {
        const n = e[s];
        let l = n[0];
        typeof l == "number"
          ? (l = a.utils.hex2rgb(l))
          : (n[0] = a.utils.rgb2hex(l)),
          (r[s * 3] = l[0]),
          (r[s * 3 + 1] = l[1]),
          (r[s * 3 + 2] = l[2]);
        let u = n[1];
        typeof u == "number"
          ? (u = a.utils.hex2rgb(u))
          : (n[1] = a.utils.rgb2hex(u)),
          (i[s * 3] = u[0]),
          (i[s * 3 + 1] = u[1]),
          (i[s * 3 + 2] = u[2]);
      }
      this._replacements = e;
    }
    get replacements() {
      return this._replacements;
    }
    refresh() {
      this.replacements = this._replacements;
    }
    get maxColors() {
      return this._maxColors;
    }
    set epsilon(e) {
      this.uniforms.epsilon = e;
    }
    get epsilon() {
      return this.uniforms.epsilon;
    }
  }
  var ur = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    cr = `varying vec2 vTextureCoord;
uniform sampler2D uSampler;
uniform vec4 filterArea;
uniform vec2 dimensions;

uniform float sepia;
uniform float noise;
uniform float noiseSize;
uniform float scratch;
uniform float scratchDensity;
uniform float scratchWidth;
uniform float vignetting;
uniform float vignettingAlpha;
uniform float vignettingBlur;
uniform float seed;

const float SQRT_2 = 1.414213;
const vec3 SEPIA_RGB = vec3(112.0 / 255.0, 66.0 / 255.0, 20.0 / 255.0);

float rand(vec2 co) {
    return fract(sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453);
}

vec3 Overlay(vec3 src, vec3 dst)
{
    // if (dst <= 0.5) then: 2 * src * dst
    // if (dst > 0.5) then: 1 - 2 * (1 - dst) * (1 - src)
    return vec3((dst.x <= 0.5) ? (2.0 * src.x * dst.x) : (1.0 - 2.0 * (1.0 - dst.x) * (1.0 - src.x)),
                (dst.y <= 0.5) ? (2.0 * src.y * dst.y) : (1.0 - 2.0 * (1.0 - dst.y) * (1.0 - src.y)),
                (dst.z <= 0.5) ? (2.0 * src.z * dst.z) : (1.0 - 2.0 * (1.0 - dst.z) * (1.0 - src.z)));
}

void main()
{
    gl_FragColor = texture2D(uSampler, vTextureCoord);
    vec3 color = gl_FragColor.rgb;

    if (sepia > 0.0)
    {
        float gray = (color.x + color.y + color.z) / 3.0;
        vec3 grayscale = vec3(gray);

        color = Overlay(SEPIA_RGB, grayscale);

        color = grayscale + sepia * (color - grayscale);
    }

    vec2 coord = vTextureCoord * filterArea.xy / dimensions.xy;

    if (vignetting > 0.0)
    {
        float outter = SQRT_2 - vignetting * SQRT_2;
        vec2 dir = vec2(vec2(0.5, 0.5) - coord);
        dir.y *= dimensions.y / dimensions.x;
        float darker = clamp((outter - length(dir) * SQRT_2) / ( 0.00001 + vignettingBlur * SQRT_2), 0.0, 1.0);
        color.rgb *= darker + (1.0 - darker) * (1.0 - vignettingAlpha);
    }

    if (scratchDensity > seed && scratch != 0.0)
    {
        float phase = seed * 256.0;
        float s = mod(floor(phase), 2.0);
        float dist = 1.0 / scratchDensity;
        float d = distance(coord, vec2(seed * dist, abs(s - seed * dist)));
        if (d < seed * 0.6 + 0.4)
        {
            highp float period = scratchDensity * 10.0;

            float xx = coord.x * period + phase;
            float aa = abs(mod(xx, 0.5) * 4.0);
            float bb = mod(floor(xx / 0.5), 2.0);
            float yy = (1.0 - bb) * aa + bb * (2.0 - aa);

            float kk = 2.0 * period;
            float dw = scratchWidth / dimensions.x * (0.75 + seed);
            float dh = dw * kk;

            float tine = (yy - (2.0 - dh));

            if (tine > 0.0) {
                float _sign = sign(scratch);

                tine = s * tine / period + scratch + 0.1;
                tine = clamp(tine + 1.0, 0.5 + _sign * 0.5, 1.5 + _sign * 0.5);

                color.rgb *= tine;
            }
        }
    }

    if (noise > 0.0 && noiseSize > 0.0)
    {
        vec2 pixelCoord = vTextureCoord.xy * filterArea.xy;
        pixelCoord.x = floor(pixelCoord.x / noiseSize);
        pixelCoord.y = floor(pixelCoord.y / noiseSize);
        // vec2 d = pixelCoord * noiseSize * vec2(1024.0 + seed * 512.0, 1024.0 - seed * 512.0);
        // float _noise = snoise(d) * 0.5;
        float _noise = rand(pixelCoord * noiseSize * seed) - 0.5;
        color += _noise * noise;
    }

    gl_FragColor.rgb = color;
}
`;
  const le = class extends a.Filter {
    constructor(t, e = 0) {
      super(ur, cr),
        (this.seed = 0),
        (this.uniforms.dimensions = new Float32Array(2)),
        typeof t == "number"
          ? ((this.seed = t), (t = void 0))
          : (this.seed = e),
        Object.assign(this, le.defaults, t);
    }
    apply(t, e, r, i) {
      var o, s;
      (this.uniforms.dimensions[0] =
        (o = e.filterFrame) == null ? void 0 : o.width),
        (this.uniforms.dimensions[1] =
          (s = e.filterFrame) == null ? void 0 : s.height),
        (this.uniforms.seed = this.seed),
        t.applyFilter(this, e, r, i);
    }
    set sepia(t) {
      this.uniforms.sepia = t;
    }
    get sepia() {
      return this.uniforms.sepia;
    }
    set noise(t) {
      this.uniforms.noise = t;
    }
    get noise() {
      return this.uniforms.noise;
    }
    set noiseSize(t) {
      this.uniforms.noiseSize = t;
    }
    get noiseSize() {
      return this.uniforms.noiseSize;
    }
    set scratch(t) {
      this.uniforms.scratch = t;
    }
    get scratch() {
      return this.uniforms.scratch;
    }
    set scratchDensity(t) {
      this.uniforms.scratchDensity = t;
    }
    get scratchDensity() {
      return this.uniforms.scratchDensity;
    }
    set scratchWidth(t) {
      this.uniforms.scratchWidth = t;
    }
    get scratchWidth() {
      return this.uniforms.scratchWidth;
    }
    set vignetting(t) {
      this.uniforms.vignetting = t;
    }
    get vignetting() {
      return this.uniforms.vignetting;
    }
    set vignettingAlpha(t) {
      this.uniforms.vignettingAlpha = t;
    }
    get vignettingAlpha() {
      return this.uniforms.vignettingAlpha;
    }
    set vignettingBlur(t) {
      this.uniforms.vignettingBlur = t;
    }
    get vignettingBlur() {
      return this.uniforms.vignettingBlur;
    }
  };
  let ue = le;
  ue.defaults = {
    sepia: 0.3,
    noise: 0.3,
    noiseSize: 1,
    scratch: 0.5,
    scratchDensity: 0.3,
    scratchWidth: 1,
    vignetting: 0.3,
    vignettingAlpha: 1,
    vignettingBlur: 0.3,
  };
  var fr = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    dr = `varying vec2 vTextureCoord;
uniform sampler2D uSampler;
uniform vec4 filterClamp;

uniform float uAlpha;
uniform vec2 uThickness;
uniform vec4 uColor;
uniform bool uKnockout;

const float DOUBLE_PI = 2. * 3.14159265358979323846264;
const float ANGLE_STEP = \${angleStep};

float outlineMaxAlphaAtPos(vec2 pos) {
    if (uThickness.x == 0. || uThickness.y == 0.) {
        return 0.;
    }

    vec4 displacedColor;
    vec2 displacedPos;
    float maxAlpha = 0.;

    for (float angle = 0.; angle <= DOUBLE_PI; angle += ANGLE_STEP) {
        displacedPos.x = vTextureCoord.x + uThickness.x * cos(angle);
        displacedPos.y = vTextureCoord.y + uThickness.y * sin(angle);
        displacedColor = texture2D(uSampler, clamp(displacedPos, filterClamp.xy, filterClamp.zw));
        maxAlpha = max(maxAlpha, displacedColor.a);
    }

    return maxAlpha;
}

void main(void) {
    vec4 sourceColor = texture2D(uSampler, vTextureCoord);
    vec4 contentColor = sourceColor * float(!uKnockout);
    float outlineAlpha = uAlpha * outlineMaxAlphaAtPos(vTextureCoord.xy) * (1.-sourceColor.a);
    vec4 outlineColor = vec4(vec3(uColor) * outlineAlpha, outlineAlpha);
    gl_FragColor = contentColor + outlineColor;
}
`;
  const z = class extends a.Filter {
    constructor(t = 1, e = 0, r = 0.1, i = 1, o = !1) {
      super(fr, dr.replace(/\$\{angleStep\}/, z.getAngleStep(r))),
        (this._thickness = 1),
        (this._alpha = 1),
        (this._knockout = !1),
        (this.uniforms.uThickness = new Float32Array([0, 0])),
        (this.uniforms.uColor = new Float32Array([0, 0, 0, 1])),
        (this.uniforms.uAlpha = i),
        (this.uniforms.uKnockout = o),
        Object.assign(this, {
          thickness: t,
          color: e,
          quality: r,
          alpha: i,
          knockout: o,
        });
    }
    static getAngleStep(t) {
      const e = Math.max(t * z.MAX_SAMPLES, z.MIN_SAMPLES);
      return ((Math.PI * 2) / e).toFixed(7);
    }
    apply(t, e, r, i) {
      (this.uniforms.uThickness[0] = this._thickness / e._frame.width),
        (this.uniforms.uThickness[1] = this._thickness / e._frame.height),
        (this.uniforms.uAlpha = this._alpha),
        (this.uniforms.uKnockout = this._knockout),
        t.applyFilter(this, e, r, i);
    }
    get alpha() {
      return this._alpha;
    }
    set alpha(t) {
      this._alpha = t;
    }
    get color() {
      return a.utils.rgb2hex(this.uniforms.uColor);
    }
    set color(t) {
      a.utils.hex2rgb(t, this.uniforms.uColor);
    }
    get knockout() {
      return this._knockout;
    }
    set knockout(t) {
      this._knockout = t;
    }
    get thickness() {
      return this._thickness;
    }
    set thickness(t) {
      (this._thickness = t), (this.padding = t);
    }
  };
  let $ = z;
  ($.MIN_SAMPLES = 1), ($.MAX_SAMPLES = 100);
  var hr = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    mr = `precision mediump float;

varying vec2 vTextureCoord;

uniform vec2 size;
uniform sampler2D uSampler;

uniform vec4 filterArea;

vec2 mapCoord( vec2 coord )
{
    coord *= filterArea.xy;
    coord += filterArea.zw;

    return coord;
}

vec2 unmapCoord( vec2 coord )
{
    coord -= filterArea.zw;
    coord /= filterArea.xy;

    return coord;
}

vec2 pixelate(vec2 coord, vec2 size)
{
	return floor( coord / size ) * size;
}

void main(void)
{
    vec2 coord = mapCoord(vTextureCoord);

    coord = pixelate(coord, size);

    coord = unmapCoord(coord);

    gl_FragColor = texture2D(uSampler, coord);
}
`;
  class gr extends a.Filter {
    constructor(e = 10) {
      super(hr, mr), (this.size = e);
    }
    get size() {
      return this.uniforms.size;
    }
    set size(e) {
      typeof e == "number" && (e = [e, e]), (this.uniforms.size = e);
    }
  }
  var vr = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    pr = `varying vec2 vTextureCoord;
uniform sampler2D uSampler;
uniform vec4 filterArea;

uniform float uRadian;
uniform vec2 uCenter;
uniform float uRadius;
uniform int uKernelSize;

const int MAX_KERNEL_SIZE = 2048;

void main(void)
{
    vec4 color = texture2D(uSampler, vTextureCoord);

    if (uKernelSize == 0)
    {
        gl_FragColor = color;
        return;
    }

    float aspect = filterArea.y / filterArea.x;
    vec2 center = uCenter.xy / filterArea.xy;
    float gradient = uRadius / filterArea.x * 0.3;
    float radius = uRadius / filterArea.x - gradient * 0.5;
    int k = uKernelSize - 1;

    vec2 coord = vTextureCoord;
    vec2 dir = vec2(center - coord);
    float dist = length(vec2(dir.x, dir.y * aspect));

    float radianStep = uRadian;
    if (radius >= 0.0 && dist > radius) {
        float delta = dist - radius;
        float gap = gradient;
        float scale = 1.0 - abs(delta / gap);
        if (scale <= 0.0) {
            gl_FragColor = color;
            return;
        }
        radianStep *= scale;
    }
    radianStep /= float(k);

    float s = sin(radianStep);
    float c = cos(radianStep);
    mat2 rotationMatrix = mat2(vec2(c, -s), vec2(s, c));

    for(int i = 0; i < MAX_KERNEL_SIZE - 1; i++) {
        if (i == k) {
            break;
        }

        coord -= center;
        coord.y *= aspect;
        coord = rotationMatrix * coord;
        coord.y /= aspect;
        coord += center;

        vec4 sample = texture2D(uSampler, coord);

        // switch to pre-multiplied alpha to correctly blur transparent images
        // sample.rgb *= sample.a;

        color += sample;
    }

    gl_FragColor = color / float(uKernelSize);
}
`;
  class xr extends a.Filter {
    constructor(e = 0, r = [0, 0], i = 5, o = -1) {
      super(vr, pr),
        (this._angle = 0),
        (this.angle = e),
        (this.center = r),
        (this.kernelSize = i),
        (this.radius = o);
    }
    apply(e, r, i, o) {
      (this.uniforms.uKernelSize = this._angle !== 0 ? this.kernelSize : 0),
        e.applyFilter(this, r, i, o);
    }
    set angle(e) {
      (this._angle = e), (this.uniforms.uRadian = (e * Math.PI) / 180);
    }
    get angle() {
      return this._angle;
    }
    get center() {
      return this.uniforms.uCenter;
    }
    set center(e) {
      this.uniforms.uCenter = e;
    }
    get radius() {
      return this.uniforms.uRadius;
    }
    set radius(e) {
      (e < 0 || e === 1 / 0) && (e = -1), (this.uniforms.uRadius = e);
    }
  }
  var yr = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    Cr = `varying vec2 vTextureCoord;
uniform sampler2D uSampler;

uniform vec4 filterArea;
uniform vec4 filterClamp;
uniform vec2 dimensions;

uniform bool mirror;
uniform float boundary;
uniform vec2 amplitude;
uniform vec2 waveLength;
uniform vec2 alpha;
uniform float time;

float rand(vec2 co) {
    return fract(sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453);
}

void main(void)
{
    vec2 pixelCoord = vTextureCoord.xy * filterArea.xy;
    vec2 coord = pixelCoord / dimensions;

    if (coord.y < boundary) {
        gl_FragColor = texture2D(uSampler, vTextureCoord);
        return;
    }

    float k = (coord.y - boundary) / (1. - boundary + 0.0001);
    float areaY = boundary * dimensions.y / filterArea.y;
    float v = areaY + areaY - vTextureCoord.y;
    float y = mirror ? v : vTextureCoord.y;

    float _amplitude = ((amplitude.y - amplitude.x) * k + amplitude.x ) / filterArea.x;
    float _waveLength = ((waveLength.y - waveLength.x) * k + waveLength.x) / filterArea.y;
    float _alpha = (alpha.y - alpha.x) * k + alpha.x;

    float x = vTextureCoord.x + cos(v * 6.28 / _waveLength - time) * _amplitude;
    x = clamp(x, filterClamp.x, filterClamp.z);

    vec4 color = texture2D(uSampler, vec2(x, y));

    gl_FragColor = color * _alpha;
}
`;
  const ce = class extends a.Filter {
    constructor(t) {
      super(yr, Cr),
        (this.time = 0),
        (this.uniforms.amplitude = new Float32Array(2)),
        (this.uniforms.waveLength = new Float32Array(2)),
        (this.uniforms.alpha = new Float32Array(2)),
        (this.uniforms.dimensions = new Float32Array(2)),
        Object.assign(this, ce.defaults, t);
    }
    apply(t, e, r, i) {
      var o, s;
      (this.uniforms.dimensions[0] =
        (o = e.filterFrame) == null ? void 0 : o.width),
        (this.uniforms.dimensions[1] =
          (s = e.filterFrame) == null ? void 0 : s.height),
        (this.uniforms.time = this.time),
        t.applyFilter(this, e, r, i);
    }
    set mirror(t) {
      this.uniforms.mirror = t;
    }
    get mirror() {
      return this.uniforms.mirror;
    }
    set boundary(t) {
      this.uniforms.boundary = t;
    }
    get boundary() {
      return this.uniforms.boundary;
    }
    set amplitude(t) {
      (this.uniforms.amplitude[0] = t[0]), (this.uniforms.amplitude[1] = t[1]);
    }
    get amplitude() {
      return this.uniforms.amplitude;
    }
    set waveLength(t) {
      (this.uniforms.waveLength[0] = t[0]),
        (this.uniforms.waveLength[1] = t[1]);
    }
    get waveLength() {
      return this.uniforms.waveLength;
    }
    set alpha(t) {
      (this.uniforms.alpha[0] = t[0]), (this.uniforms.alpha[1] = t[1]);
    }
    get alpha() {
      return this.uniforms.alpha;
    }
  };
  let fe = ce;
  fe.defaults = {
    mirror: !0,
    boundary: 0.5,
    amplitude: [0, 20],
    waveLength: [30, 100],
    alpha: [1, 1],
    time: 0,
  };
  var _r = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    br = `precision mediump float;

varying vec2 vTextureCoord;

uniform sampler2D uSampler;
uniform vec4 filterArea;
uniform vec2 red;
uniform vec2 green;
uniform vec2 blue;

void main(void)
{
   gl_FragColor.r = texture2D(uSampler, vTextureCoord + red/filterArea.xy).r;
   gl_FragColor.g = texture2D(uSampler, vTextureCoord + green/filterArea.xy).g;
   gl_FragColor.b = texture2D(uSampler, vTextureCoord + blue/filterArea.xy).b;
   gl_FragColor.a = texture2D(uSampler, vTextureCoord).a;
}
`;
  class Sr extends a.Filter {
    constructor(e = [-10, 0], r = [0, 10], i = [0, 0]) {
      super(_r, br), (this.red = e), (this.green = r), (this.blue = i);
    }
    get red() {
      return this.uniforms.red;
    }
    set red(e) {
      this.uniforms.red = e;
    }
    get green() {
      return this.uniforms.green;
    }
    set green(e) {
      this.uniforms.green = e;
    }
    get blue() {
      return this.uniforms.blue;
    }
    set blue(e) {
      this.uniforms.blue = e;
    }
  }
  var Tr = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    Fr = `varying vec2 vTextureCoord;
uniform sampler2D uSampler;
uniform vec4 filterArea;
uniform vec4 filterClamp;

uniform vec2 center;

uniform float amplitude;
uniform float wavelength;
// uniform float power;
uniform float brightness;
uniform float speed;
uniform float radius;

uniform float time;

const float PI = 3.14159;

void main()
{
    float halfWavelength = wavelength * 0.5 / filterArea.x;
    float maxRadius = radius / filterArea.x;
    float currentRadius = time * speed / filterArea.x;

    float fade = 1.0;

    if (maxRadius > 0.0) {
        if (currentRadius > maxRadius) {
            gl_FragColor = texture2D(uSampler, vTextureCoord);
            return;
        }
        fade = 1.0 - pow(currentRadius / maxRadius, 2.0);
    }

    vec2 dir = vec2(vTextureCoord - center / filterArea.xy);
    dir.y *= filterArea.y / filterArea.x;
    float dist = length(dir);

    if (dist <= 0.0 || dist < currentRadius - halfWavelength || dist > currentRadius + halfWavelength) {
        gl_FragColor = texture2D(uSampler, vTextureCoord);
        return;
    }

    vec2 diffUV = normalize(dir);

    float diff = (dist - currentRadius) / halfWavelength;

    float p = 1.0 - pow(abs(diff), 2.0);

    // float powDiff = diff * pow(p, 2.0) * ( amplitude * fade );
    float powDiff = 1.25 * sin(diff * PI) * p * ( amplitude * fade );

    vec2 offset = diffUV * powDiff / filterArea.xy;

    // Do clamp :
    vec2 coord = vTextureCoord + offset;
    vec2 clampedCoord = clamp(coord, filterClamp.xy, filterClamp.zw);
    vec4 color = texture2D(uSampler, clampedCoord);
    if (coord != clampedCoord) {
        color *= max(0.0, 1.0 - length(coord - clampedCoord));
    }

    // No clamp :
    // gl_FragColor = texture2D(uSampler, vTextureCoord + offset);

    color.rgb *= 1.0 + (brightness - 1.0) * p * fade;

    gl_FragColor = color;
}
`;
  const de = class extends a.Filter {
    constructor(t = [0, 0], e, r = 0) {
      super(Tr, Fr),
        (this.center = t),
        Object.assign(this, de.defaults, e),
        (this.time = r);
    }
    apply(t, e, r, i) {
      (this.uniforms.time = this.time), t.applyFilter(this, e, r, i);
    }
    get center() {
      return this.uniforms.center;
    }
    set center(t) {
      this.uniforms.center = t;
    }
    get amplitude() {
      return this.uniforms.amplitude;
    }
    set amplitude(t) {
      this.uniforms.amplitude = t;
    }
    get wavelength() {
      return this.uniforms.wavelength;
    }
    set wavelength(t) {
      this.uniforms.wavelength = t;
    }
    get brightness() {
      return this.uniforms.brightness;
    }
    set brightness(t) {
      this.uniforms.brightness = t;
    }
    get speed() {
      return this.uniforms.speed;
    }
    set speed(t) {
      this.uniforms.speed = t;
    }
    get radius() {
      return this.uniforms.radius;
    }
    set radius(t) {
      this.uniforms.radius = t;
    }
  };
  let he = de;
  he.defaults = {
    amplitude: 30,
    wavelength: 160,
    brightness: 1,
    speed: 500,
    radius: -1,
  };
  var Ar = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    zr = `varying vec2 vTextureCoord;
uniform sampler2D uSampler;
uniform sampler2D uLightmap;
uniform vec4 filterArea;
uniform vec2 dimensions;
uniform vec4 ambientColor;
void main() {
    vec4 diffuseColor = texture2D(uSampler, vTextureCoord);
    vec2 lightCoord = (vTextureCoord * filterArea.xy) / dimensions;
    vec4 light = texture2D(uLightmap, lightCoord);
    vec3 ambient = ambientColor.rgb * ambientColor.a;
    vec3 intensity = ambient + light.rgb;
    vec3 finalColor = diffuseColor.rgb * intensity;
    gl_FragColor = vec4(finalColor, diffuseColor.a);
}
`;
  class wr extends a.Filter {
    constructor(e, r = 0, i = 1) {
      super(Ar, zr),
        (this._color = 0),
        (this.uniforms.dimensions = new Float32Array(2)),
        (this.uniforms.ambientColor = new Float32Array([0, 0, 0, i])),
        (this.texture = e),
        (this.color = r);
    }
    apply(e, r, i, o) {
      var s, n;
      (this.uniforms.dimensions[0] =
        (s = r.filterFrame) == null ? void 0 : s.width),
        (this.uniforms.dimensions[1] =
          (n = r.filterFrame) == null ? void 0 : n.height),
        e.applyFilter(this, r, i, o);
    }
    get texture() {
      return this.uniforms.uLightmap;
    }
    set texture(e) {
      this.uniforms.uLightmap = e;
    }
    set color(e) {
      const r = this.uniforms.ambientColor;
      typeof e == "number"
        ? (a.utils.hex2rgb(e, r), (this._color = e))
        : ((r[0] = e[0]),
          (r[1] = e[1]),
          (r[2] = e[2]),
          (r[3] = e[3]),
          (this._color = a.utils.rgb2hex(r)));
    }
    get color() {
      return this._color;
    }
    get alpha() {
      return this.uniforms.ambientColor[3];
    }
    set alpha(e) {
      this.uniforms.ambientColor[3] = e;
    }
  }
  var Pr = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    Mr = `varying vec2 vTextureCoord;

uniform sampler2D uSampler;
uniform float blur;
uniform float gradientBlur;
uniform vec2 start;
uniform vec2 end;
uniform vec2 delta;
uniform vec2 texSize;

float random(vec3 scale, float seed)
{
    return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);
}

void main(void)
{
    vec4 color = vec4(0.0);
    float total = 0.0;

    float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
    vec2 normal = normalize(vec2(start.y - end.y, end.x - start.x));
    float radius = smoothstep(0.0, 1.0, abs(dot(vTextureCoord * texSize - start, normal)) / gradientBlur) * blur;

    for (float t = -30.0; t <= 30.0; t++)
    {
        float percent = (t + offset - 0.5) / 30.0;
        float weight = 1.0 - abs(percent);
        vec4 sample = texture2D(uSampler, vTextureCoord + delta / texSize * percent * radius);
        sample.rgb *= sample.a;
        color += sample * weight;
        total += weight;
    }

    color /= total;
    color.rgb /= color.a + 0.00001;

    gl_FragColor = color;
}
`;
  class E extends a.Filter {
    constructor(e) {
      var r, i;
      super(Pr, Mr),
        (this.uniforms.blur = e.blur),
        (this.uniforms.gradientBlur = e.gradientBlur),
        (this.uniforms.start =
          (r = e.start) != null ? r : new a.Point(0, window.innerHeight / 2)),
        (this.uniforms.end =
          (i = e.end) != null ? i : new a.Point(600, window.innerHeight / 2)),
        (this.uniforms.delta = new a.Point(30, 30)),
        (this.uniforms.texSize = new a.Point(
          window.innerWidth,
          window.innerHeight
        )),
        this.updateDelta();
    }
    updateDelta() {
      (this.uniforms.delta.x = 0), (this.uniforms.delta.y = 0);
    }
    get blur() {
      return this.uniforms.blur;
    }
    set blur(e) {
      this.uniforms.blur = e;
    }
    get gradientBlur() {
      return this.uniforms.gradientBlur;
    }
    set gradientBlur(e) {
      this.uniforms.gradientBlur = e;
    }
    get start() {
      return this.uniforms.start;
    }
    set start(e) {
      (this.uniforms.start = e), this.updateDelta();
    }
    get end() {
      return this.uniforms.end;
    }
    set end(e) {
      (this.uniforms.end = e), this.updateDelta();
    }
  }
  class me extends E {
    updateDelta() {
      const e = this.uniforms.end.x - this.uniforms.start.x,
        r = this.uniforms.end.y - this.uniforms.start.y,
        i = Math.sqrt(e * e + r * r);
      (this.uniforms.delta.x = e / i), (this.uniforms.delta.y = r / i);
    }
  }
  class ge extends E {
    updateDelta() {
      const e = this.uniforms.end.x - this.uniforms.start.x,
        r = this.uniforms.end.y - this.uniforms.start.y,
        i = Math.sqrt(e * e + r * r);
      (this.uniforms.delta.x = -r / i), (this.uniforms.delta.y = e / i);
    }
  }
  const ve = class extends a.Filter {
    constructor(t, e, r, i) {
      super(),
        typeof t == "number" &&
          (a.utils.deprecation(
            "5.3.0",
            "TiltShiftFilter constructor arguments is deprecated, use options."
          ),
          (t = { blur: t, gradientBlur: e, start: r, end: i })),
        (t = Object.assign({}, ve.defaults, t)),
        (this.tiltShiftXFilter = new me(t)),
        (this.tiltShiftYFilter = new ge(t));
    }
    apply(t, e, r, i) {
      const o = t.getFilterTexture();
      this.tiltShiftXFilter.apply(t, e, o, 1),
        this.tiltShiftYFilter.apply(t, o, r, i),
        t.returnFilterTexture(o);
    }
    get blur() {
      return this.tiltShiftXFilter.blur;
    }
    set blur(t) {
      this.tiltShiftXFilter.blur = this.tiltShiftYFilter.blur = t;
    }
    get gradientBlur() {
      return this.tiltShiftXFilter.gradientBlur;
    }
    set gradientBlur(t) {
      this.tiltShiftXFilter.gradientBlur = this.tiltShiftYFilter.gradientBlur =
        t;
    }
    get start() {
      return this.tiltShiftXFilter.start;
    }
    set start(t) {
      this.tiltShiftXFilter.start = this.tiltShiftYFilter.start = t;
    }
    get end() {
      return this.tiltShiftXFilter.end;
    }
    set end(t) {
      this.tiltShiftXFilter.end = this.tiltShiftYFilter.end = t;
    }
  };
  let pe = ve;
  pe.defaults = { blur: 100, gradientBlur: 600, start: void 0, end: void 0 };
  var Dr = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    kr = `varying vec2 vTextureCoord;

uniform sampler2D uSampler;
uniform float radius;
uniform float angle;
uniform vec2 offset;
uniform vec4 filterArea;

vec2 mapCoord( vec2 coord )
{
    coord *= filterArea.xy;
    coord += filterArea.zw;

    return coord;
}

vec2 unmapCoord( vec2 coord )
{
    coord -= filterArea.zw;
    coord /= filterArea.xy;

    return coord;
}

vec2 twist(vec2 coord)
{
    coord -= offset;

    float dist = length(coord);

    if (dist < radius)
    {
        float ratioDist = (radius - dist) / radius;
        float angleMod = ratioDist * ratioDist * angle;
        float s = sin(angleMod);
        float c = cos(angleMod);
        coord = vec2(coord.x * c - coord.y * s, coord.x * s + coord.y * c);
    }

    coord += offset;

    return coord;
}

void main(void)
{

    vec2 coord = mapCoord(vTextureCoord);

    coord = twist(coord);

    coord = unmapCoord(coord);

    gl_FragColor = texture2D(uSampler, coord );

}
`;
  const xe = class extends a.Filter {
    constructor(t) {
      super(Dr, kr), Object.assign(this, xe.defaults, t);
    }
    get offset() {
      return this.uniforms.offset;
    }
    set offset(t) {
      this.uniforms.offset = t;
    }
    get radius() {
      return this.uniforms.radius;
    }
    set radius(t) {
      this.uniforms.radius = t;
    }
    get angle() {
      return this.uniforms.angle;
    }
    set angle(t) {
      this.uniforms.angle = t;
    }
  };
  let ye = xe;
  ye.defaults = { radius: 200, angle: 4, padding: 20, offset: new a.Point() };
  var Or = `attribute vec2 aVertexPosition;
attribute vec2 aTextureCoord;

uniform mat3 projectionMatrix;

varying vec2 vTextureCoord;

void main(void)
{
    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
    vTextureCoord = aTextureCoord;
}`,
    Rr = `varying vec2 vTextureCoord;
uniform sampler2D uSampler;
uniform vec4 filterArea;

uniform vec2 uCenter;
uniform float uStrength;
uniform float uInnerRadius;
uniform float uRadius;

const float MAX_KERNEL_SIZE = \${maxKernelSize};

// author: http://byteblacksmith.com/improvements-to-the-canonical-one-liner-glsl-rand-for-opengl-es-2-0/
highp float rand(vec2 co, float seed) {
    const highp float a = 12.9898, b = 78.233, c = 43758.5453;
    highp float dt = dot(co + seed, vec2(a, b)), sn = mod(dt, 3.14159);
    return fract(sin(sn) * c + seed);
}

void main() {

    float minGradient = uInnerRadius * 0.3;
    float innerRadius = (uInnerRadius + minGradient * 0.5) / filterArea.x;

    float gradient = uRadius * 0.3;
    float radius = (uRadius - gradient * 0.5) / filterArea.x;

    float countLimit = MAX_KERNEL_SIZE;

    vec2 dir = vec2(uCenter.xy / filterArea.xy - vTextureCoord);
    float dist = length(vec2(dir.x, dir.y * filterArea.y / filterArea.x));

    float strength = uStrength;

    float delta = 0.0;
    float gap;
    if (dist < innerRadius) {
        delta = innerRadius - dist;
        gap = minGradient;
    } else if (radius >= 0.0 && dist > radius) { // radius < 0 means it's infinity
        delta = dist - radius;
        gap = gradient;
    }

    if (delta > 0.0) {
        float normalCount = gap / filterArea.x;
        delta = (normalCount - delta) / normalCount;
        countLimit *= delta;
        strength *= delta;
        if (countLimit < 1.0)
        {
            gl_FragColor = texture2D(uSampler, vTextureCoord);
            return;
        }
    }

    // randomize the lookup values to hide the fixed number of samples
    float offset = rand(vTextureCoord, 0.0);

    float total = 0.0;
    vec4 color = vec4(0.0);

    dir *= strength;

    for (float t = 0.0; t < MAX_KERNEL_SIZE; t++) {
        float percent = (t + offset) / MAX_KERNEL_SIZE;
        float weight = 4.0 * (percent - percent * percent);
        vec2 p = vTextureCoord + dir * percent;
        vec4 sample = texture2D(uSampler, p);

        // switch to pre-multiplied alpha to correctly blur transparent images
        // sample.rgb *= sample.a;

        color += sample * weight;
        total += weight;

        if (t > countLimit){
            break;
        }
    }

    color /= total;
    // switch back from pre-multiplied alpha
    // color.rgb /= color.a + 0.00001;

    gl_FragColor = color;
}
`,
    Ce = Object.getOwnPropertySymbols,
    $r = Object.prototype.hasOwnProperty,
    Er = Object.prototype.propertyIsEnumerable,
    jr = (t, e) => {
      var r = {};
      for (var i in t) $r.call(t, i) && e.indexOf(i) < 0 && (r[i] = t[i]);
      if (t != null && Ce)
        for (var i of Ce(t)) e.indexOf(i) < 0 && Er.call(t, i) && (r[i] = t[i]);
      return r;
    };
  const _e = class extends a.Filter {
    constructor(t) {
      const e = Object.assign(_e.defaults, t),
        { maxKernelSize: r } = e,
        i = jr(e, ["maxKernelSize"]);
      super(Or, Rr.replace("${maxKernelSize}", r.toFixed(1))),
        Object.assign(this, i);
    }
    get center() {
      return this.uniforms.uCenter;
    }
    set center(t) {
      this.uniforms.uCenter = t;
    }
    get strength() {
      return this.uniforms.uStrength;
    }
    set strength(t) {
      this.uniforms.uStrength = t;
    }
    get innerRadius() {
      return this.uniforms.uInnerRadius;
    }
    set innerRadius(t) {
      this.uniforms.uInnerRadius = t;
    }
    get radius() {
      return this.uniforms.uRadius;
    }
    set radius(t) {
      (t < 0 || t === 1 / 0) && (t = -1), (this.uniforms.uRadius = t);
    }
  };
  let be = _e;
  return (
    (be.defaults = {
      strength: 0.1,
      center: [0, 0],
      innerRadius: 0,
      radius: -1,
      maxKernelSize: 32,
    }),
    (f.AdjustmentFilter = ke),
    (f.AdvancedBloomFilter = N),
    (f.AsciiFilter = Ne),
    (f.BevelFilter = Xe),
    (f.BloomFilter = qe),
    (f.BulgePinchFilter = B),
    (f.CRTFilter = H),
    (f.ColorGradientFilter = A),
    (f.ColorMapFilter = yt),
    (f.ColorOverlayFilter = bt),
    (f.ColorReplaceFilter = Ft),
    (f.ConvolutionFilter = wt),
    (f.CrossHatchFilter = Dt),
    (f.DotFilter = Et),
    (f.DropShadowFilter = te),
    (f.EmbossFilter = Xt),
    (f.GlitchFilter = b),
    (f.GlowFilter = ie),
    (f.GodrayFilter = se),
    (f.GrayscaleFilter = er),
    (f.HslAdjustmentFilter = ne),
    (f.KawaseBlurFilter = T),
    (f.MotionBlurFilter = sr),
    (f.MultiColorReplaceFilter = lr),
    (f.OldFilmFilter = ue),
    (f.OutlineFilter = $),
    (f.PixelateFilter = gr),
    (f.RGBSplitFilter = Sr),
    (f.RadialBlurFilter = xr),
    (f.ReflectionFilter = fe),
    (f.ShockwaveFilter = he),
    (f.SimpleLightmapFilter = wr),
    (f.TiltShiftAxisFilter = E),
    (f.TiltShiftFilter = pe),
    (f.TiltShiftXFilter = me),
    (f.TiltShiftYFilter = ge),
    (f.TwistFilter = ye),
    (f.ZoomBlurFilter = be),
    Object.defineProperty(f, "__esModule", { value: !0 }),
    f
  );
})({}, PIXI, PIXI.filters, PIXI.filters);
Object.assign(PIXI.filters, __filters);
//# sourceMappingURL=pixi-filters.js.map

repo_name: onms/dead

license: unknown