dune-react 0.0.2 → 0.0.4

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

@@ -1,293 +0,0 @@
-import { removeDeleteCount, loadRandomFactor, loadMinIndex, one, none, errorPrefix, generatedTrue, generatedAttribute, canvasTag, generatedFalse, canvasFirstIndex } from "./Utils/Constants.js";
-import { executeOnSingleOrMultiple, itemFromSingleOrMultiple, getLogger } from "../Utils/Utils.js";
-import { Container } from "./Container.js";
-import { EventDispatcher } from "../Utils/EventDispatcher.js";
-import { EventType } from "../Enums/Types/EventType.js";
-import { getRandom } from "../Utils/NumberUtils.js";
-async function getItemsFromInitializer(container, map, initializers, force = false) {
-  let res = map.get(container);
-  if (!res || force) {
-    res = await Promise.all([...initializers.values()].map((t) => t(container)));
-    map.set(container, res);
-  }
-  return res;
-}
-async function getDataFromUrl(data) {
-  const url = itemFromSingleOrMultiple(data.url, data.index);
-  if (!url) {
-    return data.fallback;
-  }
-  const response = await fetch(url);
-  if (response.ok) {
-    return await response.json();
-  }
-  getLogger().error(`${errorPrefix} ${response.status} while retrieving config file`);
-  return data.fallback;
-}
-const getCanvasFromContainer = (domContainer) => {
-  let canvasEl;
-  if (domContainer instanceof HTMLCanvasElement || domContainer.tagName.toLowerCase() === canvasTag) {
-    canvasEl = domContainer;
-    if (!canvasEl.dataset[generatedAttribute]) {
-      canvasEl.dataset[generatedAttribute] = generatedFalse;
-    }
-  } else {
-    const existingCanvases = domContainer.getElementsByTagName(canvasTag);
-    if (existingCanvases.length) {
-      canvasEl = existingCanvases[canvasFirstIndex];
-      canvasEl.dataset[generatedAttribute] = generatedFalse;
-    } else {
-      canvasEl = document.createElement(canvasTag);
-      canvasEl.dataset[generatedAttribute] = generatedTrue;
-      domContainer.appendChild(canvasEl);
-    }
-  }
-  const fullPercent = "100%";
-  if (!canvasEl.style.width) {
-    canvasEl.style.width = fullPercent;
-  }
-  if (!canvasEl.style.height) {
-    canvasEl.style.height = fullPercent;
-  }
-  return canvasEl;
-}, getDomContainer = (id, source) => {
-  let domContainer = source ?? document.getElementById(id);
-  if (domContainer) {
-    return domContainer;
-  }
-  domContainer = document.createElement("div");
-  domContainer.id = id;
-  domContainer.dataset[generatedAttribute] = generatedTrue;
-  document.body.append(domContainer);
-  return domContainer;
-};
-class Engine {
-  constructor() {
-    this._configs = /* @__PURE__ */ new Map();
-    this._domArray = [];
-    this._eventDispatcher = new EventDispatcher();
-    this._initialized = false;
-    this.plugins = [];
-    this.colorManagers = /* @__PURE__ */ new Map();
-    this.easingFunctions = /* @__PURE__ */ new Map();
-    this._initializers = {
-      interactors: /* @__PURE__ */ new Map(),
-      movers: /* @__PURE__ */ new Map(),
-      updaters: /* @__PURE__ */ new Map()
-    };
-    this.interactors = /* @__PURE__ */ new Map();
-    this.movers = /* @__PURE__ */ new Map();
-    this.updaters = /* @__PURE__ */ new Map();
-    this.presets = /* @__PURE__ */ new Map();
-    this.effectDrawers = /* @__PURE__ */ new Map();
-    this.shapeDrawers = /* @__PURE__ */ new Map();
-    this.pathGenerators = /* @__PURE__ */ new Map();
-  }
-  get configs() {
-    const res = {};
-    for (const [name, config] of this._configs) {
-      res[name] = config;
-    }
-    return res;
-  }
-  get items() {
-    return this._domArray;
-  }
-  get version() {
-    return "3.9.1";
-  }
-  async addColorManager(manager, refresh = true) {
-    this.colorManagers.set(manager.key, manager);
-    await this.refresh(refresh);
-  }
-  addConfig(config) {
-    const key = config.key ?? config.name ?? "default";
-    this._configs.set(key, config);
-    this._eventDispatcher.dispatchEvent(EventType.configAdded, { data: { name: key, config } });
-  }
-  async addEasing(name, easing, refresh = true) {
-    if (this.getEasing(name)) {
-      return;
-    }
-    this.easingFunctions.set(name, easing);
-    await this.refresh(refresh);
-  }
-  async addEffect(effect, drawer, refresh = true) {
-    executeOnSingleOrMultiple(effect, (type) => {
-      if (!this.getEffectDrawer(type)) {
-        this.effectDrawers.set(type, drawer);
-      }
-    });
-    await this.refresh(refresh);
-  }
-  addEventListener(type, listener) {
-    this._eventDispatcher.addEventListener(type, listener);
-  }
-  async addInteractor(name, interactorInitializer, refresh = true) {
-    this._initializers.interactors.set(name, interactorInitializer);
-    await this.refresh(refresh);
-  }
-  async addMover(name, moverInitializer, refresh = true) {
-    this._initializers.movers.set(name, moverInitializer);
-    await this.refresh(refresh);
-  }
-  async addParticleUpdater(name, updaterInitializer, refresh = true) {
-    this._initializers.updaters.set(name, updaterInitializer);
-    await this.refresh(refresh);
-  }
-  async addPathGenerator(name, generator, refresh = true) {
-    if (!this.getPathGenerator(name)) {
-      this.pathGenerators.set(name, generator);
-    }
-    await this.refresh(refresh);
-  }
-  async addPlugin(plugin, refresh = true) {
-    if (!this.getPlugin(plugin.id)) {
-      this.plugins.push(plugin);
-    }
-    await this.refresh(refresh);
-  }
-  async addPreset(preset, options, override = false, refresh = true) {
-    if (override || !this.getPreset(preset)) {
-      this.presets.set(preset, options);
-    }
-    await this.refresh(refresh);
-  }
-  async addShape(drawer, refresh = true) {
-    for (const validType of drawer.validTypes) {
-      if (this.getShapeDrawer(validType)) {
-        continue;
-      }
-      this.shapeDrawers.set(validType, drawer);
-    }
-    await this.refresh(refresh);
-  }
-  checkVersion(pluginVersion) {
-    if (this.version === pluginVersion) {
-      return;
-    }
-    throw new Error(`The tsParticles version is different from the loaded plugins version. Engine version: ${this.version}. Plugin version: ${pluginVersion}`);
-  }
-  clearPlugins(container) {
-    this.updaters.delete(container);
-    this.movers.delete(container);
-    this.interactors.delete(container);
-  }
-  dispatchEvent(type, args) {
-    this._eventDispatcher.dispatchEvent(type, args);
-  }
-  dom() {
-    return this.items;
-  }
-  domItem(index) {
-    return this.item(index);
-  }
-  async getAvailablePlugins(container) {
-    const res = /* @__PURE__ */ new Map();
-    for (const plugin of this.plugins) {
-      if (plugin.needsPlugin(container.actualOptions)) {
-        res.set(plugin.id, await plugin.getPlugin(container));
-      }
-    }
-    return res;
-  }
-  getEasing(name) {
-    return this.easingFunctions.get(name) ?? ((value) => value);
-  }
-  getEffectDrawer(type) {
-    return this.effectDrawers.get(type);
-  }
-  async getInteractors(container, force = false) {
-    return getItemsFromInitializer(container, this.interactors, this._initializers.interactors, force);
-  }
-  async getMovers(container, force = false) {
-    return getItemsFromInitializer(container, this.movers, this._initializers.movers, force);
-  }
-  getPathGenerator(type) {
-    return this.pathGenerators.get(type);
-  }
-  getPlugin(plugin) {
-    return this.plugins.find((t) => t.id === plugin);
-  }
-  getPreset(preset) {
-    return this.presets.get(preset);
-  }
-  getShapeDrawer(type) {
-    return this.shapeDrawers.get(type);
-  }
-  getSupportedEffects() {
-    return this.effectDrawers.keys();
-  }
-  getSupportedShapes() {
-    return this.shapeDrawers.keys();
-  }
-  async getUpdaters(container, force = false) {
-    return getItemsFromInitializer(container, this.updaters, this._initializers.updaters, force);
-  }
-  init() {
-    if (this._initialized) {
-      return;
-    }
-    this._initialized = true;
-  }
-  item(index) {
-    const { items } = this, item = items[index];
-    if (!item || item.destroyed) {
-      items.splice(index, removeDeleteCount);
-      return;
-    }
-    return item;
-  }
-  async load(params) {
-    var _a;
-    const id = params.id ?? ((_a = params.element) == null ? void 0 : _a.id) ?? `tsparticles${Math.floor(getRandom() * loadRandomFactor)}`, { index, url } = params, options = url ? await getDataFromUrl({ fallback: params.options, url, index }) : params.options, currentOptions = itemFromSingleOrMultiple(options, index), { items } = this, oldIndex = items.findIndex((v) => v.id.description === id), newItem = new Container(this, id, currentOptions);
-    if (oldIndex >= loadMinIndex) {
-      const old = this.item(oldIndex), deleteCount = old ? one : none;
-      if (old && !old.destroyed) {
-        old.destroy(false);
-      }
-      items.splice(oldIndex, deleteCount, newItem);
-    } else {
-      items.push(newItem);
-    }
-    const domContainer = getDomContainer(id, params.element), canvasEl = getCanvasFromContainer(domContainer);
-    newItem.canvas.loadCanvas(canvasEl);
-    await newItem.start();
-    return newItem;
-  }
-  loadOptions(options, sourceOptions) {
-    this.plugins.forEach((plugin) => {
-      var _a;
-      return (_a = plugin.loadOptions) == null ? void 0 : _a.call(plugin, options, sourceOptions);
-    });
-  }
-  loadParticlesOptions(container, options, ...sourceOptions) {
-    const updaters = this.updaters.get(container);
-    if (!updaters) {
-      return;
-    }
-    updaters.forEach((updater) => {
-      var _a;
-      return (_a = updater.loadOptions) == null ? void 0 : _a.call(updater, options, ...sourceOptions);
-    });
-  }
-  async refresh(refresh = true) {
-    if (!refresh) {
-      return;
-    }
-    await Promise.all(this.items.map((t) => t.refresh()));
-  }
-  removeEventListener(type, listener) {
-    this._eventDispatcher.removeEventListener(type, listener);
-  }
-  setOnClickHandler(callback) {
-    const { items } = this;
-    if (!items.length) {
-      throw new Error(`${errorPrefix} can only set click handlers after calling tsParticles.load()`);
-    }
-    items.forEach((item) => item.addClickHandler(callback));
-  }
-}
-export {
-  Engine
-};

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

@@ -1,355 +0,0 @@
-import { Vector3d, Vector } from "./Utils/Vectors.js";
-import { calcExactPositionOrRandomFromSize, getParticleBaseVelocity, degToRad, getRangeValue, randomInRange, setRangeValue, getRandom, getDistance, clamp, getParticleDirectionAngle } from "../Utils/NumberUtils.js";
-import { defaultRetryCount, tryCountIncrement, minRetries, errorPrefix, double, rollFactor, half, none, minZ, defaultRadius, squareExp, randomColorValue, millisecondsToSeconds, decayOffset } from "./Utils/Constants.js";
-import { getPosition, itemFromSingleOrMultiple, initParticleNumericAnimationValue, deepExtend, isInArray } from "../Utils/Utils.js";
-import { getHslFromAnimation, rangeColorToRgb } from "../Utils/ColorUtils.js";
-import { EventType } from "../Enums/Types/EventType.js";
-import { Interactivity } from "../Options/Classes/Interactivity/Interactivity.js";
-import { MoveDirection } from "../Enums/Directions/MoveDirection.js";
-import { OutMode } from "../Enums/Modes/OutMode.js";
-import { ParticleOutType } from "../Enums/Types/ParticleOutType.js";
-import { PixelMode } from "../Enums/Modes/PixelMode.js";
-import { alterHsl } from "../Utils/CanvasUtils.js";
-import { loadParticlesOptions } from "../Utils/OptionsUtils.js";
-function loadEffectData(effect, effectOptions, id, reduceDuplicates) {
-  const effectData = effectOptions.options[effect];
-  if (!effectData) {
-    return;
-  }
-  return deepExtend({
-    close: effectOptions.close,
-    fill: effectOptions.fill
-  }, itemFromSingleOrMultiple(effectData, id, reduceDuplicates));
-}
-function loadShapeData(shape, shapeOptions, id, reduceDuplicates) {
-  const shapeData = shapeOptions.options[shape];
-  if (!shapeData) {
-    return;
-  }
-  return deepExtend({
-    close: shapeOptions.close,
-    fill: shapeOptions.fill
-  }, itemFromSingleOrMultiple(shapeData, id, reduceDuplicates));
-}
-function fixOutMode(data) {
-  if (!isInArray(data.outMode, data.checkModes)) {
-    return;
-  }
-  const diameter = data.radius * double;
-  if (data.coord > data.maxCoord - diameter) {
-    data.setCb(-data.radius);
-  } else if (data.coord < diameter) {
-    data.setCb(data.radius);
-  }
-}
-class Particle {
-  constructor(engine, container) {
-    this.container = container;
-    this._calcPosition = (container2, position, zIndex, tryCount = defaultRetryCount) => {
-      for (const plugin of container2.plugins.values()) {
-        const pluginPos = plugin.particlePosition !== void 0 ? plugin.particlePosition(position, this) : void 0;
-        if (pluginPos) {
-          return Vector3d.create(pluginPos.x, pluginPos.y, zIndex);
-        }
-      }
-      const canvasSize = container2.canvas.size, exactPosition = calcExactPositionOrRandomFromSize({
-        size: canvasSize,
-        position
-      }), pos = Vector3d.create(exactPosition.x, exactPosition.y, zIndex), radius = this.getRadius(), outModes = this.options.move.outModes, fixHorizontal = (outMode) => {
-        fixOutMode({
-          outMode,
-          checkModes: [OutMode.bounce],
-          coord: pos.x,
-          maxCoord: container2.canvas.size.width,
-          setCb: (value) => pos.x += value,
-          radius
-        });
-      }, fixVertical = (outMode) => {
-        fixOutMode({
-          outMode,
-          checkModes: [OutMode.bounce],
-          coord: pos.y,
-          maxCoord: container2.canvas.size.height,
-          setCb: (value) => pos.y += value,
-          radius
-        });
-      };
-      fixHorizontal(outModes.left ?? outModes.default);
-      fixHorizontal(outModes.right ?? outModes.default);
-      fixVertical(outModes.top ?? outModes.default);
-      fixVertical(outModes.bottom ?? outModes.default);
-      if (this._checkOverlap(pos, tryCount)) {
-        return this._calcPosition(container2, void 0, zIndex, tryCount + tryCountIncrement);
-      }
-      return pos;
-    };
-    this._calculateVelocity = () => {
-      const baseVelocity = getParticleBaseVelocity(this.direction), res = baseVelocity.copy(), moveOptions = this.options.move;
-      if (moveOptions.direction === MoveDirection.inside || moveOptions.direction === MoveDirection.outside) {
-        return res;
-      }
-      const rad = degToRad(getRangeValue(moveOptions.angle.value)), radOffset = degToRad(getRangeValue(moveOptions.angle.offset)), range = {
-        left: radOffset - rad * half,
-        right: radOffset + rad * half
-      };
-      if (!moveOptions.straight) {
-        res.angle += randomInRange(setRangeValue(range.left, range.right));
-      }
-      if (moveOptions.random && typeof moveOptions.speed === "number") {
-        res.length *= getRandom();
-      }
-      return res;
-    };
-    this._checkOverlap = (pos, tryCount = defaultRetryCount) => {
-      const collisionsOptions = this.options.collisions, radius = this.getRadius();
-      if (!collisionsOptions.enable) {
-        return false;
-      }
-      const overlapOptions = collisionsOptions.overlap;
-      if (overlapOptions.enable) {
-        return false;
-      }
-      const retries = overlapOptions.retries;
-      if (retries >= minRetries && tryCount > retries) {
-        throw new Error(`${errorPrefix} particle is overlapping and can't be placed`);
-      }
-      return !!this.container.particles.find((particle) => getDistance(pos, particle.position) < radius + particle.getRadius());
-    };
-    this._getRollColor = (color) => {
-      if (!color || !this.roll || !this.backColor && !this.roll.alter) {
-        return color;
-      }
-      const backFactor = this.roll.horizontal && this.roll.vertical ? double * rollFactor : rollFactor, backSum = this.roll.horizontal ? Math.PI * half : none, rolled = Math.floor(((this.roll.angle ?? none) + backSum) / (Math.PI / backFactor)) % double;
-      if (!rolled) {
-        return color;
-      }
-      if (this.backColor) {
-        return this.backColor;
-      }
-      if (this.roll.alter) {
-        return alterHsl(color, this.roll.alter.type, this.roll.alter.value);
-      }
-      return color;
-    };
-    this._initPosition = (position) => {
-      const container2 = this.container, zIndexValue = getRangeValue(this.options.zIndex.value);
-      this.position = this._calcPosition(container2, position, clamp(zIndexValue, minZ, container2.zLayers));
-      this.initialPosition = this.position.copy();
-      const canvasSize = container2.canvas.size;
-      this.moveCenter = {
-        ...getPosition(this.options.move.center, canvasSize),
-        radius: this.options.move.center.radius ?? defaultRadius,
-        mode: this.options.move.center.mode ?? PixelMode.percent
-      };
-      this.direction = getParticleDirectionAngle(this.options.move.direction, this.position, this.moveCenter);
-      switch (this.options.move.direction) {
-        case MoveDirection.inside:
-          this.outType = ParticleOutType.inside;
-          break;
-        case MoveDirection.outside:
-          this.outType = ParticleOutType.outside;
-          break;
-      }
-      this.offset = Vector.origin;
-    };
-    this._engine = engine;
-  }
-  destroy(override) {
-    var _a, _b, _c;
-    if (this.unbreakable || this.destroyed) {
-      return;
-    }
-    this.destroyed = true;
-    this.bubble.inRange = false;
-    this.slow.inRange = false;
-    const container = this.container, pathGenerator = this.pathGenerator, shapeDrawer = container.shapeDrawers.get(this.shape);
-    (_a = shapeDrawer == null ? void 0 : shapeDrawer.particleDestroy) == null ? void 0 : _a.call(shapeDrawer, this);
-    for (const plugin of container.plugins.values()) {
-      (_b = plugin.particleDestroyed) == null ? void 0 : _b.call(plugin, this, override);
-    }
-    for (const updater of container.particles.updaters) {
-      (_c = updater.particleDestroyed) == null ? void 0 : _c.call(updater, this, override);
-    }
-    pathGenerator == null ? void 0 : pathGenerator.reset(this);
-    this._engine.dispatchEvent(EventType.particleDestroyed, {
-      container: this.container,
-      data: {
-        particle: this
-      }
-    });
-  }
-  draw(delta) {
-    const container = this.container, canvas = container.canvas;
-    for (const plugin of container.plugins.values()) {
-      canvas.drawParticlePlugin(plugin, this, delta);
-    }
-    canvas.drawParticle(this, delta);
-  }
-  getFillColor() {
-    return this._getRollColor(this.bubble.color ?? getHslFromAnimation(this.color));
-  }
-  getMass() {
-    return this.getRadius() ** squareExp * Math.PI * half;
-  }
-  getPosition() {
-    return {
-      x: this.position.x + this.offset.x,
-      y: this.position.y + this.offset.y,
-      z: this.position.z
-    };
-  }
-  getRadius() {
-    return this.bubble.radius ?? this.size.value;
-  }
-  getStrokeColor() {
-    return this._getRollColor(this.bubble.color ?? getHslFromAnimation(this.strokeColor));
-  }
-  init(id, position, overrideOptions, group) {
-    var _a, _b, _c, _d, _e, _f;
-    const container = this.container, engine = this._engine;
-    this.id = id;
-    this.group = group;
-    this.effectClose = true;
-    this.effectFill = true;
-    this.shapeClose = true;
-    this.shapeFill = true;
-    this.pathRotation = false;
-    this.lastPathTime = 0;
-    this.destroyed = false;
-    this.unbreakable = false;
-    this.isRotating = false;
-    this.rotation = 0;
-    this.misplaced = false;
-    this.retina = {
-      maxDistance: {}
-    };
-    this.outType = ParticleOutType.normal;
-    this.ignoresResizeRatio = true;
-    const pxRatio = container.retina.pixelRatio, mainOptions = container.actualOptions, particlesOptions = loadParticlesOptions(this._engine, container, mainOptions.particles), { reduceDuplicates } = particlesOptions, effectType = particlesOptions.effect.type, shapeType = particlesOptions.shape.type;
-    this.effect = itemFromSingleOrMultiple(effectType, this.id, reduceDuplicates);
-    this.shape = itemFromSingleOrMultiple(shapeType, this.id, reduceDuplicates);
-    const effectOptions = particlesOptions.effect, shapeOptions = particlesOptions.shape;
-    if (overrideOptions) {
-      if ((_a = overrideOptions.effect) == null ? void 0 : _a.type) {
-        const overrideEffectType = overrideOptions.effect.type, effect = itemFromSingleOrMultiple(overrideEffectType, this.id, reduceDuplicates);
-        if (effect) {
-          this.effect = effect;
-          effectOptions.load(overrideOptions.effect);
-        }
-      }
-      if ((_b = overrideOptions.shape) == null ? void 0 : _b.type) {
-        const overrideShapeType = overrideOptions.shape.type, shape = itemFromSingleOrMultiple(overrideShapeType, this.id, reduceDuplicates);
-        if (shape) {
-          this.shape = shape;
-          shapeOptions.load(overrideOptions.shape);
-        }
-      }
-    }
-    if (this.effect === randomColorValue) {
-      const availableEffects = [...this.container.effectDrawers.keys()];
-      this.effect = availableEffects[Math.floor(getRandom() * availableEffects.length)];
-    }
-    if (this.shape === randomColorValue) {
-      const availableShapes = [...this.container.shapeDrawers.keys()];
-      this.shape = availableShapes[Math.floor(getRandom() * availableShapes.length)];
-    }
-    this.effectData = loadEffectData(this.effect, effectOptions, this.id, reduceDuplicates);
-    this.shapeData = loadShapeData(this.shape, shapeOptions, this.id, reduceDuplicates);
-    particlesOptions.load(overrideOptions);
-    const effectData = this.effectData;
-    if (effectData) {
-      particlesOptions.load(effectData.particles);
-    }
-    const shapeData = this.shapeData;
-    if (shapeData) {
-      particlesOptions.load(shapeData.particles);
-    }
-    const interactivity = new Interactivity(engine, container);
-    interactivity.load(container.actualOptions.interactivity);
-    interactivity.load(particlesOptions.interactivity);
-    this.interactivity = interactivity;
-    this.effectFill = (effectData == null ? void 0 : effectData.fill) ?? particlesOptions.effect.fill;
-    this.effectClose = (effectData == null ? void 0 : effectData.close) ?? particlesOptions.effect.close;
-    this.shapeFill = (shapeData == null ? void 0 : shapeData.fill) ?? particlesOptions.shape.fill;
-    this.shapeClose = (shapeData == null ? void 0 : shapeData.close) ?? particlesOptions.shape.close;
-    this.options = particlesOptions;
-    const pathOptions = this.options.move.path;
-    this.pathDelay = getRangeValue(pathOptions.delay.value) * millisecondsToSeconds;
-    if (pathOptions.generator) {
-      this.pathGenerator = this._engine.getPathGenerator(pathOptions.generator);
-      if (this.pathGenerator && container.addPath(pathOptions.generator, this.pathGenerator)) {
-        this.pathGenerator.init(container);
-      }
-    }
-    container.retina.initParticle(this);
-    this.size = initParticleNumericAnimationValue(this.options.size, pxRatio);
-    this.bubble = {
-      inRange: false
-    };
-    this.slow = {
-      inRange: false,
-      factor: 1
-    };
-    this._initPosition(position);
-    this.initialVelocity = this._calculateVelocity();
-    this.velocity = this.initialVelocity.copy();
-    this.moveDecay = decayOffset - getRangeValue(this.options.move.decay);
-    const particles = container.particles;
-    particles.setLastZIndex(this.position.z);
-    this.zIndexFactor = this.position.z / container.zLayers;
-    this.sides = 24;
-    let effectDrawer = container.effectDrawers.get(this.effect);
-    if (!effectDrawer) {
-      effectDrawer = this._engine.getEffectDrawer(this.effect);
-      if (effectDrawer) {
-        container.effectDrawers.set(this.effect, effectDrawer);
-      }
-    }
-    if (effectDrawer == null ? void 0 : effectDrawer.loadEffect) {
-      effectDrawer.loadEffect(this);
-    }
-    let shapeDrawer = container.shapeDrawers.get(this.shape);
-    if (!shapeDrawer) {
-      shapeDrawer = this._engine.getShapeDrawer(this.shape);
-      if (shapeDrawer) {
-        container.shapeDrawers.set(this.shape, shapeDrawer);
-      }
-    }
-    if (shapeDrawer == null ? void 0 : shapeDrawer.loadShape) {
-      shapeDrawer.loadShape(this);
-    }
-    const sideCountFunc = shapeDrawer == null ? void 0 : shapeDrawer.getSidesCount;
-    if (sideCountFunc) {
-      this.sides = sideCountFunc(this);
-    }
-    this.spawning = false;
-    this.shadowColor = rangeColorToRgb(this._engine, this.options.shadow.color);
-    for (const updater of particles.updaters) {
-      updater.init(this);
-    }
-    for (const mover of particles.movers) {
-      (_c = mover.init) == null ? void 0 : _c.call(mover, this);
-    }
-    (_d = effectDrawer == null ? void 0 : effectDrawer.particleInit) == null ? void 0 : _d.call(effectDrawer, container, this);
-    (_e = shapeDrawer == null ? void 0 : shapeDrawer.particleInit) == null ? void 0 : _e.call(shapeDrawer, container, this);
-    for (const plugin of container.plugins.values()) {
-      (_f = plugin.particleCreated) == null ? void 0 : _f.call(plugin, this);
-    }
-  }
-  isInsideCanvas() {
-    const radius = this.getRadius(), canvasSize = this.container.canvas.size, position = this.position;
-    return position.x >= -radius && position.y >= -radius && position.y <= canvasSize.height + radius && position.x <= canvasSize.width + radius;
-  }
-  isVisible() {
-    return !this.destroyed && !this.spawning && this.isInsideCanvas();
-  }
-  reset() {
-    var _a;
-    for (const updater of this.container.particles.updaters) {
-      (_a = updater.reset) == null ? void 0 : _a.call(updater, this);
-    }
-  }
-}
-export {
-  Particle
-};