dune-react 0.0.1

package/dist/node_modules/.pnpm/@tsparticles_interaction-external-repulse@3.9.1/node_modules/@tsparticles/interaction-external-repulse/browser/Repulser.js

@@ -0,0 +1,160 @@
+import { Repulse } from "./Options/Classes/Repulse.js";
+import { ExternalInteractorBase } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/ExternalInteractorBase.js";
+import { Circle, Rectangle } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Ranges.js";
+import { getDistances, clamp } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+import { Vector } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Vectors.js";
+import { DivType } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Types/DivType.js";
+import { divMode, isInArray, divModeExecute, isDivModeEnabled } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/Utils.js";
+import { millisecondsToSeconds, mouseMoveEvent } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Constants.js";
+const repulseMode = "repulse", minDistance = 0, repulseRadiusFactor = 6, repulseRadiusPower = 3, squarePower = 2, minRadius = 0, minSpeed = 0, easingOffset = 1, half = 0.5;
+class Repulser extends ExternalInteractorBase {
+  constructor(engine, container) {
+    super(container);
+    this._clickRepulse = () => {
+      const container2 = this.container, repulseOptions = container2.actualOptions.interactivity.modes.repulse;
+      if (!repulseOptions) {
+        return;
+      }
+      const repulse = container2.repulse ?? { particles: [] };
+      if (!repulse.finish) {
+        if (!repulse.count) {
+          repulse.count = 0;
+        }
+        repulse.count++;
+        if (repulse.count === container2.particles.count) {
+          repulse.finish = true;
+        }
+      }
+      if (repulse.clicking) {
+        const repulseDistance = container2.retina.repulseModeDistance;
+        if (!repulseDistance || repulseDistance < minDistance) {
+          return;
+        }
+        const repulseRadius = Math.pow(repulseDistance / repulseRadiusFactor, repulseRadiusPower), mouseClickPos = container2.interactivity.mouse.clickPosition;
+        if (mouseClickPos === void 0) {
+          return;
+        }
+        const range = new Circle(mouseClickPos.x, mouseClickPos.y, repulseRadius), query = container2.particles.quadTree.query(range, (p) => this.isEnabled(p));
+        for (const particle of query) {
+          const { dx, dy, distance } = getDistances(mouseClickPos, particle.position), d = distance ** squarePower, velocity = repulseOptions.speed, force = -repulseRadius * velocity / d;
+          if (d <= repulseRadius) {
+            repulse.particles.push(particle);
+            const vect = Vector.create(dx, dy);
+            vect.length = force;
+            particle.velocity.setTo(vect);
+          }
+        }
+      } else if (repulse.clicking === false) {
+        for (const particle of repulse.particles) {
+          particle.velocity.setTo(particle.initialVelocity);
+        }
+        repulse.particles = [];
+      }
+    };
+    this._hoverRepulse = () => {
+      const container2 = this.container, mousePos = container2.interactivity.mouse.position, repulseRadius = container2.retina.repulseModeDistance;
+      if (!repulseRadius || repulseRadius < minRadius || !mousePos) {
+        return;
+      }
+      this._processRepulse(mousePos, repulseRadius, new Circle(mousePos.x, mousePos.y, repulseRadius));
+    };
+    this._processRepulse = (position, repulseRadius, area, divRepulse) => {
+      const container2 = this.container, query = container2.particles.quadTree.query(area, (p) => this.isEnabled(p)), repulseOptions = container2.actualOptions.interactivity.modes.repulse;
+      if (!repulseOptions) {
+        return;
+      }
+      const { easing, speed, factor, maxSpeed } = repulseOptions, easingFunc = this._engine.getEasing(easing), velocity = ((divRepulse == null ? void 0 : divRepulse.speed) ?? speed) * factor;
+      for (const particle of query) {
+        const { dx, dy, distance } = getDistances(particle.position, position), repulseFactor = clamp(easingFunc(easingOffset - distance / repulseRadius) * velocity, minSpeed, maxSpeed), normVec = Vector.create(!distance ? velocity : dx / distance * repulseFactor, !distance ? velocity : dy / distance * repulseFactor);
+        particle.position.addTo(normVec);
+      }
+    };
+    this._singleSelectorRepulse = (selector, div) => {
+      const container2 = this.container, repulse = container2.actualOptions.interactivity.modes.repulse;
+      if (!repulse) {
+        return;
+      }
+      const query = document.querySelectorAll(selector);
+      if (!query.length) {
+        return;
+      }
+      query.forEach((item) => {
+        const elem = item, pxRatio = container2.retina.pixelRatio, pos = {
+          x: (elem.offsetLeft + elem.offsetWidth * half) * pxRatio,
+          y: (elem.offsetTop + elem.offsetHeight * half) * pxRatio
+        }, repulseRadius = elem.offsetWidth * half * pxRatio, area = div.type === DivType.circle ? new Circle(pos.x, pos.y, repulseRadius) : new Rectangle(elem.offsetLeft * pxRatio, elem.offsetTop * pxRatio, elem.offsetWidth * pxRatio, elem.offsetHeight * pxRatio), divs = repulse.divs, divRepulse = divMode(divs, elem);
+        this._processRepulse(pos, repulseRadius, area, divRepulse);
+      });
+    };
+    this._engine = engine;
+    if (!container.repulse) {
+      container.repulse = { particles: [] };
+    }
+    this.handleClickMode = (mode) => {
+      const options = this.container.actualOptions, repulseOpts = options.interactivity.modes.repulse;
+      if (!repulseOpts || mode !== repulseMode) {
+        return;
+      }
+      if (!container.repulse) {
+        container.repulse = { particles: [] };
+      }
+      const repulse = container.repulse;
+      repulse.clicking = true;
+      repulse.count = 0;
+      for (const particle of container.repulse.particles) {
+        if (!this.isEnabled(particle)) {
+          continue;
+        }
+        particle.velocity.setTo(particle.initialVelocity);
+      }
+      repulse.particles = [];
+      repulse.finish = false;
+      setTimeout(() => {
+        if (container.destroyed) {
+          return;
+        }
+        repulse.clicking = false;
+      }, repulseOpts.duration * millisecondsToSeconds);
+    };
+  }
+  clear() {
+  }
+  init() {
+    const container = this.container, repulse = container.actualOptions.interactivity.modes.repulse;
+    if (!repulse) {
+      return;
+    }
+    container.retina.repulseModeDistance = repulse.distance * container.retina.pixelRatio;
+  }
+  interact() {
+    const container = this.container, options = container.actualOptions, mouseMoveStatus = container.interactivity.status === mouseMoveEvent, events = options.interactivity.events, hover = events.onHover, hoverEnabled = hover.enable, hoverMode = hover.mode, click = events.onClick, clickEnabled = click.enable, clickMode = click.mode, divs = events.onDiv;
+    if (mouseMoveStatus && hoverEnabled && isInArray(repulseMode, hoverMode)) {
+      this._hoverRepulse();
+    } else if (clickEnabled && isInArray(repulseMode, clickMode)) {
+      this._clickRepulse();
+    } else {
+      divModeExecute(repulseMode, divs, (selector, div) => this._singleSelectorRepulse(selector, div));
+    }
+  }
+  isEnabled(particle) {
+    const container = this.container, options = container.actualOptions, mouse = container.interactivity.mouse, events = ((particle == null ? void 0 : particle.interactivity) ?? options.interactivity).events, divs = events.onDiv, hover = events.onHover, click = events.onClick, divRepulse = isDivModeEnabled(repulseMode, divs);
+    if (!(divRepulse || hover.enable && !!mouse.position || click.enable && mouse.clickPosition)) {
+      return false;
+    }
+    const hoverMode = hover.mode, clickMode = click.mode;
+    return isInArray(repulseMode, hoverMode) || isInArray(repulseMode, clickMode) || divRepulse;
+  }
+  loadModeOptions(options, ...sources) {
+    if (!options.repulse) {
+      options.repulse = new Repulse();
+    }
+    for (const source of sources) {
+      options.repulse.load(source == null ? void 0 : source.repulse);
+    }
+  }
+  reset() {
+  }
+}
+export {
+  Repulser
+};

package/dist/node_modules/.pnpm/@tsparticles_interaction-external-repulse@3.9.1/node_modules/@tsparticles/interaction-external-repulse/browser/index.js

@@ -0,0 +1,10 @@
+import { Repulser } from "./Repulser.js";
+async function loadExternalRepulseInteraction(engine, refresh = true) {
+  engine.checkVersion("3.9.1");
+  await engine.addInteractor("externalRepulse", (container) => {
+    return Promise.resolve(new Repulser(engine, container));
+  }, refresh);
+}
+export {
+  loadExternalRepulseInteraction
+};

package/dist/node_modules/.pnpm/@tsparticles_interaction-external-slow@3.9.1/node_modules/@tsparticles/interaction-external-slow/browser/Options/Classes/Slow.js

@@ -0,0 +1,21 @@
+import { isNull } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/TypeUtils.js";
+class Slow {
+  constructor() {
+    this.factor = 3;
+    this.radius = 200;
+  }
+  load(data) {
+    if (isNull(data)) {
+      return;
+    }
+    if (data.factor !== void 0) {
+      this.factor = data.factor;
+    }
+    if (data.radius !== void 0) {
+      this.radius = data.radius;
+    }
+  }
+}
+export {
+  Slow
+};

package/dist/node_modules/.pnpm/@tsparticles_interaction-external-slow@3.9.1/node_modules/@tsparticles/interaction-external-slow/browser/Slower.js

@@ -0,0 +1,53 @@
+import { Slow } from "./Options/Classes/Slow.js";
+import { ExternalInteractorBase } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/ExternalInteractorBase.js";
+import { isInArray } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/Utils.js";
+import { getDistance } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+const slowMode = "slow", minRadius = 0;
+class Slower extends ExternalInteractorBase {
+  constructor(container) {
+    super(container);
+  }
+  clear(particle, delta, force) {
+    if (particle.slow.inRange && !force) {
+      return;
+    }
+    particle.slow.factor = 1;
+  }
+  init() {
+    const container = this.container, slow = container.actualOptions.interactivity.modes.slow;
+    if (!slow) {
+      return;
+    }
+    container.retina.slowModeRadius = slow.radius * container.retina.pixelRatio;
+  }
+  interact() {
+  }
+  isEnabled(particle) {
+    const container = this.container, mouse = container.interactivity.mouse, events = ((particle == null ? void 0 : particle.interactivity) ?? container.actualOptions.interactivity).events;
+    return events.onHover.enable && !!mouse.position && isInArray(slowMode, events.onHover.mode);
+  }
+  loadModeOptions(options, ...sources) {
+    if (!options.slow) {
+      options.slow = new Slow();
+    }
+    for (const source of sources) {
+      options.slow.load(source == null ? void 0 : source.slow);
+    }
+  }
+  reset(particle) {
+    particle.slow.inRange = false;
+    const container = this.container, options = container.actualOptions, mousePos = container.interactivity.mouse.position, radius = container.retina.slowModeRadius, slowOptions = options.interactivity.modes.slow;
+    if (!slowOptions || !radius || radius < minRadius || !mousePos) {
+      return;
+    }
+    const particlePos = particle.getPosition(), dist = getDistance(mousePos, particlePos), proximityFactor = dist / radius, slowFactor = slowOptions.factor, { slow } = particle;
+    if (dist > radius) {
+      return;
+    }
+    slow.inRange = true;
+    slow.factor = proximityFactor / slowFactor;
+  }
+}
+export {
+  Slower
+};

package/dist/node_modules/.pnpm/@tsparticles_interaction-external-slow@3.9.1/node_modules/@tsparticles/interaction-external-slow/browser/index.js

@@ -0,0 +1,10 @@
+import { Slower } from "./Slower.js";
+async function loadExternalSlowInteraction(engine, refresh = true) {
+  engine.checkVersion("3.9.1");
+  await engine.addInteractor("externalSlow", (container) => {
+    return Promise.resolve(new Slower(container));
+  }, refresh);
+}
+export {
+  loadExternalSlowInteraction
+};

package/dist/node_modules/.pnpm/@tsparticles_interaction-particles-attract@3.9.1/node_modules/@tsparticles/interaction-particles-attract/browser/Attractor.js

@@ -0,0 +1,37 @@
+import { ParticlesInteractorBase } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/ParticlesInteractorBase.js";
+import { getRangeValue, getDistances } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+const attractFactor = 1e3, identity = 1;
+class Attractor extends ParticlesInteractorBase {
+  constructor(container) {
+    super(container);
+  }
+  clear() {
+  }
+  init() {
+  }
+  interact(p1) {
+    const container = this.container;
+    if (p1.attractDistance === void 0) {
+      p1.attractDistance = getRangeValue(p1.options.move.attract.distance) * container.retina.pixelRatio;
+    }
+    const distance = p1.attractDistance, pos1 = p1.getPosition(), query = container.particles.quadTree.queryCircle(pos1, distance);
+    for (const p2 of query) {
+      if (p1 === p2 || !p2.options.move.attract.enable || p2.destroyed || p2.spawning) {
+        continue;
+      }
+      const pos2 = p2.getPosition(), { dx, dy } = getDistances(pos1, pos2), rotate = p1.options.move.attract.rotate, ax = dx / (rotate.x * attractFactor), ay = dy / (rotate.y * attractFactor), p1Factor = p2.size.value / p1.size.value, p2Factor = identity / p1Factor;
+      p1.velocity.x -= ax * p1Factor;
+      p1.velocity.y -= ay * p1Factor;
+      p2.velocity.x += ax * p2Factor;
+      p2.velocity.y += ay * p2Factor;
+    }
+  }
+  isEnabled(particle) {
+    return particle.options.move.attract.enable;
+  }
+  reset() {
+  }
+}
+export {
+  Attractor
+};

package/dist/node_modules/.pnpm/@tsparticles_interaction-particles-attract@3.9.1/node_modules/@tsparticles/interaction-particles-attract/browser/index.js

@@ -0,0 +1,10 @@
+import { Attractor } from "./Attractor.js";
+async function loadParticlesAttractInteraction(engine, refresh = true) {
+  engine.checkVersion("3.9.1");
+  await engine.addInteractor("particlesAttract", (container) => {
+    return Promise.resolve(new Attractor(container));
+  }, refresh);
+}
+export {
+  loadParticlesAttractInteraction
+};

package/dist/node_modules/.pnpm/@tsparticles_interaction-particles-collisions@3.9.1/node_modules/@tsparticles/interaction-particles-collisions/browser/Absorb.js

@@ -0,0 +1,28 @@
+import { clamp } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+const half = 0.5, absorbFactor = 10, minAbsorbFactor = 0;
+function updateAbsorb(p1, r1, p2, r2, delta, pixelRatio) {
+  const factor = clamp(p1.options.collisions.absorb.speed * delta.factor / absorbFactor, minAbsorbFactor, r2);
+  p1.size.value += factor * half;
+  p2.size.value -= factor;
+  if (r2 <= pixelRatio) {
+    p2.size.value = 0;
+    p2.destroy();
+  }
+}
+function absorb(p1, p2, delta, pixelRatio) {
+  const r1 = p1.getRadius(), r2 = p2.getRadius();
+  if (r1 === void 0 && r2 !== void 0) {
+    p1.destroy();
+  } else if (r1 !== void 0 && r2 === void 0) {
+    p2.destroy();
+  } else if (r1 !== void 0 && r2 !== void 0) {
+    if (r1 >= r2) {
+      updateAbsorb(p1, r1, p2, r2, delta, pixelRatio);
+    } else {
+      updateAbsorb(p2, r2, p1, r1, delta, pixelRatio);
+    }
+  }
+}
+export {
+  absorb
+};

package/dist/node_modules/.pnpm/@tsparticles_interaction-particles-collisions@3.9.1/node_modules/@tsparticles/interaction-particles-collisions/browser/Bounce.js

@@ -0,0 +1,18 @@
+import { circleBounce, circleBounceDataFromParticle } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/Utils.js";
+import { getRangeValue } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+const fixBounceSpeed = (p) => {
+  if (p.collisionMaxSpeed === void 0) {
+    p.collisionMaxSpeed = getRangeValue(p.options.collisions.maxSpeed);
+  }
+  if (p.velocity.length > p.collisionMaxSpeed) {
+    p.velocity.length = p.collisionMaxSpeed;
+  }
+};
+function bounce(p1, p2) {
+  circleBounce(circleBounceDataFromParticle(p1), circleBounceDataFromParticle(p2));
+  fixBounceSpeed(p1);
+  fixBounceSpeed(p2);
+}
+export {
+  bounce
+};

package/dist/node_modules/.pnpm/@tsparticles_interaction-particles-collisions@3.9.1/node_modules/@tsparticles/interaction-particles-collisions/browser/Collider.js

@@ -0,0 +1,41 @@
+import { resolveCollision } from "./ResolveCollision.js";
+import { ParticlesInteractorBase } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/ParticlesInteractorBase.js";
+import { getDistance } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+const double = 2;
+class Collider extends ParticlesInteractorBase {
+  constructor(container) {
+    super(container);
+  }
+  clear() {
+  }
+  init() {
+  }
+  interact(p1, delta) {
+    if (p1.destroyed || p1.spawning) {
+      return;
+    }
+    const container = this.container, pos1 = p1.getPosition(), radius1 = p1.getRadius(), query = container.particles.quadTree.queryCircle(pos1, radius1 * double);
+    for (const p2 of query) {
+      if (p1 === p2 || !p2.options.collisions.enable || p1.options.collisions.mode !== p2.options.collisions.mode || p2.destroyed || p2.spawning) {
+        continue;
+      }
+      const pos2 = p2.getPosition(), radius2 = p2.getRadius();
+      if (Math.abs(Math.round(pos1.z) - Math.round(pos2.z)) > radius1 + radius2) {
+        continue;
+      }
+      const dist = getDistance(pos1, pos2), distP = radius1 + radius2;
+      if (dist > distP) {
+        continue;
+      }
+      resolveCollision(p1, p2, delta, container.retina.pixelRatio);
+    }
+  }
+  isEnabled(particle) {
+    return particle.options.collisions.enable;
+  }
+  reset() {
+  }
+}
+export {
+  Collider
+};

package/dist/node_modules/.pnpm/@tsparticles_interaction-particles-collisions@3.9.1/node_modules/@tsparticles/interaction-particles-collisions/browser/Destroy.js

@@ -0,0 +1,17 @@
+import { bounce } from "./Bounce.js";
+function destroy(p1, p2) {
+  if (!p1.unbreakable && !p2.unbreakable) {
+    bounce(p1, p2);
+  }
+  if (p1.getRadius() === void 0 && p2.getRadius() !== void 0) {
+    p1.destroy();
+  } else if (p1.getRadius() !== void 0 && p2.getRadius() === void 0) {
+    p2.destroy();
+  } else if (p1.getRadius() !== void 0 && p2.getRadius() !== void 0) {
+    const deleteP = p1.getRadius() >= p2.getRadius() ? p2 : p1;
+    deleteP.destroy();
+  }
+}
+export {
+  destroy
+};

package/dist/node_modules/.pnpm/@tsparticles_interaction-particles-collisions@3.9.1/node_modules/@tsparticles/interaction-particles-collisions/browser/ResolveCollision.js

@@ -0,0 +1,23 @@
+import { absorb } from "./Absorb.js";
+import { bounce } from "./Bounce.js";
+import { destroy } from "./Destroy.js";
+import { CollisionMode } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Modes/CollisionMode.js";
+function resolveCollision(p1, p2, delta, pixelRatio) {
+  switch (p1.options.collisions.mode) {
+    case CollisionMode.absorb: {
+      absorb(p1, p2, delta, pixelRatio);
+      break;
+    }
+    case CollisionMode.bounce: {
+      bounce(p1, p2);
+      break;
+    }
+    case CollisionMode.destroy: {
+      destroy(p1, p2);
+      break;
+    }
+  }
+}
+export {
+  resolveCollision
+};

package/dist/node_modules/.pnpm/@tsparticles_interaction-particles-collisions@3.9.1/node_modules/@tsparticles/interaction-particles-collisions/browser/index.js

@@ -0,0 +1,10 @@
+import { Collider } from "./Collider.js";
+async function loadParticlesCollisionsInteraction(engine, refresh = true) {
+  engine.checkVersion("3.9.1");
+  await engine.addInteractor("particlesCollisions", (container) => {
+    return Promise.resolve(new Collider(container));
+  }, refresh);
+}
+export {
+  loadParticlesCollisionsInteraction
+};

package/dist/node_modules/.pnpm/@tsparticles_interaction-particles-links@3.9.1/node_modules/@tsparticles/interaction-particles-links/browser/CircleWarp.js

@@ -0,0 +1,33 @@
+import { Circle, Rectangle } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Ranges.js";
+const double = 2;
+class CircleWarp extends Circle {
+  constructor(x, y, radius, canvasSize) {
+    super(x, y, radius);
+    this.canvasSize = canvasSize;
+    this.canvasSize = { ...canvasSize };
+  }
+  contains(point) {
+    const { width, height } = this.canvasSize, { x, y } = point;
+    return super.contains(point) || super.contains({ x: x - width, y }) || super.contains({ x: x - width, y: y - height }) || super.contains({ x, y: y - height });
+  }
+  intersects(range) {
+    if (super.intersects(range)) {
+      return true;
+    }
+    const rect = range, circle = range, newPos = {
+      x: range.position.x - this.canvasSize.width,
+      y: range.position.y - this.canvasSize.height
+    };
+    if (circle.radius !== void 0) {
+      const biggerCircle = new Circle(newPos.x, newPos.y, circle.radius * double);
+      return super.intersects(biggerCircle);
+    } else if (rect.size !== void 0) {
+      const rectSW = new Rectangle(newPos.x, newPos.y, rect.size.width * double, rect.size.height * double);
+      return super.intersects(rectSW);
+    }
+    return false;
+  }
+}
+export {
+  CircleWarp
+};

package/dist/node_modules/.pnpm/@tsparticles_interaction-particles-links@3.9.1/node_modules/@tsparticles/interaction-particles-links/browser/LinkInstance.js

@@ -0,0 +1,152 @@
+import { drawLinkLine, drawLinkTriangle, setLinkFrequency } from "./Utils.js";
+import { rangeColorToRgb, getLinkColor } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/ColorUtils.js";
+import { getRangeValue, getDistance, getRandom } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+const minOpacity = 0, minWidth = 0, minDistance = 0, half = 0.5, maxFrequency = 1;
+class LinkInstance {
+  constructor(container, engine) {
+    this._drawLinkLine = (p1, link) => {
+      const p1LinksOptions = p1.options.links;
+      if (!(p1LinksOptions == null ? void 0 : p1LinksOptions.enable)) {
+        return;
+      }
+      const container2 = this._container, options = container2.actualOptions, p2 = link.destination, pos1 = p1.getPosition(), pos2 = p2.getPosition();
+      let opacity = link.opacity;
+      container2.canvas.draw((ctx) => {
+        var _a;
+        let colorLine;
+        const twinkle = (_a = p1.options.twinkle) == null ? void 0 : _a.lines;
+        if (twinkle == null ? void 0 : twinkle.enable) {
+          const twinkleFreq = twinkle.frequency, twinkleRgb = rangeColorToRgb(this._engine, twinkle.color), twinkling = getRandom() < twinkleFreq;
+          if (twinkling && twinkleRgb) {
+            colorLine = twinkleRgb;
+            opacity = getRangeValue(twinkle.opacity);
+          }
+        }
+        if (!colorLine) {
+          const linkColor = p1LinksOptions.id !== void 0 ? container2.particles.linksColors.get(p1LinksOptions.id) : container2.particles.linksColor;
+          colorLine = getLinkColor(p1, p2, linkColor);
+        }
+        if (!colorLine) {
+          return;
+        }
+        const width = p1.retina.linksWidth ?? minWidth, maxDistance = p1.retina.linksDistance ?? minDistance, { backgroundMask } = options;
+        drawLinkLine({
+          context: ctx,
+          width,
+          begin: pos1,
+          end: pos2,
+          engine: this._engine,
+          maxDistance,
+          canvasSize: container2.canvas.size,
+          links: p1LinksOptions,
+          backgroundMask,
+          colorLine,
+          opacity
+        });
+      });
+    };
+    this._drawLinkTriangle = (p1, link1, link2) => {
+      const linksOptions = p1.options.links;
+      if (!(linksOptions == null ? void 0 : linksOptions.enable)) {
+        return;
+      }
+      const triangleOptions = linksOptions.triangles;
+      if (!triangleOptions.enable) {
+        return;
+      }
+      const container2 = this._container, options = container2.actualOptions, p2 = link1.destination, p3 = link2.destination, opacityTriangle = triangleOptions.opacity ?? (link1.opacity + link2.opacity) * half;
+      if (opacityTriangle <= minOpacity) {
+        return;
+      }
+      container2.canvas.draw((ctx) => {
+        const pos1 = p1.getPosition(), pos2 = p2.getPosition(), pos3 = p3.getPosition(), linksDistance = p1.retina.linksDistance ?? minDistance;
+        if (getDistance(pos1, pos2) > linksDistance || getDistance(pos3, pos2) > linksDistance || getDistance(pos3, pos1) > linksDistance) {
+          return;
+        }
+        let colorTriangle = rangeColorToRgb(this._engine, triangleOptions.color);
+        if (!colorTriangle) {
+          const linkColor = linksOptions.id !== void 0 ? container2.particles.linksColors.get(linksOptions.id) : container2.particles.linksColor;
+          colorTriangle = getLinkColor(p1, p2, linkColor);
+        }
+        if (!colorTriangle) {
+          return;
+        }
+        drawLinkTriangle({
+          context: ctx,
+          pos1,
+          pos2,
+          pos3,
+          backgroundMask: options.backgroundMask,
+          colorTriangle,
+          opacityTriangle
+        });
+      });
+    };
+    this._drawTriangles = (options, p1, link, p1Links) => {
+      var _a, _b, _c;
+      const p2 = link.destination;
+      if (!(((_a = options.links) == null ? void 0 : _a.triangles.enable) && ((_b = p2.options.links) == null ? void 0 : _b.triangles.enable))) {
+        return;
+      }
+      const vertices = (_c = p2.links) == null ? void 0 : _c.filter((t) => {
+        const linkFreq = this._getLinkFrequency(p2, t.destination), minCount = 0;
+        return p2.options.links && linkFreq <= p2.options.links.frequency && p1Links.findIndex((l) => l.destination === t.destination) >= minCount;
+      });
+      if (!(vertices == null ? void 0 : vertices.length)) {
+        return;
+      }
+      for (const vertex of vertices) {
+        const p3 = vertex.destination, triangleFreq = this._getTriangleFrequency(p1, p2, p3);
+        if (triangleFreq > options.links.triangles.frequency) {
+          continue;
+        }
+        this._drawLinkTriangle(p1, link, vertex);
+      }
+    };
+    this._getLinkFrequency = (p1, p2) => {
+      return setLinkFrequency([p1, p2], this._freqs.links);
+    };
+    this._getTriangleFrequency = (p1, p2, p3) => {
+      return setLinkFrequency([p1, p2, p3], this._freqs.triangles);
+    };
+    this._container = container;
+    this._engine = engine;
+    this._freqs = {
+      links: /* @__PURE__ */ new Map(),
+      triangles: /* @__PURE__ */ new Map()
+    };
+  }
+  drawParticle(context, particle) {
+    const { links, options } = particle;
+    if (!(links == null ? void 0 : links.length)) {
+      return;
+    }
+    const p1Links = links.filter((l) => options.links && (options.links.frequency >= maxFrequency || this._getLinkFrequency(particle, l.destination) <= options.links.frequency));
+    for (const link of p1Links) {
+      this._drawTriangles(options, particle, link, p1Links);
+      if (link.opacity > minOpacity && (particle.retina.linksWidth ?? minWidth) > minWidth) {
+        this._drawLinkLine(particle, link);
+      }
+    }
+  }
+  async init() {
+    this._freqs.links = /* @__PURE__ */ new Map();
+    this._freqs.triangles = /* @__PURE__ */ new Map();
+    await Promise.resolve();
+  }
+  particleCreated(particle) {
+    particle.links = [];
+    if (!particle.options.links) {
+      return;
+    }
+    const ratio = this._container.retina.pixelRatio, { retina } = particle, { distance, width } = particle.options.links;
+    retina.linksDistance = distance * ratio;
+    retina.linksWidth = width * ratio;
+  }
+  particleDestroyed(particle) {
+    particle.links = [];
+  }
+}
+export {
+  LinkInstance
+};