tsparticles 1.40.2 → 1.41.3

package/umd/Options/Classes/HslAnimation.d.ts

@@ -0,0 +1,11 @@
+import { ColorAnimation } from "./ColorAnimation";
+import type { IHslAnimation } from "../Interfaces/IHslAnimation";
+import type { IOptionLoader } from "../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../Types";
+export declare class HslAnimation implements IHslAnimation, IOptionLoader<IHslAnimation> {
+    h: ColorAnimation;
+    s: ColorAnimation;
+    l: ColorAnimation;
+    constructor();
+    load(data?: RecursivePartial<IHslAnimation>): void;
+}

package/umd/Options/Classes/HslAnimation.js

@@ -0,0 +1,30 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./ColorAnimation"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.HslAnimation = void 0;
+    const ColorAnimation_1 = require("./ColorAnimation");
+    class HslAnimation {
+        constructor() {
+            this.h = new ColorAnimation_1.ColorAnimation();
+            this.s = new ColorAnimation_1.ColorAnimation();
+            this.l = new ColorAnimation_1.ColorAnimation();
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            this.h.load(data.h);
+            this.s.load(data.s);
+            this.l.load(data.l);
+        }
+    }
+    exports.HslAnimation = HslAnimation;
+});

package/umd/Options/Classes/Interactivity/Events/ClickEvent.d.ts

@@ -0,0 +1,10 @@
+import type { RecursivePartial, SingleOrMultiple } from "../../../../Types";
+import { ClickMode } from "../../../../Enums";
+import type { IClickEvent } from "../../../Interfaces/Interactivity/Events/IClickEvent";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+export declare class ClickEvent implements IClickEvent, IOptionLoader<IClickEvent> {
+    enable: boolean;
+    mode: SingleOrMultiple<ClickMode | keyof typeof ClickMode | string>;
+    constructor();
+    load(data?: RecursivePartial<IClickEvent>): void;
+}

package/umd/Options/Classes/Interactivity/Events/ClickEvent.js

@@ -0,0 +1,31 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ClickEvent = void 0;
+    class ClickEvent {
+        constructor() {
+            this.enable = false;
+            this.mode = [];
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            if (data.mode !== undefined) {
+                this.mode = data.mode;
+            }
+        }
+    }
+    exports.ClickEvent = ClickEvent;
+});

package/umd/Options/Classes/Interactivity/Events/DivEvent.d.ts

@@ -0,0 +1,18 @@
+import { DivMode, DivType } from "../../../../Enums";
+import type { RecursivePartial, SingleOrMultiple } from "../../../../Types";
+import type { IDivEvent } from "../../../Interfaces/Interactivity/Events/IDivEvent";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+export declare class DivEvent implements IDivEvent, IOptionLoader<IDivEvent> {
+    get elementId(): SingleOrMultiple<string>;
+    set elementId(value: SingleOrMultiple<string>);
+    get el(): SingleOrMultiple<string>;
+    set el(value: SingleOrMultiple<string>);
+    get ids(): SingleOrMultiple<string>;
+    set ids(value: SingleOrMultiple<string>);
+    selectors: SingleOrMultiple<string>;
+    enable: boolean;
+    mode: SingleOrMultiple<DivMode | keyof typeof DivMode | string>;
+    type: DivType;
+    constructor();
+    load(data?: RecursivePartial<IDivEvent>): void;
+}

package/umd/Options/Classes/Interactivity/Events/DivEvent.js

@@ -0,0 +1,64 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DivEvent = void 0;
+    class DivEvent {
+        constructor() {
+            this.selectors = [];
+            this.enable = false;
+            this.mode = [];
+            this.type = "circle";
+        }
+        get elementId() {
+            return this.ids;
+        }
+        set elementId(value) {
+            this.ids = value;
+        }
+        get el() {
+            return this.elementId;
+        }
+        set el(value) {
+            this.elementId = value;
+        }
+        get ids() {
+            return this.selectors instanceof Array
+                ? this.selectors.map((t) => t.replace("#", ""))
+                : this.selectors.replace("#", "");
+        }
+        set ids(value) {
+            this.selectors = value instanceof Array ? value.map((t) => `#${t}`) : `#${value}`;
+        }
+        load(data) {
+            var _a, _b;
+            if (data === undefined) {
+                return;
+            }
+            const ids = (_b = (_a = data.ids) !== null && _a !== void 0 ? _a : data.elementId) !== null && _b !== void 0 ? _b : data.el;
+            if (ids !== undefined) {
+                this.ids = ids;
+            }
+            if (data.selectors !== undefined) {
+                this.selectors = data.selectors;
+            }
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            if (data.mode !== undefined) {
+                this.mode = data.mode;
+            }
+            if (data.type !== undefined) {
+                this.type = data.type;
+            }
+        }
+    }
+    exports.DivEvent = DivEvent;
+});

package/umd/Options/Classes/Interactivity/Events/Events.d.ts

@@ -0,0 +1,20 @@
+import type { RecursivePartial, SingleOrMultiple } from "../../../../Types";
+import { ClickEvent } from "./ClickEvent";
+import { DivEvent } from "./DivEvent";
+import { HoverEvent } from "./HoverEvent";
+import type { IEvents } from "../../../Interfaces/Interactivity/Events/IEvents";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+export declare class Events implements IEvents, IOptionLoader<IEvents> {
+    get onclick(): ClickEvent;
+    set onclick(value: ClickEvent);
+    get ondiv(): SingleOrMultiple<DivEvent>;
+    set ondiv(value: SingleOrMultiple<DivEvent>);
+    get onhover(): HoverEvent;
+    set onhover(value: HoverEvent);
+    onClick: ClickEvent;
+    onDiv: SingleOrMultiple<DivEvent>;
+    onHover: HoverEvent;
+    resize: boolean;
+    constructor();
+    load(data?: RecursivePartial<IEvents>): void;
+}

package/umd/Options/Classes/Interactivity/Events/Events.js

@@ -0,0 +1,68 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./ClickEvent", "./DivEvent", "./HoverEvent"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Events = void 0;
+    const ClickEvent_1 = require("./ClickEvent");
+    const DivEvent_1 = require("./DivEvent");
+    const HoverEvent_1 = require("./HoverEvent");
+    class Events {
+        constructor() {
+            this.onClick = new ClickEvent_1.ClickEvent();
+            this.onDiv = new DivEvent_1.DivEvent();
+            this.onHover = new HoverEvent_1.HoverEvent();
+            this.resize = true;
+        }
+        get onclick() {
+            return this.onClick;
+        }
+        set onclick(value) {
+            this.onClick = value;
+        }
+        get ondiv() {
+            return this.onDiv;
+        }
+        set ondiv(value) {
+            this.onDiv = value;
+        }
+        get onhover() {
+            return this.onHover;
+        }
+        set onhover(value) {
+            this.onHover = value;
+        }
+        load(data) {
+            var _a, _b, _c;
+            if (data === undefined) {
+                return;
+            }
+            this.onClick.load((_a = data.onClick) !== null && _a !== void 0 ? _a : data.onclick);
+            const onDiv = (_b = data.onDiv) !== null && _b !== void 0 ? _b : data.ondiv;
+            if (onDiv !== undefined) {
+                if (onDiv instanceof Array) {
+                    this.onDiv = onDiv.map((div) => {
+                        const tmp = new DivEvent_1.DivEvent();
+                        tmp.load(div);
+                        return tmp;
+                    });
+                }
+                else {
+                    this.onDiv = new DivEvent_1.DivEvent();
+                    this.onDiv.load(onDiv);
+                }
+            }
+            this.onHover.load((_c = data.onHover) !== null && _c !== void 0 ? _c : data.onhover);
+            if (data.resize !== undefined) {
+                this.resize = data.resize;
+            }
+        }
+    }
+    exports.Events = Events;
+});

package/umd/Options/Classes/Interactivity/Events/HoverEvent.d.ts

@@ -0,0 +1,12 @@
+import type { RecursivePartial, SingleOrMultiple } from "../../../../Types";
+import { HoverMode } from "../../../../Enums";
+import type { IHoverEvent } from "../../../Interfaces/Interactivity/Events/IHoverEvent";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { Parallax } from "./Parallax";
+export declare class HoverEvent implements IHoverEvent, IOptionLoader<IHoverEvent> {
+    enable: boolean;
+    mode: SingleOrMultiple<HoverMode | keyof typeof HoverMode | string>;
+    parallax: Parallax;
+    constructor();
+    load(data?: RecursivePartial<IHoverEvent>): void;
+}

package/umd/Options/Classes/Interactivity/Events/HoverEvent.js

@@ -0,0 +1,34 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./Parallax"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.HoverEvent = void 0;
+    const Parallax_1 = require("./Parallax");
+    class HoverEvent {
+        constructor() {
+            this.enable = false;
+            this.mode = [];
+            this.parallax = new Parallax_1.Parallax();
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            if (data.mode !== undefined) {
+                this.mode = data.mode;
+            }
+            this.parallax.load(data.parallax);
+        }
+    }
+    exports.HoverEvent = HoverEvent;
+});

package/umd/Options/Classes/Interactivity/Events/Parallax.d.ts

@@ -0,0 +1,10 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IParallax } from "../../../Interfaces/Interactivity/Events/IParallax";
+import type { RecursivePartial } from "../../../../Types";
+export declare class Parallax implements IParallax, IOptionLoader<IParallax> {
+    enable: boolean;
+    force: number;
+    smooth: number;
+    constructor();
+    load(data?: RecursivePartial<IParallax>): void;
+}

package/umd/Options/Classes/Interactivity/Events/Parallax.js

@@ -0,0 +1,35 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Parallax = void 0;
+    class Parallax {
+        constructor() {
+            this.enable = false;
+            this.force = 2;
+            this.smooth = 10;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            if (data.force !== undefined) {
+                this.force = data.force;
+            }
+            if (data.smooth !== undefined) {
+                this.smooth = data.smooth;
+            }
+        }
+    }
+    exports.Parallax = Parallax;
+});

package/umd/Options/Classes/Interactivity/Interactivity.d.ts

@@ -0,0 +1,15 @@
+import { InteractivityDetect } from "../../../Enums";
+import { Events } from "./Events/Events";
+import type { IInteractivity } from "../../Interfaces/Interactivity/IInteractivity";
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import { Modes } from "./Modes/Modes";
+import type { RecursivePartial } from "../../../Types";
+export declare class Interactivity implements IInteractivity, IOptionLoader<IInteractivity> {
+    get detect_on(): InteractivityDetect | keyof typeof InteractivityDetect;
+    set detect_on(value: InteractivityDetect | keyof typeof InteractivityDetect);
+    detectsOn: InteractivityDetect | keyof typeof InteractivityDetect;
+    events: Events;
+    modes: Modes;
+    constructor();
+    load(data?: RecursivePartial<IInteractivity>): void;
+}

package/umd/Options/Classes/Interactivity/Interactivity.js

@@ -0,0 +1,51 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./Events/Events", "./Modes/Modes"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Interactivity = void 0;
+    const Events_1 = require("./Events/Events");
+    const Modes_1 = require("./Modes/Modes");
+    class Interactivity {
+        constructor() {
+            this.detectsOn = "window";
+            this.events = new Events_1.Events();
+            this.modes = new Modes_1.Modes();
+        }
+        get detect_on() {
+            return this.detectsOn;
+        }
+        set detect_on(value) {
+            this.detectsOn = value;
+        }
+        load(data) {
+            var _a, _b, _c;
+            if (data === undefined) {
+                return;
+            }
+            const detectsOn = (_a = data.detectsOn) !== null && _a !== void 0 ? _a : data.detect_on;
+            if (detectsOn !== undefined) {
+                this.detectsOn = detectsOn;
+            }
+            this.events.load(data.events);
+            this.modes.load(data.modes);
+            if (((_c = (_b = data.modes) === null || _b === void 0 ? void 0 : _b.slow) === null || _c === void 0 ? void 0 : _c.active) === true) {
+                if (this.events.onHover.mode instanceof Array) {
+                    if (this.events.onHover.mode.indexOf("slow") < 0) {
+                        this.events.onHover.mode.push("slow");
+                    }
+                }
+                else if (this.events.onHover.mode !== "slow") {
+                    this.events.onHover.mode = [this.events.onHover.mode, "slow"];
+                }
+            }
+        }
+    }
+    exports.Interactivity = Interactivity;
+});

package/umd/Options/Classes/Interactivity/Modes/Attract.d.ts

@@ -0,0 +1,14 @@
+import { EasingType } from "../../../../Enums";
+import type { IAttract } from "../../../Interfaces/Interactivity/Modes/IAttract";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types";
+export declare class Attract implements IAttract, IOptionLoader<IAttract> {
+    distance: number;
+    duration: number;
+    easing: EasingType;
+    factor: number;
+    maxSpeed: number;
+    speed: number;
+    constructor();
+    load(data?: RecursivePartial<IAttract>): void;
+}

package/umd/Options/Classes/Interactivity/Modes/Attract.js

@@ -0,0 +1,47 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Attract = void 0;
+    class Attract {
+        constructor() {
+            this.distance = 200;
+            this.duration = 0.4;
+            this.easing = "ease-out-quad";
+            this.factor = 1;
+            this.maxSpeed = 50;
+            this.speed = 1;
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (data.distance !== undefined) {
+                this.distance = data.distance;
+            }
+            if (data.duration !== undefined) {
+                this.duration = data.duration;
+            }
+            if (data.easing !== undefined) {
+                this.easing = data.easing;
+            }
+            if (data.factor !== undefined) {
+                this.factor = data.factor;
+            }
+            if (data.maxSpeed !== undefined) {
+                this.maxSpeed = data.maxSpeed;
+            }
+            if (data.speed !== undefined) {
+                this.speed = data.speed;
+            }
+        }
+    }
+    exports.Attract = Attract;
+});

package/umd/Options/Classes/Interactivity/Modes/Bounce.d.ts

@@ -0,0 +1,8 @@
+import type { IBounce } from "../../../Interfaces/Interactivity/Modes/IBounce";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types";
+export declare class Bounce implements IBounce, IOptionLoader<IBounce> {
+    distance: number;
+    constructor();
+    load(data?: RecursivePartial<IBounce>): void;
+}

package/umd/Options/Classes/Interactivity/Modes/Bounce.js

@@ -0,0 +1,27 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Bounce = void 0;
+    class Bounce {
+        constructor() {
+            this.distance = 200;
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (data.distance !== undefined) {
+                this.distance = data.distance;
+            }
+        }
+    }
+    exports.Bounce = Bounce;
+});

package/umd/Options/Classes/Interactivity/Modes/Bubble.d.ts

@@ -0,0 +1,9 @@
+import type { RecursivePartial, SingleOrMultiple } from "../../../../Types";
+import { BubbleBase } from "./BubbleBase";
+import { BubbleDiv } from "./BubbleDiv";
+import type { IBubble } from "../../../Interfaces/Interactivity/Modes/IBubble";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+export declare class Bubble extends BubbleBase implements IBubble, IOptionLoader<IBubble> {
+    divs?: SingleOrMultiple<BubbleDiv>;
+    load(data?: RecursivePartial<IBubble>): void;
+}

package/umd/Options/Classes/Interactivity/Modes/Bubble.js

@@ -0,0 +1,37 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./BubbleBase", "./BubbleDiv"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Bubble = void 0;
+    const BubbleBase_1 = require("./BubbleBase");
+    const BubbleDiv_1 = require("./BubbleDiv");
+    class Bubble extends BubbleBase_1.BubbleBase {
+        load(data) {
+            super.load(data);
+            if (!(data !== undefined && data.divs !== undefined)) {
+                return;
+            }
+            if (data.divs instanceof Array) {
+                this.divs = data.divs.map((s) => {
+                    const tmp = new BubbleDiv_1.BubbleDiv();
+                    tmp.load(s);
+                    return tmp;
+                });
+            }
+            else {
+                if (this.divs instanceof Array || !this.divs) {
+                    this.divs = new BubbleDiv_1.BubbleDiv();
+                }
+                this.divs.load(data.divs);
+            }
+        }
+    }
+    exports.Bubble = Bubble;
+});

package/umd/Options/Classes/Interactivity/Modes/BubbleBase.d.ts

@@ -0,0 +1,13 @@
+import type { RecursivePartial, SingleOrMultiple } from "../../../../Types";
+import type { IBubbleBase } from "../../../Interfaces/Interactivity/Modes/IBubbleBase";
+import { OptionsColor } from "../../OptionsColor";
+export declare abstract class BubbleBase implements IBubbleBase {
+    distance: number;
+    duration: number;
+    mix: boolean;
+    opacity?: number;
+    size?: number;
+    color?: SingleOrMultiple<OptionsColor>;
+    constructor();
+    load(data?: RecursivePartial<IBubbleBase>): void;
+}

package/umd/Options/Classes/Interactivity/Modes/BubbleBase.js

@@ -0,0 +1,53 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../OptionsColor"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BubbleBase = void 0;
+    const OptionsColor_1 = require("../../OptionsColor");
+    class BubbleBase {
+        constructor() {
+            this.distance = 200;
+            this.duration = 0.4;
+            this.mix = false;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.distance !== undefined) {
+                this.distance = data.distance;
+            }
+            if (data.duration !== undefined) {
+                this.duration = data.duration;
+            }
+            if (data.mix !== undefined) {
+                this.mix = data.mix;
+            }
+            if (data.opacity !== undefined) {
+                this.opacity = data.opacity;
+            }
+            if (data.color !== undefined) {
+                if (data.color instanceof Array) {
+                    this.color = data.color.map((s) => OptionsColor_1.OptionsColor.create(undefined, s));
+                }
+                else {
+                    if (this.color instanceof Array) {
+                        this.color = new OptionsColor_1.OptionsColor();
+                    }
+                    this.color = OptionsColor_1.OptionsColor.create(this.color, data.color);
+                }
+            }
+            if (data.size !== undefined) {
+                this.size = data.size;
+            }
+        }
+    }
+    exports.BubbleBase = BubbleBase;
+});

package/umd/Options/Classes/Interactivity/Modes/BubbleDiv.d.ts

@@ -0,0 +1,11 @@
+import type { RecursivePartial, SingleOrMultiple } from "../../../../Types";
+import { BubbleBase } from "./BubbleBase";
+import type { IBubbleDiv } from "../../../Interfaces/Interactivity/Modes/IBubbleDiv";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+export declare class BubbleDiv extends BubbleBase implements IBubbleDiv, IOptionLoader<IBubbleDiv> {
+    get ids(): SingleOrMultiple<string>;
+    set ids(value: SingleOrMultiple<string>);
+    selectors: SingleOrMultiple<string>;
+    constructor();
+    load(data?: RecursivePartial<IBubbleDiv>): void;
+}