dune-react 0.0.1

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

@@ -0,0 +1,109 @@
+import { CircleWarp } from "./CircleWarp.js";
+import { Links } from "./Options/Classes/Links.js";
+import { ParticlesInteractorBase } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/ParticlesInteractorBase.js";
+import { getLinkRandomColor } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/ColorUtils.js";
+import { Circle } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Ranges.js";
+import { getDistances } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+const squarePower = 2, opacityOffset = 1, origin = {
+  x: 0,
+  y: 0
+}, minDistance = 0;
+function getLinkDistance(pos1, pos2, optDistance, canvasSize, warp) {
+  const { dx, dy, distance } = getDistances(pos1, pos2);
+  if (!warp || distance <= optDistance) {
+    return distance;
+  }
+  const absDiffs = {
+    x: Math.abs(dx),
+    y: Math.abs(dy)
+  }, warpDistances = {
+    x: Math.min(absDiffs.x, canvasSize.width - absDiffs.x),
+    y: Math.min(absDiffs.y, canvasSize.height - absDiffs.y)
+  };
+  return Math.sqrt(warpDistances.x ** squarePower + warpDistances.y ** squarePower);
+}
+class Linker extends ParticlesInteractorBase {
+  constructor(container, engine) {
+    super(container);
+    this._setColor = (p1) => {
+      if (!p1.options.links) {
+        return;
+      }
+      const container2 = this._linkContainer, linksOptions = p1.options.links;
+      let linkColor = linksOptions.id === void 0 ? container2.particles.linksColor : container2.particles.linksColors.get(linksOptions.id);
+      if (linkColor) {
+        return;
+      }
+      const optColor = linksOptions.color;
+      linkColor = getLinkRandomColor(this._engine, optColor, linksOptions.blink, linksOptions.consent);
+      if (linksOptions.id === void 0) {
+        container2.particles.linksColor = linkColor;
+      } else {
+        container2.particles.linksColors.set(linksOptions.id, linkColor);
+      }
+    };
+    this._linkContainer = container;
+    this._engine = engine;
+  }
+  clear() {
+  }
+  init() {
+    this._linkContainer.particles.linksColor = void 0;
+    this._linkContainer.particles.linksColors = /* @__PURE__ */ new Map();
+  }
+  interact(p1) {
+    if (!p1.options.links) {
+      return;
+    }
+    p1.links = [];
+    const pos1 = p1.getPosition(), container = this.container, canvasSize = container.canvas.size;
+    if (pos1.x < origin.x || pos1.y < origin.y || pos1.x > canvasSize.width || pos1.y > canvasSize.height) {
+      return;
+    }
+    const linkOpt1 = p1.options.links, optOpacity = linkOpt1.opacity, optDistance = p1.retina.linksDistance ?? minDistance, warp = linkOpt1.warp;
+    let range;
+    if (warp) {
+      range = new CircleWarp(pos1.x, pos1.y, optDistance, canvasSize);
+    } else {
+      range = new Circle(pos1.x, pos1.y, optDistance);
+    }
+    const query = container.particles.quadTree.query(range);
+    for (const p2 of query) {
+      const linkOpt2 = p2.options.links;
+      if (p1 === p2 || !(linkOpt2 == null ? void 0 : linkOpt2.enable) || linkOpt1.id !== linkOpt2.id || p2.spawning || p2.destroyed || !p2.links || p1.links.some((t) => t.destination === p2) || p2.links.some((t) => t.destination === p1)) {
+        continue;
+      }
+      const pos2 = p2.getPosition();
+      if (pos2.x < origin.x || pos2.y < origin.y || pos2.x > canvasSize.width || pos2.y > canvasSize.height) {
+        continue;
+      }
+      const distance = getLinkDistance(pos1, pos2, optDistance, canvasSize, warp && linkOpt2.warp);
+      if (distance > optDistance) {
+        continue;
+      }
+      const opacityLine = (opacityOffset - distance / optDistance) * optOpacity;
+      this._setColor(p1);
+      p1.links.push({
+        destination: p2,
+        opacity: opacityLine
+      });
+    }
+  }
+  isEnabled(particle) {
+    var _a;
+    return !!((_a = particle.options.links) == null ? void 0 : _a.enable);
+  }
+  loadParticlesOptions(options, ...sources) {
+    if (!options.links) {
+      options.links = new Links();
+    }
+    for (const source of sources) {
+      options.links.load(source == null ? void 0 : source.links);
+    }
+  }
+  reset() {
+  }
+}
+export {
+  Linker
+};

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

@@ -0,0 +1,18 @@
+import { LinkInstance } from "./LinkInstance.js";
+class LinksPlugin {
+  constructor(engine) {
+    this.id = "links";
+    this._engine = engine;
+  }
+  getPlugin(container) {
+    return Promise.resolve(new LinkInstance(container, this._engine));
+  }
+  loadOptions() {
+  }
+  needsPlugin() {
+    return true;
+  }
+}
+export {
+  LinksPlugin
+};

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

@@ -0,0 +1,58 @@
+import { LinksShadow } from "./LinksShadow.js";
+import { LinksTriangle } from "./LinksTriangle.js";
+import { OptionsColor } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Options/Classes/OptionsColor.js";
+import { isNull } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/TypeUtils.js";
+class Links {
+  constructor() {
+    this.blink = false;
+    this.color = new OptionsColor();
+    this.color.value = "#fff";
+    this.consent = false;
+    this.distance = 100;
+    this.enable = false;
+    this.frequency = 1;
+    this.opacity = 1;
+    this.shadow = new LinksShadow();
+    this.triangles = new LinksTriangle();
+    this.width = 1;
+    this.warp = false;
+  }
+  load(data) {
+    if (isNull(data)) {
+      return;
+    }
+    if (data.id !== void 0) {
+      this.id = data.id;
+    }
+    if (data.blink !== void 0) {
+      this.blink = data.blink;
+    }
+    this.color = OptionsColor.create(this.color, data.color);
+    if (data.consent !== void 0) {
+      this.consent = data.consent;
+    }
+    if (data.distance !== void 0) {
+      this.distance = data.distance;
+    }
+    if (data.enable !== void 0) {
+      this.enable = data.enable;
+    }
+    if (data.frequency !== void 0) {
+      this.frequency = data.frequency;
+    }
+    if (data.opacity !== void 0) {
+      this.opacity = data.opacity;
+    }
+    this.shadow.load(data.shadow);
+    this.triangles.load(data.triangles);
+    if (data.width !== void 0) {
+      this.width = data.width;
+    }
+    if (data.warp !== void 0) {
+      this.warp = data.warp;
+    }
+  }
+}
+export {
+  Links
+};

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

@@ -0,0 +1,25 @@
+import { OptionsColor } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Options/Classes/OptionsColor.js";
+import { isNull } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/TypeUtils.js";
+class LinksShadow {
+  constructor() {
+    this.blur = 5;
+    this.color = new OptionsColor();
+    this.color.value = "#000";
+    this.enable = false;
+  }
+  load(data) {
+    if (isNull(data)) {
+      return;
+    }
+    if (data.blur !== void 0) {
+      this.blur = data.blur;
+    }
+    this.color = OptionsColor.create(this.color, data.color);
+    if (data.enable !== void 0) {
+      this.enable = data.enable;
+    }
+  }
+}
+export {
+  LinksShadow
+};

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

@@ -0,0 +1,28 @@
+import { isNull } 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";
+class LinksTriangle {
+  constructor() {
+    this.enable = false;
+    this.frequency = 1;
+  }
+  load(data) {
+    if (isNull(data)) {
+      return;
+    }
+    if (data.color !== void 0) {
+      this.color = OptionsColor.create(this.color, data.color);
+    }
+    if (data.enable !== void 0) {
+      this.enable = data.enable;
+    }
+    if (data.frequency !== void 0) {
+      this.frequency = data.frequency;
+    }
+    if (data.opacity !== void 0) {
+      this.opacity = data.opacity;
+    }
+  }
+}
+export {
+  LinksTriangle
+};

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

@@ -0,0 +1,106 @@
+import { getStyleFromRgb, rangeColorToRgb } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/ColorUtils.js";
+import { getDistance, getDistances, getRandom } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+import { drawLine } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/CanvasUtils.js";
+function drawTriangle(context, p1, p2, p3) {
+  context.beginPath();
+  context.moveTo(p1.x, p1.y);
+  context.lineTo(p2.x, p2.y);
+  context.lineTo(p3.x, p3.y);
+  context.closePath();
+}
+function drawLinkLine(params) {
+  let drawn = false;
+  const { begin, end, engine, maxDistance, context, canvasSize, width, backgroundMask, colorLine, opacity, links } = params;
+  if (getDistance(begin, end) <= maxDistance) {
+    drawLine(context, begin, end);
+    drawn = true;
+  } else if (links.warp) {
+    let pi1;
+    let pi2;
+    const endNE = {
+      x: end.x - canvasSize.width,
+      y: end.y
+    };
+    const d1 = getDistances(begin, endNE);
+    if (d1.distance <= maxDistance) {
+      const yi = begin.y - d1.dy / d1.dx * begin.x;
+      pi1 = { x: 0, y: yi };
+      pi2 = { x: canvasSize.width, y: yi };
+    } else {
+      const endSW = {
+        x: end.x,
+        y: end.y - canvasSize.height
+      };
+      const d2 = getDistances(begin, endSW);
+      if (d2.distance <= maxDistance) {
+        const yi = begin.y - d2.dy / d2.dx * begin.x;
+        const xi = -yi / (d2.dy / d2.dx);
+        pi1 = { x: xi, y: 0 };
+        pi2 = { x: xi, y: canvasSize.height };
+      } else {
+        const endSE = {
+          x: end.x - canvasSize.width,
+          y: end.y - canvasSize.height
+        };
+        const d3 = getDistances(begin, endSE);
+        if (d3.distance <= maxDistance) {
+          const yi = begin.y - d3.dy / d3.dx * begin.x;
+          const xi = -yi / (d3.dy / d3.dx);
+          pi1 = { x: xi, y: yi };
+          pi2 = { x: pi1.x + canvasSize.width, y: pi1.y + canvasSize.height };
+        }
+      }
+    }
+    if (pi1 && pi2) {
+      drawLine(context, begin, pi1);
+      drawLine(context, end, pi2);
+      drawn = true;
+    }
+  }
+  if (!drawn) {
+    return;
+  }
+  context.lineWidth = width;
+  if (backgroundMask.enable) {
+    context.globalCompositeOperation = backgroundMask.composite;
+  }
+  context.strokeStyle = getStyleFromRgb(colorLine, opacity);
+  const { shadow } = links;
+  if (shadow.enable) {
+    const shadowColor = rangeColorToRgb(engine, shadow.color);
+    if (shadowColor) {
+      context.shadowBlur = shadow.blur;
+      context.shadowColor = getStyleFromRgb(shadowColor);
+    }
+  }
+  context.stroke();
+}
+function drawLinkTriangle(params) {
+  const { context, pos1, pos2, pos3, backgroundMask, colorTriangle, opacityTriangle } = params;
+  drawTriangle(context, pos1, pos2, pos3);
+  if (backgroundMask.enable) {
+    context.globalCompositeOperation = backgroundMask.composite;
+  }
+  context.fillStyle = getStyleFromRgb(colorTriangle, opacityTriangle);
+  context.fill();
+}
+function getLinkKey(ids) {
+  ids.sort((a, b) => a - b);
+  return ids.join("_");
+}
+function setLinkFrequency(particles, dictionary) {
+  const key = getLinkKey(particles.map((t) => t.id));
+  let res = dictionary.get(key);
+  if (res === void 0) {
+    res = getRandom();
+    dictionary.set(key, res);
+  }
+  return res;
+}
+export {
+  drawLinkLine,
+  drawLinkTriangle,
+  drawTriangle,
+  getLinkKey,
+  setLinkFrequency
+};

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

@@ -0,0 +1,10 @@
+import { loadLinksInteraction } from "./interaction.js";
+import { loadLinksPlugin } from "./plugin.js";
+async function loadParticlesLinksInteraction(engine, refresh = true) {
+  engine.checkVersion("3.9.1");
+  await loadLinksInteraction(engine, refresh);
+  await loadLinksPlugin(engine, refresh);
+}
+export {
+  loadParticlesLinksInteraction
+};

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

@@ -0,0 +1,9 @@
+import { Linker } from "./Linker.js";
+async function loadLinksInteraction(engine, refresh = true) {
+  await engine.addInteractor("particlesLinks", async (container) => {
+    return Promise.resolve(new Linker(container, engine));
+  }, refresh);
+}
+export {
+  loadLinksInteraction
+};

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

@@ -0,0 +1,8 @@
+import { LinksPlugin } from "./LinksPlugin.js";
+async function loadLinksPlugin(engine, refresh = true) {
+  const plugin = new LinksPlugin(engine);
+  await engine.addPlugin(plugin, refresh);
+}
+export {
+  loadLinksPlugin
+};

package/dist/node_modules/.pnpm/@tsparticles_move-base@3.9.1/node_modules/@tsparticles/move-base/browser/BaseMover.js

@@ -0,0 +1,37 @@
+import { initSpin, getProximitySpeedFactor, spin, move, applyDistance } from "./Utils.js";
+import { getRangeValue, getRangeMax } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+const diffFactor = 2, defaultSizeFactor = 1, defaultDeltaFactor = 1;
+class BaseMover {
+  init(particle) {
+    const options = particle.options, gravityOptions = options.move.gravity;
+    particle.gravity = {
+      enable: gravityOptions.enable,
+      acceleration: getRangeValue(gravityOptions.acceleration),
+      inverse: gravityOptions.inverse
+    };
+    initSpin(particle);
+  }
+  isEnabled(particle) {
+    return !particle.destroyed && particle.options.move.enable;
+  }
+  move(particle, delta) {
+    var _a, _b;
+    const particleOptions = particle.options, moveOptions = particleOptions.move;
+    if (!moveOptions.enable) {
+      return;
+    }
+    const container = particle.container, pxRatio = container.retina.pixelRatio;
+    (_a = particle.retina).moveSpeed ?? (_a.moveSpeed = getRangeValue(moveOptions.speed) * pxRatio);
+    (_b = particle.retina).moveDrift ?? (_b.moveDrift = getRangeValue(particle.options.move.drift) * pxRatio);
+    const slowFactor = getProximitySpeedFactor(particle), reduceFactor = container.retina.reduceFactor, baseSpeed = particle.retina.moveSpeed, moveDrift = particle.retina.moveDrift, maxSize = getRangeMax(particleOptions.size.value) * pxRatio, sizeFactor = moveOptions.size ? particle.getRadius() / maxSize : defaultSizeFactor, deltaFactor = delta.factor || defaultDeltaFactor, moveSpeed = baseSpeed * sizeFactor * slowFactor * deltaFactor / diffFactor, maxSpeed = particle.retina.maxSpeed ?? container.retina.maxSpeed;
+    if (moveOptions.spin.enable) {
+      spin(particle, moveSpeed, reduceFactor);
+    } else {
+      move(particle, moveOptions, moveSpeed, maxSpeed, moveDrift, reduceFactor, delta);
+    }
+    applyDistance(particle);
+  }
+}
+export {
+  BaseMover
+};

package/dist/node_modules/.pnpm/@tsparticles_move-base@3.9.1/node_modules/@tsparticles/move-base/browser/Utils.js

@@ -0,0 +1,128 @@
+import { getDistance, getRangeValue, getRandom, getDistances, clamp } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+import { RotateDirection } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Directions/RotateDirection.js";
+const half = 0.5, double = 2, minVelocity = 0, identity = 1, moveSpeedFactor = 60, minSpinRadius = 0, spinFactor = 0.01, doublePI = Math.PI * double;
+function applyDistance(particle) {
+  const initialPosition = particle.initialPosition, { dx, dy } = getDistances(initialPosition, particle.position), dxFixed = Math.abs(dx), dyFixed = Math.abs(dy), { maxDistance } = particle.retina, hDistance = maxDistance.horizontal, vDistance = maxDistance.vertical;
+  if (!hDistance && !vDistance) {
+    return;
+  }
+  const hasHDistance = (hDistance && dxFixed >= hDistance) ?? false, hasVDistance = (vDistance && dyFixed >= vDistance) ?? false;
+  if ((hasHDistance || hasVDistance) && !particle.misplaced) {
+    particle.misplaced = !!hDistance && dxFixed > hDistance || !!vDistance && dyFixed > vDistance;
+    if (hDistance) {
+      particle.velocity.x = particle.velocity.y * half - particle.velocity.x;
+    }
+    if (vDistance) {
+      particle.velocity.y = particle.velocity.x * half - particle.velocity.y;
+    }
+  } else if ((!hDistance || dxFixed < hDistance) && (!vDistance || dyFixed < vDistance) && particle.misplaced) {
+    particle.misplaced = false;
+  } else if (particle.misplaced) {
+    const pos = particle.position, vel = particle.velocity;
+    if (hDistance && (pos.x < initialPosition.x && vel.x < minVelocity || pos.x > initialPosition.x && vel.x > minVelocity)) {
+      vel.x *= -getRandom();
+    }
+    if (vDistance && (pos.y < initialPosition.y && vel.y < minVelocity || pos.y > initialPosition.y && vel.y > minVelocity)) {
+      vel.y *= -getRandom();
+    }
+  }
+}
+function move(particle, moveOptions, moveSpeed, maxSpeed, moveDrift, reduceFactor, delta) {
+  applyPath(particle, delta);
+  const gravityOptions = particle.gravity, gravityFactor = (gravityOptions == null ? void 0 : gravityOptions.enable) && gravityOptions.inverse ? -identity : identity;
+  if (moveDrift && moveSpeed) {
+    particle.velocity.x += moveDrift * delta.factor / (moveSpeedFactor * moveSpeed);
+  }
+  if ((gravityOptions == null ? void 0 : gravityOptions.enable) && moveSpeed) {
+    particle.velocity.y += gravityFactor * (gravityOptions.acceleration * delta.factor) / (moveSpeedFactor * moveSpeed);
+  }
+  const decay = particle.moveDecay;
+  particle.velocity.multTo(decay);
+  const velocity = particle.velocity.mult(moveSpeed);
+  if ((gravityOptions == null ? void 0 : gravityOptions.enable) && maxSpeed > minVelocity && (!gravityOptions.inverse && velocity.y >= minVelocity && velocity.y >= maxSpeed || gravityOptions.inverse && velocity.y <= minVelocity && velocity.y <= -maxSpeed)) {
+    velocity.y = gravityFactor * maxSpeed;
+    if (moveSpeed) {
+      particle.velocity.y = velocity.y / moveSpeed;
+    }
+  }
+  const zIndexOptions = particle.options.zIndex, zVelocityFactor = (identity - particle.zIndexFactor) ** zIndexOptions.velocityRate;
+  velocity.multTo(zVelocityFactor);
+  velocity.multTo(reduceFactor);
+  const { position } = particle;
+  position.addTo(velocity);
+  if (moveOptions.vibrate) {
+    position.x += Math.sin(position.x * Math.cos(position.y)) * reduceFactor;
+    position.y += Math.cos(position.y * Math.sin(position.x)) * reduceFactor;
+  }
+}
+function spin(particle, moveSpeed, reduceFactor) {
+  const container = particle.container;
+  if (!particle.spin) {
+    return;
+  }
+  const spinClockwise = particle.spin.direction === RotateDirection.clockwise, updateFunc = {
+    x: spinClockwise ? Math.cos : Math.sin,
+    y: spinClockwise ? Math.sin : Math.cos
+  };
+  particle.position.x = particle.spin.center.x + particle.spin.radius * updateFunc.x(particle.spin.angle) * reduceFactor;
+  particle.position.y = particle.spin.center.y + particle.spin.radius * updateFunc.y(particle.spin.angle) * reduceFactor;
+  particle.spin.radius += particle.spin.acceleration * reduceFactor;
+  const maxCanvasSize = Math.max(container.canvas.size.width, container.canvas.size.height), halfMaxSize = maxCanvasSize * half;
+  if (particle.spin.radius > halfMaxSize) {
+    particle.spin.radius = halfMaxSize;
+    particle.spin.acceleration *= -identity;
+  } else if (particle.spin.radius < minSpinRadius) {
+    particle.spin.radius = minSpinRadius;
+    particle.spin.acceleration *= -identity;
+  }
+  particle.spin.angle += moveSpeed * spinFactor * (identity - particle.spin.radius / maxCanvasSize);
+}
+function applyPath(particle, delta) {
+  var _a;
+  const particlesOptions = particle.options, pathOptions = particlesOptions.move.path, pathEnabled = pathOptions.enable;
+  if (!pathEnabled) {
+    return;
+  }
+  if (particle.lastPathTime <= particle.pathDelay) {
+    particle.lastPathTime += delta.value;
+    return;
+  }
+  const path = (_a = particle.pathGenerator) == null ? void 0 : _a.generate(particle, delta);
+  if (path) {
+    particle.velocity.addTo(path);
+  }
+  if (pathOptions.clamp) {
+    particle.velocity.x = clamp(particle.velocity.x, -identity, identity);
+    particle.velocity.y = clamp(particle.velocity.y, -identity, identity);
+  }
+  particle.lastPathTime -= particle.pathDelay;
+}
+function getProximitySpeedFactor(particle) {
+  return particle.slow.inRange ? particle.slow.factor : identity;
+}
+function initSpin(particle) {
+  const container = particle.container, options = particle.options, spinOptions = options.move.spin;
+  if (!spinOptions.enable) {
+    return;
+  }
+  const spinPos = spinOptions.position ?? { x: 50, y: 50 }, spinFactor2 = 0.01, spinCenter = {
+    x: spinPos.x * spinFactor2 * container.canvas.size.width,
+    y: spinPos.y * spinFactor2 * container.canvas.size.height
+  }, pos = particle.getPosition(), distance = getDistance(pos, spinCenter), spinAcceleration = getRangeValue(spinOptions.acceleration);
+  particle.retina.spinAcceleration = spinAcceleration * container.retina.pixelRatio;
+  particle.spin = {
+    center: spinCenter,
+    direction: particle.velocity.x >= minVelocity ? RotateDirection.clockwise : RotateDirection.counterClockwise,
+    angle: getRandom() * doublePI,
+    radius: distance,
+    acceleration: particle.retina.spinAcceleration
+  };
+}
+export {
+  applyDistance,
+  applyPath,
+  getProximitySpeedFactor,
+  initSpin,
+  move,
+  spin
+};

package/dist/node_modules/.pnpm/@tsparticles_move-base@3.9.1/node_modules/@tsparticles/move-base/browser/index.js

@@ -0,0 +1,10 @@
+import { BaseMover } from "./BaseMover.js";
+async function loadBaseMover(engine, refresh = true) {
+  engine.checkVersion("3.9.1");
+  await engine.addMover("base", () => {
+    return Promise.resolve(new BaseMover());
+  }, refresh);
+}
+export {
+  loadBaseMover
+};

package/dist/node_modules/.pnpm/@tsparticles_move-parallax@3.9.1/node_modules/@tsparticles/move-parallax/browser/ParallaxMover.js

@@ -0,0 +1,31 @@
+import { isSsr } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/Utils.js";
+const half = 0.5;
+class ParallaxMover {
+  init() {
+  }
+  isEnabled(particle) {
+    return !isSsr() && !particle.destroyed && particle.container.actualOptions.interactivity.events.onHover.parallax.enable;
+  }
+  move(particle) {
+    const container = particle.container, options = container.actualOptions, parallaxOptions = options.interactivity.events.onHover.parallax;
+    if (isSsr() || !parallaxOptions.enable) {
+      return;
+    }
+    const parallaxForce = parallaxOptions.force, mousePos = container.interactivity.mouse.position;
+    if (!mousePos) {
+      return;
+    }
+    const canvasSize = container.canvas.size, canvasCenter = {
+      x: canvasSize.width * half,
+      y: canvasSize.height * half
+    }, parallaxSmooth = parallaxOptions.smooth, factor = particle.getRadius() / parallaxForce, centerDistance = {
+      x: (mousePos.x - canvasCenter.x) * factor,
+      y: (mousePos.y - canvasCenter.y) * factor
+    }, { offset } = particle;
+    offset.x += (centerDistance.x - offset.x) / parallaxSmooth;
+    offset.y += (centerDistance.y - offset.y) / parallaxSmooth;
+  }
+}
+export {
+  ParallaxMover
+};

package/dist/node_modules/.pnpm/@tsparticles_move-parallax@3.9.1/node_modules/@tsparticles/move-parallax/browser/index.js

@@ -0,0 +1,10 @@
+import { ParallaxMover } from "./ParallaxMover.js";
+async function loadParallaxMover(engine, refresh = true) {
+  engine.checkVersion("3.9.1");
+  await engine.addMover("parallax", () => {
+    return Promise.resolve(new ParallaxMover());
+  }, refresh);
+}
+export {
+  loadParallaxMover
+};

package/dist/node_modules/.pnpm/@tsparticles_plugin-easing-quad@3.9.1/node_modules/@tsparticles/plugin-easing-quad/browser/index.js

@@ -0,0 +1,11 @@
+import { EasingType } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Types/EasingType.js";
+async function loadEasingQuadPlugin(engine, refresh = true) {
+  engine.checkVersion("3.9.1");
+  await engine.addEasing(EasingType.easeInQuad, (value) => value ** 2, false);
+  await engine.addEasing(EasingType.easeOutQuad, (value) => 1 - (1 - value) ** 2, false);
+  await engine.addEasing(EasingType.easeInOutQuad, (value) => value < 0.5 ? 2 * value ** 2 : 1 - (-2 * value + 2) ** 2 / 2, false);
+  await engine.refresh(refresh);
+}
+export {
+  loadEasingQuadPlugin
+};

package/dist/node_modules/.pnpm/@tsparticles_plugin-hex-color@3.9.1/node_modules/@tsparticles/plugin-hex-color/browser/HexColorManager.js

@@ -0,0 +1,43 @@
+var RgbIndexes;
+(function(RgbIndexes2) {
+  RgbIndexes2[RgbIndexes2["r"] = 1] = "r";
+  RgbIndexes2[RgbIndexes2["g"] = 2] = "g";
+  RgbIndexes2[RgbIndexes2["b"] = 3] = "b";
+  RgbIndexes2[RgbIndexes2["a"] = 4] = "a";
+})(RgbIndexes || (RgbIndexes = {}));
+const shorthandHexRegex = /^#?([a-f\d])([a-f\d])([a-f\d])([a-f\d])?$/i, hexRegex = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})?$/i, hexRadix = 16, defaultAlpha = 1, alphaFactor = 255;
+class HexColorManager {
+  constructor() {
+    this.key = "hex";
+    this.stringPrefix = "#";
+  }
+  handleColor(color) {
+    return this._parseString(color.value);
+  }
+  handleRangeColor(color) {
+    return this._parseString(color.value);
+  }
+  parseString(input) {
+    return this._parseString(input);
+  }
+  _parseString(hexColor) {
+    if (typeof hexColor !== "string") {
+      return;
+    }
+    if (!(hexColor == null ? void 0 : hexColor.startsWith(this.stringPrefix))) {
+      return;
+    }
+    const hexFixed = hexColor.replace(shorthandHexRegex, (_, r, g, b, a) => {
+      return r + r + g + g + b + b + (a !== void 0 ? a + a : "");
+    }), result = hexRegex.exec(hexFixed);
+    return result ? {
+      a: result[RgbIndexes.a] !== void 0 ? parseInt(result[RgbIndexes.a], hexRadix) / alphaFactor : defaultAlpha,
+      b: parseInt(result[RgbIndexes.b], hexRadix),
+      g: parseInt(result[RgbIndexes.g], hexRadix),
+      r: parseInt(result[RgbIndexes.r], hexRadix)
+    } : void 0;
+  }
+}
+export {
+  HexColorManager
+};

package/dist/node_modules/.pnpm/@tsparticles_plugin-hex-color@3.9.1/node_modules/@tsparticles/plugin-hex-color/browser/index.js

@@ -0,0 +1,8 @@
+import { HexColorManager } from "./HexColorManager.js";
+async function loadHexColorPlugin(engine, refresh = true) {
+  engine.checkVersion("3.9.1");
+  await engine.addColorManager(new HexColorManager(), refresh);
+}
+export {
+  loadHexColorPlugin
+};