@tsparticles/engine 4.0.0-alpha.2 → 4.0.0-alpha.4

package/esm/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/esm/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/esm/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/{browser/Options/Classes/Interactivity/Events → esm/Options/Classes}/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/esm/Utils/CanvasUtils.js

@@ -1,4 +1,4 @@
-import { defaultTransform, identity, lFactor, minStrokeWidth, originPoint } from "../Core/Utils/Constants.js";
+import { lFactor, minStrokeWidth, originPoint } from "../Core/Utils/Constants.js";
 import { AlterType } from "../Enums/Types/AlterType.js";
 export function clearDrawPlugin(context, plugin, delta) {
     if (!plugin.clearDraw) {
@@ -28,15 +28,7 @@ export function clear(context, dimension) {
     context.clearRect(originPoint.x, originPoint.y, dimension.width, dimension.height);
 }
 export function drawParticle(data) {
-    const { container, context, particle, delta, colorStyles, radius, opacity, transform } = data, pos = particle.getPosition(), angle = particle.getAngle(), rotateData = {
-        sin: Math.sin(angle),
-        cos: Math.cos(angle),
-    }, rotating = particle.isRotating, transformData = {
-        a: rotateData.cos * (transform.a ?? defaultTransform.a),
-        b: rotating ? rotateData.sin * (transform.b ?? identity) : (transform.b ?? defaultTransform.b),
-        c: rotating ? -rotateData.sin * (transform.c ?? identity) : (transform.c ?? defaultTransform.c),
-        d: rotateData.cos * (transform.d ?? defaultTransform.d),
-    };
+    const { container, context, particle, delta, colorStyles, radius, opacity, transform } = data, pos = particle.getPosition(), transformData = particle.getTransformData(transform);
     context.setTransform(transformData.a, transformData.b, transformData.c, transformData.d, pos.x, pos.y);
     if (colorStyles.fill) {
         context.fillStyle = colorStyles.fill;
@@ -47,24 +39,25 @@ export function drawParticle(data) {
         context.strokeStyle = colorStyles.stroke;
     }
     const drawData = {
-        container,
         context,
         particle,
         radius,
         opacity,
         delta,
+        pixelRatio: container.retina.pixelRatio,
+        fill: particle.shapeFill,
+        stroke: strokeWidth > minStrokeWidth || !particle.shapeFill,
         transformData,
-        strokeWidth,
     };
-    drawBeforeEffect(drawData);
-    drawShapeBeforeDraw(drawData);
-    drawShape(drawData);
-    drawShapeAfterDraw(drawData);
-    drawAfterEffect(drawData);
+    drawBeforeEffect(container, drawData);
+    drawShapeBeforeDraw(container, drawData);
+    drawShape(container, drawData);
+    drawShapeAfterDraw(container, drawData);
+    drawAfterEffect(container, drawData);
     context.resetTransform();
 }
-export function drawAfterEffect(data) {
-    const { container, context, particle, radius, opacity, strokeWidth, delta, transformData } = data;
+export function drawAfterEffect(container, data) {
+    const { particle } = data;
     if (!particle.effect) {
         return;
     }
@@ -72,20 +65,10 @@ export function drawAfterEffect(data) {
     if (!drawFunc) {
         return;
     }
-    drawFunc({
-        context,
-        particle,
-        radius,
-        opacity,
-        delta,
-        pixelRatio: container.retina.pixelRatio,
-        fill: particle.shapeFill,
-        stroke: strokeWidth > minStrokeWidth || !particle.shapeFill,
-        transformData: { ...transformData },
-    });
+    drawFunc(data);
 }
-export function drawBeforeEffect(data) {
-    const { container, context, particle, radius, opacity, strokeWidth, delta, transformData } = data;
+export function drawBeforeEffect(container, data) {
+    const { particle } = data;
     if (!particle.effect) {
         return;
     }
@@ -93,20 +76,10 @@ export function drawBeforeEffect(data) {
     if (!drawer?.drawBefore) {
         return;
     }
-    drawer.drawBefore({
-        context,
-        particle,
-        radius,
-        opacity,
-        delta,
-        pixelRatio: container.retina.pixelRatio,
-        fill: particle.shapeFill,
-        stroke: strokeWidth > minStrokeWidth || !particle.shapeFill,
-        transformData: { ...transformData },
-    });
+    drawer.drawBefore(data);
 }
-export function drawShape(data) {
-    const { container, context, particle, radius, opacity, delta, strokeWidth, transformData } = data;
+export function drawShape(container, data) {
+    const { context, particle, stroke } = data;
     if (!particle.shape) {
         return;
     }
@@ -115,29 +88,19 @@ export function drawShape(data) {
         return;
     }
     context.beginPath();
-    drawer.draw({
-        context,
-        particle,
-        radius,
-        opacity,
-        delta,
-        pixelRatio: container.retina.pixelRatio,
-        fill: particle.shapeFill,
-        stroke: strokeWidth > minStrokeWidth || !particle.shapeFill,
-        transformData: { ...transformData },
-    });
+    drawer.draw(data);
     if (particle.shapeClose) {
         context.closePath();
     }
-    if (strokeWidth > minStrokeWidth) {
+    if (stroke) {
         context.stroke();
     }
     if (particle.shapeFill) {
         context.fill();
     }
 }
-export function drawShapeAfterDraw(data) {
-    const { container, context, particle, radius, opacity, strokeWidth, delta, transformData } = data;
+export function drawShapeAfterDraw(container, data) {
+    const { particle } = data;
     if (!particle.shape) {
         return;
     }
@@ -145,20 +108,10 @@ export function drawShapeAfterDraw(data) {
     if (!drawer?.afterDraw) {
         return;
     }
-    drawer.afterDraw({
-        context,
-        particle,
-        radius,
-        opacity,
-        delta,
-        pixelRatio: container.retina.pixelRatio,
-        fill: particle.shapeFill,
-        stroke: strokeWidth > minStrokeWidth || !particle.shapeFill,
-        transformData: { ...transformData },
-    });
+    drawer.afterDraw(data);
 }
-export function drawShapeBeforeDraw(data) {
-    const { container, context, particle, radius, opacity, strokeWidth, delta, transformData } = data;
+export function drawShapeBeforeDraw(container, data) {
+    const { particle } = data;
     if (!particle.shape) {
         return;
     }
@@ -166,17 +119,7 @@ export function drawShapeBeforeDraw(data) {
     if (!drawer?.beforeDraw) {
         return;
     }
-    drawer.beforeDraw({
-        context,
-        particle,
-        radius,
-        opacity,
-        delta,
-        pixelRatio: container.retina.pixelRatio,
-        fill: particle.shapeFill,
-        stroke: strokeWidth > minStrokeWidth || !particle.shapeFill,
-        transformData: { ...transformData },
-    });
+    drawer.beforeDraw(data);
 }
 export function drawPlugin(context, plugin, delta) {
     if (!plugin.draw) {

package/esm/Utils/ColorUtils.js

@@ -3,6 +3,19 @@ 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, firstIndex = 0, rgbFixedPrecision = 2, hslFixedPrecision = 2;
+function getCachedStyle(key, generator) {
+    let cached = styleCache.get(key);
+    if (!cached) {
+        cached = generator();
+        if (styleCache.size >= maxCacheSize) {
+            const keysToDelete = [...styleCache.keys()].slice(firstIndex, maxCacheSize * half);
+            keysToDelete.forEach(k => styleCache.delete(k));
+        }
+        styleCache.set(key, cached);
+    }
+    return cached;
+}
 function stringToRgba(engine, input) {
     if (!input) {
         return;
@@ -155,7 +168,8 @@ export function getRandomRgbColor(min) {
     };
 }
 export function getStyleFromRgb(color, hdr, opacity) {
-    return hdr ? getHdrStyleFromRgb(color, opacity) : getSdrStyleFromRgb(color, opacity);
+    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) {
     return `color(display-p3 ${(color.r / rgbMax).toString()} ${(color.g / rgbMax).toString()} ${(color.b / rgbMax).toString()} / ${(opacity ?? defaultOpacity).toString()})`;
@@ -164,7 +178,8 @@ function getSdrStyleFromRgb(color, opacity) {
     return `rgba(${color.r.toString()}, ${color.g.toString()}, ${color.b.toString()}, ${(opacity ?? defaultOpacity).toString()})`;
 }
 export function getStyleFromHsl(color, hdr, opacity) {
-    return hdr ? getHdrStyleFromHsl(color, opacity) : getSdrStyleFromHsl(color, opacity);
+    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) {
     return getHdrStyleFromRgb(hslToRgb(color), opacity);

package/esm/Utils/MathUtils.js

@@ -137,9 +137,10 @@ export function calcPositionOrRandomFromSizeRanged(data) {
     return calcPositionOrRandomFromSize({ size: data.size, position });
 }
 export function calcExactPositionOrRandomFromSize(data) {
+    const { position, size } = data;
     return {
-        x: data.position?.x ?? getRandom() * data.size.width,
-        y: data.position?.y ?? getRandom() * data.size.height,
+        x: position?.x ?? getRandom() * size.width,
+        y: position?.y ?? getRandom() * size.height,
     };
 }
 export function calcExactPositionOrRandomFromSizeRanged(data) {