@tsparticles/engine 4.0.0-alpha.1 → 4.0.0-alpha.14

package/umd/Core/Utils/EventListeners.js

@@ -4,329 +4,25 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./Constants.js", "../../Utils/Utils.js", "../../Enums/InteractivityDetect.js", "../../Utils/TypeUtils.js"], factory);
+        define(["require", "exports", "../../Utils/Utils.js", "./Constants.js"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.EventListeners = void 0;
-    const Constants_js_1 = require("./Constants.js");
     const Utils_js_1 = require("../../Utils/Utils.js");
-    const InteractivityDetect_js_1 = require("../../Enums/InteractivityDetect.js");
-    const TypeUtils_js_1 = require("../../Utils/TypeUtils.js");
-    function manageListener(element, event, handler, add, options) {
-        if (add) {
-            let addOptions = { passive: true };
-            if ((0, TypeUtils_js_1.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);
-        }
-    }
+    const Constants_js_1 = require("./Constants.js");
     class EventListeners {
+        container;
+        _handlers;
+        _resizeObserver;
+        _resizeTimeout;
         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;
-                    (0, Utils_js_1.executeOnSingleOrMultiple)(onClick.mode, mode => {
-                        this.container.handleClickMode(mode);
-                    });
-                }
-                if (e.type === "touchend") {
-                    setTimeout(() => {
-                        this._mouseTouchFinish();
-                    }, Constants_js_1.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;
-                }
-                if ((0, Utils_js_1.safeDocument)().hidden) {
-                    container.pageHidden = true;
-                    container.pause();
-                }
-                else {
-                    container.pageHidden = false;
-                    if (container.animationStatus) {
-                        container.play(true);
-                    }
-                    else {
-                        container.draw(true);
-                    }
-                }
-            };
-            this._handleWindowResize = () => {
-                if (this._resizeTimeout) {
-                    clearTimeout(this._resizeTimeout);
-                    delete this._resizeTimeout;
-                }
-                const handleResize = async () => {
-                    const canvas = this.container.canvas;
-                    await canvas.windowResize();
-                };
-                this._resizeTimeout = setTimeout(() => void handleResize(), this.container.actualOptions.interactivity.events.resize.delay * Constants_js_1.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, Constants_js_1.mouseMoveEvent, handlers.mouseMove, add);
-                manageListener(interactivityEl, Constants_js_1.touchStartEvent, handlers.touchStart, add);
-                manageListener(interactivityEl, Constants_js_1.touchMoveEvent, handlers.touchMove, add);
-                if (options.interactivity.events.onClick.enable) {
-                    manageListener(interactivityEl, Constants_js_1.touchEndEvent, handlers.touchEndClick, add);
-                    manageListener(interactivityEl, Constants_js_1.mouseUpEvent, handlers.mouseUp, add);
-                    manageListener(interactivityEl, Constants_js_1.mouseDownEvent, handlers.mouseDown, add);
-                }
-                else {
-                    manageListener(interactivityEl, Constants_js_1.touchEndEvent, handlers.touchEnd, add);
-                }
-                manageListener(interactivityEl, mouseLeaveTmpEvent, handlers.mouseLeave, add);
-                manageListener(interactivityEl, Constants_js_1.touchCancelEvent, handlers.touchCancel, add);
-            };
-            this._manageListeners = add => {
-                const handlers = this._handlers, container = this.container, options = container.actualOptions, detectType = options.interactivity.detectsOn, canvasEl = container.canvas.element;
-                let mouseLeaveTmpEvent = Constants_js_1.mouseLeaveEvent;
-                if (detectType === InteractivityDetect_js_1.InteractivityDetect.window) {
-                    container.interactivity.element = window;
-                    mouseLeaveTmpEvent = Constants_js_1.mouseOutEvent;
-                }
-                else if (detectType === InteractivityDetect_js_1.InteractivityDetect.parent && canvasEl) {
-                    container.interactivity.element = canvasEl.parentElement ?? canvasEl.parentNode;
-                }
-                else {
-                    container.interactivity.element = canvasEl;
-                }
-                this._manageMediaMatch(add);
-                this._manageResize(add);
-                this._manageInteractivityListeners(mouseLeaveTmpEvent, add);
-                manageListener(document, Constants_js_1.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) {
-                    return;
-                }
-                if (typeof ResizeObserver === "undefined") {
-                    manageListener(globalThis, Constants_js_1.resizeEvent, handlers.resize, add);
-                    return;
-                }
-                const canvasEl = container.canvas.element;
-                if (this._resizeObserver && !add) {
-                    if (canvasEl) {
-                        this._resizeObserver.unobserve(canvasEl);
-                    }
-                    this._resizeObserver.disconnect();
-                    delete this._resizeObserver;
-                }
-                else if (!this._resizeObserver && add && canvasEl) {
-                    this._resizeObserver = new ResizeObserver((entries) => {
-                        const entry = entries.find(e => e.target === canvasEl);
-                        if (!entry) {
-                            return;
-                        }
-                        this._handleWindowResize();
-                    });
-                    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 = Constants_js_1.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_js_1.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 + Constants_js_1.double * sourceRect.left - (targetRect.left + canvasRect.left),
-                                y: mouseEvent.offsetY + Constants_js_1.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 - Constants_js_1.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 = Constants_js_1.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 = (0, Utils_js_1.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();
                 },
@@ -338,6 +34,69 @@
         removeListeners() {
             this._manageListeners(false);
         }
+        _handleVisibilityChange = () => {
+            const container = this.container, options = container.actualOptions;
+            if (!options.pauseOnBlur) {
+                return;
+            }
+            if ((0, Utils_js_1.safeDocument)().hidden) {
+                container.pageHidden = true;
+                container.pause();
+            }
+            else {
+                container.pageHidden = false;
+                if (container.animationStatus) {
+                    container.play(true);
+                }
+                else {
+                    container.draw(true);
+                }
+            }
+        };
+        _handleWindowResize = () => {
+            if (this._resizeTimeout) {
+                clearTimeout(this._resizeTimeout);
+                delete this._resizeTimeout;
+            }
+            const handleResize = async () => {
+                const canvas = this.container.canvas;
+                await canvas.windowResize();
+            };
+            this._resizeTimeout = setTimeout(() => void handleResize(), this.container.actualOptions.resize.delay * Constants_js_1.millisecondsToSeconds);
+        };
+        _manageListeners = add => {
+            const handlers = this._handlers;
+            this._manageResize(add);
+            (0, Utils_js_1.manageListener)(document, Constants_js_1.visibilityChangeEvent, handlers.visibilityChange, add, false);
+        };
+        _manageResize = add => {
+            const handlers = this._handlers, container = this.container, options = container.actualOptions;
+            if (!options.resize.enable) {
+                return;
+            }
+            if (typeof ResizeObserver === "undefined") {
+                (0, Utils_js_1.manageListener)(globalThis, Constants_js_1.resizeEvent, handlers.resize, add);
+                return;
+            }
+            const canvasEl = container.canvas.element;
+            if (this._resizeObserver && !add) {
+                if (canvasEl) {
+                    this._resizeObserver.unobserve(canvasEl);
+                }
+                this._resizeObserver.disconnect();
+                delete this._resizeObserver;
+            }
+            else if (!this._resizeObserver && add && canvasEl) {
+                this._resizeObserver = new ResizeObserver((entries) => {
+                    const entry = entries.find(e => e.target === canvasEl);
+                    if (!entry) {
+                        return;
+                    }
+                    this._handleWindowResize();
+                });
+                this._resizeObserver.observe(canvasEl);
+            }
+        };
     }
     exports.EventListeners = EventListeners;
 });

package/umd/Core/Utils/Point.js

@@ -11,6 +11,8 @@
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.Point = void 0;
     class Point {
+        particle;
+        position;
         constructor(position, particle) {
             this.position = position;
             this.particle = particle;

package/umd/Core/Utils/QuadTree.js

@@ -14,17 +14,14 @@
     const Constants_js_1 = require("./Constants.js");
     const MathUtils_js_1 = require("../../Utils/MathUtils.js");
     class QuadTree {
+        rectangle;
+        capacity;
+        _divided;
+        _points;
+        _subs;
         constructor(rectangle, capacity) {
             this.rectangle = rectangle;
             this.capacity = capacity;
-            this._subdivide = () => {
-                const { x, y } = this.rectangle.position, { width, height } = this.rectangle.size, { capacity } = this;
-                for (let i = 0; i < Constants_js_1.subdivideCount; i++) {
-                    const fixedIndex = i % Constants_js_1.double;
-                    this._subs.push(new QuadTree(new Ranges_js_1.Rectangle(x + width * Constants_js_1.half * fixedIndex, y + height * Constants_js_1.half * (Math.round(i * Constants_js_1.half) - fixedIndex), width * Constants_js_1.half, height * Constants_js_1.half), capacity));
-                }
-                this._divided = true;
-            };
             this._points = [];
             this._divided = false;
             this._subs = [];
@@ -68,6 +65,14 @@
         queryRectangle(position, size, check) {
             return this.query(new Ranges_js_1.Rectangle(position.x, position.y, size.width, size.height), check);
         }
+        _subdivide = () => {
+            const { x, y } = this.rectangle.position, { width, height } = this.rectangle.size, { capacity } = this;
+            for (let i = 0; i < Constants_js_1.subdivideCount; i++) {
+                const fixedIndex = i % Constants_js_1.double;
+                this._subs.push(new QuadTree(new Ranges_js_1.Rectangle(x + width * Constants_js_1.half * fixedIndex, y + height * Constants_js_1.half * (Math.round(i * Constants_js_1.half) - fixedIndex), width * Constants_js_1.half, height * Constants_js_1.half), capacity));
+            }
+            this._divided = true;
+        };
     }
     exports.QuadTree = QuadTree;
 });

package/umd/Core/Utils/Ranges.js

@@ -14,6 +14,8 @@
     const MathUtils_js_1 = require("../../Utils/MathUtils.js");
     const Constants_js_1 = require("./Constants.js");
     class BaseRange {
+        position;
+        type;
         constructor(x, y, type) {
             this.position = {
                 x: x,
@@ -24,6 +26,7 @@
     }
     exports.BaseRange = BaseRange;
     class Circle extends BaseRange {
+        radius;
         constructor(x, y, radius) {
             super(x, y, RangeType_js_1.RangeType.circle);
             this.radius = radius;
@@ -49,6 +52,7 @@
     }
     exports.Circle = Circle;
     class Rectangle extends BaseRange {
+        size;
         constructor(x, y, width, height) {
             super(x, y, RangeType_js_1.RangeType.rectangle);
             this.size = {

package/umd/Core/Utils/Vectors.js

@@ -12,11 +12,10 @@
     exports.Vector = exports.Vector3d = void 0;
     const Constants_js_1 = require("./Constants.js");
     class Vector3d {
+        x;
+        y;
+        z;
         constructor(x = Constants_js_1.originPoint.x, y = Constants_js_1.originPoint.y, z = Constants_js_1.originPoint.z) {
-            this._updateFromAngle = (angle, length) => {
-                this.x = Math.cos(angle) * length;
-                this.y = Math.sin(angle) * length;
-            };
             this.x = x;
             this.y = y;
             this.z = z;
@@ -104,6 +103,10 @@
             this.y -= v.y;
             this.z -= v.z;
         }
+        _updateFromAngle = (angle, length) => {
+            this.x = Math.cos(angle) * length;
+            this.y = Math.sin(angle) * length;
+        };
     }
     exports.Vector3d = Vector3d;
     class Vector extends Vector3d {

package/umd/Enums/Types/EasingType.js

@@ -13,31 +13,46 @@
     var EasingType;
     (function (EasingType) {
         EasingType["easeInBack"] = "ease-in-back";
+        EasingType["easeInBounce"] = "ease-in-bounce";
         EasingType["easeInCirc"] = "ease-in-circ";
         EasingType["easeInCubic"] = "ease-in-cubic";
+        EasingType["easeInElastic"] = "ease-in-elastic";
+        EasingType["easeInExpo"] = "ease-in-expo";
+        EasingType["easeInGaussian"] = "ease-in-gaussian";
         EasingType["easeInLinear"] = "ease-in-linear";
         EasingType["easeInQuad"] = "ease-in-quad";
         EasingType["easeInQuart"] = "ease-in-quart";
         EasingType["easeInQuint"] = "ease-in-quint";
-        EasingType["easeInExpo"] = "ease-in-expo";
+        EasingType["easeInSigmoid"] = "ease-in-sigmoid";
         EasingType["easeInSine"] = "ease-in-sine";
+        EasingType["easeInSmoothstep"] = "ease-in-smoothstep";
         EasingType["easeOutBack"] = "ease-out-back";
+        EasingType["easeOutBounce"] = "ease-out-bounce";
         EasingType["easeOutCirc"] = "ease-out-circ";
         EasingType["easeOutCubic"] = "ease-out-cubic";
+        EasingType["easeOutElastic"] = "ease-out-elastic";
+        EasingType["easeOutExpo"] = "ease-out-expo";
+        EasingType["easeOutGaussian"] = "ease-out-gaussian";
         EasingType["easeOutLinear"] = "ease-out-linear";
         EasingType["easeOutQuad"] = "ease-out-quad";
         EasingType["easeOutQuart"] = "ease-out-quart";
         EasingType["easeOutQuint"] = "ease-out-quint";
-        EasingType["easeOutExpo"] = "ease-out-expo";
+        EasingType["easeOutSigmoid"] = "ease-out-sigmoid";
         EasingType["easeOutSine"] = "ease-out-sine";
+        EasingType["easeOutSmoothstep"] = "ease-out-smoothstep";
         EasingType["easeInOutBack"] = "ease-in-out-back";
+        EasingType["easeInOutBounce"] = "ease-in-out-bounce";
         EasingType["easeInOutCirc"] = "ease-in-out-circ";
         EasingType["easeInOutCubic"] = "ease-in-out-cubic";
+        EasingType["easeInOutElastic"] = "ease-in-out-elastic";
+        EasingType["easeInOutExpo"] = "ease-in-out-expo";
+        EasingType["easeInOutGaussian"] = "ease-in-out-gaussian";
         EasingType["easeInOutLinear"] = "ease-in-out-linear";
         EasingType["easeInOutQuad"] = "ease-in-out-quad";
         EasingType["easeInOutQuart"] = "ease-in-out-quart";
         EasingType["easeInOutQuint"] = "ease-in-out-quint";
-        EasingType["easeInOutExpo"] = "ease-in-out-expo";
+        EasingType["easeInOutSigmoid"] = "ease-in-out-sigmoid";
         EasingType["easeInOutSine"] = "ease-in-out-sine";
+        EasingType["easeInOutSmoothstep"] = "ease-in-out-smoothstep";
     })(EasingType || (exports.EasingType = EasingType = {}));
 });

package/umd/Options/Classes/AnimatableColor.js

@@ -14,6 +14,7 @@
     const HslAnimation_js_1 = require("./HslAnimation.js");
     const OptionsColor_js_1 = require("./OptionsColor.js");
     class AnimatableColor extends OptionsColor_js_1.OptionsColor {
+        animation;
         constructor() {
             super();
             this.animation = new HslAnimation_js_1.HslAnimation();

package/umd/Options/Classes/AnimationOptions.js

@@ -15,6 +15,12 @@
     const TypeUtils_js_1 = require("../../Utils/TypeUtils.js");
     const MathUtils_js_1 = require("../../Utils/MathUtils.js");
     class AnimationOptions {
+        count;
+        decay;
+        delay;
+        enable;
+        speed;
+        sync;
         constructor() {
             this.count = 0;
             this.enable = false;
@@ -49,6 +55,8 @@
     }
     exports.AnimationOptions = AnimationOptions;
     class RangedAnimationOptions extends AnimationOptions {
+        mode;
+        startValue;
         constructor() {
             super();
             this.mode = AnimationMode_js_1.AnimationMode.auto;

package/umd/Options/Classes/Background/Background.js

@@ -13,6 +13,12 @@
     const OptionsColor_js_1 = require("../OptionsColor.js");
     const TypeUtils_js_1 = require("../../../Utils/TypeUtils.js");
     class Background {
+        color;
+        image;
+        opacity;
+        position;
+        repeat;
+        size;
         constructor() {
             this.color = new OptionsColor_js_1.OptionsColor();
             this.color.value = "";

package/umd/Options/Classes/ColorAnimation.js

@@ -14,6 +14,7 @@
     const TypeUtils_js_1 = require("../../Utils/TypeUtils.js");
     const MathUtils_js_1 = require("../../Utils/MathUtils.js");
     class ColorAnimation extends AnimationOptions_js_1.AnimationOptions {
+        offset;
         constructor() {
             super();
             this.offset = 0;

package/umd/Options/Classes/FullScreen/FullScreen.js

@@ -12,6 +12,8 @@
     exports.FullScreen = void 0;
     const TypeUtils_js_1 = require("../../../Utils/TypeUtils.js");
     class FullScreen {
+        enable;
+        zIndex;
         constructor() {
             this.enable = true;
             this.zIndex = 0;

package/umd/Options/Classes/HslAnimation.js

@@ -13,11 +13,9 @@
     const ColorAnimation_js_1 = require("./ColorAnimation.js");
     const TypeUtils_js_1 = require("../../Utils/TypeUtils.js");
     class HslAnimation {
-        constructor() {
-            this.h = new ColorAnimation_js_1.ColorAnimation();
-            this.s = new ColorAnimation_js_1.ColorAnimation();
-            this.l = new ColorAnimation_js_1.ColorAnimation();
-        }
+        h = new ColorAnimation_js_1.ColorAnimation();
+        l = new ColorAnimation_js_1.ColorAnimation();
+        s = new ColorAnimation_js_1.ColorAnimation();
         load(data) {
             if ((0, TypeUtils_js_1.isNull)(data)) {
                 return;