dune-react 0.0.1

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/EventListeners.js

@@ -0,0 +1,309 @@
+import { touchDelay, millisecondsToSeconds, mouseMoveEvent, touchStartEvent, touchMoveEvent, touchEndEvent, mouseUpEvent, mouseDownEvent, touchCancelEvent, mouseLeaveEvent, visibilityChangeEvent, resizeEvent, double, lengthOffset, minCoordinate, mouseOutEvent } from "./Constants.js";
+import { executeOnSingleOrMultiple, safeMatchMedia } from "../../Utils/Utils.js";
+import { InteractivityDetect } from "../../Enums/InteractivityDetect.js";
+import { isBoolean } from "../../Utils/TypeUtils.js";
+function manageListener(element, event, handler, add, options) {
+  if (add) {
+    let addOptions = { passive: true };
+    if (isBoolean(options)) {
+      addOptions.capture = options;
+    } else if (options !== void 0) {
+      addOptions = options;
+    }
+    element.addEventListener(event, handler, addOptions);
+  } else {
+    const removeOptions = options;
+    element.removeEventListener(event, handler, removeOptions);
+  }
+}
+class EventListeners {
+  constructor(container) {
+    this.container = container;
+    this._doMouseTouchClick = (e) => {
+      const container2 = this.container, options = container2.actualOptions;
+      if (this._canPush) {
+        const mouseInteractivity = container2.interactivity.mouse, mousePos = mouseInteractivity.position;
+        if (!mousePos) {
+          return;
+        }
+        mouseInteractivity.clickPosition = { ...mousePos };
+        mouseInteractivity.clickTime = (/* @__PURE__ */ new Date()).getTime();
+        const onClick = options.interactivity.events.onClick;
+        executeOnSingleOrMultiple(onClick.mode, (mode) => this.container.handleClickMode(mode));
+      }
+      if (e.type === "touchend") {
+        setTimeout(() => this._mouseTouchFinish(), touchDelay);
+      }
+    };
+    this._handleThemeChange = (e) => {
+      const mediaEvent = e, container2 = this.container, options = container2.options, defaultThemes = options.defaultThemes, themeName = mediaEvent.matches ? defaultThemes.dark : defaultThemes.light, theme = options.themes.find((theme2) => theme2.name === themeName);
+      if (theme == null ? void 0 : theme.default.auto) {
+        void container2.loadTheme(themeName);
+      }
+    };
+    this._handleVisibilityChange = () => {
+      const container2 = this.container, options = container2.actualOptions;
+      this._mouseTouchFinish();
+      if (!options.pauseOnBlur) {
+        return;
+      }
+      if (document == null ? void 0 : document.hidden) {
+        container2.pageHidden = true;
+        container2.pause();
+      } else {
+        container2.pageHidden = false;
+        if (container2.animationStatus) {
+          void container2.play(true);
+        } else {
+          void container2.draw(true);
+        }
+      }
+    };
+    this._handleWindowResize = () => {
+      if (this._resizeTimeout) {
+        clearTimeout(this._resizeTimeout);
+        delete this._resizeTimeout;
+      }
+      const handleResize = async () => {
+        const canvas = this.container.canvas;
+        await (canvas == null ? void 0 : canvas.windowResize());
+      };
+      this._resizeTimeout = setTimeout(() => void handleResize(), this.container.actualOptions.interactivity.events.resize.delay * millisecondsToSeconds);
+    };
+    this._manageInteractivityListeners = (mouseLeaveTmpEvent, add) => {
+      const handlers = this._handlers, container2 = this.container, options = container2.actualOptions, interactivityEl = container2.interactivity.element;
+      if (!interactivityEl) {
+        return;
+      }
+      const html = interactivityEl, canvas = container2.canvas;
+      canvas.setPointerEvents(html === canvas.element ? "initial" : "none");
+      if (!(options.interactivity.events.onHover.enable || options.interactivity.events.onClick.enable)) {
+        return;
+      }
+      manageListener(interactivityEl, mouseMoveEvent, handlers.mouseMove, add);
+      manageListener(interactivityEl, touchStartEvent, handlers.touchStart, add);
+      manageListener(interactivityEl, touchMoveEvent, handlers.touchMove, add);
+      if (!options.interactivity.events.onClick.enable) {
+        manageListener(interactivityEl, touchEndEvent, handlers.touchEnd, add);
+      } else {
+        manageListener(interactivityEl, touchEndEvent, handlers.touchEndClick, add);
+        manageListener(interactivityEl, mouseUpEvent, handlers.mouseUp, add);
+        manageListener(interactivityEl, mouseDownEvent, handlers.mouseDown, add);
+      }
+      manageListener(interactivityEl, mouseLeaveTmpEvent, handlers.mouseLeave, add);
+      manageListener(interactivityEl, touchCancelEvent, handlers.touchCancel, add);
+    };
+    this._manageListeners = (add) => {
+      const handlers = this._handlers, container2 = this.container, options = container2.actualOptions, detectType = options.interactivity.detectsOn, canvasEl = container2.canvas.element;
+      let mouseLeaveTmpEvent = mouseLeaveEvent;
+      if (detectType === InteractivityDetect.window) {
+        container2.interactivity.element = window;
+        mouseLeaveTmpEvent = mouseOutEvent;
+      } else if (detectType === InteractivityDetect.parent && canvasEl) {
+        container2.interactivity.element = canvasEl.parentElement ?? canvasEl.parentNode;
+      } else {
+        container2.interactivity.element = canvasEl;
+      }
+      this._manageMediaMatch(add);
+      this._manageResize(add);
+      this._manageInteractivityListeners(mouseLeaveTmpEvent, add);
+      if (document) {
+        manageListener(document, visibilityChangeEvent, handlers.visibilityChange, add, false);
+      }
+    };
+    this._manageMediaMatch = (add) => {
+      const handlers = this._handlers, mediaMatch = safeMatchMedia("(prefers-color-scheme: dark)");
+      if (!mediaMatch) {
+        return;
+      }
+      if (mediaMatch.addEventListener !== void 0) {
+        manageListener(mediaMatch, "change", handlers.themeChange, add);
+        return;
+      }
+      if (mediaMatch.addListener === void 0) {
+        return;
+      }
+      if (add) {
+        mediaMatch.addListener(handlers.oldThemeChange);
+      } else {
+        mediaMatch.removeListener(handlers.oldThemeChange);
+      }
+    };
+    this._manageResize = (add) => {
+      const handlers = this._handlers, container2 = this.container, options = container2.actualOptions;
+      if (!options.interactivity.events.resize) {
+        return;
+      }
+      if (typeof ResizeObserver === "undefined") {
+        manageListener(window, resizeEvent, handlers.resize, add);
+        return;
+      }
+      const canvasEl = container2.canvas.element;
+      if (this._resizeObserver && !add) {
+        if (canvasEl) {
+          this._resizeObserver.unobserve(canvasEl);
+        }
+        this._resizeObserver.disconnect();
+        delete this._resizeObserver;
+      } else if (!this._resizeObserver && add && canvasEl) {
+        this._resizeObserver = new ResizeObserver((entries) => {
+          const entry = entries.find((e) => e.target === canvasEl);
+          if (!entry) {
+            return;
+          }
+          this._handleWindowResize();
+        });
+        this._resizeObserver.observe(canvasEl);
+      }
+    };
+    this._mouseDown = () => {
+      const { interactivity } = this.container;
+      if (!interactivity) {
+        return;
+      }
+      const { mouse } = interactivity;
+      mouse.clicking = true;
+      mouse.downPosition = mouse.position;
+    };
+    this._mouseTouchClick = (e) => {
+      const container2 = this.container, options = container2.actualOptions, { mouse } = container2.interactivity;
+      mouse.inside = true;
+      let handled = false;
+      const mousePosition = mouse.position;
+      if (!mousePosition || !options.interactivity.events.onClick.enable) {
+        return;
+      }
+      for (const plugin of container2.plugins.values()) {
+        if (!plugin.clickPositionValid) {
+          continue;
+        }
+        handled = plugin.clickPositionValid(mousePosition);
+        if (handled) {
+          break;
+        }
+      }
+      if (!handled) {
+        this._doMouseTouchClick(e);
+      }
+      mouse.clicking = false;
+    };
+    this._mouseTouchFinish = () => {
+      const interactivity = this.container.interactivity;
+      if (!interactivity) {
+        return;
+      }
+      const mouse = interactivity.mouse;
+      delete mouse.position;
+      delete mouse.clickPosition;
+      delete mouse.downPosition;
+      interactivity.status = mouseLeaveEvent;
+      mouse.inside = false;
+      mouse.clicking = false;
+    };
+    this._mouseTouchMove = (e) => {
+      const container2 = this.container, options = container2.actualOptions, interactivity = container2.interactivity, canvasEl = container2.canvas.element;
+      if (!(interactivity == null ? void 0 : interactivity.element)) {
+        return;
+      }
+      interactivity.mouse.inside = true;
+      let pos;
+      if (e.type.startsWith("pointer")) {
+        this._canPush = true;
+        const mouseEvent = e;
+        if (interactivity.element === window) {
+          if (canvasEl) {
+            const clientRect = canvasEl.getBoundingClientRect();
+            pos = {
+              x: mouseEvent.clientX - clientRect.left,
+              y: mouseEvent.clientY - clientRect.top
+            };
+          }
+        } else if (options.interactivity.detectsOn === InteractivityDetect.parent) {
+          const source = mouseEvent.target, target = mouseEvent.currentTarget;
+          if (source && target && canvasEl) {
+            const sourceRect = source.getBoundingClientRect(), targetRect = target.getBoundingClientRect(), canvasRect = canvasEl.getBoundingClientRect();
+            pos = {
+              x: mouseEvent.offsetX + double * sourceRect.left - (targetRect.left + canvasRect.left),
+              y: mouseEvent.offsetY + double * sourceRect.top - (targetRect.top + canvasRect.top)
+            };
+          } else {
+            pos = {
+              x: mouseEvent.offsetX ?? mouseEvent.clientX,
+              y: mouseEvent.offsetY ?? mouseEvent.clientY
+            };
+          }
+        } else if (mouseEvent.target === canvasEl) {
+          pos = {
+            x: mouseEvent.offsetX ?? mouseEvent.clientX,
+            y: mouseEvent.offsetY ?? mouseEvent.clientY
+          };
+        }
+      } else {
+        this._canPush = e.type !== "touchmove";
+        if (canvasEl) {
+          const touchEvent = e, lastTouch = touchEvent.touches[touchEvent.touches.length - lengthOffset], canvasRect = canvasEl.getBoundingClientRect();
+          pos = {
+            x: lastTouch.clientX - (canvasRect.left ?? minCoordinate),
+            y: lastTouch.clientY - (canvasRect.top ?? minCoordinate)
+          };
+        }
+      }
+      const pxRatio = container2.retina.pixelRatio;
+      if (pos) {
+        pos.x *= pxRatio;
+        pos.y *= pxRatio;
+      }
+      interactivity.mouse.position = pos;
+      interactivity.status = mouseMoveEvent;
+    };
+    this._touchEnd = (e) => {
+      const evt = e, touches = Array.from(evt.changedTouches);
+      for (const touch of touches) {
+        this._touches.delete(touch.identifier);
+      }
+      this._mouseTouchFinish();
+    };
+    this._touchEndClick = (e) => {
+      const evt = e, touches = Array.from(evt.changedTouches);
+      for (const touch of touches) {
+        this._touches.delete(touch.identifier);
+      }
+      this._mouseTouchClick(e);
+    };
+    this._touchStart = (e) => {
+      const evt = e, touches = Array.from(evt.changedTouches);
+      for (const touch of touches) {
+        this._touches.set(touch.identifier, performance.now());
+      }
+      this._mouseTouchMove(e);
+    };
+    this._canPush = true;
+    this._touches = /* @__PURE__ */ new Map();
+    this._handlers = {
+      mouseDown: () => this._mouseDown(),
+      mouseLeave: () => this._mouseTouchFinish(),
+      mouseMove: (e) => this._mouseTouchMove(e),
+      mouseUp: (e) => this._mouseTouchClick(e),
+      touchStart: (e) => this._touchStart(e),
+      touchMove: (e) => this._mouseTouchMove(e),
+      touchEnd: (e) => this._touchEnd(e),
+      touchCancel: (e) => this._touchEnd(e),
+      touchEndClick: (e) => this._touchEndClick(e),
+      visibilityChange: () => this._handleVisibilityChange(),
+      themeChange: (e) => this._handleThemeChange(e),
+      oldThemeChange: (e) => this._handleThemeChange(e),
+      resize: () => {
+        this._handleWindowResize();
+      }
+    };
+  }
+  addListeners() {
+    this._manageListeners(true);
+  }
+  removeListeners() {
+    this._manageListeners(false);
+  }
+}
+export {
+  EventListeners
+};

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/ExternalInteractorBase.js

@@ -0,0 +1,10 @@
+import { InteractorType } from "../../Enums/Types/InteractorType.js";
+class ExternalInteractorBase {
+  constructor(container) {
+    this.type = InteractorType.external;
+    this.container = container;
+  }
+}
+export {
+  ExternalInteractorBase
+};

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/InteractionManager.js

@@ -0,0 +1,64 @@
+import { InteractorType } from "../../Enums/Types/InteractorType.js";
+class InteractionManager {
+  constructor(engine, container) {
+    this.container = container;
+    this._engine = engine;
+    this._interactors = [];
+    this._externalInteractors = [];
+    this._particleInteractors = [];
+  }
+  externalInteract(delta) {
+    for (const interactor of this._externalInteractors) {
+      if (interactor.isEnabled()) {
+        interactor.interact(delta);
+      }
+    }
+  }
+  handleClickMode(mode) {
+    var _a;
+    for (const interactor of this._externalInteractors) {
+      (_a = interactor.handleClickMode) == null ? void 0 : _a.call(interactor, mode);
+    }
+  }
+  async init() {
+    this._interactors = await this._engine.getInteractors(this.container, true);
+    this._externalInteractors = [];
+    this._particleInteractors = [];
+    for (const interactor of this._interactors) {
+      switch (interactor.type) {
+        case InteractorType.external:
+          this._externalInteractors.push(interactor);
+          break;
+        case InteractorType.particles:
+          this._particleInteractors.push(interactor);
+          break;
+      }
+      interactor.init();
+    }
+  }
+  particlesInteract(particle, delta) {
+    for (const interactor of this._externalInteractors) {
+      interactor.clear(particle, delta);
+    }
+    for (const interactor of this._particleInteractors) {
+      if (interactor.isEnabled(particle)) {
+        interactor.interact(particle, delta);
+      }
+    }
+  }
+  reset(particle) {
+    for (const interactor of this._externalInteractors) {
+      if (interactor.isEnabled()) {
+        interactor.reset(particle);
+      }
+    }
+    for (const interactor of this._particleInteractors) {
+      if (interactor.isEnabled(particle)) {
+        interactor.reset(particle);
+      }
+    }
+  }
+}
+export {
+  InteractionManager
+};

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/ParticlesInteractorBase.js

@@ -0,0 +1,10 @@
+import { InteractorType } from "../../Enums/Types/InteractorType.js";
+class ParticlesInteractorBase {
+  constructor(container) {
+    this.type = InteractorType.particles;
+    this.container = container;
+  }
+}
+export {
+  ParticlesInteractorBase
+};

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Point.js

@@ -0,0 +1,9 @@
+class Point {
+  constructor(position, particle) {
+    this.position = position;
+    this.particle = particle;
+  }
+}
+export {
+  Point
+};

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/QuadTree.js

@@ -0,0 +1,60 @@
+import { Rectangle, Circle } from "./Ranges.js";
+import { subdivideCount, half, double } from "./Constants.js";
+import { getDistance } from "../../Utils/NumberUtils.js";
+class QuadTree {
+  constructor(rectangle, capacity) {
+    this.rectangle = rectangle;
+    this.capacity = capacity;
+    this._subdivide = () => {
+      const { x, y } = this.rectangle.position, { width, height } = this.rectangle.size, { capacity: capacity2 } = this;
+      for (let i = 0; i < subdivideCount; i++) {
+        const fixedIndex = i % double;
+        this._subs.push(new QuadTree(new Rectangle(x + width * half * fixedIndex, y + height * half * (Math.round(i * half) - fixedIndex), width * half, height * half), capacity2));
+      }
+      this._divided = true;
+    };
+    this._points = [];
+    this._divided = false;
+    this._subs = [];
+  }
+  insert(point) {
+    if (!this.rectangle.contains(point.position)) {
+      return false;
+    }
+    if (this._points.length < this.capacity) {
+      this._points.push(point);
+      return true;
+    }
+    if (!this._divided) {
+      this._subdivide();
+    }
+    return this._subs.some((sub) => sub.insert(point));
+  }
+  query(range, check) {
+    const res = [];
+    if (!range.intersects(this.rectangle)) {
+      return [];
+    }
+    for (const p of this._points) {
+      if (!range.contains(p.position) && getDistance(range.position, p.position) > p.particle.getRadius() && (!check || check(p.particle))) {
+        continue;
+      }
+      res.push(p.particle);
+    }
+    if (this._divided) {
+      for (const sub of this._subs) {
+        res.push(...sub.query(range, check));
+      }
+    }
+    return res;
+  }
+  queryCircle(position, radius, check) {
+    return this.query(new Circle(position.x, position.y, radius), check);
+  }
+  queryRectangle(position, size, check) {
+    return this.query(new Rectangle(position.x, position.y, size.width, size.height), check);
+  }
+}
+export {
+  QuadTree
+};

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Ranges.js

@@ -0,0 +1,57 @@
+import { RangeType } from "../../Types/RangeType.js";
+import { getDistance } from "../../Utils/NumberUtils.js";
+import { squareExp } from "./Constants.js";
+class BaseRange {
+  constructor(x, y, type) {
+    this.position = {
+      x,
+      y
+    };
+    this.type = type;
+  }
+}
+class Circle extends BaseRange {
+  constructor(x, y, radius) {
+    super(x, y, RangeType.circle);
+    this.radius = radius;
+  }
+  contains(point) {
+    return getDistance(point, this.position) <= this.radius;
+  }
+  intersects(range) {
+    const pos1 = this.position, pos2 = range.position, distPos = { x: Math.abs(pos2.x - pos1.x), y: Math.abs(pos2.y - pos1.y) }, r = this.radius;
+    if (range instanceof Circle || range.type === RangeType.circle) {
+      const circleRange = range, rSum = r + circleRange.radius, dist = Math.sqrt(distPos.x ** squareExp + distPos.y ** squareExp);
+      return rSum > dist;
+    } else if (range instanceof Rectangle || range.type === RangeType.rectangle) {
+      const rectRange = range, { width, height } = rectRange.size, edges = Math.pow(distPos.x - width, squareExp) + Math.pow(distPos.y - height, squareExp);
+      return edges <= r ** squareExp || distPos.x <= r + width && distPos.y <= r + height || distPos.x <= width || distPos.y <= height;
+    }
+    return false;
+  }
+}
+class Rectangle extends BaseRange {
+  constructor(x, y, width, height) {
+    super(x, y, RangeType.rectangle);
+    this.size = {
+      height,
+      width
+    };
+  }
+  contains(point) {
+    const w = this.size.width, h = this.size.height, pos = this.position;
+    return point.x >= pos.x && point.x <= pos.x + w && point.y >= pos.y && point.y <= pos.y + h;
+  }
+  intersects(range) {
+    if (range instanceof Circle) {
+      return range.intersects(this);
+    }
+    const w = this.size.width, h = this.size.height, pos1 = this.position, pos2 = range.position, size2 = range instanceof Rectangle ? range.size : { width: 0, height: 0 }, w2 = size2.width, h2 = size2.height;
+    return pos2.x < pos1.x + w && pos2.x + w2 > pos1.x && pos2.y < pos1.y + h && pos2.y + h2 > pos1.y;
+  }
+}
+export {
+  BaseRange,
+  Circle,
+  Rectangle
+};

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Vectors.js

@@ -0,0 +1,120 @@
+import { originPoint, errorPrefix, squareExp, none, inverseFactorNumerator } from "./Constants.js";
+import { isNumber } from "../../Utils/TypeUtils.js";
+class Vector3d {
+  constructor(xOrCoords, y, z) {
+    this._updateFromAngle = (angle, length) => {
+      this.x = Math.cos(angle) * length;
+      this.y = Math.sin(angle) * length;
+    };
+    if (!isNumber(xOrCoords) && xOrCoords) {
+      this.x = xOrCoords.x;
+      this.y = xOrCoords.y;
+      const coords3d = xOrCoords;
+      this.z = coords3d.z ? coords3d.z : originPoint.z;
+    } else if (xOrCoords !== void 0 && y !== void 0) {
+      this.x = xOrCoords;
+      this.y = y;
+      this.z = z ?? originPoint.z;
+    } else {
+      throw new Error(`${errorPrefix} Vector3d not initialized correctly`);
+    }
+  }
+  static get origin() {
+    return Vector3d.create(originPoint.x, originPoint.y, originPoint.z);
+  }
+  get angle() {
+    return Math.atan2(this.y, this.x);
+  }
+  set angle(angle) {
+    this._updateFromAngle(angle, this.length);
+  }
+  get length() {
+    return Math.sqrt(this.getLengthSq());
+  }
+  set length(length) {
+    this._updateFromAngle(this.angle, length);
+  }
+  static clone(source) {
+    return Vector3d.create(source.x, source.y, source.z);
+  }
+  static create(x, y, z) {
+    return new Vector3d(x, y, z);
+  }
+  add(v) {
+    return Vector3d.create(this.x + v.x, this.y + v.y, this.z + v.z);
+  }
+  addTo(v) {
+    this.x += v.x;
+    this.y += v.y;
+    this.z += v.z;
+  }
+  copy() {
+    return Vector3d.clone(this);
+  }
+  distanceTo(v) {
+    return this.sub(v).length;
+  }
+  distanceToSq(v) {
+    return this.sub(v).getLengthSq();
+  }
+  div(n) {
+    return Vector3d.create(this.x / n, this.y / n, this.z / n);
+  }
+  divTo(n) {
+    this.x /= n;
+    this.y /= n;
+    this.z /= n;
+  }
+  getLengthSq() {
+    return this.x ** squareExp + this.y ** squareExp;
+  }
+  mult(n) {
+    return Vector3d.create(this.x * n, this.y * n, this.z * n);
+  }
+  multTo(n) {
+    this.x *= n;
+    this.y *= n;
+    this.z *= n;
+  }
+  normalize() {
+    const length = this.length;
+    if (length != none) {
+      this.multTo(inverseFactorNumerator / length);
+    }
+  }
+  rotate(angle) {
+    return Vector3d.create(this.x * Math.cos(angle) - this.y * Math.sin(angle), this.x * Math.sin(angle) + this.y * Math.cos(angle), originPoint.z);
+  }
+  setTo(c) {
+    this.x = c.x;
+    this.y = c.y;
+    const v3d = c;
+    this.z = v3d.z ? v3d.z : originPoint.z;
+  }
+  sub(v) {
+    return Vector3d.create(this.x - v.x, this.y - v.y, this.z - v.z);
+  }
+  subFrom(v) {
+    this.x -= v.x;
+    this.y -= v.y;
+    this.z -= v.z;
+  }
+}
+class Vector extends Vector3d {
+  constructor(xOrCoords, y) {
+    super(xOrCoords, y, originPoint.z);
+  }
+  static get origin() {
+    return Vector.create(originPoint.x, originPoint.y);
+  }
+  static clone(source) {
+    return Vector.create(source.x, source.y);
+  }
+  static create(x, y) {
+    return new Vector(x, y);
+  }
+}
+export {
+  Vector,
+  Vector3d
+};

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/AnimationStatus.js

@@ -0,0 +1,8 @@
+var AnimationStatus;
+(function(AnimationStatus2) {
+  AnimationStatus2["increasing"] = "increasing";
+  AnimationStatus2["decreasing"] = "decreasing";
+})(AnimationStatus || (AnimationStatus = {}));
+export {
+  AnimationStatus
+};

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Directions/MoveDirection.js

@@ -0,0 +1,17 @@
+var MoveDirection;
+(function(MoveDirection2) {
+  MoveDirection2["bottom"] = "bottom";
+  MoveDirection2["bottomLeft"] = "bottom-left";
+  MoveDirection2["bottomRight"] = "bottom-right";
+  MoveDirection2["left"] = "left";
+  MoveDirection2["none"] = "none";
+  MoveDirection2["right"] = "right";
+  MoveDirection2["top"] = "top";
+  MoveDirection2["topLeft"] = "top-left";
+  MoveDirection2["topRight"] = "top-right";
+  MoveDirection2["outside"] = "outside";
+  MoveDirection2["inside"] = "inside";
+})(MoveDirection || (MoveDirection = {}));
+export {
+  MoveDirection
+};

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Directions/OutModeDirection.js

@@ -0,0 +1,10 @@
+var OutModeDirection;
+(function(OutModeDirection2) {
+  OutModeDirection2["bottom"] = "bottom";
+  OutModeDirection2["left"] = "left";
+  OutModeDirection2["right"] = "right";
+  OutModeDirection2["top"] = "top";
+})(OutModeDirection || (OutModeDirection = {}));
+export {
+  OutModeDirection
+};

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Directions/RotateDirection.js

@@ -0,0 +1,9 @@
+var RotateDirection;
+(function(RotateDirection2) {
+  RotateDirection2["clockwise"] = "clockwise";
+  RotateDirection2["counterClockwise"] = "counter-clockwise";
+  RotateDirection2["random"] = "random";
+})(RotateDirection || (RotateDirection = {}));
+export {
+  RotateDirection
+};