dune-react 0.0.1

package/dist/node_modules/.pnpm/@tsparticles_interaction-external-attract@3.9.1/node_modules/@tsparticles/interaction-external-attract/browser/Utils.js

@@ -0,0 +1,50 @@
+import { Circle } 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";
+const minFactor = 1, identity = 1, minRadius = 0;
+function processAttract(engine, container, position, attractRadius, area, queryCb) {
+  const attractOptions = container.actualOptions.interactivity.modes.attract;
+  if (!attractOptions) {
+    return;
+  }
+  const query = container.particles.quadTree.query(area, queryCb);
+  for (const particle of query) {
+    const { dx, dy, distance } = getDistances(particle.position, position), velocity = attractOptions.speed * attractOptions.factor, attractFactor = clamp(engine.getEasing(attractOptions.easing)(identity - distance / attractRadius) * velocity, minFactor, attractOptions.maxSpeed), normVec = Vector.create(!distance ? velocity : dx / distance * attractFactor, !distance ? velocity : dy / distance * attractFactor);
+    particle.position.subFrom(normVec);
+  }
+}
+function clickAttract(engine, container, enabledCb) {
+  if (!container.attract) {
+    container.attract = { particles: [] };
+  }
+  const { attract } = container;
+  if (!attract.finish) {
+    if (!attract.count) {
+      attract.count = 0;
+    }
+    attract.count++;
+    if (attract.count === container.particles.count) {
+      attract.finish = true;
+    }
+  }
+  if (attract.clicking) {
+    const mousePos = container.interactivity.mouse.clickPosition, attractRadius = container.retina.attractModeDistance;
+    if (!attractRadius || attractRadius < minRadius || !mousePos) {
+      return;
+    }
+    processAttract(engine, container, mousePos, attractRadius, new Circle(mousePos.x, mousePos.y, attractRadius), (p) => enabledCb(p));
+  } else if (attract.clicking === false) {
+    attract.particles = [];
+  }
+}
+function hoverAttract(engine, container, enabledCb) {
+  const mousePos = container.interactivity.mouse.position, attractRadius = container.retina.attractModeDistance;
+  if (!attractRadius || attractRadius < minRadius || !mousePos) {
+    return;
+  }
+  processAttract(engine, container, mousePos, attractRadius, new Circle(mousePos.x, mousePos.y, attractRadius), (p) => enabledCb(p));
+}
+export {
+  clickAttract,
+  hoverAttract
+};

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

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

package/dist/node_modules/.pnpm/@tsparticles_interaction-external-bounce@3.9.1/node_modules/@tsparticles/interaction-external-bounce/browser/Bouncer.js

@@ -0,0 +1,45 @@
+import { mouseBounce, divBounce } from "./Utils.js";
+import { Bounce } from "./Options/Classes/Bounce.js";
+import { isInArray, isDivModeEnabled } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/Utils.js";
+import { ExternalInteractorBase } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/ExternalInteractorBase.js";
+import { mouseMoveEvent } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Constants.js";
+const bounceMode = "bounce";
+class Bouncer extends ExternalInteractorBase {
+  constructor(container) {
+    super(container);
+  }
+  clear() {
+  }
+  init() {
+    const container = this.container, bounce = container.actualOptions.interactivity.modes.bounce;
+    if (!bounce) {
+      return;
+    }
+    container.retina.bounceModeDistance = bounce.distance * container.retina.pixelRatio;
+  }
+  interact() {
+    const container = this.container, options = container.actualOptions, events = options.interactivity.events, mouseMoveStatus = container.interactivity.status === mouseMoveEvent, hoverEnabled = events.onHover.enable, hoverMode = events.onHover.mode, divs = events.onDiv;
+    if (mouseMoveStatus && hoverEnabled && isInArray(bounceMode, hoverMode)) {
+      mouseBounce(this.container, (p) => this.isEnabled(p));
+    } else {
+      divBounce(this.container, divs, bounceMode, (p) => this.isEnabled(p));
+    }
+  }
+  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;
+    return !!mouse.position && events.onHover.enable && isInArray(bounceMode, events.onHover.mode) || isDivModeEnabled(bounceMode, divs);
+  }
+  loadModeOptions(options, ...sources) {
+    if (!options.bounce) {
+      options.bounce = new Bounce();
+    }
+    for (const source of sources) {
+      options.bounce.load(source == null ? void 0 : source.bounce);
+    }
+  }
+  reset() {
+  }
+}
+export {
+  Bouncer
+};

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

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

package/dist/node_modules/.pnpm/@tsparticles_interaction-external-bounce@3.9.1/node_modules/@tsparticles/interaction-external-bounce/browser/Utils.js

@@ -0,0 +1,47 @@
+import { divModeExecute, circleBounce, circleBounceDataFromParticle, rectBounce, calculateBounds } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/Utils.js";
+import { Circle, Rectangle } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Ranges.js";
+import { DivType } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Types/DivType.js";
+import { Vector } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Vectors.js";
+const squareExp = 2, half = 0.5, halfPI = Math.PI * half, double = 2, toleranceFactor = 10, minRadius = 0;
+function processBounce(container, position, radius, area, enabledCb) {
+  const query = container.particles.quadTree.query(area, enabledCb);
+  for (const particle of query) {
+    if (area instanceof Circle) {
+      circleBounce(circleBounceDataFromParticle(particle), {
+        position,
+        mass: radius ** squareExp * halfPI,
+        velocity: Vector.origin,
+        factor: Vector.origin
+      });
+    } else if (area instanceof Rectangle) {
+      rectBounce(particle, calculateBounds(position, radius));
+    }
+  }
+}
+function singleSelectorBounce(container, selector, div, bounceCb) {
+  const query = document.querySelectorAll(selector);
+  if (!query.length) {
+    return;
+  }
+  query.forEach((item) => {
+    const elem = item, pxRatio = container.retina.pixelRatio, pos = {
+      x: (elem.offsetLeft + elem.offsetWidth * half) * pxRatio,
+      y: (elem.offsetTop + elem.offsetHeight * half) * pxRatio
+    }, radius = elem.offsetWidth * half * pxRatio, tolerance = toleranceFactor * pxRatio, area = div.type === DivType.circle ? new Circle(pos.x, pos.y, radius + tolerance) : new Rectangle(elem.offsetLeft * pxRatio - tolerance, elem.offsetTop * pxRatio - tolerance, elem.offsetWidth * pxRatio + tolerance * double, elem.offsetHeight * pxRatio + tolerance * double);
+    bounceCb(pos, radius, area);
+  });
+}
+function divBounce(container, divs, bounceMode, enabledCb) {
+  divModeExecute(bounceMode, divs, (selector, div) => singleSelectorBounce(container, selector, div, (pos, radius, area) => processBounce(container, pos, radius, area, enabledCb)));
+}
+function mouseBounce(container, enabledCb) {
+  const pxRatio = container.retina.pixelRatio, tolerance = toleranceFactor * pxRatio, mousePos = container.interactivity.mouse.position, radius = container.retina.bounceModeDistance;
+  if (!radius || radius < minRadius || !mousePos) {
+    return;
+  }
+  processBounce(container, mousePos, radius, new Circle(mousePos.x, mousePos.y, radius + tolerance), enabledCb);
+}
+export {
+  divBounce,
+  mouseBounce
+};

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

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

package/dist/node_modules/.pnpm/@tsparticles_interaction-external-bubble@3.9.1/node_modules/@tsparticles/interaction-external-bubble/browser/Bubbler.js

@@ -0,0 +1,274 @@
+import { Bubble } from "./Options/Classes/Bubble.js";
+import { ProcessBubbleType } from "./Enums.js";
+import { calculateBubbleValue } from "./Utils.js";
+import { millisecondsToSeconds, mouseMoveEvent, mouseLeaveEvent } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Constants.js";
+import { rangeColorToHsl, rgbToHsl, colorMix } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/ColorUtils.js";
+import { itemFromSingleOrMultiple, divMode, isInArray, divModeExecute, isDivModeEnabled } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/Utils.js";
+import { ExternalInteractorBase } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/ExternalInteractorBase.js";
+import { getDistance, getRangeMax } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+import { DivType } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Types/DivType.js";
+import { Circle, Rectangle } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Ranges.js";
+const bubbleMode = "bubble", minDistance = 0, defaultClickTime = 0, double = 2, defaultOpacity = 1, ratioOffset = 1, defaultBubbleValue = 0, minRatio = 0, half = 0.5, defaultRatio = 1;
+class Bubbler extends ExternalInteractorBase {
+  constructor(container, engine) {
+    super(container);
+    this._clickBubble = () => {
+      var _a;
+      const container2 = this.container, options = container2.actualOptions, mouseClickPos = container2.interactivity.mouse.clickPosition, bubbleOptions = options.interactivity.modes.bubble;
+      if (!bubbleOptions || !mouseClickPos) {
+        return;
+      }
+      if (!container2.bubble) {
+        container2.bubble = {};
+      }
+      const distance = container2.retina.bubbleModeDistance;
+      if (!distance || distance < minDistance) {
+        return;
+      }
+      const query = container2.particles.quadTree.queryCircle(mouseClickPos, distance, (p) => this.isEnabled(p)), { bubble } = container2;
+      for (const particle of query) {
+        if (!bubble.clicking) {
+          continue;
+        }
+        particle.bubble.inRange = !bubble.durationEnd;
+        const pos = particle.getPosition(), distMouse = getDistance(pos, mouseClickPos), timeSpent = ((/* @__PURE__ */ new Date()).getTime() - (container2.interactivity.mouse.clickTime ?? defaultClickTime)) / millisecondsToSeconds;
+        if (timeSpent > bubbleOptions.duration) {
+          bubble.durationEnd = true;
+        }
+        if (timeSpent > bubbleOptions.duration * double) {
+          bubble.clicking = false;
+          bubble.durationEnd = false;
+        }
+        const sizeData = {
+          bubbleObj: {
+            optValue: container2.retina.bubbleModeSize,
+            value: particle.bubble.radius
+          },
+          particlesObj: {
+            optValue: getRangeMax(particle.options.size.value) * container2.retina.pixelRatio,
+            value: particle.size.value
+          },
+          type: ProcessBubbleType.size
+        };
+        this._process(particle, distMouse, timeSpent, sizeData);
+        const opacityData = {
+          bubbleObj: {
+            optValue: bubbleOptions.opacity,
+            value: particle.bubble.opacity
+          },
+          particlesObj: {
+            optValue: getRangeMax(particle.options.opacity.value),
+            value: ((_a = particle.opacity) == null ? void 0 : _a.value) ?? defaultOpacity
+          },
+          type: ProcessBubbleType.opacity
+        };
+        this._process(particle, distMouse, timeSpent, opacityData);
+        if (!bubble.durationEnd && distMouse <= distance) {
+          this._hoverBubbleColor(particle, distMouse);
+        } else {
+          delete particle.bubble.color;
+        }
+      }
+    };
+    this._hoverBubble = () => {
+      const container2 = this.container, mousePos = container2.interactivity.mouse.position, distance = container2.retina.bubbleModeDistance;
+      if (!distance || distance < minDistance || !mousePos) {
+        return;
+      }
+      const query = container2.particles.quadTree.queryCircle(mousePos, distance, (p) => this.isEnabled(p));
+      for (const particle of query) {
+        particle.bubble.inRange = true;
+        const pos = particle.getPosition(), pointDistance = getDistance(pos, mousePos), ratio = ratioOffset - pointDistance / distance;
+        if (pointDistance <= distance) {
+          if (ratio >= minRatio && container2.interactivity.status === mouseMoveEvent) {
+            this._hoverBubbleSize(particle, ratio);
+            this._hoverBubbleOpacity(particle, ratio);
+            this._hoverBubbleColor(particle, ratio);
+          }
+        } else {
+          this.reset(particle);
+        }
+        if (container2.interactivity.status === mouseLeaveEvent) {
+          this.reset(particle);
+        }
+      }
+    };
+    this._hoverBubbleColor = (particle, ratio, divBubble) => {
+      const options = this.container.actualOptions, bubbleOptions = divBubble ?? options.interactivity.modes.bubble;
+      if (!bubbleOptions) {
+        return;
+      }
+      if (!particle.bubble.finalColor) {
+        const modeColor = bubbleOptions.color;
+        if (!modeColor) {
+          return;
+        }
+        const bubbleColor = itemFromSingleOrMultiple(modeColor);
+        particle.bubble.finalColor = rangeColorToHsl(this._engine, bubbleColor);
+      }
+      if (!particle.bubble.finalColor) {
+        return;
+      }
+      if (bubbleOptions.mix) {
+        particle.bubble.color = void 0;
+        const pColor = particle.getFillColor();
+        particle.bubble.color = pColor ? rgbToHsl(colorMix(pColor, particle.bubble.finalColor, ratioOffset - ratio, ratio)) : particle.bubble.finalColor;
+      } else {
+        particle.bubble.color = particle.bubble.finalColor;
+      }
+    };
+    this._hoverBubbleOpacity = (particle, ratio, divBubble) => {
+      var _a, _b;
+      const container2 = this.container, options = container2.actualOptions, modeOpacity = (divBubble == null ? void 0 : divBubble.opacity) ?? ((_a = options.interactivity.modes.bubble) == null ? void 0 : _a.opacity);
+      if (!modeOpacity) {
+        return;
+      }
+      const optOpacity = particle.options.opacity.value, pOpacity = ((_b = particle.opacity) == null ? void 0 : _b.value) ?? defaultOpacity, opacity = calculateBubbleValue(pOpacity, modeOpacity, getRangeMax(optOpacity), ratio);
+      if (opacity !== void 0) {
+        particle.bubble.opacity = opacity;
+      }
+    };
+    this._hoverBubbleSize = (particle, ratio, divBubble) => {
+      const container2 = this.container, modeSize = (divBubble == null ? void 0 : divBubble.size) ? divBubble.size * container2.retina.pixelRatio : container2.retina.bubbleModeSize;
+      if (modeSize === void 0) {
+        return;
+      }
+      const optSize = getRangeMax(particle.options.size.value) * container2.retina.pixelRatio, pSize = particle.size.value, size = calculateBubbleValue(pSize, modeSize, optSize, ratio);
+      if (size !== void 0) {
+        particle.bubble.radius = size;
+      }
+    };
+    this._process = (particle, distMouse, timeSpent, data) => {
+      const container2 = this.container, bubbleParam = data.bubbleObj.optValue, options = container2.actualOptions, bubbleOptions = options.interactivity.modes.bubble;
+      if (!bubbleOptions || bubbleParam === void 0) {
+        return;
+      }
+      const bubbleDuration = bubbleOptions.duration, bubbleDistance = container2.retina.bubbleModeDistance, particlesParam = data.particlesObj.optValue, pObjBubble = data.bubbleObj.value, pObj = data.particlesObj.value ?? defaultBubbleValue, type = data.type;
+      if (!bubbleDistance || bubbleDistance < minDistance || bubbleParam === particlesParam) {
+        return;
+      }
+      if (!container2.bubble) {
+        container2.bubble = {};
+      }
+      if (container2.bubble.durationEnd) {
+        if (pObjBubble) {
+          if (type === ProcessBubbleType.size) {
+            delete particle.bubble.radius;
+          }
+          if (type === ProcessBubbleType.opacity) {
+            delete particle.bubble.opacity;
+          }
+        }
+      } else {
+        if (distMouse <= bubbleDistance) {
+          const obj = pObjBubble ?? pObj;
+          if (obj !== bubbleParam) {
+            const value = pObj - timeSpent * (pObj - bubbleParam) / bubbleDuration;
+            if (type === ProcessBubbleType.size) {
+              particle.bubble.radius = value;
+            }
+            if (type === ProcessBubbleType.opacity) {
+              particle.bubble.opacity = value;
+            }
+          }
+        } else {
+          if (type === ProcessBubbleType.size) {
+            delete particle.bubble.radius;
+          }
+          if (type === ProcessBubbleType.opacity) {
+            delete particle.bubble.opacity;
+          }
+        }
+      }
+    };
+    this._singleSelectorHover = (delta, selector, div) => {
+      const container2 = this.container, selectors = document.querySelectorAll(selector), bubble = container2.actualOptions.interactivity.modes.bubble;
+      if (!bubble || !selectors.length) {
+        return;
+      }
+      selectors.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), query = container2.particles.quadTree.query(area, (p) => this.isEnabled(p));
+        for (const particle of query) {
+          if (!area.contains(particle.getPosition())) {
+            continue;
+          }
+          particle.bubble.inRange = true;
+          const divs = bubble.divs, divBubble = divMode(divs, elem);
+          if (!particle.bubble.div || particle.bubble.div !== elem) {
+            this.clear(particle, delta, true);
+            particle.bubble.div = elem;
+          }
+          this._hoverBubbleSize(particle, defaultRatio, divBubble);
+          this._hoverBubbleOpacity(particle, defaultRatio, divBubble);
+          this._hoverBubbleColor(particle, defaultRatio, divBubble);
+        }
+      });
+    };
+    this._engine = engine;
+    if (!container.bubble) {
+      container.bubble = {};
+    }
+    this.handleClickMode = (mode) => {
+      if (mode !== bubbleMode) {
+        return;
+      }
+      if (!container.bubble) {
+        container.bubble = {};
+      }
+      container.bubble.clicking = true;
+    };
+  }
+  clear(particle, delta, force) {
+    if (particle.bubble.inRange && !force) {
+      return;
+    }
+    delete particle.bubble.div;
+    delete particle.bubble.opacity;
+    delete particle.bubble.radius;
+    delete particle.bubble.color;
+  }
+  init() {
+    const container = this.container, bubble = container.actualOptions.interactivity.modes.bubble;
+    if (!bubble) {
+      return;
+    }
+    container.retina.bubbleModeDistance = bubble.distance * container.retina.pixelRatio;
+    if (bubble.size !== void 0) {
+      container.retina.bubbleModeSize = bubble.size * container.retina.pixelRatio;
+    }
+  }
+  interact(delta) {
+    const options = this.container.actualOptions, events = options.interactivity.events, onHover = events.onHover, onClick = events.onClick, hoverEnabled = onHover.enable, hoverMode = onHover.mode, clickEnabled = onClick.enable, clickMode = onClick.mode, divs = events.onDiv;
+    if (hoverEnabled && isInArray(bubbleMode, hoverMode)) {
+      this._hoverBubble();
+    } else if (clickEnabled && isInArray(bubbleMode, clickMode)) {
+      this._clickBubble();
+    } else {
+      divModeExecute(bubbleMode, divs, (selector, div) => this._singleSelectorHover(delta, 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, { onClick, onDiv, onHover } = events, divBubble = isDivModeEnabled(bubbleMode, onDiv);
+    if (!(divBubble || onHover.enable && !!mouse.position || onClick.enable && mouse.clickPosition)) {
+      return false;
+    }
+    return isInArray(bubbleMode, onHover.mode) || isInArray(bubbleMode, onClick.mode) || divBubble;
+  }
+  loadModeOptions(options, ...sources) {
+    if (!options.bubble) {
+      options.bubble = new Bubble();
+    }
+    for (const source of sources) {
+      options.bubble.load(source == null ? void 0 : source.bubble);
+    }
+  }
+  reset(particle) {
+    particle.bubble.inRange = false;
+  }
+}
+export {
+  Bubbler
+};

package/dist/node_modules/.pnpm/@tsparticles_interaction-external-bubble@3.9.1/node_modules/@tsparticles/interaction-external-bubble/browser/Enums.js

@@ -0,0 +1,9 @@
+var ProcessBubbleType;
+(function(ProcessBubbleType2) {
+  ProcessBubbleType2["color"] = "color";
+  ProcessBubbleType2["opacity"] = "opacity";
+  ProcessBubbleType2["size"] = "size";
+})(ProcessBubbleType || (ProcessBubbleType = {}));
+export {
+  ProcessBubbleType
+};

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

@@ -0,0 +1,20 @@
+import { BubbleBase } from "./BubbleBase.js";
+import { BubbleDiv } from "./BubbleDiv.js";
+import { isNull } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/TypeUtils.js";
+import { executeOnSingleOrMultiple } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/Utils.js";
+class Bubble extends BubbleBase {
+  load(data) {
+    super.load(data);
+    if (isNull(data)) {
+      return;
+    }
+    this.divs = executeOnSingleOrMultiple(data.divs, (div) => {
+      const tmp = new BubbleDiv();
+      tmp.load(div);
+      return tmp;
+    });
+  }
+}
+export {
+  Bubble
+};

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

@@ -0,0 +1,39 @@
+import { isNull, isArray } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/TypeUtils.js";
+import { OptionsColor } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Options/Classes/OptionsColor.js";
+import { executeOnSingleOrMultiple } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/Utils.js";
+class BubbleBase {
+  constructor() {
+    this.distance = 200;
+    this.duration = 0.4;
+    this.mix = false;
+  }
+  load(data) {
+    if (isNull(data)) {
+      return;
+    }
+    if (data.distance !== void 0) {
+      this.distance = data.distance;
+    }
+    if (data.duration !== void 0) {
+      this.duration = data.duration;
+    }
+    if (data.mix !== void 0) {
+      this.mix = data.mix;
+    }
+    if (data.opacity !== void 0) {
+      this.opacity = data.opacity;
+    }
+    if (data.color !== void 0) {
+      const sourceColor = isArray(this.color) ? void 0 : this.color;
+      this.color = executeOnSingleOrMultiple(data.color, (color) => {
+        return OptionsColor.create(sourceColor, color);
+      });
+    }
+    if (data.size !== void 0) {
+      this.size = data.size;
+    }
+  }
+}
+export {
+  BubbleBase
+};

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

@@ -0,0 +1,20 @@
+import { BubbleBase } from "./BubbleBase.js";
+import { isNull } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/TypeUtils.js";
+class BubbleDiv extends BubbleBase {
+  constructor() {
+    super();
+    this.selectors = [];
+  }
+  load(data) {
+    super.load(data);
+    if (isNull(data)) {
+      return;
+    }
+    if (data.selectors !== void 0) {
+      this.selectors = data.selectors;
+    }
+  }
+}
+export {
+  BubbleDiv
+};

package/dist/node_modules/.pnpm/@tsparticles_interaction-external-bubble@3.9.1/node_modules/@tsparticles/interaction-external-bubble/browser/Utils.js

@@ -0,0 +1,13 @@
+import { clamp } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+function calculateBubbleValue(particleValue, modeValue, optionsValue, ratio) {
+  if (modeValue >= optionsValue) {
+    const value = particleValue + (modeValue - optionsValue) * ratio;
+    return clamp(value, particleValue, modeValue);
+  } else if (modeValue < optionsValue) {
+    const value = particleValue - (optionsValue - modeValue) * ratio;
+    return clamp(value, modeValue, particleValue);
+  }
+}
+export {
+  calculateBubbleValue
+};

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

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

package/dist/node_modules/.pnpm/@tsparticles_interaction-external-connect@3.9.1/node_modules/@tsparticles/interaction-external-connect/browser/Connector.js

@@ -0,0 +1,59 @@
+import { Connect } from "./Options/Classes/Connect.js";
+import { drawConnection } from "./Utils.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";
+const connectMode = "connect", minDistance = 0;
+class Connector extends ExternalInteractorBase {
+  constructor(container) {
+    super(container);
+  }
+  clear() {
+  }
+  init() {
+    const container = this.container, connect = container.actualOptions.interactivity.modes.connect;
+    if (!connect) {
+      return;
+    }
+    container.retina.connectModeDistance = connect.distance * container.retina.pixelRatio;
+    container.retina.connectModeRadius = connect.radius * container.retina.pixelRatio;
+  }
+  interact() {
+    const container = this.container, options = container.actualOptions;
+    if (options.interactivity.events.onHover.enable && container.interactivity.status === "pointermove") {
+      const mousePos = container.interactivity.mouse.position, { connectModeDistance, connectModeRadius } = container.retina;
+      if (!connectModeDistance || connectModeDistance < minDistance || !connectModeRadius || connectModeRadius < minDistance || !mousePos) {
+        return;
+      }
+      const distance = Math.abs(connectModeRadius), query = container.particles.quadTree.queryCircle(mousePos, distance, (p) => this.isEnabled(p));
+      query.forEach((p1, i) => {
+        const pos1 = p1.getPosition(), indexOffset = 1;
+        for (const p2 of query.slice(i + indexOffset)) {
+          const pos2 = p2.getPosition(), distMax = Math.abs(connectModeDistance), xDiff = Math.abs(pos1.x - pos2.x), yDiff = Math.abs(pos1.y - pos2.y);
+          if (xDiff < distMax && yDiff < distMax) {
+            drawConnection(container, p1, p2);
+          }
+        }
+      });
+    }
+  }
+  isEnabled(particle) {
+    const container = this.container, mouse = container.interactivity.mouse, events = ((particle == null ? void 0 : particle.interactivity) ?? container.actualOptions.interactivity).events;
+    if (!(events.onHover.enable && mouse.position)) {
+      return false;
+    }
+    return isInArray(connectMode, events.onHover.mode);
+  }
+  loadModeOptions(options, ...sources) {
+    if (!options.connect) {
+      options.connect = new Connect();
+    }
+    for (const source of sources) {
+      options.connect.load(source == null ? void 0 : source.connect);
+    }
+  }
+  reset() {
+  }
+}
+export {
+  Connector
+};

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

@@ -0,0 +1,24 @@
+import { ConnectLinks } from "./ConnectLinks.js";
+import { isNull } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/TypeUtils.js";
+class Connect {
+  constructor() {
+    this.distance = 80;
+    this.links = new ConnectLinks();
+    this.radius = 60;
+  }
+  load(data) {
+    if (isNull(data)) {
+      return;
+    }
+    if (data.distance !== void 0) {
+      this.distance = data.distance;
+    }
+    this.links.load(data.links);
+    if (data.radius !== void 0) {
+      this.radius = data.radius;
+    }
+  }
+}
+export {
+  Connect
+};