@courtneyring/components-library 1.0.14 → 1.0.16

package/dist/Particles-O0-WQKRj.js

@@ -0,0 +1,2786 @@
+import ge, { Component as Ne } from "react";
+const B = "generated", qe = "pointerdown", Xe = "pointerup", ye = "pointerleave", Ye = "pointerout", ve = "pointermove", Ze = "touchstart", _e = "touchend", Qe = "touchmove", Je = "touchcancel", je = "resize", Ke = "visibilitychange", I = "tsParticles - Error";
+class M {
+  constructor(e, t, i) {
+    if (this._updateFromAngle = (s, r) => {
+      this.x = Math.cos(s) * r, this.y = Math.sin(s) * r;
+    }, !k(e) && e) {
+      this.x = e.x, this.y = e.y;
+      const s = e;
+      this.z = s.z ? s.z : 0;
+    } else if (e !== void 0 && t !== void 0)
+      this.x = e, this.y = t, this.z = i ?? 0;
+    else
+      throw new Error(`${I} Vector3d not initialized correctly`);
+  }
+  static get origin() {
+    return M.create(0, 0, 0);
+  }
+  get angle() {
+    return Math.atan2(this.y, this.x);
+  }
+  set angle(e) {
+    this._updateFromAngle(e, this.length);
+  }
+  get length() {
+    return Math.sqrt(this.getLengthSq());
+  }
+  set length(e) {
+    this._updateFromAngle(this.angle, e);
+  }
+  static clone(e) {
+    return M.create(e.x, e.y, e.z);
+  }
+  static create(e, t, i) {
+    return new M(e, t, i);
+  }
+  add(e) {
+    return M.create(this.x + e.x, this.y + e.y, this.z + e.z);
+  }
+  addTo(e) {
+    this.x += e.x, this.y += e.y, this.z += e.z;
+  }
+  copy() {
+    return M.clone(this);
+  }
+  distanceTo(e) {
+    return this.sub(e).length;
+  }
+  distanceToSq(e) {
+    return this.sub(e).getLengthSq();
+  }
+  div(e) {
+    return M.create(this.x / e, this.y / e, this.z / e);
+  }
+  divTo(e) {
+    this.x /= e, this.y /= e, this.z /= e;
+  }
+  getLengthSq() {
+    return this.x ** 2 + this.y ** 2;
+  }
+  mult(e) {
+    return M.create(this.x * e, this.y * e, this.z * e);
+  }
+  multTo(e) {
+    this.x *= e, this.y *= e, this.z *= e;
+  }
+  normalize() {
+    const e = this.length;
+    e != 0 && this.multTo(1 / e);
+  }
+  rotate(e) {
+    return M.create(this.x * Math.cos(e) - this.y * Math.sin(e), this.x * Math.sin(e) + this.y * Math.cos(e), 0);
+  }
+  setTo(e) {
+    this.x = e.x, this.y = e.y;
+    const t = e;
+    this.z = t.z ? t.z : 0;
+  }
+  sub(e) {
+    return M.create(this.x - e.x, this.y - e.y, this.z - e.z);
+  }
+  subFrom(e) {
+    this.x -= e.x, this.y -= e.y, this.z -= e.z;
+  }
+}
+class L extends M {
+  constructor(e, t) {
+    super(e, t, 0);
+  }
+  static get origin() {
+    return L.create(0, 0);
+  }
+  static clone(e) {
+    return L.create(e.x, e.y);
+  }
+  static create(e, t) {
+    return new L(e, t);
+  }
+}
+let et = Math.random;
+function T() {
+  return Re(et(), 0, 1 - 1e-16);
+}
+function Re(n, e, t) {
+  return Math.min(Math.max(n, e), t);
+}
+function F(n) {
+  const e = ue(n);
+  let t = ce(n);
+  return e === t && (t = 0), T() * (e - t) + t;
+}
+function g(n) {
+  return k(n) ? n : F(n);
+}
+function ce(n) {
+  return k(n) ? n : n.min;
+}
+function ue(n) {
+  return k(n) ? n : n.max;
+}
+function p(n, e) {
+  if (n === e || e === void 0 && k(n))
+    return n;
+  const t = ce(n), i = ue(n);
+  return e !== void 0 ? {
+    min: Math.min(t, e),
+    max: Math.max(i, e)
+  } : p(t, i);
+}
+function tt(n) {
+  const e = n.random, { enable: t, minimumValue: i } = R(e) ? {
+    enable: e,
+    minimumValue: 0
+  } : e;
+  return g(t ? p(n.value, i) : n.value);
+}
+function it(n, e) {
+  const t = n.x - e.x, i = n.y - e.y;
+  return { dx: t, dy: i, distance: Math.sqrt(t ** 2 + i ** 2) };
+}
+function fe(n, e) {
+  return it(n, e).distance;
+}
+function st(n, e, t) {
+  if (k(n))
+    return n * Math.PI / 180;
+  switch (n) {
+    case "top":
+      return -Math.PI / 2;
+    case "top-right":
+      return -Math.PI / 4;
+    case "right":
+      return 0;
+    case "bottom-right":
+      return Math.PI / 4;
+    case "bottom":
+      return Math.PI / 2;
+    case "bottom-left":
+      return 3 * Math.PI / 4;
+    case "left":
+      return Math.PI;
+    case "top-left":
+      return -3 * Math.PI / 4;
+    case "inside":
+      return Math.atan2(t.y - e.y, t.x - e.x);
+    case "outside":
+      return Math.atan2(e.y - t.y, e.x - t.x);
+    default:
+      return T() * Math.PI * 2;
+  }
+}
+function nt(n) {
+  const e = L.origin;
+  return e.length = 1, e.angle = n, e;
+}
+function rt(n) {
+  return {
+    x: n.position?.x ?? T() * n.size.width,
+    y: n.position?.y ?? T() * n.size.height
+  };
+}
+function Ie(n) {
+  return n ? n.endsWith("%") ? parseFloat(n) / 100 : parseFloat(n) : 1;
+}
+const ot = {
+  debug: console.debug,
+  error: console.error,
+  info: console.info,
+  log: console.log,
+  verbose: console.log,
+  warning: console.warn
+};
+function $() {
+  return ot;
+}
+function Z() {
+  return typeof window > "u" || !window || typeof window.document > "u" || !window.document;
+}
+function at() {
+  return !Z() && typeof matchMedia < "u";
+}
+function Ee(n) {
+  if (at())
+    return matchMedia(n);
+}
+function ht(n) {
+  if (!(Z() || typeof MutationObserver > "u"))
+    return new MutationObserver(n);
+}
+function lt(n, e) {
+  return n === e || S(e) && e.indexOf(n) > -1;
+}
+function ct(n) {
+  return Math.floor(T() * n.length);
+}
+function de(n, e, t = !0) {
+  return n[e !== void 0 && t ? e % n.length : ct(n)];
+}
+function x(n, ...e) {
+  for (const t of e) {
+    if (t == null)
+      continue;
+    if (!U(t)) {
+      n = t;
+      continue;
+    }
+    const i = Array.isArray(t);
+    i && (U(n) || !n || !Array.isArray(n)) ? n = [] : !i && (U(n) || !n || Array.isArray(n)) && (n = {});
+    for (const s in t) {
+      if (s === "__proto__")
+        continue;
+      const r = t, o = r[s], a = n;
+      a[s] = U(o) && Array.isArray(o) ? o.map((h) => x(a[s], h)) : x(a[s], o);
+    }
+  }
+  return n;
+}
+function E(n, e) {
+  return S(n) ? n.map((t, i) => e(t, i)) : e(n, 0);
+}
+function W(n, e, t) {
+  return S(n) ? de(n, e, t) : n;
+}
+function ut(n, e) {
+  const t = n.value, i = n.animation, s = {
+    delayTime: g(i.delay) * 1e3,
+    enable: i.enable,
+    value: g(n.value) * e,
+    max: ue(t) * e,
+    min: ce(t) * e,
+    loops: 0,
+    maxLoops: g(i.count),
+    time: 0
+  };
+  if (i.enable) {
+    switch (s.decay = 1 - g(i.decay), i.mode) {
+      case "increase":
+        s.status = "increasing";
+        break;
+      case "decrease":
+        s.status = "decreasing";
+        break;
+      case "random":
+        s.status = T() >= 0.5 ? "increasing" : "decreasing";
+        break;
+    }
+    const r = i.mode === "auto";
+    switch (i.startValue) {
+      case "min":
+        s.value = s.min, r && (s.status = "increasing");
+        break;
+      case "max":
+        s.value = s.max, r && (s.status = "decreasing");
+        break;
+      case "random":
+      default:
+        s.value = F(s), r && (s.status = T() >= 0.5 ? "increasing" : "decreasing");
+        break;
+    }
+  }
+  return s.initialValue = s.value, s;
+}
+function ft(n, e) {
+  if (!(n.mode === "percent")) {
+    const { mode: s, ...r } = n;
+    return r;
+  }
+  return "x" in n ? {
+    x: n.x / 100 * e.width,
+    y: n.y / 100 * e.height
+  } : {
+    width: n.width / 100 * e.width,
+    height: n.height / 100 * e.height
+  };
+}
+function De(n, e) {
+  return ft(n, e);
+}
+function R(n) {
+  return typeof n == "boolean";
+}
+function C(n) {
+  return typeof n == "string";
+}
+function k(n) {
+  return typeof n == "number";
+}
+function Ae(n) {
+  return typeof n == "function";
+}
+function U(n) {
+  return typeof n == "object" && n !== null;
+}
+function S(n) {
+  return Array.isArray(n);
+}
+const dt = "random", Q = /* @__PURE__ */ new Map();
+function we(n) {
+  Q.set(n.key, n);
+}
+function j(n, e, t) {
+  return t < 0 && (t += 1), t > 1 && (t -= 1), t < 1 / 6 ? n + (e - n) * 6 * t : t < 1 / 2 ? e : t < 2 / 3 ? n + (e - n) * (2 / 3 - t) * 6 : n;
+}
+function pt(n) {
+  for (const [, r] of Q)
+    if (n.startsWith(r.stringPrefix))
+      return r.parseString(n);
+  const e = /^#?([a-f\d])([a-f\d])([a-f\d])([a-f\d])?$/i, t = n.replace(e, (r, o, a, h, l) => o + o + a + a + h + h + (l !== void 0 ? l + l : "")), i = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})?$/i, s = i.exec(t);
+  return s ? {
+    a: s[4] !== void 0 ? parseInt(s[4], 16) / 255 : 1,
+    b: parseInt(s[3], 16),
+    g: parseInt(s[2], 16),
+    r: parseInt(s[1], 16)
+  } : void 0;
+}
+function V(n, e, t = !0) {
+  if (!n)
+    return;
+  const i = C(n) ? { value: n } : n;
+  if (C(i.value))
+    return Le(i.value, e, t);
+  if (S(i.value))
+    return V({
+      value: de(i.value, e, t)
+    });
+  for (const [, s] of Q) {
+    const r = s.handleRangeColor(i);
+    if (r)
+      return r;
+  }
+}
+function Le(n, e, t = !0) {
+  if (!n)
+    return;
+  const i = C(n) ? { value: n } : n;
+  if (C(i.value))
+    return i.value === dt ? vt() : gt(i.value);
+  if (S(i.value))
+    return Le({
+      value: de(i.value, e, t)
+    });
+  for (const [, s] of Q) {
+    const r = s.handleColor(i);
+    if (r)
+      return r;
+  }
+}
+function be(n, e, t = !0) {
+  const i = V(n, e, t);
+  return i ? mt(i) : void 0;
+}
+function mt(n) {
+  const e = n.r / 255, t = n.g / 255, i = n.b / 255, s = Math.max(e, t, i), r = Math.min(e, t, i), o = {
+    h: 0,
+    l: (s + r) / 2,
+    s: 0
+  };
+  return s !== r && (o.s = o.l < 0.5 ? (s - r) / (s + r) : (s - r) / (2 - s - r), o.h = e === s ? (t - i) / (s - r) : o.h = t === s ? 2 + (i - e) / (s - r) : 4 + (e - t) / (s - r)), o.l *= 100, o.s *= 100, o.h *= 60, o.h < 0 && (o.h += 360), o.h >= 360 && (o.h -= 360), o;
+}
+function gt(n) {
+  return pt(n);
+}
+function he(n) {
+  const e = { b: 0, g: 0, r: 0 }, t = {
+    h: n.h / 360,
+    l: n.l / 100,
+    s: n.s / 100
+  };
+  if (!t.s)
+    e.r = e.g = e.b = t.l;
+  else {
+    const i = t.l < 0.5 ? t.l * (1 + t.s) : t.l + t.s - t.l * t.s, s = 2 * t.l - i;
+    e.r = j(s, i, t.h + 1 / 3), e.g = j(s, i, t.h), e.b = j(s, i, t.h - 1 / 3);
+  }
+  return e.r = Math.floor(e.r * 255), e.g = Math.floor(e.g * 255), e.b = Math.floor(e.b * 255), e;
+}
+function yt(n) {
+  const e = he(n);
+  return {
+    a: n.a,
+    b: e.b,
+    g: e.g,
+    r: e.r
+  };
+}
+function vt(n) {
+  return {
+    b: Math.floor(F(p(0, 256))),
+    g: Math.floor(F(p(0, 256))),
+    r: Math.floor(F(p(0, 256)))
+  };
+}
+function q(n, e) {
+  return `rgba(${n.r}, ${n.g}, ${n.b}, ${e ?? 1})`;
+}
+function xe(n, e) {
+  return `hsla(${n.h}, ${n.s}%, ${n.l}%, ${e ?? 1})`;
+}
+function ze(n) {
+  return n !== void 0 ? {
+    h: n.h.value,
+    s: n.s.value,
+    l: n.l.value
+  } : void 0;
+}
+function _t(n, e, t) {
+  n.fillStyle = t ?? "rgba(0,0,0,0)", n.fillRect(0, 0, e.width, e.height);
+}
+function wt(n, e, t, i) {
+  t && (n.globalAlpha = i, n.drawImage(t, 0, 0, e.width, e.height), n.globalAlpha = 1);
+}
+function K(n, e) {
+  n.clearRect(0, 0, e.width, e.height);
+}
+function bt(n) {
+  const { container: e, context: t, particle: i, delta: s, colorStyles: r, backgroundMask: o, composite: a, radius: h, opacity: l, shadow: c, transform: u } = n, f = i.getPosition(), d = i.rotation + (i.pathRotation ? i.velocity.angle : 0), y = {
+    sin: Math.sin(d),
+    cos: Math.cos(d)
+  }, m = {
+    a: y.cos * (u.a ?? 1),
+    b: y.sin * (u.b ?? 1),
+    c: -y.sin * (u.c ?? 1),
+    d: y.cos * (u.d ?? 1)
+  };
+  t.setTransform(m.a, m.b, m.c, m.d, f.x, f.y), t.beginPath(), o && (t.globalCompositeOperation = a);
+  const b = i.shadowColor;
+  c.enable && b && (t.shadowBlur = c.blur, t.shadowColor = q(b), t.shadowOffsetX = c.offset.x, t.shadowOffsetY = c.offset.y), r.fill && (t.fillStyle = r.fill);
+  const _ = i.strokeWidth ?? 0;
+  t.lineWidth = _, r.stroke && (t.strokeStyle = r.stroke), xt(e, t, i, h, l, s), _ > 0 && t.stroke(), i.close && t.closePath(), i.fill && t.fill(), zt(e, t, i, h, l, s), t.globalCompositeOperation = "source-over", t.setTransform(1, 0, 0, 1, 0, 0);
+}
+function xt(n, e, t, i, s, r) {
+  if (!t.shape)
+    return;
+  const o = n.drawers.get(t.shape);
+  o && o.draw(e, t, i, s, r, n.retina.pixelRatio);
+}
+function zt(n, e, t, i, s, r) {
+  if (!t.shape)
+    return;
+  const o = n.drawers.get(t.shape);
+  !o || !o.afterEffect || o.afterEffect(e, t, i, s, r, n.retina.pixelRatio);
+}
+function Mt(n, e, t) {
+  e.draw && e.draw(n, t);
+}
+function Pt(n, e, t, i) {
+  e.drawParticle && e.drawParticle(n, t, i);
+}
+function kt(n, e, t) {
+  return {
+    h: n.h,
+    s: n.s,
+    l: n.l + (e === "darken" ? -1 : 1) * t
+  };
+}
+function Ct(n, e, t) {
+  const i = e[t];
+  i !== void 0 && (n[t] = (n[t] ?? 1) * i);
+}
+class St {
+  constructor(e) {
+    this.container = e, this._applyPostDrawUpdaters = (t) => {
+      for (const i of this._postDrawUpdaters)
+        i.afterDraw && i.afterDraw(t);
+    }, this._applyPreDrawUpdaters = (t, i, s, r, o, a) => {
+      for (const h of this._preDrawUpdaters) {
+        if (h.getColorStyles) {
+          const { fill: l, stroke: c } = h.getColorStyles(i, t, s, r);
+          l && (o.fill = l), c && (o.stroke = c);
+        }
+        if (h.getTransformValues) {
+          const l = h.getTransformValues(i);
+          for (const c in l)
+            Ct(a, l, c);
+        }
+        h.beforeDraw && h.beforeDraw(i);
+      }
+    }, this._applyResizePlugins = () => {
+      for (const t of this._resizePlugins)
+        t.resize && t.resize();
+    }, this._getPluginParticleColors = (t) => {
+      let i, s;
+      for (const r of this._colorPlugins)
+        if (!i && r.particleFillColor && (i = be(r.particleFillColor(t))), !s && r.particleStrokeColor && (s = be(r.particleStrokeColor(t))), i && s)
+          break;
+      return [i, s];
+    }, this._initCover = () => {
+      const t = this.container.actualOptions, i = t.backgroundMask.cover, s = i.color, r = V(s);
+      if (r) {
+        const o = {
+          ...r,
+          a: i.opacity
+        };
+        this._coverColorStyle = q(o, o.a);
+      }
+    }, this._initStyle = () => {
+      const t = this.element, i = this.container.actualOptions;
+      if (t) {
+        this._fullScreen ? (this._originalStyle = x({}, t.style), this._setFullScreenStyle()) : this._resetOriginalStyle();
+        for (const s in i.style) {
+          if (!s || !i.style)
+            continue;
+          const r = i.style[s];
+          r && t.style.setProperty(s, r, "important");
+        }
+      }
+    }, this._initTrail = async () => {
+      const t = this.container.actualOptions, i = t.particles.move.trail, s = i.fill;
+      if (i.enable)
+        if (s.color) {
+          const r = V(s.color);
+          if (!r)
+            return;
+          const o = t.particles.move.trail;
+          this._trailFill = {
+            color: {
+              ...r
+            },
+            opacity: 1 / o.length
+          };
+        } else
+          await new Promise((r, o) => {
+            if (!s.image)
+              return;
+            const a = document.createElement("img");
+            a.addEventListener("load", () => {
+              this._trailFill = {
+                image: a,
+                opacity: 1 / i.length
+              }, r();
+            }), a.addEventListener("error", (h) => {
+              o(h.error);
+            }), a.src = s.image;
+          });
+    }, this._paintBase = (t) => {
+      this.draw((i) => _t(i, this.size, t));
+    }, this._paintImage = (t, i) => {
+      this.draw((s) => wt(s, this.size, t, i));
+    }, this._repairStyle = () => {
+      const t = this.element;
+      t && (this._safeMutationObserver((i) => i.disconnect()), this._initStyle(), this.initBackground(), this._safeMutationObserver((i) => i.observe(t, { attributes: !0 })));
+    }, this._resetOriginalStyle = () => {
+      const t = this.element, i = this._originalStyle;
+      if (!(t && i))
+        return;
+      const s = t.style;
+      s.position = i.position, s.zIndex = i.zIndex, s.top = i.top, s.left = i.left, s.width = i.width, s.height = i.height;
+    }, this._safeMutationObserver = (t) => {
+      this._mutationObserver && t(this._mutationObserver);
+    }, this._setFullScreenStyle = () => {
+      const t = this.element;
+      if (!t)
+        return;
+      const i = "important", s = t.style;
+      s.setProperty("position", "fixed", i), s.setProperty("z-index", this.container.actualOptions.fullScreen.zIndex.toString(10), i), s.setProperty("top", "0", i), s.setProperty("left", "0", i), s.setProperty("width", "100%", i), s.setProperty("height", "100%", i);
+    }, this.size = {
+      height: 0,
+      width: 0
+    }, this._context = null, this._generated = !1, this._preDrawUpdaters = [], this._postDrawUpdaters = [], this._resizePlugins = [], this._colorPlugins = [];
+  }
+  get _fullScreen() {
+    return this.container.actualOptions.fullScreen.enable;
+  }
+  clear() {
+    const e = this.container.actualOptions, t = e.particles.move.trail, i = this._trailFill;
+    e.backgroundMask.enable ? this.paint() : t.enable && t.length > 0 && i ? i.color ? this._paintBase(q(i.color, i.opacity)) : i.image && this._paintImage(i.image, i.opacity) : this.draw((s) => {
+      K(s, this.size);
+    });
+  }
+  destroy() {
+    if (this.stop(), this._generated) {
+      const e = this.element;
+      e && e.remove();
+    } else
+      this._resetOriginalStyle();
+    this._preDrawUpdaters = [], this._postDrawUpdaters = [], this._resizePlugins = [], this._colorPlugins = [];
+  }
+  draw(e) {
+    const t = this._context;
+    if (t)
+      return e(t);
+  }
+  drawParticle(e, t) {
+    if (e.spawning || e.destroyed)
+      return;
+    const i = e.getRadius();
+    if (i <= 0)
+      return;
+    const s = e.getFillColor(), r = e.getStrokeColor() ?? s;
+    let [o, a] = this._getPluginParticleColors(e);
+    o || (o = s), a || (a = r), !(!o && !a) && this.draw((h) => {
+      const l = this.container, c = l.actualOptions, u = e.options.zIndex, f = (1 - e.zIndexFactor) ** u.opacityRate, d = e.bubble.opacity ?? e.opacity?.value ?? 1, y = e.strokeOpacity ?? d, m = d * f, b = y * f, _ = {}, z = {
+        fill: o ? xe(o, m) : void 0
+      };
+      z.stroke = a ? xe(a, b) : z.fill, this._applyPreDrawUpdaters(h, e, i, m, z, _), bt({
+        container: l,
+        context: h,
+        particle: e,
+        delta: t,
+        colorStyles: z,
+        backgroundMask: c.backgroundMask.enable,
+        composite: c.backgroundMask.composite,
+        radius: i * (1 - e.zIndexFactor) ** u.sizeRate,
+        opacity: m,
+        shadow: e.options.shadow,
+        transform: _
+      }), this._applyPostDrawUpdaters(e);
+    });
+  }
+  drawParticlePlugin(e, t, i) {
+    this.draw((s) => Pt(s, e, t, i));
+  }
+  drawPlugin(e, t) {
+    this.draw((i) => Mt(i, e, t));
+  }
+  async init() {
+    this._safeMutationObserver((e) => e.disconnect()), this._mutationObserver = ht((e) => {
+      for (const t of e)
+        t.type === "attributes" && t.attributeName === "style" && this._repairStyle();
+    }), this.resize(), this._initStyle(), this._initCover();
+    try {
+      await this._initTrail();
+    } catch (e) {
+      $().error(e);
+    }
+    this.initBackground(), this._safeMutationObserver((e) => {
+      this.element && e.observe(this.element, { attributes: !0 });
+    }), this.initUpdaters(), this.initPlugins(), this.paint();
+  }
+  initBackground() {
+    const e = this.container.actualOptions, t = e.background, i = this.element;
+    if (!i)
+      return;
+    const s = i.style;
+    if (s) {
+      if (t.color) {
+        const r = V(t.color);
+        s.backgroundColor = r ? q(r, t.opacity) : "";
+      } else
+        s.backgroundColor = "";
+      s.backgroundImage = t.image || "", s.backgroundPosition = t.position || "", s.backgroundRepeat = t.repeat || "", s.backgroundSize = t.size || "";
+    }
+  }
+  initPlugins() {
+    this._resizePlugins = [];
+    for (const [, e] of this.container.plugins)
+      e.resize && this._resizePlugins.push(e), (e.particleFillColor || e.particleStrokeColor) && this._colorPlugins.push(e);
+  }
+  initUpdaters() {
+    this._preDrawUpdaters = [], this._postDrawUpdaters = [];
+    for (const e of this.container.particles.updaters)
+      e.afterDraw && this._postDrawUpdaters.push(e), (e.getColorStyles || e.getTransformValues || e.beforeDraw) && this._preDrawUpdaters.push(e);
+  }
+  loadCanvas(e) {
+    this._generated && this.element && this.element.remove(), this._generated = e.dataset && B in e.dataset ? e.dataset[B] === "true" : this._generated, this.element = e, this.element.ariaHidden = "true", this._originalStyle = x({}, this.element.style), this.size.height = e.offsetHeight, this.size.width = e.offsetWidth, this._context = this.element.getContext("2d"), this._safeMutationObserver((t) => {
+      this.element && t.observe(this.element, { attributes: !0 });
+    }), this.container.retina.init(), this.initBackground();
+  }
+  paint() {
+    const e = this.container.actualOptions;
+    this.draw((t) => {
+      e.backgroundMask.enable && e.backgroundMask.cover ? (K(t, this.size), this._paintBase(this._coverColorStyle)) : this._paintBase();
+    });
+  }
+  resize() {
+    if (!this.element)
+      return !1;
+    const e = this.container, t = e.retina.pixelRatio, i = e.canvas.size, s = {
+      width: this.element.offsetWidth * t,
+      height: this.element.offsetHeight * t
+    };
+    if (s.height === i.height && s.width === i.width && s.height === this.element.height && s.width === this.element.width)
+      return !1;
+    const r = { ...i };
+    return this.element.width = i.width = this.element.offsetWidth * t, this.element.height = i.height = this.element.offsetHeight * t, this.container.started && (this.resizeFactor = {
+      width: i.width / r.width,
+      height: i.height / r.height
+    }), !0;
+  }
+  stop() {
+    this._safeMutationObserver((e) => e.disconnect()), this._mutationObserver = void 0, this.draw((e) => K(e, this.size));
+  }
+  async windowResize() {
+    if (!this.element || !this.resize())
+      return;
+    const e = this.container, t = e.updateActualOptions();
+    e.particles.setDensity(), this._applyResizePlugins(), t && await e.refresh();
+  }
+}
+function P(n, e, t, i, s) {
+  if (i) {
+    let r = { passive: !0 };
+    R(s) ? r.capture = s : s !== void 0 && (r = s), n.addEventListener(e, t, r);
+  } else {
+    const r = s;
+    n.removeEventListener(e, t, r);
+  }
+}
+class Ot {
+  constructor(e) {
+    this.container = e, this._doMouseTouchClick = (t) => {
+      const i = this.container, s = i.actualOptions;
+      if (this._canPush) {
+        const r = i.interactivity.mouse, o = r.position;
+        if (!o)
+          return;
+        r.clickPosition = { ...o }, r.clickTime = (/* @__PURE__ */ new Date()).getTime();
+        const a = s.interactivity.events.onClick;
+        E(a.mode, (h) => this.container.handleClickMode(h));
+      }
+      t.type === "touchend" && setTimeout(() => this._mouseTouchFinish(), 500);
+    }, this._handleThemeChange = (t) => {
+      const i = t, s = this.container, r = s.options, o = r.defaultThemes, a = i.matches ? o.dark : o.light, h = r.themes.find((l) => l.name === a);
+      h && h.default.auto && s.loadTheme(a);
+    }, this._handleVisibilityChange = () => {
+      const t = this.container, i = t.actualOptions;
+      this._mouseTouchFinish(), i.pauseOnBlur && (document && document.hidden ? (t.pageHidden = !0, t.pause()) : (t.pageHidden = !1, t.getAnimationStatus() ? t.play(!0) : t.draw(!0)));
+    }, this._handleWindowResize = async () => {
+      this._resizeTimeout && (clearTimeout(this._resizeTimeout), delete this._resizeTimeout), this._resizeTimeout = setTimeout(async () => {
+        const t = this.container.canvas;
+        t && await t.windowResize();
+      }, this.container.actualOptions.interactivity.events.resize.delay * 1e3);
+    }, this._manageInteractivityListeners = (t, i) => {
+      const s = this._handlers, r = this.container, o = r.actualOptions, a = r.interactivity.element;
+      if (!a)
+        return;
+      const h = a, l = r.canvas.element;
+      l && (l.style.pointerEvents = h === l ? "initial" : "none"), (o.interactivity.events.onHover.enable || o.interactivity.events.onClick.enable) && (P(a, ve, s.mouseMove, i), P(a, Ze, s.touchStart, i), P(a, Qe, s.touchMove, i), o.interactivity.events.onClick.enable ? (P(a, _e, s.touchEndClick, i), P(a, Xe, s.mouseUp, i), P(a, qe, s.mouseDown, i)) : P(a, _e, s.touchEnd, i), P(a, t, s.mouseLeave, i), P(a, Je, s.touchCancel, i));
+    }, this._manageListeners = (t) => {
+      const i = this._handlers, s = this.container, r = s.actualOptions, o = r.interactivity.detectsOn, a = s.canvas.element;
+      let h = ye;
+      o === "window" ? (s.interactivity.element = window, h = Ye) : o === "parent" && a ? s.interactivity.element = a.parentElement ?? a.parentNode : s.interactivity.element = a, this._manageMediaMatch(t), this._manageResize(t), this._manageInteractivityListeners(h, t), document && P(document, Ke, i.visibilityChange, t, !1);
+    }, this._manageMediaMatch = (t) => {
+      const i = this._handlers, s = Ee("(prefers-color-scheme: dark)");
+      if (s) {
+        if (s.addEventListener !== void 0) {
+          P(s, "change", i.themeChange, t);
+          return;
+        }
+        s.addListener !== void 0 && (t ? s.addListener(i.oldThemeChange) : s.removeListener(i.oldThemeChange));
+      }
+    }, this._manageResize = (t) => {
+      const i = this._handlers, s = this.container;
+      if (!s.actualOptions.interactivity.events.resize)
+        return;
+      if (typeof ResizeObserver > "u") {
+        P(window, je, i.resize, t);
+        return;
+      }
+      const o = s.canvas.element;
+      this._resizeObserver && !t ? (o && this._resizeObserver.unobserve(o), this._resizeObserver.disconnect(), delete this._resizeObserver) : !this._resizeObserver && t && o && (this._resizeObserver = new ResizeObserver(async (a) => {
+        a.find((l) => l.target === o) && await this._handleWindowResize();
+      }), this._resizeObserver.observe(o));
+    }, this._mouseDown = () => {
+      const { interactivity: t } = this.container;
+      if (!t)
+        return;
+      const { mouse: i } = t;
+      i.clicking = !0, i.downPosition = i.position;
+    }, this._mouseTouchClick = (t) => {
+      const i = this.container, s = i.actualOptions, { mouse: r } = i.interactivity;
+      r.inside = !0;
+      let o = !1;
+      const a = r.position;
+      if (!(!a || !s.interactivity.events.onClick.enable)) {
+        for (const [, h] of i.plugins)
+          if (h.clickPositionValid && (o = h.clickPositionValid(a), o))
+            break;
+        o || this._doMouseTouchClick(t), r.clicking = !1;
+      }
+    }, this._mouseTouchFinish = () => {
+      const t = this.container.interactivity;
+      if (!t)
+        return;
+      const i = t.mouse;
+      delete i.position, delete i.clickPosition, delete i.downPosition, t.status = ye, i.inside = !1, i.clicking = !1;
+    }, this._mouseTouchMove = (t) => {
+      const i = this.container, s = i.actualOptions, r = i.interactivity, o = i.canvas.element;
+      if (!r || !r.element)
+        return;
+      r.mouse.inside = !0;
+      let a;
+      if (t.type.startsWith("pointer")) {
+        this._canPush = !0;
+        const l = t;
+        if (r.element === window) {
+          if (o) {
+            const c = o.getBoundingClientRect();
+            a = {
+              x: l.clientX - c.left,
+              y: l.clientY - c.top
+            };
+          }
+        } else if (s.interactivity.detectsOn === "parent") {
+          const c = l.target, u = l.currentTarget;
+          if (c && u && o) {
+            const f = c.getBoundingClientRect(), d = u.getBoundingClientRect(), y = o.getBoundingClientRect();
+            a = {
+              x: l.offsetX + 2 * f.left - (d.left + y.left),
+              y: l.offsetY + 2 * f.top - (d.top + y.top)
+            };
+          } else
+            a = {
+              x: l.offsetX ?? l.clientX,
+              y: l.offsetY ?? l.clientY
+            };
+        } else l.target === o && (a = {
+          x: l.offsetX ?? l.clientX,
+          y: l.offsetY ?? l.clientY
+        });
+      } else if (this._canPush = t.type !== "touchmove", o) {
+        const l = t, c = l.touches[l.touches.length - 1], u = o.getBoundingClientRect();
+        a = {
+          x: c.clientX - (u.left ?? 0),
+          y: c.clientY - (u.top ?? 0)
+        };
+      }
+      const h = i.retina.pixelRatio;
+      a && (a.x *= h, a.y *= h), r.mouse.position = a, r.status = ve;
+    }, this._touchEnd = (t) => {
+      const i = t, s = Array.from(i.changedTouches);
+      for (const r of s)
+        this._touches.delete(r.identifier);
+      this._mouseTouchFinish();
+    }, this._touchEndClick = (t) => {
+      const i = t, s = Array.from(i.changedTouches);
+      for (const r of s)
+        this._touches.delete(r.identifier);
+      this._mouseTouchClick(t);
+    }, this._touchStart = (t) => {
+      const i = t, s = Array.from(i.changedTouches);
+      for (const r of s)
+        this._touches.set(r.identifier, performance.now());
+      this._mouseTouchMove(t);
+    }, this._canPush = !0, this._touches = /* @__PURE__ */ new Map(), this._handlers = {
+      mouseDown: () => this._mouseDown(),
+      mouseLeave: () => this._mouseTouchFinish(),
+      mouseMove: (t) => this._mouseTouchMove(t),
+      mouseUp: (t) => this._mouseTouchClick(t),
+      touchStart: (t) => this._touchStart(t),
+      touchMove: (t) => this._mouseTouchMove(t),
+      touchEnd: (t) => this._touchEnd(t),
+      touchCancel: (t) => this._touchEnd(t),
+      touchEndClick: (t) => this._touchEndClick(t),
+      visibilityChange: () => this._handleVisibilityChange(),
+      themeChange: (t) => this._handleThemeChange(t),
+      oldThemeChange: (t) => this._handleThemeChange(t),
+      resize: () => {
+        this._handleWindowResize();
+      }
+    };
+  }
+  addListeners() {
+    this._manageListeners(!0);
+  }
+  removeListeners() {
+    this._manageListeners(!1);
+  }
+}
+class O {
+  constructor() {
+    this.value = "";
+  }
+  static create(e, t) {
+    const i = new O();
+    return i.load(e), t !== void 0 && (C(t) || S(t) ? i.load({ value: t }) : i.load(t)), i;
+  }
+  load(e) {
+    e?.value !== void 0 && (this.value = e.value);
+  }
+}
+class Tt {
+  constructor() {
+    this.color = new O(), this.color.value = "", this.image = "", this.position = "", this.repeat = "", this.size = "", this.opacity = 1;
+  }
+  load(e) {
+    e && (e.color !== void 0 && (this.color = O.create(this.color, e.color)), e.image !== void 0 && (this.image = e.image), e.position !== void 0 && (this.position = e.position), e.repeat !== void 0 && (this.repeat = e.repeat), e.size !== void 0 && (this.size = e.size), e.opacity !== void 0 && (this.opacity = e.opacity));
+  }
+}
+class Rt {
+  constructor() {
+    this.color = new O(), this.color.value = "#fff", this.opacity = 1;
+  }
+  load(e) {
+    e && (e.color !== void 0 && (this.color = O.create(this.color, e.color)), e.opacity !== void 0 && (this.opacity = e.opacity));
+  }
+}
+class It {
+  constructor() {
+    this.composite = "destination-out", this.cover = new Rt(), this.enable = !1;
+  }
+  load(e) {
+    if (e) {
+      if (e.composite !== void 0 && (this.composite = e.composite), e.cover !== void 0) {
+        const t = e.cover, i = C(e.cover) ? { color: e.cover } : e.cover;
+        this.cover.load(t.color !== void 0 ? t : { color: i });
+      }
+      e.enable !== void 0 && (this.enable = e.enable);
+    }
+  }
+}
+class Et {
+  constructor() {
+    this.enable = !0, this.zIndex = 0;
+  }
+  load(e) {
+    e && (e.enable !== void 0 && (this.enable = e.enable), e.zIndex !== void 0 && (this.zIndex = e.zIndex));
+  }
+}
+class Dt {
+  constructor() {
+    this.enable = !1, this.mode = [];
+  }
+  load(e) {
+    e && (e.enable !== void 0 && (this.enable = e.enable), e.mode !== void 0 && (this.mode = e.mode));
+  }
+}
+class Me {
+  constructor() {
+    this.selectors = [], this.enable = !1, this.mode = [], this.type = "circle";
+  }
+  get el() {
+    return this.elementId;
+  }
+  set el(e) {
+    this.elementId = e;
+  }
+  get elementId() {
+    return this.ids;
+  }
+  set elementId(e) {
+    this.ids = e;
+  }
+  get ids() {
+    return E(this.selectors, (e) => e.replace("#", ""));
+  }
+  set ids(e) {
+    this.selectors = E(e, (t) => `#${t}`);
+  }
+  load(e) {
+    if (!e)
+      return;
+    const t = e.ids ?? e.elementId ?? e.el;
+    t !== void 0 && (this.ids = t), e.selectors !== void 0 && (this.selectors = e.selectors), e.enable !== void 0 && (this.enable = e.enable), e.mode !== void 0 && (this.mode = e.mode), e.type !== void 0 && (this.type = e.type);
+  }
+}
+class At {
+  constructor() {
+    this.enable = !1, this.force = 2, this.smooth = 10;
+  }
+  load(e) {
+    e && (e.enable !== void 0 && (this.enable = e.enable), e.force !== void 0 && (this.force = e.force), e.smooth !== void 0 && (this.smooth = e.smooth));
+  }
+}
+class Lt {
+  constructor() {
+    this.enable = !1, this.mode = [], this.parallax = new At();
+  }
+  load(e) {
+    e && (e.enable !== void 0 && (this.enable = e.enable), e.mode !== void 0 && (this.mode = e.mode), this.parallax.load(e.parallax));
+  }
+}
+class Ft {
+  constructor() {
+    this.delay = 0.5, this.enable = !0;
+  }
+  load(e) {
+    e !== void 0 && (e.delay !== void 0 && (this.delay = e.delay), e.enable !== void 0 && (this.enable = e.enable));
+  }
+}
+class Vt {
+  constructor() {
+    this.onClick = new Dt(), this.onDiv = new Me(), this.onHover = new Lt(), this.resize = new Ft();
+  }
+  get onclick() {
+    return this.onClick;
+  }
+  set onclick(e) {
+    this.onClick = e;
+  }
+  get ondiv() {
+    return this.onDiv;
+  }
+  set ondiv(e) {
+    this.onDiv = e;
+  }
+  get onhover() {
+    return this.onHover;
+  }
+  set onhover(e) {
+    this.onHover = e;
+  }
+  load(e) {
+    if (!e)
+      return;
+    this.onClick.load(e.onClick ?? e.onclick);
+    const t = e.onDiv ?? e.ondiv;
+    t !== void 0 && (this.onDiv = E(t, (i) => {
+      const s = new Me();
+      return s.load(i), s;
+    })), this.onHover.load(e.onHover ?? e.onhover), R(e.resize) ? this.resize.enable = e.resize : this.resize.load(e.resize);
+  }
+}
+class Ht {
+  constructor(e, t) {
+    this._engine = e, this._container = t;
+  }
+  load(e) {
+    if (!e || !this._container)
+      return;
+    const t = this._engine.plugins.interactors.get(this._container);
+    if (t)
+      for (const i of t)
+        i.loadModeOptions && i.loadModeOptions(this, e);
+  }
+}
+class Fe {
+  constructor(e, t) {
+    this.detectsOn = "window", this.events = new Vt(), this.modes = new Ht(e, t);
+  }
+  get detect_on() {
+    return this.detectsOn;
+  }
+  set detect_on(e) {
+    this.detectsOn = e;
+  }
+  load(e) {
+    if (!e)
+      return;
+    const t = e.detectsOn ?? e.detect_on;
+    t !== void 0 && (this.detectsOn = t), this.events.load(e.events), this.modes.load(e.modes);
+  }
+}
+class Ut {
+  load(e) {
+    e && (e.position && (this.position = {
+      x: e.position.x ?? 50,
+      y: e.position.y ?? 50,
+      mode: e.position.mode ?? "percent"
+    }), e.options && (this.options = x({}, e.options)));
+  }
+}
+class Bt {
+  constructor() {
+    this.maxWidth = 1 / 0, this.options = {}, this.mode = "canvas";
+  }
+  load(e) {
+    e && (e.maxWidth !== void 0 && (this.maxWidth = e.maxWidth), e.mode !== void 0 && (e.mode === "screen" ? this.mode = "screen" : this.mode = "canvas"), e.options !== void 0 && (this.options = x({}, e.options)));
+  }
+}
+class Wt {
+  constructor() {
+    this.auto = !1, this.mode = "any", this.value = !1;
+  }
+  load(e) {
+    e && (e.auto !== void 0 && (this.auto = e.auto), e.mode !== void 0 && (this.mode = e.mode), e.value !== void 0 && (this.value = e.value));
+  }
+}
+class $t {
+  constructor() {
+    this.name = "", this.default = new Wt();
+  }
+  load(e) {
+    e && (e.name !== void 0 && (this.name = e.name), this.default.load(e.default), e.options !== void 0 && (this.options = x({}, e.options)));
+  }
+}
+class ee {
+  constructor() {
+    this.count = 0, this.enable = !1, this.offset = 0, this.speed = 1, this.delay = 0, this.decay = 0, this.sync = !0;
+  }
+  load(e) {
+    e && (e.count !== void 0 && (this.count = p(e.count)), e.enable !== void 0 && (this.enable = e.enable), e.offset !== void 0 && (this.offset = p(e.offset)), e.speed !== void 0 && (this.speed = p(e.speed)), e.decay !== void 0 && (this.decay = p(e.decay)), e.delay !== void 0 && (this.delay = p(e.delay)), e.sync !== void 0 && (this.sync = e.sync));
+  }
+}
+class Gt {
+  constructor() {
+    this.h = new ee(), this.s = new ee(), this.l = new ee();
+  }
+  load(e) {
+    e && (this.h.load(e.h), this.s.load(e.s), this.l.load(e.l));
+  }
+}
+class G extends O {
+  constructor() {
+    super(), this.animation = new Gt();
+  }
+  static create(e, t) {
+    const i = new G();
+    return i.load(e), t !== void 0 && (C(t) || S(t) ? i.load({ value: t }) : i.load(t)), i;
+  }
+  load(e) {
+    if (super.load(e), !e)
+      return;
+    const t = e.animation;
+    t !== void 0 && (t.enable !== void 0 ? this.animation.h.load(t) : this.animation.load(e.animation));
+  }
+}
+class Nt {
+  constructor() {
+    this.speed = 2;
+  }
+  load(e) {
+    e && e.speed !== void 0 && (this.speed = e.speed);
+  }
+}
+class qt {
+  constructor() {
+    this.enable = !0, this.retries = 0;
+  }
+  load(e) {
+    e && (e.enable !== void 0 && (this.enable = e.enable), e.retries !== void 0 && (this.retries = e.retries));
+  }
+}
+class Xt {
+  constructor() {
+    this.count = 0, this.enable = !1, this.speed = 1, this.decay = 0, this.delay = 0, this.sync = !1;
+  }
+  load(e) {
+    e && (e.count !== void 0 && (this.count = p(e.count)), e.enable !== void 0 && (this.enable = e.enable), e.speed !== void 0 && (this.speed = p(e.speed)), e.decay !== void 0 && (this.decay = p(e.decay)), e.delay !== void 0 && (this.delay = p(e.delay)), e.sync !== void 0 && (this.sync = e.sync));
+  }
+}
+class Ve extends Xt {
+  constructor() {
+    super(), this.mode = "auto", this.startValue = "random";
+  }
+  load(e) {
+    super.load(e), e && (e.minimumValue !== void 0 && (this.minimumValue = e.minimumValue), e.mode !== void 0 && (this.mode = e.mode), e.startValue !== void 0 && (this.startValue = e.startValue));
+  }
+}
+class Yt {
+  constructor() {
+    this.enable = !1, this.minimumValue = 0;
+  }
+  load(e) {
+    e && (e.enable !== void 0 && (this.enable = e.enable), e.minimumValue !== void 0 && (this.minimumValue = e.minimumValue));
+  }
+}
+class N {
+  constructor() {
+    this.random = new Yt(), this.value = 0;
+  }
+  load(e) {
+    e && (R(e.random) ? this.random.enable = e.random : this.random.load(e.random), e.value !== void 0 && (this.value = p(e.value, this.random.enable ? this.random.minimumValue : void 0)));
+  }
+}
+class Pe extends N {
+  constructor() {
+    super(), this.random.minimumValue = 0.1, this.value = 1;
+  }
+}
+class He {
+  constructor() {
+    this.horizontal = new Pe(), this.vertical = new Pe();
+  }
+  load(e) {
+    e && (this.horizontal.load(e.horizontal), this.vertical.load(e.vertical));
+  }
+}
+class Zt {
+  constructor() {
+    this.absorb = new Nt(), this.bounce = new He(), this.enable = !1, this.maxSpeed = 50, this.mode = "bounce", this.overlap = new qt();
+  }
+  load(e) {
+    e && (this.absorb.load(e.absorb), this.bounce.load(e.bounce), e.enable !== void 0 && (this.enable = e.enable), e.maxSpeed !== void 0 && (this.maxSpeed = p(e.maxSpeed)), e.mode !== void 0 && (this.mode = e.mode), this.overlap.load(e.overlap));
+  }
+}
+class Qt {
+  constructor() {
+    this.offset = 0, this.value = 90;
+  }
+  load(e) {
+    e && (e.offset !== void 0 && (this.offset = p(e.offset)), e.value !== void 0 && (this.value = p(e.value)));
+  }
+}
+class Jt {
+  constructor() {
+    this.distance = 200, this.enable = !1, this.rotate = {
+      x: 3e3,
+      y: 3e3
+    };
+  }
+  get rotateX() {
+    return this.rotate.x;
+  }
+  set rotateX(e) {
+    this.rotate.x = e;
+  }
+  get rotateY() {
+    return this.rotate.y;
+  }
+  set rotateY(e) {
+    this.rotate.y = e;
+  }
+  load(e) {
+    if (!e)
+      return;
+    e.distance !== void 0 && (this.distance = p(e.distance)), e.enable !== void 0 && (this.enable = e.enable);
+    const t = e.rotate?.x ?? e.rotateX;
+    t !== void 0 && (this.rotate.x = t);
+    const i = e.rotate?.y ?? e.rotateY;
+    i !== void 0 && (this.rotate.y = i);
+  }
+}
+class jt {
+  constructor() {
+    this.x = 50, this.y = 50, this.mode = "percent", this.radius = 0;
+  }
+  load(e) {
+    e && (e.x !== void 0 && (this.x = e.x), e.y !== void 0 && (this.y = e.y), e.mode !== void 0 && (this.mode = e.mode), e.radius !== void 0 && (this.radius = e.radius));
+  }
+}
+class Kt {
+  constructor() {
+    this.acceleration = 9.81, this.enable = !1, this.inverse = !1, this.maxSpeed = 50;
+  }
+  load(e) {
+    e && (e.acceleration !== void 0 && (this.acceleration = p(e.acceleration)), e.enable !== void 0 && (this.enable = e.enable), e.inverse !== void 0 && (this.inverse = e.inverse), e.maxSpeed !== void 0 && (this.maxSpeed = p(e.maxSpeed)));
+  }
+}
+class ei {
+  constructor() {
+    this.clamp = !0, this.delay = new N(), this.enable = !1, this.options = {};
+  }
+  load(e) {
+    e && (e.clamp !== void 0 && (this.clamp = e.clamp), this.delay.load(e.delay), e.enable !== void 0 && (this.enable = e.enable), this.generator = e.generator, e.options && (this.options = x(this.options, e.options)));
+  }
+}
+class ti {
+  load(e) {
+    e && (e.color !== void 0 && (this.color = O.create(this.color, e.color)), e.image !== void 0 && (this.image = e.image));
+  }
+}
+class ii {
+  constructor() {
+    this.enable = !1, this.length = 10, this.fill = new ti();
+  }
+  get fillColor() {
+    return this.fill.color;
+  }
+  set fillColor(e) {
+    this.fill.load({ color: e });
+  }
+  load(e) {
+    e && (e.enable !== void 0 && (this.enable = e.enable), (e.fill !== void 0 || e.fillColor !== void 0) && this.fill.load(e.fill || { color: e.fillColor }), e.length !== void 0 && (this.length = e.length));
+  }
+}
+class si {
+  constructor() {
+    this.default = "out";
+  }
+  load(e) {
+    e && (e.default !== void 0 && (this.default = e.default), this.bottom = e.bottom ?? e.default, this.left = e.left ?? e.default, this.right = e.right ?? e.default, this.top = e.top ?? e.default);
+  }
+}
+class ni {
+  constructor() {
+    this.acceleration = 0, this.enable = !1;
+  }
+  load(e) {
+    e && (e.acceleration !== void 0 && (this.acceleration = p(e.acceleration)), e.enable !== void 0 && (this.enable = e.enable), e.position && (this.position = x({}, e.position)));
+  }
+}
+class ri {
+  constructor() {
+    this.angle = new Qt(), this.attract = new Jt(), this.center = new jt(), this.decay = 0, this.distance = {}, this.direction = "none", this.drift = 0, this.enable = !1, this.gravity = new Kt(), this.path = new ei(), this.outModes = new si(), this.random = !1, this.size = !1, this.speed = 2, this.spin = new ni(), this.straight = !1, this.trail = new ii(), this.vibrate = !1, this.warp = !1;
+  }
+  get bounce() {
+    return this.collisions;
+  }
+  set bounce(e) {
+    this.collisions = e;
+  }
+  get collisions() {
+    return !1;
+  }
+  set collisions(e) {
+  }
+  get noise() {
+    return this.path;
+  }
+  set noise(e) {
+    this.path = e;
+  }
+  get outMode() {
+    return this.outModes.default;
+  }
+  set outMode(e) {
+    this.outModes.default = e;
+  }
+  get out_mode() {
+    return this.outMode;
+  }
+  set out_mode(e) {
+    this.outMode = e;
+  }
+  load(e) {
+    if (!e)
+      return;
+    this.angle.load(k(e.angle) ? { value: e.angle } : e.angle), this.attract.load(e.attract), this.center.load(e.center), e.decay !== void 0 && (this.decay = p(e.decay)), e.direction !== void 0 && (this.direction = e.direction), e.distance !== void 0 && (this.distance = k(e.distance) ? {
+      horizontal: e.distance,
+      vertical: e.distance
+    } : { ...e.distance }), e.drift !== void 0 && (this.drift = p(e.drift)), e.enable !== void 0 && (this.enable = e.enable), this.gravity.load(e.gravity);
+    const t = e.outModes ?? e.outMode ?? e.out_mode;
+    t !== void 0 && (U(t) ? this.outModes.load(t) : this.outModes.load({
+      default: t
+    })), this.path.load(e.path ?? e.noise), e.random !== void 0 && (this.random = e.random), e.size !== void 0 && (this.size = e.size), e.speed !== void 0 && (this.speed = p(e.speed)), this.spin.load(e.spin), e.straight !== void 0 && (this.straight = e.straight), this.trail.load(e.trail), e.vibrate !== void 0 && (this.vibrate = e.vibrate), e.warp !== void 0 && (this.warp = e.warp);
+  }
+}
+class oi extends Ve {
+  constructor() {
+    super(), this.destroy = "none", this.speed = 2;
+  }
+  get opacity_min() {
+    return this.minimumValue;
+  }
+  set opacity_min(e) {
+    this.minimumValue = e;
+  }
+  load(e) {
+    e?.opacity_min !== void 0 && e.minimumValue === void 0 && (e.minimumValue = e.opacity_min), super.load(e), e && e.destroy !== void 0 && (this.destroy = e.destroy);
+  }
+}
+class ai extends N {
+  constructor() {
+    super(), this.animation = new oi(), this.random.minimumValue = 0.1, this.value = 1;
+  }
+  get anim() {
+    return this.animation;
+  }
+  set anim(e) {
+    this.animation = e;
+  }
+  load(e) {
+    if (!e)
+      return;
+    super.load(e);
+    const t = e.animation ?? e.anim;
+    t !== void 0 && (this.animation.load(t), this.value = p(this.value, this.animation.enable ? this.animation.minimumValue : void 0));
+  }
+}
+class hi {
+  constructor() {
+    this.enable = !1, this.width = 1920, this.height = 1080;
+  }
+  get area() {
+    return this.width;
+  }
+  set area(e) {
+    this.width = e;
+  }
+  get factor() {
+    return this.height;
+  }
+  set factor(e) {
+    this.height = e;
+  }
+  get value_area() {
+    return this.area;
+  }
+  set value_area(e) {
+    this.area = e;
+  }
+  load(e) {
+    if (!e)
+      return;
+    e.enable !== void 0 && (this.enable = e.enable);
+    const t = e.width ?? e.area ?? e.value_area;
+    t !== void 0 && (this.width = t);
+    const i = e.height ?? e.factor;
+    i !== void 0 && (this.height = i);
+  }
+}
+class li {
+  constructor() {
+    this.density = new hi(), this.limit = 0, this.value = 0;
+  }
+  get max() {
+    return this.limit;
+  }
+  set max(e) {
+    this.limit = e;
+  }
+  load(e) {
+    if (!e)
+      return;
+    this.density.load(e.density);
+    const t = e.limit ?? e.max;
+    t !== void 0 && (this.limit = t), e.value !== void 0 && (this.value = e.value);
+  }
+}
+class ci {
+  constructor() {
+    this.blur = 0, this.color = new O(), this.enable = !1, this.offset = {
+      x: 0,
+      y: 0
+    }, this.color.value = "#000";
+  }
+  load(e) {
+    e && (e.blur !== void 0 && (this.blur = e.blur), this.color = O.create(this.color, e.color), e.enable !== void 0 && (this.enable = e.enable), e.offset !== void 0 && (e.offset.x !== void 0 && (this.offset.x = e.offset.x), e.offset.y !== void 0 && (this.offset.y = e.offset.y)));
+  }
+}
+const te = "character", ie = "char", se = "image", ne = "images", re = "polygon", oe = "star";
+class ui {
+  constructor() {
+    this.loadShape = (e, t, i, s) => {
+      if (!e)
+        return;
+      const r = S(e), o = r ? [] : {}, a = r !== S(this.options[t]), h = r !== S(this.options[i]);
+      a && (this.options[t] = o), h && s && (this.options[i] = o), this.options[t] = x(this.options[t] ?? o, e), (!this.options[i] || s) && (this.options[i] = x(this.options[i] ?? o, e));
+    }, this.close = !0, this.fill = !0, this.options = {}, this.type = "circle";
+  }
+  get character() {
+    return this.options[te] ?? this.options[ie];
+  }
+  set character(e) {
+    this.options[ie] = this.options[te] = e;
+  }
+  get custom() {
+    return this.options;
+  }
+  set custom(e) {
+    this.options = e;
+  }
+  get image() {
+    return this.options[se] ?? this.options[ne];
+  }
+  set image(e) {
+    this.options[ne] = this.options[se] = e;
+  }
+  get images() {
+    return this.image;
+  }
+  set images(e) {
+    this.image = e;
+  }
+  get polygon() {
+    return this.options[re] ?? this.options[oe];
+  }
+  set polygon(e) {
+    this.options[oe] = this.options[re] = e;
+  }
+  get stroke() {
+    return [];
+  }
+  set stroke(e) {
+  }
+  load(e) {
+    if (!e)
+      return;
+    const t = e.options ?? e.custom;
+    if (t !== void 0)
+      for (const i in t) {
+        const s = t[i];
+        s && (this.options[i] = x(this.options[i] ?? {}, s));
+      }
+    this.loadShape(e.character, te, ie, !0), this.loadShape(e.polygon, re, oe, !1), this.loadShape(e.image ?? e.images, se, ne, !0), e.close !== void 0 && (this.close = e.close), e.fill !== void 0 && (this.fill = e.fill), e.type !== void 0 && (this.type = e.type);
+  }
+}
+class fi extends Ve {
+  constructor() {
+    super(), this.destroy = "none", this.speed = 5;
+  }
+  get size_min() {
+    return this.minimumValue;
+  }
+  set size_min(e) {
+    this.minimumValue = e;
+  }
+  load(e) {
+    e?.size_min !== void 0 && e.minimumValue === void 0 && (e.minimumValue = e.size_min), super.load(e), e && e.destroy !== void 0 && (this.destroy = e.destroy);
+  }
+}
+class di extends N {
+  constructor() {
+    super(), this.animation = new fi(), this.random.minimumValue = 1, this.value = 3;
+  }
+  get anim() {
+    return this.animation;
+  }
+  set anim(e) {
+    this.animation = e;
+  }
+  load(e) {
+    if (super.load(e), !e)
+      return;
+    const t = e.animation ?? e.anim;
+    t !== void 0 && (this.animation.load(t), this.value = p(this.value, this.animation.enable ? this.animation.minimumValue : void 0));
+  }
+}
+class ke {
+  constructor() {
+    this.width = 0;
+  }
+  load(e) {
+    e && (e.color !== void 0 && (this.color = G.create(this.color, e.color)), e.width !== void 0 && (this.width = p(e.width)), e.opacity !== void 0 && (this.opacity = p(e.opacity)));
+  }
+}
+class pi extends N {
+  constructor() {
+    super(), this.opacityRate = 1, this.sizeRate = 1, this.velocityRate = 1;
+  }
+  load(e) {
+    super.load(e), e && (e.opacityRate !== void 0 && (this.opacityRate = e.opacityRate), e.sizeRate !== void 0 && (this.sizeRate = e.sizeRate), e.velocityRate !== void 0 && (this.velocityRate = e.velocityRate));
+  }
+}
+class mi {
+  constructor(e, t) {
+    this._engine = e, this._container = t, this.bounce = new He(), this.collisions = new Zt(), this.color = new G(), this.color.value = "#fff", this.groups = {}, this.move = new ri(), this.number = new li(), this.opacity = new ai(), this.reduceDuplicates = !1, this.shadow = new ci(), this.shape = new ui(), this.size = new di(), this.stroke = new ke(), this.zIndex = new pi();
+  }
+  load(e) {
+    if (!e)
+      return;
+    if (this.bounce.load(e.bounce), this.color.load(G.create(this.color, e.color)), e.groups !== void 0)
+      for (const s in e.groups) {
+        const r = e.groups[s];
+        r !== void 0 && (this.groups[s] = x(this.groups[s] ?? {}, r));
+      }
+    this.move.load(e.move), this.number.load(e.number), this.opacity.load(e.opacity), e.reduceDuplicates !== void 0 && (this.reduceDuplicates = e.reduceDuplicates), this.shape.load(e.shape), this.size.load(e.size), this.shadow.load(e.shadow), this.zIndex.load(e.zIndex);
+    const t = e.move?.collisions ?? e.move?.bounce;
+    t !== void 0 && (this.collisions.enable = t), this.collisions.load(e.collisions), e.interactivity !== void 0 && (this.interactivity = x({}, e.interactivity));
+    const i = e.stroke ?? e.shape?.stroke;
+    if (i && (this.stroke = E(i, (s) => {
+      const r = new ke();
+      return r.load(s), r;
+    })), this._container) {
+      const s = this._engine.plugins.updaters.get(this._container);
+      if (s)
+        for (const o of s)
+          o.loadOptions && o.loadOptions(this, e);
+      const r = this._engine.plugins.interactors.get(this._container);
+      if (r)
+        for (const o of r)
+          o.loadParticlesOptions && o.loadParticlesOptions(this, e);
+    }
+  }
+}
+function Ue(n, ...e) {
+  for (const t of e)
+    n.load(t);
+}
+function Be(n, e, ...t) {
+  const i = new mi(n, e);
+  return Ue(i, ...t), i;
+}
+class gi {
+  constructor(e, t) {
+    this._findDefaultTheme = (i) => this.themes.find((s) => s.default.value && s.default.mode === i) ?? this.themes.find((s) => s.default.value && s.default.mode === "any"), this._importPreset = (i) => {
+      this.load(this._engine.plugins.getPreset(i));
+    }, this._engine = e, this._container = t, this.autoPlay = !0, this.background = new Tt(), this.backgroundMask = new It(), this.defaultThemes = {}, this.delay = 0, this.fullScreen = new Et(), this.detectRetina = !0, this.duration = 0, this.fpsLimit = 120, this.interactivity = new Fe(e, t), this.manualParticles = [], this.particles = Be(this._engine, this._container), this.pauseOnBlur = !0, this.pauseOnOutsideViewport = !0, this.responsive = [], this.smooth = !1, this.style = {}, this.themes = [], this.zLayers = 100;
+  }
+  get backgroundMode() {
+    return this.fullScreen;
+  }
+  set backgroundMode(e) {
+    this.fullScreen.load(e);
+  }
+  get fps_limit() {
+    return this.fpsLimit;
+  }
+  set fps_limit(e) {
+    this.fpsLimit = e;
+  }
+  get retina_detect() {
+    return this.detectRetina;
+  }
+  set retina_detect(e) {
+    this.detectRetina = e;
+  }
+  load(e) {
+    if (!e)
+      return;
+    e.preset !== void 0 && E(e.preset, (o) => this._importPreset(o)), e.autoPlay !== void 0 && (this.autoPlay = e.autoPlay), e.delay !== void 0 && (this.delay = p(e.delay));
+    const t = e.detectRetina ?? e.retina_detect;
+    t !== void 0 && (this.detectRetina = t), e.duration !== void 0 && (this.duration = p(e.duration));
+    const i = e.fpsLimit ?? e.fps_limit;
+    i !== void 0 && (this.fpsLimit = i), e.pauseOnBlur !== void 0 && (this.pauseOnBlur = e.pauseOnBlur), e.pauseOnOutsideViewport !== void 0 && (this.pauseOnOutsideViewport = e.pauseOnOutsideViewport), e.zLayers !== void 0 && (this.zLayers = e.zLayers), this.background.load(e.background);
+    const s = e.fullScreen ?? e.backgroundMode;
+    R(s) ? this.fullScreen.enable = s : this.fullScreen.load(s), this.backgroundMask.load(e.backgroundMask), this.interactivity.load(e.interactivity), e.manualParticles && (this.manualParticles = e.manualParticles.map((o) => {
+      const a = new Ut();
+      return a.load(o), a;
+    })), this.particles.load(e.particles), this.style = x(this.style, e.style), this._engine.plugins.loadOptions(this, e), e.smooth !== void 0 && (this.smooth = e.smooth);
+    const r = this._engine.plugins.interactors.get(this._container);
+    if (r)
+      for (const o of r)
+        o.loadOptions && o.loadOptions(this, e);
+    if (e.responsive !== void 0)
+      for (const o of e.responsive) {
+        const a = new Bt();
+        a.load(o), this.responsive.push(a);
+      }
+    if (this.responsive.sort((o, a) => o.maxWidth - a.maxWidth), e.themes !== void 0)
+      for (const o of e.themes) {
+        const a = this.themes.find((h) => h.name === o.name);
+        if (a)
+          a.load(o);
+        else {
+          const h = new $t();
+          h.load(o), this.themes.push(h);
+        }
+      }
+    this.defaultThemes.dark = this._findDefaultTheme("dark")?.name, this.defaultThemes.light = this._findDefaultTheme("light")?.name;
+  }
+  setResponsive(e, t, i) {
+    this.load(i);
+    const s = this.responsive.find((r) => r.mode === "screen" && screen ? r.maxWidth > screen.availWidth : r.maxWidth * t > e);
+    return this.load(s?.options), s?.maxWidth;
+  }
+  setTheme(e) {
+    if (e) {
+      const t = this.themes.find((i) => i.name === e);
+      t && this.load(t.options);
+    } else {
+      const t = Ee("(prefers-color-scheme: dark)"), i = t && t.matches, s = this._findDefaultTheme(i ? "dark" : "light");
+      s && this.load(s.options);
+    }
+  }
+}
+class yi {
+  constructor(e, t) {
+    this.container = t, this._engine = e, this._interactors = e.plugins.getInteractors(this.container, !0), this._externalInteractors = [], this._particleInteractors = [];
+  }
+  async externalInteract(e) {
+    for (const t of this._externalInteractors)
+      t.isEnabled() && await t.interact(e);
+  }
+  handleClickMode(e) {
+    for (const t of this._externalInteractors)
+      t.handleClickMode && t.handleClickMode(e);
+  }
+  init() {
+    this._externalInteractors = [], this._particleInteractors = [];
+    for (const e of this._interactors) {
+      switch (e.type) {
+        case "external":
+          this._externalInteractors.push(e);
+          break;
+        case "particles":
+          this._particleInteractors.push(e);
+          break;
+      }
+      e.init();
+    }
+  }
+  async particlesInteract(e, t) {
+    for (const i of this._externalInteractors)
+      i.clear(e, t);
+    for (const i of this._particleInteractors)
+      i.isEnabled(e) && await i.interact(e, t);
+  }
+  async reset(e) {
+    for (const t of this._externalInteractors)
+      t.isEnabled() && t.reset(e);
+    for (const t of this._particleInteractors)
+      t.isEnabled(e) && t.reset(e);
+  }
+}
+const Ce = (n) => {
+  if (!lt(n.outMode, n.checkModes))
+    return;
+  const e = n.radius * 2;
+  n.coord > n.maxCoord - e ? n.setCb(-n.radius) : n.coord < e && n.setCb(n.radius);
+};
+class vi {
+  constructor(e, t, i, s, r, o) {
+    this.container = i, this._calcPosition = (a, h, l, c = 0) => {
+      for (const [, z] of a.plugins) {
+        const w = z.particlePosition !== void 0 ? z.particlePosition(h, this) : void 0;
+        if (w)
+          return M.create(w.x, w.y, l);
+      }
+      const u = a.canvas.size, f = rt({
+        size: u,
+        position: h
+      }), d = M.create(f.x, f.y, l), y = this.getRadius(), m = this.options.move.outModes, b = (z) => {
+        Ce({
+          outMode: z,
+          checkModes: ["bounce", "bounce-horizontal"],
+          coord: d.x,
+          maxCoord: a.canvas.size.width,
+          setCb: (w) => d.x += w,
+          radius: y
+        });
+      }, _ = (z) => {
+        Ce({
+          outMode: z,
+          checkModes: ["bounce", "bounce-vertical"],
+          coord: d.y,
+          maxCoord: a.canvas.size.height,
+          setCb: (w) => d.y += w,
+          radius: y
+        });
+      };
+      return b(m.left ?? m.default), b(m.right ?? m.default), _(m.top ?? m.default), _(m.bottom ?? m.default), this._checkOverlap(d, c) ? this._calcPosition(a, void 0, l, c + 1) : d;
+    }, this._calculateVelocity = () => {
+      const a = nt(this.direction), h = a.copy(), l = this.options.move;
+      if (l.direction === "inside" || l.direction === "outside")
+        return h;
+      const c = Math.PI / 180 * g(l.angle.value), u = Math.PI / 180 * g(l.angle.offset), f = {
+        left: u - c / 2,
+        right: u + c / 2
+      };
+      return l.straight || (h.angle += F(p(f.left, f.right))), l.random && typeof l.speed == "number" && (h.length *= T()), h;
+    }, this._checkOverlap = (a, h = 0) => {
+      const l = this.options.collisions, c = this.getRadius();
+      if (!l.enable)
+        return !1;
+      const u = l.overlap;
+      if (u.enable)
+        return !1;
+      const f = u.retries;
+      if (f >= 0 && h > f)
+        throw new Error(`${I} particle is overlapping and can't be placed`);
+      return !!this.container.particles.find((d) => fe(a, d.position) < c + d.getRadius());
+    }, this._getRollColor = (a) => {
+      if (!a || !this.roll || !this.backColor && !this.roll.alter)
+        return a;
+      const h = this.roll.horizontal && this.roll.vertical ? 2 : 1, l = this.roll.horizontal ? Math.PI / 2 : 0;
+      return Math.floor(((this.roll.angle ?? 0) + l) / (Math.PI / h)) % 2 ? this.backColor ? this.backColor : this.roll.alter ? kt(a, this.roll.alter.type, this.roll.alter.value) : a : a;
+    }, this._initPosition = (a) => {
+      const h = this.container, l = g(this.options.zIndex.value);
+      this.position = this._calcPosition(h, a, Re(l, 0, h.zLayers)), this.initialPosition = this.position.copy();
+      const c = h.canvas.size;
+      switch (this.moveCenter = {
+        ...De(this.options.move.center, c),
+        radius: this.options.move.center.radius ?? 0,
+        mode: this.options.move.center.mode ?? "percent"
+      }, this.direction = st(this.options.move.direction, this.position, this.moveCenter), this.options.move.direction) {
+        case "inside":
+          this.outType = "inside";
+          break;
+        case "outside":
+          this.outType = "outside";
+          break;
+      }
+      this.offset = L.origin;
+    }, this._loadShapeData = (a, h) => {
+      const l = a.options[this.shape];
+      if (l)
+        return x({
+          close: a.close,
+          fill: a.fill
+        }, W(l, this.id, h));
+    }, this._engine = e, this.init(t, s, r, o);
+  }
+  destroy(e) {
+    if (this.unbreakable || this.destroyed)
+      return;
+    this.destroyed = !0, this.bubble.inRange = !1, this.slow.inRange = !1;
+    const t = this.container, i = this.pathGenerator;
+    for (const [, s] of t.plugins)
+      s.particleDestroyed && s.particleDestroyed(this, e);
+    for (const s of t.particles.updaters)
+      s.particleDestroyed && s.particleDestroyed(this, e);
+    i && i.reset(this);
+  }
+  draw(e) {
+    const t = this.container;
+    for (const [, i] of t.plugins)
+      t.canvas.drawParticlePlugin(i, this, e);
+    t.canvas.drawParticle(this, e);
+  }
+  getFillColor() {
+    return this._getRollColor(this.bubble.color ?? ze(this.color));
+  }
+  getMass() {
+    return this.getRadius() ** 2 * Math.PI / 2;
+  }
+  getPosition() {
+    return {
+      x: this.position.x + this.offset.x,
+      y: this.position.y + this.offset.y,
+      z: this.position.z
+    };
+  }
+  getRadius() {
+    return this.bubble.radius ?? this.size.value;
+  }
+  getStrokeColor() {
+    return this._getRollColor(this.bubble.color ?? ze(this.strokeColor));
+  }
+  init(e, t, i, s) {
+    const r = this.container, o = this._engine;
+    this.id = e, this.group = s, this.fill = !0, this.pathRotation = !1, this.close = !0, this.lastPathTime = 0, this.destroyed = !1, this.unbreakable = !1, this.rotation = 0, this.misplaced = !1, this.retina = {
+      maxDistance: {}
+    }, this.outType = "normal", this.ignoresResizeRatio = !0;
+    const a = r.retina.pixelRatio, h = r.actualOptions, l = Be(this._engine, r, h.particles), c = l.shape.type, { reduceDuplicates: u } = l;
+    this.shape = W(c, this.id, u);
+    const f = l.shape;
+    if (i && i.shape && i.shape.type) {
+      const w = i.shape.type, me = W(w, this.id, u);
+      me && (this.shape = me, f.load(i.shape));
+    }
+    this.shapeData = this._loadShapeData(f, u), l.load(i);
+    const d = this.shapeData;
+    d && l.load(d.particles);
+    const y = new Fe(o, r);
+    y.load(r.actualOptions.interactivity), y.load(l.interactivity), this.interactivity = y, this.fill = d?.fill ?? l.shape.fill, this.close = d?.close ?? l.shape.close, this.options = l;
+    const m = this.options.move.path;
+    this.pathDelay = tt(m.delay) * 1e3, m.generator && (this.pathGenerator = this._engine.plugins.getPathGenerator(m.generator), this.pathGenerator && r.addPath(m.generator, this.pathGenerator) && this.pathGenerator.init(r)), r.retina.initParticle(this), this.size = ut(this.options.size, a), this.bubble = {
+      inRange: !1
+    }, this.slow = {
+      inRange: !1,
+      factor: 1
+    }, this._initPosition(t), this.initialVelocity = this._calculateVelocity(), this.velocity = this.initialVelocity.copy(), this.moveDecay = 1 - g(this.options.move.decay);
+    const b = r.particles;
+    b.needsSort = b.needsSort || b.lastZIndex < this.position.z, b.lastZIndex = this.position.z, this.zIndexFactor = this.position.z / r.zLayers, this.sides = 24;
+    let _ = r.drawers.get(this.shape);
+    _ || (_ = this._engine.plugins.getShapeDrawer(this.shape), _ && r.drawers.set(this.shape, _)), _ && _.loadShape && _.loadShape(this);
+    const z = _?.getSidesCount;
+    z && (this.sides = z(this)), this.spawning = !1, this.shadowColor = V(this.options.shadow.color);
+    for (const w of r.particles.updaters)
+      w.init(this);
+    for (const w of r.particles.movers)
+      w.init && w.init(this);
+    _ && _.particleInit && _.particleInit(r, this);
+    for (const [, w] of r.plugins)
+      w.particleCreated && w.particleCreated(this);
+  }
+  isInsideCanvas() {
+    const e = this.getRadius(), t = this.container.canvas.size, i = this.position;
+    return i.x >= -e && i.y >= -e && i.y <= t.height + e && i.x <= t.width + e;
+  }
+  isVisible() {
+    return !this.destroyed && !this.spawning && this.isInsideCanvas();
+  }
+  reset() {
+    for (const e of this.container.particles.updaters)
+      e.reset && e.reset(this);
+  }
+}
+class _i {
+  constructor(e, t) {
+    this.position = e, this.particle = t;
+  }
+}
+class We {
+  constructor(e, t) {
+    this.position = {
+      x: e,
+      y: t
+    };
+  }
+}
+class H extends We {
+  constructor(e, t, i, s) {
+    super(e, t), this.size = {
+      height: s,
+      width: i
+    };
+  }
+  contains(e) {
+    const t = this.size.width, i = this.size.height, s = this.position;
+    return e.x >= s.x && e.x <= s.x + t && e.y >= s.y && e.y <= s.y + i;
+  }
+  intersects(e) {
+    e instanceof J && e.intersects(this);
+    const t = this.size.width, i = this.size.height, s = this.position, r = e.position, o = e instanceof H ? e.size : { width: 0, height: 0 }, a = o.width, h = o.height;
+    return r.x < s.x + t && r.x + a > s.x && r.y < s.y + i && r.y + h > s.y;
+  }
+}
+class J extends We {
+  constructor(e, t, i) {
+    super(e, t), this.radius = i;
+  }
+  contains(e) {
+    return fe(e, this.position) <= this.radius;
+  }
+  intersects(e) {
+    const t = this.position, i = e.position, s = { x: Math.abs(i.x - t.x), y: Math.abs(i.y - t.y) }, r = this.radius;
+    if (e instanceof J) {
+      const o = r + e.radius, a = Math.sqrt(s.x ** 2 + s.y ** 2);
+      return o > a;
+    } else if (e instanceof H) {
+      const { width: o, height: a } = e.size;
+      return Math.pow(s.x - o, 2) + Math.pow(s.y - a, 2) <= r ** 2 || s.x <= r + o && s.y <= r + a || s.x <= o || s.y <= a;
+    }
+    return !1;
+  }
+}
+class X {
+  constructor(e, t) {
+    this.rectangle = e, this.capacity = t, this._subdivide = () => {
+      const { x: i, y: s } = this.rectangle.position, { width: r, height: o } = this.rectangle.size, { capacity: a } = this;
+      for (let h = 0; h < 4; h++)
+        this._subs.push(new X(new H(i + r / 2 * (h % 2), s + o / 2 * (Math.round(h / 2) - h % 2), r / 2, o / 2), a));
+      this._divided = !0;
+    }, this._points = [], this._divided = !1, this._subs = [];
+  }
+  insert(e) {
+    return this.rectangle.contains(e.position) ? this._points.length < this.capacity ? (this._points.push(e), !0) : (this._divided || this._subdivide(), this._subs.some((t) => t.insert(e))) : !1;
+  }
+  query(e, t, i) {
+    const s = i || [];
+    if (!e.intersects(this.rectangle))
+      return [];
+    for (const r of this._points)
+      !e.contains(r.position) && fe(e.position, r.position) > r.particle.getRadius() && (!t || t(r.particle)) || s.push(r.particle);
+    if (this._divided)
+      for (const r of this._subs)
+        r.query(e, t, s);
+    return s;
+  }
+  queryCircle(e, t, i) {
+    return this.query(new J(e.x, e.y, t), i);
+  }
+  queryRectangle(e, t, i) {
+    return this.query(new H(e.x, e.y, t.width, t.height), i);
+  }
+}
+const Se = 4, Oe = (n) => new H(-n.width / 4, -n.height / 4, n.width * 3 / 2, n.height * 3 / 2);
+let wi = class {
+  constructor(e, t) {
+    this._applyDensity = (s, r, o) => {
+      if (!s.number.density?.enable)
+        return;
+      const a = s.number, h = this._initDensityFactor(a.density), l = a.value, c = a.limit > 0 ? a.limit : l, u = Math.min(l, c) * h + r, f = Math.min(this.count, this.filter((d) => d.group === o).length);
+      this.limit = a.limit * h, f < u ? this.push(Math.abs(u - f), void 0, s, o) : f > u && this.removeQuantity(f - u, o);
+    }, this._initDensityFactor = (s) => {
+      const r = this._container;
+      if (!r.canvas.element || !s.enable)
+        return 1;
+      const o = r.canvas.element, a = r.retina.pixelRatio;
+      return o.width * o.height / (s.factor * a ** 2 * s.area);
+    }, this._pushParticle = (s, r, o, a) => {
+      try {
+        let h = this.pool.pop();
+        h ? h.init(this._nextId, s, r, o) : h = new vi(this._engine, this._nextId, this._container, s, r, o);
+        let l = !0;
+        return a && (l = a(h)), l ? (this._array.push(h), this._zArray.push(h), this._nextId++, this._engine.dispatchEvent("particleAdded", {
+          container: this._container,
+          data: {
+            particle: h
+          }
+        }), h) : void 0;
+      } catch (h) {
+        $().warning(`${I} adding particle: ${h}`);
+        return;
+      }
+    }, this._removeParticle = (s, r, o) => {
+      const a = this._array[s];
+      if (!a || a.group !== r)
+        return !1;
+      a.destroy(o);
+      const h = this._zArray.indexOf(a);
+      return this._array.splice(s, 1), this._zArray.splice(h, 1), this.pool.push(a), this._engine.dispatchEvent("particleRemoved", {
+        container: this._container,
+        data: {
+          particle: a
+        }
+      }), !0;
+    }, this._engine = e, this._container = t, this._nextId = 0, this._array = [], this._zArray = [], this.pool = [], this.limit = 0, this.needsSort = !1, this.lastZIndex = 0, this._interactionManager = new yi(e, t);
+    const i = t.canvas.size;
+    this.quadTree = new X(Oe(i), Se), this.movers = this._engine.plugins.getMovers(t, !0), this.updaters = this._engine.plugins.getUpdaters(t, !0);
+  }
+  get count() {
+    return this._array.length;
+  }
+  addManualParticles() {
+    const e = this._container, t = e.actualOptions;
+    for (const i of t.manualParticles)
+      this.addParticle(i.position ? De(i.position, e.canvas.size) : void 0, i.options);
+  }
+  addParticle(e, t, i, s) {
+    const r = this._container, o = r.actualOptions, a = o.particles.number.limit;
+    if (a > 0) {
+      const h = this.count + 1 - a;
+      h > 0 && this.removeQuantity(h);
+    }
+    return this._pushParticle(e, t, i, s);
+  }
+  clear() {
+    this._array = [], this._zArray = [];
+  }
+  destroy() {
+    this._array = [], this._zArray = [], this.movers = [], this.updaters = [];
+  }
+  async draw(e) {
+    const t = this._container;
+    t.canvas.clear(), await this.update(e);
+    for (const [, i] of t.plugins)
+      t.canvas.drawPlugin(i, e);
+    for (const i of this._zArray)
+      i.draw(e);
+  }
+  filter(e) {
+    return this._array.filter(e);
+  }
+  find(e) {
+    return this._array.find(e);
+  }
+  handleClickMode(e) {
+    this._interactionManager.handleClickMode(e);
+  }
+  init() {
+    const e = this._container, t = e.actualOptions;
+    this.lastZIndex = 0, this.needsSort = !1;
+    let i = !1;
+    this.updaters = this._engine.plugins.getUpdaters(e, !0), this._interactionManager.init();
+    for (const [, s] of e.plugins)
+      if (s.particlesInitialization !== void 0 && (i = s.particlesInitialization()), i)
+        break;
+    this._interactionManager.init();
+    for (const [, s] of e.pathGenerators)
+      s.init(e);
+    if (this.addManualParticles(), !i) {
+      for (const s in t.particles.groups) {
+        const r = t.particles.groups[s];
+        for (let o = this.count, a = 0; a < r.number?.value && o < t.particles.number.value; o++, a++)
+          this.addParticle(void 0, r, s);
+      }
+      for (let s = this.count; s < t.particles.number.value; s++)
+        this.addParticle();
+    }
+  }
+  push(e, t, i, s) {
+    this.pushing = !0;
+    for (let r = 0; r < e; r++)
+      this.addParticle(t?.position, i, s);
+    this.pushing = !1;
+  }
+  async redraw() {
+    this.clear(), this.init(), await this.draw({ value: 0, factor: 0 });
+  }
+  remove(e, t, i) {
+    this.removeAt(this._array.indexOf(e), void 0, t, i);
+  }
+  removeAt(e, t = 1, i, s) {
+    if (e < 0 || e > this.count)
+      return;
+    let r = 0;
+    for (let o = e; r < t && o < this.count; o++)
+      this._removeParticle(o--, i, s) && r++;
+  }
+  removeQuantity(e, t) {
+    this.removeAt(0, e, t);
+  }
+  setDensity() {
+    const e = this._container.actualOptions, t = e.particles.groups;
+    for (const i in t)
+      this._applyDensity(t[i], 0, i);
+    this._applyDensity(e.particles, e.manualParticles.length);
+  }
+  async update(e) {
+    const t = this._container, i = /* @__PURE__ */ new Set();
+    this.quadTree = new X(Oe(t.canvas.size), Se);
+    for (const [, s] of t.pathGenerators)
+      s.update();
+    for (const [, s] of t.plugins)
+      s.update && s.update(e);
+    for (const s of this._array) {
+      const r = t.canvas.resizeFactor;
+      r && !s.ignoresResizeRatio && (s.position.x *= r.width, s.position.y *= r.height, s.initialPosition.x *= r.width, s.initialPosition.y *= r.height), s.ignoresResizeRatio = !1, await this._interactionManager.reset(s);
+      for (const [, o] of this._container.plugins) {
+        if (s.destroyed)
+          break;
+        o.particleUpdate && o.particleUpdate(s, e);
+      }
+      for (const o of this.movers)
+        o.isEnabled(s) && o.move(s, e);
+      if (s.destroyed) {
+        i.add(s);
+        continue;
+      }
+      this.quadTree.insert(new _i(s.getPosition(), s));
+    }
+    if (i.size) {
+      const s = (r) => !i.has(r);
+      this._array = this.filter(s), this._zArray = this._zArray.filter(s), this.pool.push(...i);
+    }
+    await this._interactionManager.externalInteract(e);
+    for (const s of this._array) {
+      for (const r of this.updaters)
+        r.update(s, e);
+      !s.destroyed && !s.spawning && await this._interactionManager.particlesInteract(s, e);
+    }
+    if (delete t.canvas.resizeFactor, this.needsSort) {
+      const s = this._zArray;
+      s.sort((r, o) => o.position.z - r.position.z || r.id - o.id), this.lastZIndex = s[s.length - 1].position.z, this.needsSort = !1;
+    }
+  }
+};
+class bi {
+  constructor(e) {
+    this.container = e, this.pixelRatio = 1, this.reduceFactor = 1;
+  }
+  init() {
+    const e = this.container, t = e.actualOptions;
+    this.pixelRatio = !t.detectRetina || Z() ? 1 : window.devicePixelRatio, this.reduceFactor = 1;
+    const i = this.pixelRatio;
+    if (e.canvas.element) {
+      const o = e.canvas.element;
+      e.canvas.size.width = o.offsetWidth * i, e.canvas.size.height = o.offsetHeight * i;
+    }
+    const s = t.particles, r = s.move;
+    this.attractDistance = g(r.attract.distance) * i, this.maxSpeed = g(r.gravity.maxSpeed) * i, this.sizeAnimationSpeed = g(s.size.animation.speed) * i;
+  }
+  initParticle(e) {
+    const t = e.options, i = this.pixelRatio, s = t.move, r = s.distance, o = e.retina;
+    o.attractDistance = g(s.attract.distance) * i, o.moveDrift = g(s.drift) * i, o.moveSpeed = g(s.speed) * i, o.sizeAnimationSpeed = g(t.size.animation.speed) * i;
+    const a = o.maxDistance;
+    a.horizontal = r.horizontal !== void 0 ? r.horizontal * i : void 0, a.vertical = r.vertical !== void 0 ? r.vertical * i : void 0, o.maxSpeed = g(s.gravity.maxSpeed) * i;
+  }
+}
+function v(n) {
+  return n && !n.destroyed;
+}
+function xi(n, e = 60, t = !1) {
+  return {
+    value: n,
+    factor: t ? 60 / e : 60 * n / 1e3
+  };
+}
+function D(n, e, ...t) {
+  const i = new gi(n, e);
+  return Ue(i, ...t), i;
+}
+const zi = "default", Te = {
+  generate: (n) => n.velocity,
+  init: () => {
+  },
+  update: () => {
+  },
+  reset: () => {
+  }
+};
+class Mi {
+  constructor(e, t, i) {
+    this.id = t, this._intersectionManager = (s) => {
+      if (!(!v(this) || !this.actualOptions.pauseOnOutsideViewport))
+        for (const r of s)
+          r.target === this.interactivity.element && (r.isIntersecting ? this.play : this.pause)();
+    }, this._nextFrame = async (s) => {
+      try {
+        if (!this.smooth && this.lastFrameTime !== void 0 && s < this.lastFrameTime + 1e3 / this.fpsLimit) {
+          this.draw(!1);
+          return;
+        }
+        this.lastFrameTime ??= s;
+        const r = xi(s - this.lastFrameTime, this.fpsLimit, this.smooth);
+        if (this.addLifeTime(r.value), this.lastFrameTime = s, r.value > 1e3) {
+          this.draw(!1);
+          return;
+        }
+        if (await this.particles.draw(r), !this.alive()) {
+          this.destroy();
+          return;
+        }
+        this.getAnimationStatus() && this.draw(!1);
+      } catch (r) {
+        $().error(`${I} in animation loop`, r);
+      }
+    }, this._engine = e, this.fpsLimit = 120, this.smooth = !1, this._delay = 0, this._duration = 0, this._lifeTime = 0, this._firstStart = !0, this.started = !1, this.destroyed = !1, this._paused = !0, this.lastFrameTime = 0, this.zLayers = 100, this.pageHidden = !1, this._sourceOptions = i, this._initialSourceOptions = i, this.retina = new bi(this), this.canvas = new St(this), this.particles = new wi(this._engine, this), this.pathGenerators = /* @__PURE__ */ new Map(), this.interactivity = {
+      mouse: {
+        clicking: !1,
+        inside: !1
+      }
+    }, this.plugins = /* @__PURE__ */ new Map(), this.drawers = /* @__PURE__ */ new Map(), this._options = D(this._engine, this), this.actualOptions = D(this._engine, this), this._eventListeners = new Ot(this), typeof IntersectionObserver < "u" && IntersectionObserver && (this._intersectionObserver = new IntersectionObserver((s) => this._intersectionManager(s))), this._engine.dispatchEvent("containerBuilt", { container: this });
+  }
+  get options() {
+    return this._options;
+  }
+  get sourceOptions() {
+    return this._sourceOptions;
+  }
+  addClickHandler(e) {
+    if (!v(this))
+      return;
+    const t = this.interactivity.element;
+    if (!t)
+      return;
+    const i = (u, f, d) => {
+      if (!v(this))
+        return;
+      const y = this.retina.pixelRatio, m = {
+        x: f.x * y,
+        y: f.y * y
+      }, b = this.particles.quadTree.queryCircle(m, d * y);
+      e(u, b);
+    }, s = (u) => {
+      if (!v(this))
+        return;
+      const f = u, d = {
+        x: f.offsetX || f.clientX,
+        y: f.offsetY || f.clientY
+      };
+      i(u, d, 1);
+    }, r = () => {
+      v(this) && (l = !0, c = !1);
+    }, o = () => {
+      v(this) && (c = !0);
+    }, a = (u) => {
+      if (v(this)) {
+        if (l && !c) {
+          const f = u;
+          let d = f.touches[f.touches.length - 1];
+          if (!d && (d = f.changedTouches[f.changedTouches.length - 1], !d))
+            return;
+          const y = this.canvas.element, m = y ? y.getBoundingClientRect() : void 0, b = {
+            x: d.clientX - (m ? m.left : 0),
+            y: d.clientY - (m ? m.top : 0)
+          };
+          i(u, b, Math.max(d.radiusX, d.radiusY));
+        }
+        l = !1, c = !1;
+      }
+    }, h = () => {
+      v(this) && (l = !1, c = !1);
+    };
+    let l = !1, c = !1;
+    t.addEventListener("click", s), t.addEventListener("touchstart", r), t.addEventListener("touchmove", o), t.addEventListener("touchend", a), t.addEventListener("touchcancel", h);
+  }
+  addLifeTime(e) {
+    this._lifeTime += e;
+  }
+  addPath(e, t, i = !1) {
+    return !v(this) || !i && this.pathGenerators.has(e) ? !1 : (this.pathGenerators.set(e, t ?? Te), !0);
+  }
+  alive() {
+    return !this._duration || this._lifeTime <= this._duration;
+  }
+  destroy() {
+    if (!v(this))
+      return;
+    this.stop(), this.particles.destroy(), this.canvas.destroy();
+    for (const [, i] of this.drawers)
+      i.destroy && i.destroy(this);
+    for (const i of this.drawers.keys())
+      this.drawers.delete(i);
+    this._engine.plugins.destroy(this), this.destroyed = !0;
+    const e = this._engine.dom(), t = e.findIndex((i) => i === this);
+    t >= 0 && e.splice(t, 1), this._engine.dispatchEvent("containerDestroyed", { container: this });
+  }
+  draw(e) {
+    if (!v(this))
+      return;
+    let t = e;
+    this._drawAnimationFrame = requestAnimationFrame(async (i) => {
+      t && (this.lastFrameTime = void 0, t = !1), await this._nextFrame(i);
+    });
+  }
+  async export(e, t = {}) {
+    for (const [, i] of this.plugins) {
+      if (!i.export)
+        continue;
+      const s = await i.export(e, t);
+      if (s.supported)
+        return s.blob;
+    }
+    $().error(`${I} - Export plugin with type ${e} not found`);
+  }
+  getAnimationStatus() {
+    return !this._paused && !this.pageHidden && v(this);
+  }
+  handleClickMode(e) {
+    if (v(this)) {
+      this.particles.handleClickMode(e);
+      for (const [, t] of this.plugins)
+        t.handleClickMode && t.handleClickMode(e);
+    }
+  }
+  async init() {
+    if (!v(this))
+      return;
+    const e = this._engine.plugins.getSupportedShapes();
+    for (const i of e) {
+      const s = this._engine.plugins.getShapeDrawer(i);
+      s && this.drawers.set(i, s);
+    }
+    this._options = D(this._engine, this, this._initialSourceOptions, this.sourceOptions), this.actualOptions = D(this._engine, this, this._options);
+    const t = this._engine.plugins.getAvailablePlugins(this);
+    for (const [i, s] of t)
+      this.plugins.set(i, s);
+    this.retina.init(), await this.canvas.init(), this.updateActualOptions(), this.canvas.initBackground(), this.canvas.resize(), this.zLayers = this.actualOptions.zLayers, this._duration = g(this.actualOptions.duration) * 1e3, this._delay = g(this.actualOptions.delay) * 1e3, this._lifeTime = 0, this.fpsLimit = this.actualOptions.fpsLimit > 0 ? this.actualOptions.fpsLimit : 120, this.smooth = this.actualOptions.smooth;
+    for (const [, i] of this.drawers)
+      i.init && await i.init(this);
+    for (const [, i] of this.plugins)
+      i.init && await i.init();
+    this._engine.dispatchEvent("containerInit", { container: this }), this.particles.init(), this.particles.setDensity();
+    for (const [, i] of this.plugins)
+      i.particlesSetup && i.particlesSetup();
+    this._engine.dispatchEvent("particlesSetup", { container: this });
+  }
+  async loadTheme(e) {
+    v(this) && (this._currentTheme = e, await this.refresh());
+  }
+  pause() {
+    if (v(this) && (this._drawAnimationFrame !== void 0 && (cancelAnimationFrame(this._drawAnimationFrame), delete this._drawAnimationFrame), !this._paused)) {
+      for (const [, e] of this.plugins)
+        e.pause && e.pause();
+      this.pageHidden || (this._paused = !0), this._engine.dispatchEvent("containerPaused", { container: this });
+    }
+  }
+  play(e) {
+    if (!v(this))
+      return;
+    const t = this._paused || e;
+    if (this._firstStart && !this.actualOptions.autoPlay) {
+      this._firstStart = !1;
+      return;
+    }
+    if (this._paused && (this._paused = !1), t)
+      for (const [, i] of this.plugins)
+        i.play && i.play();
+    this._engine.dispatchEvent("containerPlay", { container: this }), this.draw(t || !1);
+  }
+  async refresh() {
+    if (v(this))
+      return this.stop(), this.start();
+  }
+  async reset() {
+    if (v(this))
+      return this._initialSourceOptions = void 0, this._options = D(this._engine, this), this.actualOptions = D(this._engine, this, this._options), this.refresh();
+  }
+  setNoise(e, t, i) {
+    v(this) && this.setPath(e, t, i);
+  }
+  setPath(e, t, i) {
+    if (!e || !v(this))
+      return;
+    const s = { ...Te };
+    if (Ae(e))
+      s.generate = e, t && (s.init = t), i && (s.update = i);
+    else {
+      const r = s;
+      s.generate = e.generate || r.generate, s.init = e.init || r.init, s.update = e.update || r.update;
+    }
+    this.addPath(zi, s, !0);
+  }
+  async start() {
+    !v(this) || this.started || (await this.init(), this.started = !0, await new Promise((e) => {
+      this._delayTimeout = setTimeout(async () => {
+        this._eventListeners.addListeners(), this.interactivity.element instanceof HTMLElement && this._intersectionObserver && this._intersectionObserver.observe(this.interactivity.element);
+        for (const [, t] of this.plugins)
+          t.start && await t.start();
+        this._engine.dispatchEvent("containerStarted", { container: this }), this.play(), e();
+      }, this._delay);
+    }));
+  }
+  stop() {
+    if (!(!v(this) || !this.started)) {
+      this._delayTimeout && (clearTimeout(this._delayTimeout), delete this._delayTimeout), this._firstStart = !0, this.started = !1, this._eventListeners.removeListeners(), this.pause(), this.particles.clear(), this.canvas.stop(), this.interactivity.element instanceof HTMLElement && this._intersectionObserver && this._intersectionObserver.unobserve(this.interactivity.element);
+      for (const [, e] of this.plugins)
+        e.stop && e.stop();
+      for (const e of this.plugins.keys())
+        this.plugins.delete(e);
+      this._sourceOptions = this._options, this._engine.dispatchEvent("containerStopped", { container: this });
+    }
+  }
+  updateActualOptions() {
+    this.actualOptions.responsive = [];
+    const e = this.actualOptions.setResponsive(this.canvas.size.width, this.retina.pixelRatio, this._options);
+    return this.actualOptions.setTheme(this._currentTheme), this.responsiveMaxWidth === e ? !1 : (this.responsiveMaxWidth = e, !0);
+  }
+}
+class Pi {
+  constructor() {
+    this._listeners = /* @__PURE__ */ new Map();
+  }
+  addEventListener(e, t) {
+    this.removeEventListener(e, t);
+    let i = this._listeners.get(e);
+    i || (i = [], this._listeners.set(e, i)), i.push(t);
+  }
+  dispatchEvent(e, t) {
+    const i = this._listeners.get(e);
+    i && i.forEach((s) => s(t));
+  }
+  hasEventListener(e) {
+    return !!this._listeners.get(e);
+  }
+  removeAllEventListeners(e) {
+    e ? this._listeners.delete(e) : this._listeners = /* @__PURE__ */ new Map();
+  }
+  removeEventListener(e, t) {
+    const i = this._listeners.get(e);
+    if (!i)
+      return;
+    const s = i.length, r = i.indexOf(t);
+    r < 0 || (s === 1 ? this._listeners.delete(e) : i.splice(r, 1));
+  }
+}
+function ae(n, e, t, i = !1) {
+  let s = e.get(n);
+  return (!s || i) && (s = [...t.values()].map((r) => r(n)), e.set(n, s)), s;
+}
+class ki {
+  constructor(e) {
+    this._engine = e, this.plugins = [], this._initializers = {
+      interactors: /* @__PURE__ */ new Map(),
+      movers: /* @__PURE__ */ new Map(),
+      updaters: /* @__PURE__ */ new Map()
+    }, this.interactors = /* @__PURE__ */ new Map(), this.movers = /* @__PURE__ */ new Map(), this.updaters = /* @__PURE__ */ new Map(), this.presets = /* @__PURE__ */ new Map(), this.drawers = /* @__PURE__ */ new Map(), this.pathGenerators = /* @__PURE__ */ new Map();
+  }
+  addInteractor(e, t) {
+    this._initializers.interactors.set(e, t);
+  }
+  addParticleMover(e, t) {
+    this._initializers.movers.set(e, t);
+  }
+  addParticleUpdater(e, t) {
+    this._initializers.updaters.set(e, t);
+  }
+  addPathGenerator(e, t) {
+    !this.getPathGenerator(e) && this.pathGenerators.set(e, t);
+  }
+  addPlugin(e) {
+    !this.getPlugin(e.id) && this.plugins.push(e);
+  }
+  addPreset(e, t, i = !1) {
+    (i || !this.getPreset(e)) && this.presets.set(e, t);
+  }
+  addShapeDrawer(e, t) {
+    E(e, (i) => {
+      !this.getShapeDrawer(i) && this.drawers.set(i, t);
+    });
+  }
+  destroy(e) {
+    this.updaters.delete(e), this.movers.delete(e), this.interactors.delete(e);
+  }
+  getAvailablePlugins(e) {
+    const t = /* @__PURE__ */ new Map();
+    for (const i of this.plugins)
+      i.needsPlugin(e.actualOptions) && t.set(i.id, i.getPlugin(e));
+    return t;
+  }
+  getInteractors(e, t = !1) {
+    return ae(e, this.interactors, this._initializers.interactors, t);
+  }
+  getMovers(e, t = !1) {
+    return ae(e, this.movers, this._initializers.movers, t);
+  }
+  getPathGenerator(e) {
+    return this.pathGenerators.get(e);
+  }
+  getPlugin(e) {
+    return this.plugins.find((t) => t.id === e);
+  }
+  getPreset(e) {
+    return this.presets.get(e);
+  }
+  getShapeDrawer(e) {
+    return this.drawers.get(e);
+  }
+  getSupportedShapes() {
+    return this.drawers.keys();
+  }
+  getUpdaters(e, t = !1) {
+    return ae(e, this.updaters, this._initializers.updaters, t);
+  }
+  loadOptions(e, t) {
+    for (const i of this.plugins)
+      i.loadOptions(e, t);
+  }
+  loadParticlesOptions(e, t, ...i) {
+    const s = this.updaters.get(e);
+    if (s)
+      for (const r of s)
+        r.loadOptions && r.loadOptions(t, ...i);
+  }
+}
+async function Ci(n) {
+  const e = W(n.url, n.index);
+  if (!e)
+    return n.fallback;
+  const t = await fetch(e);
+  return t.ok ? t.json() : ($().error(`${I} ${t.status} while retrieving config file`), n.fallback);
+}
+function Si(n) {
+  return !n.id && !n.element && !n.url && !n.options;
+}
+function Oi(n) {
+  return !Si(n);
+}
+class Ti {
+  constructor() {
+    this._configs = /* @__PURE__ */ new Map(), this._domArray = [], this._eventDispatcher = new Pi(), this._initialized = !1, this.plugins = new ki(this);
+  }
+  get configs() {
+    const e = {};
+    for (const [t, i] of this._configs)
+      e[t] = i;
+    return e;
+  }
+  get version() {
+    return "2.12.0";
+  }
+  addConfig(e, t) {
+    C(e) ? t && (t.name = e, this._configs.set(e, t)) : this._configs.set(e.name ?? "default", e);
+  }
+  addEventListener(e, t) {
+    this._eventDispatcher.addEventListener(e, t);
+  }
+  async addInteractor(e, t, i = !0) {
+    this.plugins.addInteractor(e, t), await this.refresh(i);
+  }
+  async addMover(e, t, i = !0) {
+    this.plugins.addParticleMover(e, t), await this.refresh(i);
+  }
+  async addParticleUpdater(e, t, i = !0) {
+    this.plugins.addParticleUpdater(e, t), await this.refresh(i);
+  }
+  async addPathGenerator(e, t, i = !0) {
+    this.plugins.addPathGenerator(e, t), await this.refresh(i);
+  }
+  async addPlugin(e, t = !0) {
+    this.plugins.addPlugin(e), await this.refresh(t);
+  }
+  async addPreset(e, t, i = !1, s = !0) {
+    this.plugins.addPreset(e, t, i), await this.refresh(s);
+  }
+  async addShape(e, t, i, s, r, o = !0) {
+    let a, h = o, l, c, u;
+    R(i) ? (h = i, l = void 0) : l = i, R(s) ? (h = s, c = void 0) : c = s, R(r) ? (h = r, u = void 0) : u = r, Ae(t) ? a = {
+      afterEffect: c,
+      destroy: u,
+      draw: t,
+      init: l
+    } : a = t, this.plugins.addShapeDrawer(e, a), await this.refresh(h);
+  }
+  dispatchEvent(e, t) {
+    this._eventDispatcher.dispatchEvent(e, t);
+  }
+  dom() {
+    return this._domArray;
+  }
+  domItem(e) {
+    const t = this.dom(), i = t[e];
+    if (!i || i.destroyed) {
+      t.splice(e, 1);
+      return;
+    }
+    return i;
+  }
+  init() {
+    this._initialized || (this._initialized = !0);
+  }
+  async load(e, t) {
+    return this.loadFromArray(e, t);
+  }
+  async loadFromArray(e, t, i) {
+    let s;
+    return Oi(e) ? s = e : (s = {}, C(e) ? s.id = e : s.options = e, k(t) ? s.index = t : s.options = t ?? s.options, s.index = i ?? s.index), this._loadParams(s);
+  }
+  async loadJSON(e, t, i) {
+    let s, r;
+    return k(t) || t === void 0 ? s = e : (r = e, s = t), this._loadParams({ id: r, url: s, index: i });
+  }
+  async refresh(e = !0) {
+    e && this.dom().forEach((t) => t.refresh());
+  }
+  removeEventListener(e, t) {
+    this._eventDispatcher.removeEventListener(e, t);
+  }
+  async set(e, t, i, s) {
+    const r = { index: s };
+    return C(e) ? r.id = e : r.element = e, t instanceof HTMLElement ? r.element = t : r.options = t, k(i) ? r.index = i : r.options = i ?? r.options, this._loadParams(r);
+  }
+  async setJSON(e, t, i, s) {
+    const r = {};
+    return e instanceof HTMLElement ? (r.element = e, r.url = t, r.index = i) : (r.id = e, r.element = t, r.url = i, r.index = s), this._loadParams(r);
+  }
+  setOnClickHandler(e) {
+    const t = this.dom();
+    if (!t.length)
+      throw new Error(`${I} can only set click handlers after calling tsParticles.load()`);
+    for (const i of t)
+      i.addClickHandler(e);
+  }
+  async _loadParams(e) {
+    const t = e.id ?? `tsparticles${Math.floor(T() * 1e4)}`, { index: i, url: s } = e, r = s ? await Ci({ fallback: e.options, url: s, index: i }) : e.options;
+    let o = e.element ?? document.getElementById(t);
+    o || (o = document.createElement("div"), o.id = t, document.body.append(o));
+    const a = W(r, i), h = this.dom(), l = h.findIndex((f) => f.id === t);
+    if (l >= 0) {
+      const f = this.domItem(l);
+      f && !f.destroyed && (f.destroy(), h.splice(l, 1));
+    }
+    let c;
+    if (o.tagName.toLowerCase() === "canvas")
+      c = o, c.dataset[B] = "false";
+    else {
+      const f = o.getElementsByTagName("canvas");
+      f.length ? (c = f[0], c.dataset[B] = "false") : (c = document.createElement("canvas"), c.dataset[B] = "true", o.appendChild(c));
+    }
+    c.style.width || (c.style.width = "100%"), c.style.height || (c.style.height = "100%");
+    const u = new Mi(this, t, a);
+    return l >= 0 ? h.splice(l, 0, u) : h.push(u), u.canvas.loadCanvas(c), await u.start(), u;
+  }
+}
+class Ri {
+  constructor() {
+    this.key = "hsl", this.stringPrefix = "hsl";
+  }
+  handleColor(e) {
+    const t = e.value, i = t.hsl ?? e.value;
+    if (i.h !== void 0 && i.s !== void 0 && i.l !== void 0)
+      return he(i);
+  }
+  handleRangeColor(e) {
+    const t = e.value, i = t.hsl ?? e.value;
+    if (i.h !== void 0 && i.l !== void 0)
+      return he({
+        h: g(i.h),
+        l: g(i.l),
+        s: g(i.s)
+      });
+  }
+  parseString(e) {
+    if (!e.startsWith("hsl"))
+      return;
+    const t = /hsla?\(\s*(\d+)\s*,\s*(\d+)%\s*,\s*(\d+)%\s*(,\s*([\d.%]+)\s*)?\)/i, i = t.exec(e);
+    return i ? yt({
+      a: i.length > 4 ? Ie(i[5]) : 1,
+      h: parseInt(i[1], 10),
+      l: parseInt(i[3], 10),
+      s: parseInt(i[2], 10)
+    }) : void 0;
+  }
+}
+class Ii {
+  constructor() {
+    this.key = "rgb", this.stringPrefix = "rgb";
+  }
+  handleColor(e) {
+    const t = e.value, i = t.rgb ?? e.value;
+    if (i.r !== void 0)
+      return i;
+  }
+  handleRangeColor(e) {
+    const t = e.value, i = t.rgb ?? e.value;
+    if (i.r !== void 0)
+      return {
+        r: g(i.r),
+        g: g(i.g),
+        b: g(i.b)
+      };
+  }
+  parseString(e) {
+    if (!e.startsWith(this.stringPrefix))
+      return;
+    const t = /rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(,\s*([\d.%]+)\s*)?\)/i, i = t.exec(e);
+    return i ? {
+      a: i.length > 4 ? Ie(i[5]) : 1,
+      b: parseInt(i[3], 10),
+      g: parseInt(i[2], 10),
+      r: parseInt(i[1], 10)
+    } : void 0;
+  }
+}
+function Ei() {
+  const n = new Ii(), e = new Ri();
+  we(n), we(e);
+  const t = new Ti();
+  return t.init(), t;
+}
+const le = Ei();
+Z() || (window.tsParticles = le);
+const A = (n) => typeof n == "object" && n !== null;
+function Y(n, e, t = () => !1) {
+  if (!A(n) || !A(e))
+    return n === e;
+  const i = Object.keys(n).filter((r) => !t(r)), s = Object.keys(e).filter((r) => !t(r));
+  if (i.length !== s.length)
+    return !1;
+  for (const r of i) {
+    const o = n[r], a = e[r];
+    if (A(o) && A(a)) {
+      if (o === e && a === n)
+        continue;
+      if (!Y(o, a, t))
+        return !1;
+    } else if (Array.isArray(o) && Array.isArray(a)) {
+      if (!$e(o, a, t))
+        return !1;
+    } else if (o !== a)
+      return !1;
+  }
+  return !0;
+}
+function $e(n, e, t) {
+  if (n.length !== e.length)
+    return !1;
+  for (let i = 0; i < n.length; i++) {
+    const s = n[i], r = e[i];
+    if (Array.isArray(s) && Array.isArray(r)) {
+      if (!$e(s, r, t))
+        return !1;
+    } else if (A(s) && A(r)) {
+      if (!Y(s, r, t))
+        return !1;
+    } else if (s !== r)
+      return !1;
+  }
+  return !0;
+}
+const Ge = "tsparticles";
+class pe extends Ne {
+  constructor(e) {
+    super(e), this.state = {
+      init: !1,
+      library: void 0
+    };
+  }
+  destroy() {
+    this.state.library && (this.state.library.destroy(), this.setState({
+      library: void 0
+    }));
+  }
+  shouldComponentUpdate(e) {
+    const t = e.options ?? e.params, i = this.props.options ?? this.props.params;
+    return e.url !== this.props.url || e.id !== this.props.id || e.canvasClassName !== this.props.canvasClassName || e.className !== this.props.className || e.height !== this.props.height || e.width !== this.props.width || !Y(e.style, this.props.style) || e.init !== this.props.init || e.loaded !== this.props.loaded || !Y(t, i, (s) => s.startsWith("_"));
+  }
+  componentDidUpdate() {
+    this.refresh();
+  }
+  forceUpdate() {
+    this.refresh().then(() => {
+      super.forceUpdate();
+    });
+  }
+  componentDidMount() {
+    (async () => (this.props.init && await this.props.init(le), this.setState({
+      init: !0
+    }, async () => {
+      await this.loadParticles();
+    })))();
+  }
+  componentWillUnmount() {
+    this.destroy();
+  }
+  render() {
+    const { width: e, height: t, className: i, canvasClassName: s, id: r } = this.props;
+    return ge.createElement(
+      "div",
+      { className: i, id: r },
+      ge.createElement("canvas", { className: s, style: {
+        ...this.props.style,
+        width: e,
+        height: t
+      } })
+    );
+  }
+  async refresh() {
+    this.destroy(), await this.loadParticles();
+  }
+  async loadParticles() {
+    if (!this.state.init)
+      return;
+    const e = this.props.id ?? pe.defaultProps.id ?? Ge, t = await le.load({
+      url: this.props.url,
+      id: e,
+      options: this.props.options ?? this.props.params
+    });
+    this.props.container && (this.props.container.current = t), this.setState({
+      library: t
+    }), this.props.loaded && await this.props.loaded(t);
+  }
+}
+pe.defaultProps = {
+  width: "100%",
+  height: "100%",
+  options: {},
+  style: {},
+  url: void 0,
+  id: Ge
+};