@tsparticles/engine 4.0.0-alpha.3 → 4.0.0-alpha.5

package/cjs/Core/Utils/EventListeners.js

@@ -1,56 +1,10 @@
-import { double, lengthOffset, millisecondsToSeconds, mouseDownEvent, mouseLeaveEvent, mouseMoveEvent, mouseOutEvent, mouseUpEvent, resizeEvent, touchCancelEvent, touchDelay, touchEndEvent, touchMoveEvent, touchStartEvent, visibilityChangeEvent, } from "./Constants.js";
-import { executeOnSingleOrMultiple, safeDocument, 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 !== undefined) {
-            addOptions = options;
-        }
-        element.addEventListener(event, handler, addOptions);
-    }
-    else {
-        const removeOptions = options;
-        element.removeEventListener(event, handler, removeOptions);
-    }
-}
+import { manageListener, safeDocument } from "../../Utils/Utils.js";
+import { millisecondsToSeconds, resizeEvent, visibilityChangeEvent } from "./Constants.js";
 export class EventListeners {
     constructor(container) {
         this.container = container;
-        this._canPush = true;
-        this._doMouseTouchClick = e => {
-            const container = this.container, options = container.actualOptions;
-            if (this._canPush) {
-                const mouseInteractivity = container.interactivity.mouse, mousePos = mouseInteractivity.position;
-                if (!mousePos) {
-                    return;
-                }
-                mouseInteractivity.clickPosition = { ...mousePos };
-                mouseInteractivity.clickTime = Date.now();
-                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, container = this.container, options = container.options, defaultThemes = options.defaultThemes, themeName = mediaEvent.matches ? defaultThemes.dark : defaultThemes.light, theme = options.themes.find(theme => theme.name === themeName);
-            if (theme?.default.auto) {
-                void container.loadTheme(themeName);
-            }
-        };
         this._handleVisibilityChange = () => {
             const container = this.container, options = container.actualOptions;
-            this._mouseTouchFinish();
             if (!options.pauseOnBlur) {
                 return;
             }
@@ -77,60 +31,16 @@ export class EventListeners {
                 const canvas = this.container.canvas;
                 await canvas.windowResize();
             };
-            this._resizeTimeout = setTimeout(() => void handleResize(), this.container.actualOptions.interactivity.events.resize.delay * millisecondsToSeconds);
-        };
-        this._manageInteractivityListeners = (mouseLeaveTmpEvent, add) => {
-            const handlers = this._handlers, container = this.container, options = container.actualOptions, interactivityEl = container.interactivity.element;
-            if (!interactivityEl) {
-                return;
-            }
-            const html = interactivityEl, canvas = container.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.touchEndClick, add);
-                manageListener(interactivityEl, mouseUpEvent, handlers.mouseUp, add);
-                manageListener(interactivityEl, mouseDownEvent, handlers.mouseDown, add);
-            }
-            else {
-                manageListener(interactivityEl, touchEndEvent, handlers.touchEnd, add);
-            }
-            manageListener(interactivityEl, mouseLeaveTmpEvent, handlers.mouseLeave, add);
-            manageListener(interactivityEl, touchCancelEvent, handlers.touchCancel, add);
+            this._resizeTimeout = setTimeout(() => void handleResize(), this.container.actualOptions.resize.delay * millisecondsToSeconds);
         };
         this._manageListeners = add => {
-            const handlers = this._handlers, container = this.container, options = container.actualOptions, detectType = options.interactivity.detectsOn, canvasEl = container.canvas.element;
-            let mouseLeaveTmpEvent = mouseLeaveEvent;
-            if (detectType === InteractivityDetect.window) {
-                container.interactivity.element = window;
-                mouseLeaveTmpEvent = mouseOutEvent;
-            }
-            else if (detectType === InteractivityDetect.parent && canvasEl) {
-                container.interactivity.element = canvasEl.parentElement ?? canvasEl.parentNode;
-            }
-            else {
-                container.interactivity.element = canvasEl;
-            }
-            this._manageMediaMatch(add);
+            const handlers = this._handlers;
             this._manageResize(add);
-            this._manageInteractivityListeners(mouseLeaveTmpEvent, add);
             manageListener(document, visibilityChangeEvent, handlers.visibilityChange, add, false);
         };
-        this._manageMediaMatch = add => {
-            const handlers = this._handlers;
-            if (!this._matchMedia) {
-                return;
-            }
-            manageListener(this._matchMedia, "change", handlers.themeChange, add);
-        };
         this._manageResize = add => {
             const handlers = this._handlers, container = this.container, options = container.actualOptions;
-            if (!options.interactivity.events.resize.enable) {
+            if (!options.resize.enable) {
                 return;
             }
             if (typeof ResizeObserver === "undefined") {
@@ -156,165 +66,10 @@ export class EventListeners {
                 this._resizeObserver.observe(canvasEl);
             }
         };
-        this._mouseDown = () => {
-            const { interactivity } = this.container, { mouse } = interactivity;
-            mouse.clicking = true;
-            mouse.downPosition = mouse.position;
-        };
-        this._mouseTouchClick = e => {
-            const container = this.container, options = container.actualOptions, { mouse } = container.interactivity;
-            mouse.inside = true;
-            let handled = false;
-            const mousePosition = mouse.position;
-            if (!mousePosition || !options.interactivity.events.onClick.enable) {
-                return;
-            }
-            for (const plugin of container.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, { mouse } = interactivity;
-            delete mouse.position;
-            delete mouse.clickPosition;
-            delete mouse.downPosition;
-            interactivity.status = mouseLeaveEvent;
-            mouse.inside = false;
-            mouse.clicking = false;
-        };
-        this._mouseTouchMove = e => {
-            const container = this.container, options = container.actualOptions, interactivity = container.interactivity, canvasEl = container.canvas.element;
-            if (!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 (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,
-                            y: mouseEvent.offsetY,
-                        };
-                    }
-                }
-                else if (mouseEvent.target === canvasEl) {
-                    pos = {
-                        x: mouseEvent.offsetX,
-                        y: mouseEvent.offsetY,
-                    };
-                }
-            }
-            else {
-                this._canPush = e.type !== "touchmove";
-                if (canvasEl) {
-                    const touchEvent = e, lastTouch = touchEvent.touches[touchEvent.touches.length - lengthOffset], canvasRect = canvasEl.getBoundingClientRect();
-                    if (!lastTouch) {
-                        return;
-                    }
-                    pos = {
-                        x: lastTouch.clientX - canvasRect.left,
-                        y: lastTouch.clientY - canvasRect.top,
-                    };
-                }
-            }
-            const pxRatio = container.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._matchMedia = safeMatchMedia("(prefers-color-scheme: dark)");
-        this._touches = 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();
             },

package/cjs/Options/Classes/Options.js

@@ -1,21 +1,12 @@
-import { deepExtend, executeOnSingleOrMultiple, safeMatchMedia } from "../../Utils/Utils.js";
+import { deepExtend, executeOnSingleOrMultiple } from "../../Utils/Utils.js";
 import { isBoolean, isNull } from "../../Utils/TypeUtils.js";
 import { Background } from "./Background/Background.js";
 import { FullScreen } from "./FullScreen/FullScreen.js";
-import { Interactivity } from "./Interactivity/Interactivity.js";
-import { ManualParticle } from "./ManualParticle.js";
-import { Responsive } from "./Responsive.js";
-import { ResponsiveMode } from "../../Enums/Modes/ResponsiveMode.js";
-import { Theme } from "./Theme/Theme.js";
-import { ThemeMode } from "../../Enums/Modes/ThemeMode.js";
+import { ResizeEvent } from "./ResizeEvent.js";
 import { loadParticlesOptions } from "../../Utils/OptionsUtils.js";
 import { setRangeValue } from "../../Utils/MathUtils.js";
 export class Options {
     constructor(engine, container) {
-        this._findDefaultTheme = mode => {
-            return (this.themes.find(theme => theme.default.value && theme.default.mode === mode) ??
-                this.themes.find(theme => theme.default.value && theme.default.mode === ThemeMode.any));
-        };
         this._importPreset = preset => {
             this.load(this._engine.getPreset(preset));
         };
@@ -31,15 +22,12 @@ export class Options {
         this.duration = 0;
         this.fpsLimit = 120;
         this.hdr = true;
-        this.interactivity = new Interactivity(engine, container);
-        this.manualParticles = [];
         this.particles = loadParticlesOptions(this._engine, this._container);
         this.pauseOnBlur = true;
         this.pauseOnOutsideViewport = true;
-        this.responsive = [];
+        this.resize = new ResizeEvent();
         this.smooth = false;
         this.style = {};
-        this.themes = [];
         this.zLayers = 100;
     }
     load(data) {
@@ -97,70 +85,14 @@ export class Options {
         else {
             this.fullScreen.load(fullScreen);
         }
-        this.interactivity.load(data.interactivity);
-        if (data.manualParticles) {
-            this.manualParticles = data.manualParticles.map(t => {
-                const tmp = new ManualParticle();
-                tmp.load(t);
-                return tmp;
-            });
-        }
         this.particles.load(data.particles);
+        this.resize.load(data.resize);
         this.style = deepExtend(this.style, data.style);
-        this._engine.loadOptions(this, data);
         if (data.smooth !== undefined) {
             this.smooth = data.smooth;
         }
-        const interactors = this._engine.interactors.get(this._container);
-        if (interactors) {
-            for (const interactor of interactors) {
-                if (interactor.loadOptions) {
-                    interactor.loadOptions(this, data);
-                }
-            }
-        }
-        if (data.responsive !== undefined) {
-            for (const responsive of data.responsive) {
-                const optResponsive = new Responsive();
-                optResponsive.load(responsive);
-                this.responsive.push(optResponsive);
-            }
-        }
-        this.responsive.sort((a, b) => a.maxWidth - b.maxWidth);
-        if (data.themes !== undefined) {
-            for (const theme of data.themes) {
-                const existingTheme = this.themes.find(t => t.name === theme.name);
-                if (existingTheme) {
-                    existingTheme.load(theme);
-                }
-                else {
-                    const optTheme = new Theme();
-                    optTheme.load(theme);
-                    this.themes.push(optTheme);
-                }
-            }
-        }
-        this.defaultThemes.dark = this._findDefaultTheme(ThemeMode.dark)?.name;
-        this.defaultThemes.light = this._findDefaultTheme(ThemeMode.light)?.name;
-    }
-    setResponsive(width, pxRatio, defaultOptions) {
-        this.load(defaultOptions);
-        const responsiveOptions = this.responsive.find(t => t.mode === ResponsiveMode.screen ? t.maxWidth > screen.availWidth : t.maxWidth * pxRatio > width);
-        this.load(responsiveOptions?.options);
-        return responsiveOptions?.maxWidth;
-    }
-    setTheme(name) {
-        if (name) {
-            const chosenTheme = this.themes.find(theme => theme.name === name);
-            if (chosenTheme) {
-                this.load(chosenTheme.options);
-            }
-        }
-        else {
-            const mediaMatch = safeMatchMedia("(prefers-color-scheme: dark)"), clientDarkMode = mediaMatch?.matches, defaultTheme = this._findDefaultTheme(clientDarkMode ? ThemeMode.dark : ThemeMode.light);
-            if (defaultTheme) {
-                this.load(defaultTheme.options);
-            }
-        }
+        this._engine.plugins.forEach(plugin => {
+            plugin.loadOptions(this._container, this, data);
+        });
     }
 }

package/cjs/Options/Classes/Particles/ParticlesOptions.js

@@ -55,9 +55,6 @@ export class ParticlesOptions {
         this.shape.load(data.shape);
         this.size.load(data.size);
         this.zIndex.load(data.zIndex);
-        if (data.interactivity !== undefined) {
-            this.interactivity = deepExtend({}, data.interactivity);
-        }
         const strokeToLoad = data.stroke;
         if (strokeToLoad) {
             this.stroke = executeOnSingleOrMultiple(strokeToLoad, t => {
@@ -67,6 +64,11 @@ export class ParticlesOptions {
             });
         }
         if (this._container) {
+            for (const plugin of this._engine.plugins) {
+                if (plugin.loadParticlesOptions) {
+                    plugin.loadParticlesOptions(this._container, this, data);
+                }
+            }
             const updaters = this._engine.updaters.get(this._container);
             if (updaters) {
                 for (const updater of updaters) {
@@ -75,14 +77,6 @@ export class ParticlesOptions {
                     }
                 }
             }
-            const interactors = this._engine.interactors.get(this._container);
-            if (interactors) {
-                for (const interactor of interactors) {
-                    if (interactor.loadParticlesOptions) {
-                        interactor.loadParticlesOptions(this, data);
-                    }
-                }
-            }
         }
     }
 }

package/cjs/Options/Classes/{Interactivity/Events/ResizeEvent.js → ResizeEvent.js}

@@ -1,4 +1,4 @@
-import { isNull } from "../../../../Utils/TypeUtils.js";
+import { isNull } from "../../Utils/TypeUtils.js";
 export class ResizeEvent {
     constructor() {
         this.delay = 0.5;

package/cjs/Utils/ColorUtils.js

@@ -3,14 +3,16 @@ import { decayOffset, defaultLoops, defaultOpacity, defaultRgbMin, defaultTime,
 import { isArray, isString } from "./TypeUtils.js";
 import { AnimationStatus } from "../Enums/AnimationStatus.js";
 import { itemFromArray } from "./Utils.js";
-const styleCache = new Map(), maxCacheSize = 1000;
+const styleCache = new Map(), maxCacheSize = 1000, firstIndex = 0, rgbFixedPrecision = 2, hslFixedPrecision = 2;
 function getCachedStyle(key, generator) {
     let cached = styleCache.get(key);
     if (!cached) {
         cached = generator();
-        if (styleCache.size < maxCacheSize) {
-            styleCache.set(key, cached);
+        if (styleCache.size >= maxCacheSize) {
+            const keysToDelete = [...styleCache.keys()].slice(firstIndex, maxCacheSize * half);
+            keysToDelete.forEach(k => styleCache.delete(k));
         }
+        styleCache.set(key, cached);
     }
     return cached;
 }
@@ -166,7 +168,7 @@ export function getRandomRgbColor(min) {
     };
 }
 export function getStyleFromRgb(color, hdr, opacity) {
-    const op = opacity ?? defaultOpacity, key = `rgb-${color.r.toString()}-${color.g.toString()}-${color.b.toString()}-${hdr ? "hdr" : "sdr"}-${op.toString()}`;
+    const op = opacity ?? defaultOpacity, key = `rgb-${color.r.toFixed(rgbFixedPrecision)}-${color.g.toFixed(rgbFixedPrecision)}-${color.b.toFixed(rgbFixedPrecision)}-${hdr ? "hdr" : "sdr"}-${op.toString()}`;
     return getCachedStyle(key, () => (hdr ? getHdrStyleFromRgb(color, opacity) : getSdrStyleFromRgb(color, opacity)));
 }
 function getHdrStyleFromRgb(color, opacity) {
@@ -176,7 +178,7 @@ function getSdrStyleFromRgb(color, opacity) {
     return `rgba(${color.r.toString()}, ${color.g.toString()}, ${color.b.toString()}, ${(opacity ?? defaultOpacity).toString()})`;
 }
 export function getStyleFromHsl(color, hdr, opacity) {
-    const op = opacity ?? defaultOpacity, key = `hsl-${color.h.toString()}-${color.s.toString()}-${color.l.toString()}-${hdr ? "hdr" : "sdr"}-${op.toString()}`;
+    const op = opacity ?? defaultOpacity, key = `hsl-${color.h.toFixed(hslFixedPrecision)}-${color.s.toFixed(hslFixedPrecision)}-${color.l.toFixed(hslFixedPrecision)}-${hdr ? "hdr" : "sdr"}-${op.toString()}`;
     return getCachedStyle(key, () => (hdr ? getHdrStyleFromHsl(color, opacity) : getSdrStyleFromHsl(color, opacity)));
 }
 function getHdrStyleFromHsl(color, opacity) {

package/cjs/Utils/Utils.js

@@ -1,6 +1,6 @@
 import { clamp, collisionVelocity, getDistances, getRandom, getRangeMax, getRangeMin, getRangeValue, randomInRangeValue, } from "./MathUtils.js";
 import { half, millisecondsToSeconds, percentDenominator } from "../Core/Utils/Constants.js";
-import { isArray, isNull, isObject } from "./TypeUtils.js";
+import { isArray, isBoolean, 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";
@@ -21,12 +21,6 @@ function memoize(fn) {
         return result;
     };
 }
-function checkSelector(element, selectors) {
-    const res = executeOnSingleOrMultiple(selectors, selector => {
-        return element.matches(selector);
-    });
-    return isArray(res) ? res.some(t => t) : res;
-}
 export function hasMatchMedia() {
     return typeof matchMedia !== "undefined";
 }
@@ -104,11 +98,15 @@ export function deepExtend(destination, ...sources) {
             continue;
         }
         const sourceIsArray = Array.isArray(source);
-        if (sourceIsArray && (isObject(destination) || !destination || !Array.isArray(destination))) {
-            destination = [];
+        if (sourceIsArray) {
+            if (!Array.isArray(destination)) {
+                destination = [];
+            }
         }
-        else if (!sourceIsArray && (isObject(destination) || !destination || Array.isArray(destination))) {
-            destination = {};
+        else {
+            if (!isObject(destination) || Array.isArray(destination)) {
+                destination = {};
+            }
         }
         for (const key in source) {
             if (key === "__proto__") {
@@ -123,31 +121,6 @@ export function deepExtend(destination, ...sources) {
     }
     return destination;
 }
-export function isDivModeEnabled(mode, divs) {
-    return !!findItemFromSingleOrMultiple(divs, t => t.enable && isInArray(mode, t.mode));
-}
-export function divModeExecute(mode, divs, callback) {
-    executeOnSingleOrMultiple(divs, div => {
-        const divMode = div.mode, divEnabled = div.enable;
-        if (divEnabled && isInArray(mode, divMode)) {
-            singleDivModeExecute(div, callback);
-        }
-    });
-}
-export function singleDivModeExecute(div, callback) {
-    const selectors = div.selectors;
-    executeOnSingleOrMultiple(selectors, selector => {
-        callback(selector, div);
-    });
-}
-export function divMode(divs, element) {
-    if (!element || !divs) {
-        return;
-    }
-    return findItemFromSingleOrMultiple(divs, div => {
-        return checkSelector(element, div.selectors);
-    });
-}
 export function circleBounceDataFromParticle(p) {
     return {
         position: p.getPosition(),
@@ -368,3 +341,27 @@ function computeFullScreenStyle(zIndex) {
     return fullScreenStyle;
 }
 export const getFullScreenStyle = memoize(computeFullScreenStyle);
+export function manageListener(element, event, handler, add, options) {
+    if (add) {
+        let addOptions = { passive: true };
+        if (isBoolean(options)) {
+            addOptions.capture = options;
+        }
+        else if (options !== undefined) {
+            addOptions = options;
+        }
+        element.addEventListener(event, handler, addOptions);
+    }
+    else {
+        const removeOptions = options;
+        element.removeEventListener(event, handler, removeOptions);
+    }
+}
+export 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;
+}

package/cjs/exports.js

@@ -1,6 +1,4 @@
 export * from "./Core/Utils/Constants.js";
-export * from "./Core/Utils/ExternalInteractorBase.js";
-export * from "./Core/Utils/ParticlesInteractorBase.js";
 export * from "./Core/Utils/Point.js";
 export * from "./Core/Utils/Ranges.js";
 export * from "./Core/Utils/Vectors.js";
@@ -11,36 +9,20 @@ export * from "./Enums/Modes/AnimationMode.js";
 export * from "./Enums/Modes/LimitMode.js";
 export * from "./Enums/Modes/OutMode.js";
 export * from "./Enums/Modes/PixelMode.js";
-export * from "./Enums/Modes/ThemeMode.js";
-export * from "./Enums/Modes/ResponsiveMode.js";
 export * from "./Enums/Types/AlterType.js";
 export * from "./Enums/Types/DestroyType.js";
 export * from "./Enums/Types/GradientType.js";
-export * from "./Enums/Types/InteractorType.js";
 export * from "./Enums/Types/ParticleOutType.js";
 export * from "./Enums/Types/StartValueType.js";
-export * from "./Enums/Types/DivType.js";
 export * from "./Enums/Types/EasingType.js";
 export * from "./Enums/Types/EventType.js";
 export * from "./Enums/AnimationStatus.js";
-export * from "./Enums/InteractivityDetect.js";
 export * from "./Options/Classes/AnimatableColor.js";
 export * from "./Options/Classes/AnimationOptions.js";
 export * from "./Options/Classes/Background/Background.js";
 export * from "./Options/Classes/ColorAnimation.js";
 export * from "./Options/Classes/FullScreen/FullScreen.js";
 export * from "./Options/Classes/HslAnimation.js";
-export * from "./Options/Classes/Interactivity/Events/ClickEvent.js";
-export * from "./Options/Classes/Interactivity/Events/DivEvent.js";
-export * from "./Options/Classes/Interactivity/Events/ClickEvent.js";
-export * from "./Options/Classes/Interactivity/Events/DivEvent.js";
-export * from "./Options/Classes/Interactivity/Events/Events.js";
-export * from "./Options/Classes/Interactivity/Events/HoverEvent.js";
-export * from "./Options/Classes/Interactivity/Events/Parallax.js";
-export * from "./Options/Classes/Interactivity/Events/ResizeEvent.js";
-export * from "./Options/Classes/Interactivity/Interactivity.js";
-export * from "./Options/Classes/Interactivity/Modes/Modes.js";
-export * from "./Options/Classes/ManualParticle.js";
 export * from "./Options/Classes/Options.js";
 export * from "./Options/Classes/OptionsColor.js";
 export * from "./Options/Classes/Particles/Bounce/ParticlesBounce.js";
@@ -64,9 +46,7 @@ export * from "./Options/Classes/Particles/Shape/Shape.js";
 export * from "./Options/Classes/Particles/Size/Size.js";
 export * from "./Options/Classes/Particles/Size/SizeAnimation.js";
 export * from "./Options/Classes/Particles/ZIndex/ZIndex.js";
-export * from "./Options/Classes/Responsive.js";
-export * from "./Options/Classes/Theme/Theme.js";
-export * from "./Options/Classes/Theme/ThemeDefault.js";
+export * from "./Options/Classes/ResizeEvent.js";
 export * from "./Options/Classes/ValueWithRandom.js";
 export * from "./Utils/CanvasUtils.js";
 export * from "./Utils/ColorUtils.js";