dune-react 0.0.1

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

@@ -0,0 +1,475 @@
+import { getRandom, getRangeValue, getRangeMin, getRangeMax, randomInRange, clamp, getDistances, collisionVelocity } from "./NumberUtils.js";
+import { millisecondsToSeconds, half, percentDenominator, minVelocity } from "../Core/Utils/Constants.js";
+import { isArray, isNull, isObject } from "./TypeUtils.js";
+import { AnimationMode } from "../Enums/Modes/AnimationMode.js";
+import { AnimationStatus } from "../Enums/AnimationStatus.js";
+import { DestroyType } from "../Enums/Types/DestroyType.js";
+import { OutModeDirection } from "../Enums/Directions/OutModeDirection.js";
+import { PixelMode } from "../Enums/Modes/PixelMode.js";
+import { StartValueType } from "../Enums/Types/StartValueType.js";
+import { Vector } from "../Core/Utils/Vectors.js";
+const _logger = {
+  debug: console.debug,
+  error: console.error,
+  info: console.info,
+  log: console.log,
+  verbose: console.log,
+  warning: console.warn
+};
+function getLogger() {
+  return _logger;
+}
+function memoize(fn) {
+  const cache = /* @__PURE__ */ new Map();
+  return (...args) => {
+    const key = JSON.stringify(args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn(...args);
+    cache.set(key, result);
+    return result;
+  };
+}
+function rectSideBounce(data) {
+  const res = { bounced: false }, { pSide, pOtherSide, rectSide, rectOtherSide, velocity, factor } = data;
+  if (pOtherSide.min < rectOtherSide.min || pOtherSide.min > rectOtherSide.max || pOtherSide.max < rectOtherSide.min || pOtherSide.max > rectOtherSide.max) {
+    return res;
+  }
+  if (pSide.max >= rectSide.min && pSide.max <= (rectSide.max + rectSide.min) * half && velocity > minVelocity || pSide.min <= rectSide.max && pSide.min > (rectSide.max + rectSide.min) * half && velocity < minVelocity) {
+    res.velocity = velocity * -factor;
+    res.bounced = true;
+  }
+  return res;
+}
+function checkSelector(element, selectors) {
+  const res = executeOnSingleOrMultiple(selectors, (selector) => {
+    return element.matches(selector);
+  });
+  return isArray(res) ? res.some((t) => t) : res;
+}
+function isSsr() {
+  return typeof window === "undefined" || !window || typeof window.document === "undefined" || !window.document;
+}
+function hasMatchMedia() {
+  return !isSsr() && typeof matchMedia !== "undefined";
+}
+function safeMatchMedia(query) {
+  if (!hasMatchMedia()) {
+    return;
+  }
+  return matchMedia(query);
+}
+function safeIntersectionObserver(callback) {
+  if (isSsr() || typeof IntersectionObserver === "undefined") {
+    return;
+  }
+  return new IntersectionObserver(callback);
+}
+function safeMutationObserver(callback) {
+  if (isSsr() || typeof MutationObserver === "undefined") {
+    return;
+  }
+  return new MutationObserver(callback);
+}
+function isInArray(value, array) {
+  const invalidIndex = -1;
+  return value === array || isArray(array) && array.indexOf(value) > invalidIndex;
+}
+async function loadFont(font, weight) {
+  try {
+    await document.fonts.load(`${weight ?? "400"} 36px '${font ?? "Verdana"}'`);
+  } catch {
+  }
+}
+function arrayRandomIndex(array) {
+  return Math.floor(getRandom() * array.length);
+}
+function itemFromArray(array, index, useIndex = true) {
+  return array[index !== void 0 && useIndex ? index % array.length : arrayRandomIndex(array)];
+}
+function isPointInside(point, size, offset, radius, direction) {
+  const minRadius = 0;
+  return areBoundsInside(calculateBounds(point, radius ?? minRadius), size, offset, direction);
+}
+function areBoundsInside(bounds, size, offset, direction) {
+  let inside = true;
+  if (!direction || direction === OutModeDirection.bottom) {
+    inside = bounds.top < size.height + offset.x;
+  }
+  if (inside && (!direction || direction === OutModeDirection.left)) {
+    inside = bounds.right > offset.x;
+  }
+  if (inside && (!direction || direction === OutModeDirection.right)) {
+    inside = bounds.left < size.width + offset.y;
+  }
+  if (inside && (!direction || direction === OutModeDirection.top)) {
+    inside = bounds.bottom > offset.y;
+  }
+  return inside;
+}
+function calculateBounds(point, radius) {
+  return {
+    bottom: point.y + radius,
+    left: point.x - radius,
+    right: point.x + radius,
+    top: point.y - radius
+  };
+}
+function deepExtend(destination, ...sources) {
+  for (const source of sources) {
+    if (source === void 0 || source === null) {
+      continue;
+    }
+    if (!isObject(source)) {
+      destination = source;
+      continue;
+    }
+    const sourceIsArray = Array.isArray(source);
+    if (sourceIsArray && (isObject(destination) || !destination || !Array.isArray(destination))) {
+      destination = [];
+    } else if (!sourceIsArray && (isObject(destination) || !destination || Array.isArray(destination))) {
+      destination = {};
+    }
+    for (const key in source) {
+      if (key === "__proto__") {
+        continue;
+      }
+      const sourceDict = source, value = sourceDict[key], destDict = destination;
+      destDict[key] = isObject(value) && Array.isArray(value) ? value.map((v) => deepExtend(destDict[key], v)) : deepExtend(destDict[key], value);
+    }
+  }
+  return destination;
+}
+function isDivModeEnabled(mode, divs) {
+  return !!findItemFromSingleOrMultiple(divs, (t) => t.enable && isInArray(mode, t.mode));
+}
+function divModeExecute(mode, divs, callback) {
+  executeOnSingleOrMultiple(divs, (div) => {
+    const divMode2 = div.mode, divEnabled = div.enable;
+    if (divEnabled && isInArray(mode, divMode2)) {
+      singleDivModeExecute(div, callback);
+    }
+  });
+}
+function singleDivModeExecute(div, callback) {
+  const selectors = div.selectors;
+  executeOnSingleOrMultiple(selectors, (selector) => {
+    callback(selector, div);
+  });
+}
+function divMode(divs, element) {
+  if (!element || !divs) {
+    return;
+  }
+  return findItemFromSingleOrMultiple(divs, (div) => {
+    return checkSelector(element, div.selectors);
+  });
+}
+function circleBounceDataFromParticle(p) {
+  return {
+    position: p.getPosition(),
+    radius: p.getRadius(),
+    mass: p.getMass(),
+    velocity: p.velocity,
+    factor: Vector.create(getRangeValue(p.options.bounce.horizontal.value), getRangeValue(p.options.bounce.vertical.value))
+  };
+}
+function circleBounce(p1, p2) {
+  const { x: xVelocityDiff, y: yVelocityDiff } = p1.velocity.sub(p2.velocity), [pos1, pos2] = [p1.position, p2.position], { dx: xDist, dy: yDist } = getDistances(pos2, pos1), minimumDistance = 0;
+  if (xVelocityDiff * xDist + yVelocityDiff * yDist < minimumDistance) {
+    return;
+  }
+  const angle = -Math.atan2(yDist, xDist), m1 = p1.mass, m2 = p2.mass, u1 = p1.velocity.rotate(angle), u2 = p2.velocity.rotate(angle), v1 = collisionVelocity(u1, u2, m1, m2), v2 = collisionVelocity(u2, u1, m1, m2), vFinal1 = v1.rotate(-angle), vFinal2 = v2.rotate(-angle);
+  p1.velocity.x = vFinal1.x * p1.factor.x;
+  p1.velocity.y = vFinal1.y * p1.factor.y;
+  p2.velocity.x = vFinal2.x * p2.factor.x;
+  p2.velocity.y = vFinal2.y * p2.factor.y;
+}
+function rectBounce(particle, divBounds) {
+  const pPos = particle.getPosition(), size = particle.getRadius(), bounds = calculateBounds(pPos, size), bounceOptions = particle.options.bounce, resH = rectSideBounce({
+    pSide: {
+      min: bounds.left,
+      max: bounds.right
+    },
+    pOtherSide: {
+      min: bounds.top,
+      max: bounds.bottom
+    },
+    rectSide: {
+      min: divBounds.left,
+      max: divBounds.right
+    },
+    rectOtherSide: {
+      min: divBounds.top,
+      max: divBounds.bottom
+    },
+    velocity: particle.velocity.x,
+    factor: getRangeValue(bounceOptions.horizontal.value)
+  });
+  if (resH.bounced) {
+    if (resH.velocity !== void 0) {
+      particle.velocity.x = resH.velocity;
+    }
+    if (resH.position !== void 0) {
+      particle.position.x = resH.position;
+    }
+  }
+  const resV = rectSideBounce({
+    pSide: {
+      min: bounds.top,
+      max: bounds.bottom
+    },
+    pOtherSide: {
+      min: bounds.left,
+      max: bounds.right
+    },
+    rectSide: {
+      min: divBounds.top,
+      max: divBounds.bottom
+    },
+    rectOtherSide: {
+      min: divBounds.left,
+      max: divBounds.right
+    },
+    velocity: particle.velocity.y,
+    factor: getRangeValue(bounceOptions.vertical.value)
+  });
+  if (resV.bounced) {
+    if (resV.velocity !== void 0) {
+      particle.velocity.y = resV.velocity;
+    }
+    if (resV.position !== void 0) {
+      particle.position.y = resV.position;
+    }
+  }
+}
+function executeOnSingleOrMultiple(obj, callback) {
+  const defaultIndex = 0;
+  return isArray(obj) ? obj.map((item, index) => callback(item, index)) : callback(obj, defaultIndex);
+}
+function itemFromSingleOrMultiple(obj, index, useIndex) {
+  return isArray(obj) ? itemFromArray(obj, index, useIndex) : obj;
+}
+function findItemFromSingleOrMultiple(obj, callback) {
+  if (isArray(obj)) {
+    return obj.find((t, index) => callback(t, index));
+  }
+  const defaultIndex = 0;
+  return callback(obj, defaultIndex) ? obj : void 0;
+}
+function initParticleNumericAnimationValue(options, pxRatio) {
+  const valueRange = options.value, animationOptions = options.animation, res = {
+    delayTime: getRangeValue(animationOptions.delay) * millisecondsToSeconds,
+    enable: animationOptions.enable,
+    value: getRangeValue(options.value) * pxRatio,
+    max: getRangeMax(valueRange) * pxRatio,
+    min: getRangeMin(valueRange) * pxRatio,
+    loops: 0,
+    maxLoops: getRangeValue(animationOptions.count),
+    time: 0
+  }, decayOffset = 1;
+  if (animationOptions.enable) {
+    res.decay = decayOffset - getRangeValue(animationOptions.decay);
+    switch (animationOptions.mode) {
+      case AnimationMode.increase:
+        res.status = AnimationStatus.increasing;
+        break;
+      case AnimationMode.decrease:
+        res.status = AnimationStatus.decreasing;
+        break;
+      case AnimationMode.random:
+        res.status = getRandom() >= half ? AnimationStatus.increasing : AnimationStatus.decreasing;
+        break;
+    }
+    const autoStatus = animationOptions.mode === AnimationMode.auto;
+    switch (animationOptions.startValue) {
+      case StartValueType.min:
+        res.value = res.min;
+        if (autoStatus) {
+          res.status = AnimationStatus.increasing;
+        }
+        break;
+      case StartValueType.max:
+        res.value = res.max;
+        if (autoStatus) {
+          res.status = AnimationStatus.decreasing;
+        }
+        break;
+      case StartValueType.random:
+      default:
+        res.value = randomInRange(res);
+        if (autoStatus) {
+          res.status = getRandom() >= half ? AnimationStatus.increasing : AnimationStatus.decreasing;
+        }
+        break;
+    }
+  }
+  res.initialValue = res.value;
+  return res;
+}
+function getPositionOrSize(positionOrSize, canvasSize) {
+  const isPercent = positionOrSize.mode === PixelMode.percent;
+  if (!isPercent) {
+    const { mode: _, ...rest } = positionOrSize;
+    return rest;
+  }
+  const isPosition = "x" in positionOrSize;
+  if (isPosition) {
+    return {
+      x: positionOrSize.x / percentDenominator * canvasSize.width,
+      y: positionOrSize.y / percentDenominator * canvasSize.height
+    };
+  } else {
+    return {
+      width: positionOrSize.width / percentDenominator * canvasSize.width,
+      height: positionOrSize.height / percentDenominator * canvasSize.height
+    };
+  }
+}
+function getPosition(position, canvasSize) {
+  return getPositionOrSize(position, canvasSize);
+}
+function checkDestroy(particle, destroyType, value, minValue, maxValue) {
+  switch (destroyType) {
+    case DestroyType.max:
+      if (value >= maxValue) {
+        particle.destroy();
+      }
+      break;
+    case DestroyType.min:
+      if (value <= minValue) {
+        particle.destroy();
+      }
+      break;
+  }
+}
+function updateAnimation(particle, data, changeDirection, destroyType, delta) {
+  const minLoops = 0, minDelay = 0, identity = 1, minVelocity2 = 0, minDecay = 1;
+  if (particle.destroyed || !data || !data.enable || (data.maxLoops ?? minLoops) > minLoops && (data.loops ?? minLoops) > (data.maxLoops ?? minLoops)) {
+    return;
+  }
+  const velocity = (data.velocity ?? minVelocity2) * delta.factor, minValue = data.min, maxValue = data.max, decay = data.decay ?? minDecay;
+  if (!data.time) {
+    data.time = 0;
+  }
+  if ((data.delayTime ?? minDelay) > minDelay && data.time < (data.delayTime ?? minDelay)) {
+    data.time += delta.value;
+  }
+  if ((data.delayTime ?? minDelay) > minDelay && data.time < (data.delayTime ?? minDelay)) {
+    return;
+  }
+  switch (data.status) {
+    case AnimationStatus.increasing:
+      if (data.value >= maxValue) {
+        if (changeDirection) {
+          data.status = AnimationStatus.decreasing;
+        } else {
+          data.value -= maxValue;
+        }
+        if (!data.loops) {
+          data.loops = minLoops;
+        }
+        data.loops++;
+      } else {
+        data.value += velocity;
+      }
+      break;
+    case AnimationStatus.decreasing:
+      if (data.value <= minValue) {
+        if (changeDirection) {
+          data.status = AnimationStatus.increasing;
+        } else {
+          data.value += maxValue;
+        }
+        if (!data.loops) {
+          data.loops = minLoops;
+        }
+        data.loops++;
+      } else {
+        data.value -= velocity;
+      }
+  }
+  if (data.velocity && decay !== identity) {
+    data.velocity *= decay;
+  }
+  checkDestroy(particle, destroyType, data.value, minValue, maxValue);
+  if (!particle.destroyed) {
+    data.value = clamp(data.value, minValue, maxValue);
+  }
+}
+function cloneStyle(style) {
+  var _a, _b, _c, _d;
+  const clonedStyle = document.createElement("div").style;
+  if (!style) {
+    return clonedStyle;
+  }
+  for (const key in style) {
+    const styleKey = style[key];
+    if (!Object.prototype.hasOwnProperty.call(style, key) || isNull(styleKey)) {
+      continue;
+    }
+    const styleValue = (_a = style.getPropertyValue) == null ? void 0 : _a.call(style, styleKey);
+    if (!styleValue) {
+      continue;
+    }
+    const stylePriority = (_b = style.getPropertyPriority) == null ? void 0 : _b.call(style, styleKey);
+    if (!stylePriority) {
+      (_c = clonedStyle.setProperty) == null ? void 0 : _c.call(clonedStyle, styleKey, styleValue);
+    } else {
+      (_d = clonedStyle.setProperty) == null ? void 0 : _d.call(clonedStyle, styleKey, styleValue, stylePriority);
+    }
+  }
+  return clonedStyle;
+}
+function computeFullScreenStyle(zIndex) {
+  const fullScreenStyle = document.createElement("div").style, radix = 10, style = {
+    width: "100%",
+    height: "100%",
+    margin: "0",
+    padding: "0",
+    borderWidth: "0",
+    position: "fixed",
+    zIndex: zIndex.toString(radix),
+    "z-index": zIndex.toString(radix),
+    top: "0",
+    left: "0"
+  };
+  for (const key in style) {
+    const value = style[key];
+    fullScreenStyle.setProperty(key, value);
+  }
+  return fullScreenStyle;
+}
+const getFullScreenStyle = memoize(computeFullScreenStyle);
+export {
+  areBoundsInside,
+  arrayRandomIndex,
+  calculateBounds,
+  circleBounce,
+  circleBounceDataFromParticle,
+  cloneStyle,
+  deepExtend,
+  divMode,
+  divModeExecute,
+  executeOnSingleOrMultiple,
+  findItemFromSingleOrMultiple,
+  getFullScreenStyle,
+  getLogger,
+  getPosition,
+  hasMatchMedia,
+  initParticleNumericAnimationValue,
+  isDivModeEnabled,
+  isInArray,
+  isPointInside,
+  isSsr,
+  itemFromArray,
+  itemFromSingleOrMultiple,
+  loadFont,
+  rectBounce,
+  safeIntersectionObserver,
+  safeMatchMedia,
+  safeMutationObserver,
+  singleDivModeExecute,
+  updateAnimation
+};

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

@@ -0,0 +1,82 @@
+import { init } from "./init.js";
+import { isSsr } from "./Utils/Utils.js";
+import { areBoundsInside, arrayRandomIndex, calculateBounds, circleBounce, circleBounceDataFromParticle, cloneStyle, deepExtend, divMode, divModeExecute, executeOnSingleOrMultiple, findItemFromSingleOrMultiple, getFullScreenStyle, getLogger, getPosition, hasMatchMedia, initParticleNumericAnimationValue, isDivModeEnabled, isInArray, isPointInside, itemFromArray, itemFromSingleOrMultiple, loadFont, rectBounce, safeIntersectionObserver, safeMatchMedia, safeMutationObserver, singleDivModeExecute, updateAnimation } from "./Utils/Utils.js";
+import { InteractorType } from "./Enums/Types/InteractorType.js";
+import "./Types/RangeType.js";
+import { MoveDirection } from "./Enums/Directions/MoveDirection.js";
+import { RotateDirection } from "./Enums/Directions/RotateDirection.js";
+import { OutModeDirection } from "./Enums/Directions/OutModeDirection.js";
+import { AnimationMode } from "./Enums/Modes/AnimationMode.js";
+import { CollisionMode } from "./Enums/Modes/CollisionMode.js";
+import { LimitMode } from "./Enums/Modes/LimitMode.js";
+import { OutMode } from "./Enums/Modes/OutMode.js";
+import { PixelMode } from "./Enums/Modes/PixelMode.js";
+import { ThemeMode } from "./Enums/Modes/ThemeMode.js";
+import { ResponsiveMode } from "./Enums/Modes/ResponsiveMode.js";
+import { AlterType } from "./Enums/Types/AlterType.js";
+import { DestroyType } from "./Enums/Types/DestroyType.js";
+import { GradientType } from "./Enums/Types/GradientType.js";
+import { ParticleOutType } from "./Enums/Types/ParticleOutType.js";
+import { StartValueType } from "./Enums/Types/StartValueType.js";
+import { DivType } from "./Enums/Types/DivType.js";
+import { EasingType } from "./Enums/Types/EasingType.js";
+import { EventType } from "./Enums/Types/EventType.js";
+import { AnimationStatus } from "./Enums/AnimationStatus.js";
+import { InteractivityDetect } from "./Enums/InteractivityDetect.js";
+const tsParticles = init();
+if (!isSsr()) {
+  window.tsParticles = tsParticles;
+}
+export {
+  AlterType,
+  AnimationMode,
+  AnimationStatus,
+  CollisionMode,
+  DestroyType,
+  DivType,
+  EasingType,
+  EventType,
+  GradientType,
+  InteractivityDetect,
+  InteractorType,
+  LimitMode,
+  MoveDirection,
+  OutMode,
+  OutModeDirection,
+  ParticleOutType,
+  PixelMode,
+  ResponsiveMode,
+  RotateDirection,
+  StartValueType,
+  ThemeMode,
+  areBoundsInside,
+  arrayRandomIndex,
+  calculateBounds,
+  circleBounce,
+  circleBounceDataFromParticle,
+  cloneStyle,
+  deepExtend,
+  divMode,
+  divModeExecute,
+  executeOnSingleOrMultiple,
+  findItemFromSingleOrMultiple,
+  getFullScreenStyle,
+  getLogger,
+  getPosition,
+  hasMatchMedia,
+  initParticleNumericAnimationValue,
+  isDivModeEnabled,
+  isInArray,
+  isPointInside,
+  isSsr,
+  itemFromArray,
+  itemFromSingleOrMultiple,
+  loadFont,
+  rectBounce,
+  safeIntersectionObserver,
+  safeMatchMedia,
+  safeMutationObserver,
+  singleDivModeExecute,
+  tsParticles,
+  updateAnimation
+};

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

@@ -0,0 +1,9 @@
+import { Engine } from "./Core/Engine.js";
+function init() {
+  const engine = new Engine();
+  engine.init();
+  return engine;
+}
+export {
+  init
+};

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

@@ -0,0 +1,81 @@
+import { hoverAttract, clickAttract } from "./Utils.js";
+import { Attract } from "./Options/Classes/Attract.js";
+import { ExternalInteractorBase } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/ExternalInteractorBase.js";
+import { millisecondsToSeconds, mouseMoveEvent } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Constants.js";
+import { isInArray } from "../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/Utils.js";
+const attractMode = "attract";
+class Attractor extends ExternalInteractorBase {
+  constructor(engine, container) {
+    super(container);
+    this._engine = engine;
+    if (!container.attract) {
+      container.attract = { particles: [] };
+    }
+    this.handleClickMode = (mode) => {
+      const options = this.container.actualOptions, attract = options.interactivity.modes.attract;
+      if (!attract || mode !== attractMode) {
+        return;
+      }
+      if (!container.attract) {
+        container.attract = { particles: [] };
+      }
+      container.attract.clicking = true;
+      container.attract.count = 0;
+      for (const particle of container.attract.particles) {
+        if (!this.isEnabled(particle)) {
+          continue;
+        }
+        particle.velocity.setTo(particle.initialVelocity);
+      }
+      container.attract.particles = [];
+      container.attract.finish = false;
+      setTimeout(() => {
+        if (container.destroyed) {
+          return;
+        }
+        if (!container.attract) {
+          container.attract = { particles: [] };
+        }
+        container.attract.clicking = false;
+      }, attract.duration * millisecondsToSeconds);
+    };
+  }
+  clear() {
+  }
+  init() {
+    const container = this.container, attract = container.actualOptions.interactivity.modes.attract;
+    if (!attract) {
+      return;
+    }
+    container.retina.attractModeDistance = attract.distance * container.retina.pixelRatio;
+  }
+  interact() {
+    const container = this.container, options = container.actualOptions, mouseMoveStatus = container.interactivity.status === mouseMoveEvent, events = options.interactivity.events, { enable: hoverEnabled, mode: hoverMode } = events.onHover, { enable: clickEnabled, mode: clickMode } = events.onClick;
+    if (mouseMoveStatus && hoverEnabled && isInArray(attractMode, hoverMode)) {
+      hoverAttract(this._engine, this.container, (p) => this.isEnabled(p));
+    } else if (clickEnabled && isInArray(attractMode, clickMode)) {
+      clickAttract(this._engine, this.container, (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;
+    if ((!mouse.position || !events.onHover.enable) && (!mouse.clickPosition || !events.onClick.enable)) {
+      return false;
+    }
+    const hoverMode = events.onHover.mode, clickMode = events.onClick.mode;
+    return isInArray(attractMode, hoverMode) || isInArray(attractMode, clickMode);
+  }
+  loadModeOptions(options, ...sources) {
+    if (!options.attract) {
+      options.attract = new Attract();
+    }
+    for (const source of sources) {
+      options.attract.load(source == null ? void 0 : source.attract);
+    }
+  }
+  reset() {
+  }
+}
+export {
+  Attractor
+};

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

@@ -0,0 +1,38 @@
+import { isNull } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Utils/TypeUtils.js";
+import { EasingType } from "../../../../../../../@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Enums/Types/EasingType.js";
+class Attract {
+  constructor() {
+    this.distance = 200;
+    this.duration = 0.4;
+    this.easing = EasingType.easeOutQuad;
+    this.factor = 1;
+    this.maxSpeed = 50;
+    this.speed = 1;
+  }
+  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.easing !== void 0) {
+      this.easing = data.easing;
+    }
+    if (data.factor !== void 0) {
+      this.factor = data.factor;
+    }
+    if (data.maxSpeed !== void 0) {
+      this.maxSpeed = data.maxSpeed;
+    }
+    if (data.speed !== void 0) {
+      this.speed = data.speed;
+    }
+  }
+}
+export {
+  Attract
+};