dune-react 0.0.1

package/dist/node_modules/.pnpm/@tsparticles_updater-life@3.9.1/node_modules/@tsparticles/updater-life/browser/Utils.js

@@ -0,0 +1,58 @@
+import { setRangeValue, randomInRange, getRangeValue } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+import { millisecondsToSeconds } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Constants.js";
+const noTime = 0, infiniteValue = -1, noLife = 0, minCanvasSize = 0;
+function updateLife(particle, delta, canvasSize) {
+  if (!particle.life) {
+    return;
+  }
+  const life = particle.life;
+  let justSpawned = false;
+  if (particle.spawning) {
+    life.delayTime += delta.value;
+    if (life.delayTime >= particle.life.delay) {
+      justSpawned = true;
+      particle.spawning = false;
+      life.delayTime = noTime;
+      life.time = noTime;
+    } else {
+      return;
+    }
+  }
+  if (life.duration === infiniteValue) {
+    return;
+  }
+  if (particle.spawning) {
+    return;
+  }
+  if (justSpawned) {
+    life.time = noTime;
+  } else {
+    life.time += delta.value;
+  }
+  if (life.time < life.duration) {
+    return;
+  }
+  life.time = noTime;
+  if (particle.life.count > noLife) {
+    particle.life.count--;
+  }
+  if (particle.life.count === noLife) {
+    particle.destroy();
+    return;
+  }
+  const widthRange = setRangeValue(minCanvasSize, canvasSize.width), heightRange = setRangeValue(minCanvasSize, canvasSize.width);
+  particle.position.x = randomInRange(widthRange);
+  particle.position.y = randomInRange(heightRange);
+  particle.spawning = true;
+  life.delayTime = noTime;
+  life.time = noTime;
+  particle.reset();
+  const lifeOptions = particle.options.life;
+  if (lifeOptions) {
+    life.delay = getRangeValue(lifeOptions.delay.value) * millisecondsToSeconds;
+    life.duration = getRangeValue(lifeOptions.duration.value) * millisecondsToSeconds;
+  }
+}
+export {
+  updateLife
+};

package/dist/node_modules/.pnpm/@tsparticles_updater-life@3.9.1/node_modules/@tsparticles/updater-life/browser/index.js

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

package/dist/node_modules/.pnpm/@tsparticles_updater-opacity@3.9.1/node_modules/@tsparticles/updater-opacity/browser/OpacityUpdater.js

@@ -0,0 +1,38 @@
+import { initParticleNumericAnimationValue, updateAnimation } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/Utils.js";
+import { percentDenominator } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Constants.js";
+import { getRangeValue, getRandom } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+class OpacityUpdater {
+  constructor(container) {
+    this.container = container;
+  }
+  init(particle) {
+    const opacityOptions = particle.options.opacity, pxRatio = 1;
+    particle.opacity = initParticleNumericAnimationValue(opacityOptions, pxRatio);
+    const opacityAnimation = opacityOptions.animation;
+    if (opacityAnimation.enable) {
+      particle.opacity.velocity = getRangeValue(opacityAnimation.speed) / percentDenominator * this.container.retina.reduceFactor;
+      if (!opacityAnimation.sync) {
+        particle.opacity.velocity *= getRandom();
+      }
+    }
+  }
+  isEnabled(particle) {
+    const none = 0;
+    return !particle.destroyed && !particle.spawning && !!particle.opacity && particle.opacity.enable && ((particle.opacity.maxLoops ?? none) <= none || (particle.opacity.maxLoops ?? none) > none && (particle.opacity.loops ?? none) < (particle.opacity.maxLoops ?? none));
+  }
+  reset(particle) {
+    if (particle.opacity) {
+      particle.opacity.time = 0;
+      particle.opacity.loops = 0;
+    }
+  }
+  update(particle, delta) {
+    if (!this.isEnabled(particle) || !particle.opacity) {
+      return;
+    }
+    updateAnimation(particle, particle.opacity, true, particle.options.opacity.animation.destroy, delta);
+  }
+}
+export {
+  OpacityUpdater
+};

package/dist/node_modules/.pnpm/@tsparticles_updater-opacity@3.9.1/node_modules/@tsparticles/updater-opacity/browser/index.js

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

package/dist/node_modules/.pnpm/@tsparticles_updater-out-modes@3.9.1/node_modules/@tsparticles/updater-out-modes/browser/BounceOutMode.js

@@ -0,0 +1,36 @@
+import { bounceHorizontal, bounceVertical } from "./Utils.js";
+import { calculateBounds } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/Utils.js";
+import { OutMode } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Modes/OutMode.js";
+class BounceOutMode {
+  constructor(container) {
+    this.container = container;
+    this.modes = [
+      OutMode.bounce,
+      OutMode.split
+    ];
+  }
+  update(particle, direction, delta, outMode) {
+    if (!this.modes.includes(outMode)) {
+      return;
+    }
+    const container = this.container;
+    let handled = false;
+    for (const plugin of container.plugins.values()) {
+      if (plugin.particleBounce !== void 0) {
+        handled = plugin.particleBounce(particle, delta, direction);
+      }
+      if (handled) {
+        break;
+      }
+    }
+    if (handled) {
+      return;
+    }
+    const pos = particle.getPosition(), offset = particle.offset, size = particle.getRadius(), bounds = calculateBounds(pos, size), canvasSize = container.canvas.size;
+    bounceHorizontal({ particle, outMode, direction, bounds, canvasSize, offset, size });
+    bounceVertical({ particle, outMode, direction, bounds, canvasSize, offset, size });
+  }
+}
+export {
+  BounceOutMode
+};

package/dist/node_modules/.pnpm/@tsparticles_updater-out-modes@3.9.1/node_modules/@tsparticles/updater-out-modes/browser/DestroyOutMode.js

@@ -0,0 +1,37 @@
+import { ParticleOutType } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Types/ParticleOutType.js";
+import { isPointInside } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/Utils.js";
+import { Vector } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Vectors.js";
+import { OutMode } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Modes/OutMode.js";
+import { getDistances } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+const minVelocity = 0;
+class DestroyOutMode {
+  constructor(container) {
+    this.container = container;
+    this.modes = [OutMode.destroy];
+  }
+  update(particle, direction, _delta, outMode) {
+    if (!this.modes.includes(outMode)) {
+      return;
+    }
+    const container = this.container;
+    switch (particle.outType) {
+      case ParticleOutType.normal:
+      case ParticleOutType.outside:
+        if (isPointInside(particle.position, container.canvas.size, Vector.origin, particle.getRadius(), direction)) {
+          return;
+        }
+        break;
+      case ParticleOutType.inside: {
+        const { dx, dy } = getDistances(particle.position, particle.moveCenter), { x: vx, y: vy } = particle.velocity;
+        if (vx < minVelocity && dx > particle.moveCenter.radius || vy < minVelocity && dy > particle.moveCenter.radius || vx >= minVelocity && dx < -particle.moveCenter.radius || vy >= minVelocity && dy < -particle.moveCenter.radius) {
+          return;
+        }
+        break;
+      }
+    }
+    container.particles.remove(particle, particle.group, true);
+  }
+}
+export {
+  DestroyOutMode
+};

package/dist/node_modules/.pnpm/@tsparticles_updater-out-modes@3.9.1/node_modules/@tsparticles/updater-out-modes/browser/NoneOutMode.js

@@ -0,0 +1,36 @@
+import { OutMode } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Modes/OutMode.js";
+import { OutModeDirection } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Directions/OutModeDirection.js";
+import { isPointInside } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/Utils.js";
+import { Vector } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Vectors.js";
+const minVelocity = 0;
+class NoneOutMode {
+  constructor(container) {
+    this.container = container;
+    this.modes = [OutMode.none];
+  }
+  update(particle, direction, delta, outMode) {
+    if (!this.modes.includes(outMode)) {
+      return;
+    }
+    if ((particle.options.move.distance.horizontal && (direction === OutModeDirection.left || direction === OutModeDirection.right)) ?? (particle.options.move.distance.vertical && (direction === OutModeDirection.top || direction === OutModeDirection.bottom))) {
+      return;
+    }
+    const gravityOptions = particle.options.move.gravity, container = this.container, canvasSize = container.canvas.size, pRadius = particle.getRadius();
+    if (!gravityOptions.enable) {
+      if (particle.velocity.y > minVelocity && particle.position.y <= canvasSize.height + pRadius || particle.velocity.y < minVelocity && particle.position.y >= -pRadius || particle.velocity.x > minVelocity && particle.position.x <= canvasSize.width + pRadius || particle.velocity.x < minVelocity && particle.position.x >= -pRadius) {
+        return;
+      }
+      if (!isPointInside(particle.position, container.canvas.size, Vector.origin, pRadius, direction)) {
+        container.particles.remove(particle);
+      }
+    } else {
+      const position = particle.position;
+      if (!gravityOptions.inverse && position.y > canvasSize.height + pRadius && direction === OutModeDirection.bottom || gravityOptions.inverse && position.y < -pRadius && direction === OutModeDirection.top) {
+        container.particles.remove(particle);
+      }
+    }
+  }
+}
+export {
+  NoneOutMode
+};

package/dist/node_modules/.pnpm/@tsparticles_updater-out-modes@3.9.1/node_modules/@tsparticles/updater-out-modes/browser/OutOfCanvasUpdater.js

@@ -0,0 +1,45 @@
+import { BounceOutMode } from "./BounceOutMode.js";
+import { DestroyOutMode } from "./DestroyOutMode.js";
+import { NoneOutMode } from "./NoneOutMode.js";
+import { OutOutMode } from "./OutOutMode.js";
+import { OutMode } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Modes/OutMode.js";
+import { OutModeDirection } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Directions/OutModeDirection.js";
+const checkOutMode = (outModes, outMode) => {
+  return outModes.default === outMode || outModes.bottom === outMode || outModes.left === outMode || outModes.right === outMode || outModes.top === outMode;
+};
+class OutOfCanvasUpdater {
+  constructor(container) {
+    this._addUpdaterIfMissing = (particle, outMode, getUpdater) => {
+      const outModes = particle.options.move.outModes;
+      if (!this.updaters.has(outMode) && checkOutMode(outModes, outMode)) {
+        this.updaters.set(outMode, getUpdater(this.container));
+      }
+    };
+    this._updateOutMode = (particle, delta, outMode, direction) => {
+      for (const updater of this.updaters.values()) {
+        updater.update(particle, direction, delta, outMode);
+      }
+    };
+    this.container = container;
+    this.updaters = /* @__PURE__ */ new Map();
+  }
+  init(particle) {
+    this._addUpdaterIfMissing(particle, OutMode.bounce, (container) => new BounceOutMode(container));
+    this._addUpdaterIfMissing(particle, OutMode.out, (container) => new OutOutMode(container));
+    this._addUpdaterIfMissing(particle, OutMode.destroy, (container) => new DestroyOutMode(container));
+    this._addUpdaterIfMissing(particle, OutMode.none, (container) => new NoneOutMode(container));
+  }
+  isEnabled(particle) {
+    return !particle.destroyed && !particle.spawning;
+  }
+  update(particle, delta) {
+    const outModes = particle.options.move.outModes;
+    this._updateOutMode(particle, delta, outModes.bottom ?? outModes.default, OutModeDirection.bottom);
+    this._updateOutMode(particle, delta, outModes.left ?? outModes.default, OutModeDirection.left);
+    this._updateOutMode(particle, delta, outModes.right ?? outModes.default, OutModeDirection.right);
+    this._updateOutMode(particle, delta, outModes.top ?? outModes.default, OutModeDirection.top);
+  }
+}
+export {
+  OutOfCanvasUpdater
+};

package/dist/node_modules/.pnpm/@tsparticles_updater-out-modes@3.9.1/node_modules/@tsparticles/updater-out-modes/browser/OutOutMode.js

@@ -0,0 +1,110 @@
+import { getRandom, randomInRange, getDistances } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+import { OutMode } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Modes/OutMode.js";
+import { isPointInside, calculateBounds } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/Utils.js";
+import { Vector } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Vectors.js";
+import { ParticleOutType } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Types/ParticleOutType.js";
+import { OutModeDirection } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Directions/OutModeDirection.js";
+const minVelocity = 0, minDistance = 0;
+class OutOutMode {
+  constructor(container) {
+    this.container = container;
+    this.modes = [OutMode.out];
+  }
+  update(particle, direction, delta, outMode) {
+    if (!this.modes.includes(outMode)) {
+      return;
+    }
+    const container = this.container;
+    switch (particle.outType) {
+      case ParticleOutType.inside: {
+        const { x: vx, y: vy } = particle.velocity;
+        const circVec = Vector.origin;
+        circVec.length = particle.moveCenter.radius;
+        circVec.angle = particle.velocity.angle + Math.PI;
+        circVec.addTo(Vector.create(particle.moveCenter));
+        const { dx, dy } = getDistances(particle.position, circVec);
+        if (vx <= minVelocity && dx >= minDistance || vy <= minVelocity && dy >= minDistance || vx >= minVelocity && dx <= minDistance || vy >= minVelocity && dy <= minDistance) {
+          return;
+        }
+        particle.position.x = Math.floor(randomInRange({
+          min: 0,
+          max: container.canvas.size.width
+        }));
+        particle.position.y = Math.floor(randomInRange({
+          min: 0,
+          max: container.canvas.size.height
+        }));
+        const { dx: newDx, dy: newDy } = getDistances(particle.position, particle.moveCenter);
+        particle.direction = Math.atan2(-newDy, -newDx);
+        particle.velocity.angle = particle.direction;
+        break;
+      }
+      default: {
+        if (isPointInside(particle.position, container.canvas.size, Vector.origin, particle.getRadius(), direction)) {
+          return;
+        }
+        switch (particle.outType) {
+          case ParticleOutType.outside: {
+            particle.position.x = Math.floor(randomInRange({
+              min: -particle.moveCenter.radius,
+              max: particle.moveCenter.radius
+            })) + particle.moveCenter.x;
+            particle.position.y = Math.floor(randomInRange({
+              min: -particle.moveCenter.radius,
+              max: particle.moveCenter.radius
+            })) + particle.moveCenter.y;
+            const { dx, dy } = getDistances(particle.position, particle.moveCenter);
+            if (particle.moveCenter.radius) {
+              particle.direction = Math.atan2(dy, dx);
+              particle.velocity.angle = particle.direction;
+            }
+            break;
+          }
+          case ParticleOutType.normal: {
+            const warp = particle.options.move.warp, canvasSize = container.canvas.size, newPos = {
+              bottom: canvasSize.height + particle.getRadius() + particle.offset.y,
+              left: -particle.getRadius() - particle.offset.x,
+              right: canvasSize.width + particle.getRadius() + particle.offset.x,
+              top: -particle.getRadius() - particle.offset.y
+            }, sizeValue = particle.getRadius(), nextBounds = calculateBounds(particle.position, sizeValue);
+            if (direction === OutModeDirection.right && nextBounds.left > canvasSize.width + particle.offset.x) {
+              particle.position.x = newPos.left;
+              particle.initialPosition.x = particle.position.x;
+              if (!warp) {
+                particle.position.y = getRandom() * canvasSize.height;
+                particle.initialPosition.y = particle.position.y;
+              }
+            } else if (direction === OutModeDirection.left && nextBounds.right < -particle.offset.x) {
+              particle.position.x = newPos.right;
+              particle.initialPosition.x = particle.position.x;
+              if (!warp) {
+                particle.position.y = getRandom() * canvasSize.height;
+                particle.initialPosition.y = particle.position.y;
+              }
+            }
+            if (direction === OutModeDirection.bottom && nextBounds.top > canvasSize.height + particle.offset.y) {
+              if (!warp) {
+                particle.position.x = getRandom() * canvasSize.width;
+                particle.initialPosition.x = particle.position.x;
+              }
+              particle.position.y = newPos.top;
+              particle.initialPosition.y = particle.position.y;
+            } else if (direction === OutModeDirection.top && nextBounds.bottom < -particle.offset.y) {
+              if (!warp) {
+                particle.position.x = getRandom() * canvasSize.width;
+                particle.initialPosition.x = particle.position.x;
+              }
+              particle.position.y = newPos.bottom;
+              particle.initialPosition.y = particle.position.y;
+            }
+            break;
+          }
+        }
+        break;
+      }
+    }
+  }
+}
+export {
+  OutOutMode
+};

package/dist/node_modules/.pnpm/@tsparticles_updater-out-modes@3.9.1/node_modules/@tsparticles/updater-out-modes/browser/Utils.js

@@ -0,0 +1,66 @@
+import { OutMode } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Modes/OutMode.js";
+import { OutModeDirection } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Directions/OutModeDirection.js";
+import { getRangeValue } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+const minVelocity = 0, boundsMin = 0;
+function bounceHorizontal(data) {
+  if (data.outMode !== OutMode.bounce && data.outMode !== OutMode.split || data.direction !== OutModeDirection.left && data.direction !== OutModeDirection.right) {
+    return;
+  }
+  if (data.bounds.right < boundsMin && data.direction === OutModeDirection.left) {
+    data.particle.position.x = data.size + data.offset.x;
+  } else if (data.bounds.left > data.canvasSize.width && data.direction === OutModeDirection.right) {
+    data.particle.position.x = data.canvasSize.width - data.size - data.offset.x;
+  }
+  const velocity = data.particle.velocity.x;
+  let bounced = false;
+  if (data.direction === OutModeDirection.right && data.bounds.right >= data.canvasSize.width && velocity > minVelocity || data.direction === OutModeDirection.left && data.bounds.left <= boundsMin && velocity < minVelocity) {
+    const newVelocity = getRangeValue(data.particle.options.bounce.horizontal.value);
+    data.particle.velocity.x *= -newVelocity;
+    bounced = true;
+  }
+  if (!bounced) {
+    return;
+  }
+  const minPos = data.offset.x + data.size;
+  if (data.bounds.right >= data.canvasSize.width && data.direction === OutModeDirection.right) {
+    data.particle.position.x = data.canvasSize.width - minPos;
+  } else if (data.bounds.left <= boundsMin && data.direction === OutModeDirection.left) {
+    data.particle.position.x = minPos;
+  }
+  if (data.outMode === OutMode.split) {
+    data.particle.destroy();
+  }
+}
+function bounceVertical(data) {
+  if (data.outMode !== OutMode.bounce && data.outMode !== OutMode.split || data.direction !== OutModeDirection.bottom && data.direction !== OutModeDirection.top) {
+    return;
+  }
+  if (data.bounds.bottom < boundsMin && data.direction === OutModeDirection.top) {
+    data.particle.position.y = data.size + data.offset.y;
+  } else if (data.bounds.top > data.canvasSize.height && data.direction === OutModeDirection.bottom) {
+    data.particle.position.y = data.canvasSize.height - data.size - data.offset.y;
+  }
+  const velocity = data.particle.velocity.y;
+  let bounced = false;
+  if (data.direction === OutModeDirection.bottom && data.bounds.bottom >= data.canvasSize.height && velocity > minVelocity || data.direction === OutModeDirection.top && data.bounds.top <= boundsMin && velocity < minVelocity) {
+    const newVelocity = getRangeValue(data.particle.options.bounce.vertical.value);
+    data.particle.velocity.y *= -newVelocity;
+    bounced = true;
+  }
+  if (!bounced) {
+    return;
+  }
+  const minPos = data.offset.y + data.size;
+  if (data.bounds.bottom >= data.canvasSize.height && data.direction === OutModeDirection.bottom) {
+    data.particle.position.y = data.canvasSize.height - minPos;
+  } else if (data.bounds.top <= boundsMin && data.direction === OutModeDirection.top) {
+    data.particle.position.y = minPos;
+  }
+  if (data.outMode === OutMode.split) {
+    data.particle.destroy();
+  }
+}
+export {
+  bounceHorizontal,
+  bounceVertical
+};

package/dist/node_modules/.pnpm/@tsparticles_updater-out-modes@3.9.1/node_modules/@tsparticles/updater-out-modes/browser/index.js

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

package/dist/node_modules/.pnpm/@tsparticles_updater-rotate@3.9.1/node_modules/@tsparticles/updater-rotate/browser/Options/Classes/Rotate.js

@@ -0,0 +1,29 @@
+import { RotateAnimation } from "./RotateAnimation.js";
+import { ValueWithRandom } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Options/Classes/ValueWithRandom.js";
+import { RotateDirection } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Directions/RotateDirection.js";
+import { isNull } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/TypeUtils.js";
+class Rotate extends ValueWithRandom {
+  constructor() {
+    super();
+    this.animation = new RotateAnimation();
+    this.direction = RotateDirection.clockwise;
+    this.path = false;
+    this.value = 0;
+  }
+  load(data) {
+    if (isNull(data)) {
+      return;
+    }
+    super.load(data);
+    if (data.direction !== void 0) {
+      this.direction = data.direction;
+    }
+    this.animation.load(data.animation);
+    if (data.path !== void 0) {
+      this.path = data.path;
+    }
+  }
+}
+export {
+  Rotate
+};

package/dist/node_modules/.pnpm/@tsparticles_updater-rotate@3.9.1/node_modules/@tsparticles/updater-rotate/browser/Options/Classes/RotateAnimation.js

@@ -0,0 +1,30 @@
+import { isNull } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/TypeUtils.js";
+import { setRangeValue } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+class RotateAnimation {
+  constructor() {
+    this.enable = false;
+    this.speed = 0;
+    this.decay = 0;
+    this.sync = false;
+  }
+  load(data) {
+    if (isNull(data)) {
+      return;
+    }
+    if (data.enable !== void 0) {
+      this.enable = data.enable;
+    }
+    if (data.speed !== void 0) {
+      this.speed = setRangeValue(data.speed);
+    }
+    if (data.decay !== void 0) {
+      this.decay = setRangeValue(data.decay);
+    }
+    if (data.sync !== void 0) {
+      this.sync = data.sync;
+    }
+  }
+}
+export {
+  RotateAnimation
+};

package/dist/node_modules/.pnpm/@tsparticles_updater-rotate@3.9.1/node_modules/@tsparticles/updater-rotate/browser/RotateUpdater.js

@@ -0,0 +1,77 @@
+import { Rotate } from "./Options/Classes/Rotate.js";
+import { AnimationStatus } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/AnimationStatus.js";
+import { DestroyType } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Types/DestroyType.js";
+import { degToRad, getRangeValue, getRandom } 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";
+import { updateAnimation } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/Utils.js";
+const double = 2, doublePI = Math.PI * double, identity = 1, doublePIDeg = 360;
+class RotateUpdater {
+  constructor(container) {
+    this.container = container;
+  }
+  init(particle) {
+    const rotateOptions = particle.options.rotate;
+    if (!rotateOptions) {
+      return;
+    }
+    particle.rotate = {
+      enable: rotateOptions.animation.enable,
+      value: degToRad(getRangeValue(rotateOptions.value)),
+      min: 0,
+      max: doublePI
+    };
+    particle.pathRotation = rotateOptions.path;
+    let rotateDirection = rotateOptions.direction;
+    if (rotateDirection === RotateDirection.random) {
+      const index = Math.floor(getRandom() * double), minIndex = 0;
+      rotateDirection = index > minIndex ? RotateDirection.counterClockwise : RotateDirection.clockwise;
+    }
+    switch (rotateDirection) {
+      case RotateDirection.counterClockwise:
+      case "counterClockwise":
+        particle.rotate.status = AnimationStatus.decreasing;
+        break;
+      case RotateDirection.clockwise:
+        particle.rotate.status = AnimationStatus.increasing;
+        break;
+    }
+    const rotateAnimation = rotateOptions.animation;
+    if (rotateAnimation.enable) {
+      particle.rotate.decay = identity - getRangeValue(rotateAnimation.decay);
+      particle.rotate.velocity = getRangeValue(rotateAnimation.speed) / doublePIDeg * this.container.retina.reduceFactor;
+      if (!rotateAnimation.sync) {
+        particle.rotate.velocity *= getRandom();
+      }
+    }
+    particle.rotation = particle.rotate.value;
+  }
+  isEnabled(particle) {
+    const rotate = particle.options.rotate;
+    if (!rotate) {
+      return false;
+    }
+    return !particle.destroyed && !particle.spawning && (!!rotate.value || rotate.animation.enable || rotate.path);
+  }
+  loadOptions(options, ...sources) {
+    if (!options.rotate) {
+      options.rotate = new Rotate();
+    }
+    for (const source of sources) {
+      options.rotate.load(source == null ? void 0 : source.rotate);
+    }
+  }
+  update(particle, delta) {
+    if (!this.isEnabled(particle)) {
+      return;
+    }
+    particle.isRotating = !!particle.rotate;
+    if (!particle.rotate) {
+      return;
+    }
+    updateAnimation(particle, particle.rotate, false, DestroyType.none, delta);
+    particle.rotation = particle.rotate.value;
+  }
+}
+export {
+  RotateUpdater
+};

package/dist/node_modules/.pnpm/@tsparticles_updater-rotate@3.9.1/node_modules/@tsparticles/updater-rotate/browser/index.js

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

package/dist/node_modules/.pnpm/@tsparticles_updater-size@3.9.1/node_modules/@tsparticles/updater-size/browser/SizeUpdater.js

@@ -0,0 +1,30 @@
+import { percentDenominator } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Constants.js";
+import { getRandom } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/NumberUtils.js";
+import { updateAnimation } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/Utils.js";
+const minLoops = 0;
+class SizeUpdater {
+  init(particle) {
+    const container = particle.container, sizeOptions = particle.options.size, sizeAnimation = sizeOptions.animation;
+    if (sizeAnimation.enable) {
+      particle.size.velocity = (particle.retina.sizeAnimationSpeed ?? container.retina.sizeAnimationSpeed) / percentDenominator * container.retina.reduceFactor;
+      if (!sizeAnimation.sync) {
+        particle.size.velocity *= getRandom();
+      }
+    }
+  }
+  isEnabled(particle) {
+    return !particle.destroyed && !particle.spawning && particle.size.enable && ((particle.size.maxLoops ?? minLoops) <= minLoops || (particle.size.maxLoops ?? minLoops) > minLoops && (particle.size.loops ?? minLoops) < (particle.size.maxLoops ?? minLoops));
+  }
+  reset(particle) {
+    particle.size.loops = minLoops;
+  }
+  update(particle, delta) {
+    if (!this.isEnabled(particle)) {
+      return;
+    }
+    updateAnimation(particle, particle.size, true, particle.options.size.animation.destroy, delta);
+  }
+}
+export {
+  SizeUpdater
+};

package/dist/node_modules/.pnpm/@tsparticles_updater-size@3.9.1/node_modules/@tsparticles/updater-size/browser/index.js

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