dune-react 0.0.1

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

@@ -0,0 +1,293 @@
+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

@@ -0,0 +1,355 @@
+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
+};