tsparticles 1.40.2 → 1.41.3

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

@@ -0,0 +1,41 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BubbleDiv = void 0;
+    const BubbleBase_1 = require("./BubbleBase");
+    class BubbleDiv extends BubbleBase_1.BubbleBase {
+        constructor() {
+            super();
+            this.selectors = [];
+        }
+        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) {
+            super.load(data);
+            if (data === undefined) {
+                return;
+            }
+            if (data.ids !== undefined) {
+                this.ids = data.ids;
+            }
+            if (data.selectors !== undefined) {
+                this.selectors = data.selectors;
+            }
+        }
+    }
+    exports.BubbleDiv = BubbleDiv;
+});

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

@@ -0,0 +1,15 @@
+import { ConnectLinks } from "./ConnectLinks";
+import type { IConnect } from "../../../Interfaces/Interactivity/Modes/IConnect";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types";
+export declare class Connect implements IConnect, IOptionLoader<IConnect> {
+    get line_linked(): ConnectLinks;
+    set line_linked(value: ConnectLinks);
+    get lineLinked(): ConnectLinks;
+    set lineLinked(value: ConnectLinks);
+    distance: number;
+    links: ConnectLinks;
+    radius: number;
+    constructor();
+    load(data?: RecursivePartial<IConnect>): void;
+}

package/umd/Options/Classes/Interactivity/Modes/Connect.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", "./ConnectLinks"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Connect = void 0;
+    const ConnectLinks_1 = require("./ConnectLinks");
+    class Connect {
+        constructor() {
+            this.distance = 80;
+            this.links = new ConnectLinks_1.ConnectLinks();
+            this.radius = 60;
+        }
+        get line_linked() {
+            return this.links;
+        }
+        set line_linked(value) {
+            this.links = value;
+        }
+        get lineLinked() {
+            return this.links;
+        }
+        set lineLinked(value) {
+            this.links = value;
+        }
+        load(data) {
+            var _a, _b;
+            if (data === undefined) {
+                return;
+            }
+            if (data.distance !== undefined) {
+                this.distance = data.distance;
+            }
+            this.links.load((_b = (_a = data.links) !== null && _a !== void 0 ? _a : data.lineLinked) !== null && _b !== void 0 ? _b : data.line_linked);
+            if (data.radius !== undefined) {
+                this.radius = data.radius;
+            }
+        }
+    }
+    exports.Connect = Connect;
+});

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

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

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

@@ -0,0 +1,25 @@
+(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.ConnectLinks = void 0;
+    class ConnectLinks {
+        constructor() {
+            this.opacity = 0.5;
+        }
+        load(data) {
+            if (!(data !== undefined && data.opacity !== undefined)) {
+                return;
+            }
+            this.opacity = data.opacity;
+        }
+    }
+    exports.ConnectLinks = ConnectLinks;
+});

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

@@ -0,0 +1,14 @@
+import { GrabLinks } from "./GrabLinks";
+import type { IGrab } from "../../../Interfaces/Interactivity/Modes/IGrab";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types";
+export declare class Grab implements IGrab, IOptionLoader<IGrab> {
+    get line_linked(): GrabLinks;
+    set line_linked(value: GrabLinks);
+    get lineLinked(): GrabLinks;
+    set lineLinked(value: GrabLinks);
+    distance: number;
+    links: GrabLinks;
+    constructor();
+    load(data?: RecursivePartial<IGrab>): void;
+}

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

@@ -0,0 +1,43 @@
+(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", "./GrabLinks"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Grab = void 0;
+    const GrabLinks_1 = require("./GrabLinks");
+    class Grab {
+        constructor() {
+            this.distance = 100;
+            this.links = new GrabLinks_1.GrabLinks();
+        }
+        get line_linked() {
+            return this.links;
+        }
+        set line_linked(value) {
+            this.links = value;
+        }
+        get lineLinked() {
+            return this.links;
+        }
+        set lineLinked(value) {
+            this.links = value;
+        }
+        load(data) {
+            var _a, _b;
+            if (data === undefined) {
+                return;
+            }
+            if (data.distance !== undefined) {
+                this.distance = data.distance;
+            }
+            this.links.load((_b = (_a = data.links) !== null && _a !== void 0 ? _a : data.lineLinked) !== null && _b !== void 0 ? _b : data.line_linked);
+        }
+    }
+    exports.Grab = Grab;
+});

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

@@ -0,0 +1,12 @@
+import type { IGrabLinks } from "../../../Interfaces/Interactivity/Modes/IGrabLinks";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { OptionsColor } from "../../OptionsColor";
+import type { RecursivePartial } from "../../../../Types";
+export declare class GrabLinks implements IGrabLinks, IOptionLoader<IGrabLinks> {
+    blink: boolean;
+    color?: OptionsColor;
+    consent: boolean;
+    opacity: number;
+    constructor();
+    load(data?: RecursivePartial<IGrabLinks>): void;
+}

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

@@ -0,0 +1,39 @@
+(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.GrabLinks = void 0;
+    const OptionsColor_1 = require("../../OptionsColor");
+    class GrabLinks {
+        constructor() {
+            this.blink = false;
+            this.consent = false;
+            this.opacity = 1;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.blink !== undefined) {
+                this.blink = data.blink;
+            }
+            if (data.color !== undefined) {
+                this.color = OptionsColor_1.OptionsColor.create(this.color, data.color);
+            }
+            if (data.consent !== undefined) {
+                this.consent = data.consent;
+            }
+            if (data.opacity !== undefined) {
+                this.opacity = data.opacity;
+            }
+        }
+    }
+    exports.GrabLinks = GrabLinks;
+});

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

@@ -0,0 +1,11 @@
+import type { ILight } from "../../../Interfaces/Interactivity/Modes/ILight";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { LightArea } from "./LightArea";
+import { LightShadow } from "./LightShadow";
+import type { RecursivePartial } from "../../../../Types";
+export declare class Light implements ILight, IOptionLoader<ILight> {
+    area: LightArea;
+    shadow: LightShadow;
+    constructor();
+    load(data?: RecursivePartial<ILight>): void;
+}

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

@@ -0,0 +1,29 @@
+(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", "./LightArea", "./LightShadow"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Light = void 0;
+    const LightArea_1 = require("./LightArea");
+    const LightShadow_1 = require("./LightShadow");
+    class Light {
+        constructor() {
+            this.area = new LightArea_1.LightArea();
+            this.shadow = new LightShadow_1.LightShadow();
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            this.area.load(data.area);
+            this.shadow.load(data.shadow);
+        }
+    }
+    exports.Light = Light;
+});

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

@@ -0,0 +1,10 @@
+import type { ILightArea } from "../../../Interfaces/Interactivity/Modes/ILightArea";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { LightGradient } from "./LightGradient";
+import type { RecursivePartial } from "../../../../Types";
+export declare class LightArea implements ILightArea, IOptionLoader<ILightArea> {
+    gradient: LightGradient;
+    radius: number;
+    constructor();
+    load(data?: RecursivePartial<ILightArea>): void;
+}

package/umd/Options/Classes/Interactivity/Modes/LightArea.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", "./LightGradient"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.LightArea = void 0;
+    const LightGradient_1 = require("./LightGradient");
+    class LightArea {
+        constructor() {
+            this.gradient = new LightGradient_1.LightGradient();
+            this.radius = 1000;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            this.gradient.load(data.gradient);
+            if (data.radius !== undefined) {
+                this.radius = data.radius;
+            }
+        }
+    }
+    exports.LightArea = LightArea;
+});

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

@@ -0,0 +1,10 @@
+import type { ILightGradient } from "../../../Interfaces/Interactivity/Modes/ILightArea";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { OptionsColor } from "../../OptionsColor";
+import type { RecursivePartial } from "../../../../Types";
+export declare class LightGradient implements ILightGradient, IOptionLoader<ILightGradient> {
+    start: OptionsColor;
+    stop: OptionsColor;
+    constructor();
+    load(data?: RecursivePartial<ILightGradient>): void;
+}

package/umd/Options/Classes/Interactivity/Modes/LightGradient.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", "../../OptionsColor"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.LightGradient = void 0;
+    const OptionsColor_1 = require("../../OptionsColor");
+    class LightGradient {
+        constructor() {
+            this.start = new OptionsColor_1.OptionsColor();
+            this.stop = new OptionsColor_1.OptionsColor();
+            this.start.value = "#ffffff";
+            this.stop.value = "#000000";
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            this.start = OptionsColor_1.OptionsColor.create(this.start, data.start);
+            this.stop = OptionsColor_1.OptionsColor.create(this.stop, data.stop);
+        }
+    }
+    exports.LightGradient = LightGradient;
+});

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

@@ -0,0 +1,10 @@
+import type { ILightShadow } from "../../../Interfaces/Interactivity/Modes/ILightShadow";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { OptionsColor } from "../../OptionsColor";
+import type { RecursivePartial } from "../../../../Types";
+export declare class LightShadow implements ILightShadow, IOptionLoader<ILightShadow> {
+    color: OptionsColor;
+    length: number;
+    constructor();
+    load(data?: RecursivePartial<ILightShadow>): void;
+}

package/umd/Options/Classes/Interactivity/Modes/LightShadow.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", "../../OptionsColor"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.LightShadow = void 0;
+    const OptionsColor_1 = require("../../OptionsColor");
+    class LightShadow {
+        constructor() {
+            this.color = new OptionsColor_1.OptionsColor();
+            this.color.value = "#000000";
+            this.length = 2000;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            this.color = OptionsColor_1.OptionsColor.create(this.color, data.color);
+            if (data.length !== undefined) {
+                this.length = data.length;
+            }
+        }
+    }
+    exports.LightShadow = LightShadow;
+});

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

@@ -0,0 +1,29 @@
+import { Attract } from "./Attract";
+import { Bounce } from "./Bounce";
+import { Bubble } from "./Bubble";
+import { Connect } from "./Connect";
+import { Grab } from "./Grab";
+import type { IModes } from "../../../Interfaces/Interactivity/Modes/IModes";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { Light } from "./Light";
+import { Push } from "./Push";
+import type { RecursivePartial } from "../../../../Types";
+import { Remove } from "./Remove";
+import { Repulse } from "./Repulse";
+import { Slow } from "./Slow";
+import { Trail } from "./Trail";
+export declare class Modes implements IModes, IOptionLoader<IModes> {
+    attract: Attract;
+    bounce: Bounce;
+    bubble: Bubble;
+    connect: Connect;
+    grab: Grab;
+    light: Light;
+    push: Push;
+    remove: Remove;
+    repulse: Repulse;
+    slow: Slow;
+    trail: Trail;
+    constructor();
+    load(data?: RecursivePartial<IModes>): void;
+}

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

@@ -0,0 +1,55 @@
+(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", "./Attract", "./Bounce", "./Bubble", "./Connect", "./Grab", "./Light", "./Push", "./Remove", "./Repulse", "./Slow", "./Trail"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Modes = void 0;
+    const Attract_1 = require("./Attract");
+    const Bounce_1 = require("./Bounce");
+    const Bubble_1 = require("./Bubble");
+    const Connect_1 = require("./Connect");
+    const Grab_1 = require("./Grab");
+    const Light_1 = require("./Light");
+    const Push_1 = require("./Push");
+    const Remove_1 = require("./Remove");
+    const Repulse_1 = require("./Repulse");
+    const Slow_1 = require("./Slow");
+    const Trail_1 = require("./Trail");
+    class Modes {
+        constructor() {
+            this.attract = new Attract_1.Attract();
+            this.bounce = new Bounce_1.Bounce();
+            this.bubble = new Bubble_1.Bubble();
+            this.connect = new Connect_1.Connect();
+            this.grab = new Grab_1.Grab();
+            this.light = new Light_1.Light();
+            this.push = new Push_1.Push();
+            this.remove = new Remove_1.Remove();
+            this.repulse = new Repulse_1.Repulse();
+            this.slow = new Slow_1.Slow();
+            this.trail = new Trail_1.Trail();
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            this.attract.load(data.attract);
+            this.bubble.load(data.bubble);
+            this.connect.load(data.connect);
+            this.grab.load(data.grab);
+            this.light.load(data.light);
+            this.push.load(data.push);
+            this.remove.load(data.remove);
+            this.repulse.load(data.repulse);
+            this.slow.load(data.slow);
+            this.trail.load(data.trail);
+        }
+    }
+    exports.Modes = Modes;
+});

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

@@ -0,0 +1,12 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IPush } from "../../../Interfaces/Interactivity/Modes/IPush";
+import type { RecursivePartial } from "../../../../Types";
+export declare class Push implements IPush, IOptionLoader<IPush> {
+    get particles_nb(): number;
+    set particles_nb(value: number);
+    default: boolean;
+    groups: string[];
+    quantity: number;
+    constructor();
+    load(data?: RecursivePartial<IPush>): void;
+}

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

@@ -0,0 +1,46 @@
+(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.Push = void 0;
+    class Push {
+        constructor() {
+            this.default = true;
+            this.groups = [];
+            this.quantity = 4;
+        }
+        get particles_nb() {
+            return this.quantity;
+        }
+        set particles_nb(value) {
+            this.quantity = value;
+        }
+        load(data) {
+            var _a;
+            if (data === undefined) {
+                return;
+            }
+            if (data.default !== undefined) {
+                this.default = data.default;
+            }
+            if (data.groups !== undefined) {
+                this.groups = data.groups.map((t) => t);
+            }
+            if (!this.groups.length) {
+                this.default = true;
+            }
+            const quantity = (_a = data.quantity) !== null && _a !== void 0 ? _a : data.particles_nb;
+            if (quantity !== undefined) {
+                this.quantity = quantity;
+            }
+        }
+    }
+    exports.Push = Push;
+});

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

@@ -0,0 +1,10 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IRemove } from "../../../Interfaces/Interactivity/Modes/IRemove";
+import type { RecursivePartial } from "../../../../Types";
+export declare class Remove implements IRemove, IOptionLoader<IRemove> {
+    get particles_nb(): number;
+    set particles_nb(value: number);
+    quantity: number;
+    constructor();
+    load(data?: RecursivePartial<IRemove>): void;
+}

package/umd/Options/Classes/Interactivity/Modes/Remove.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.Remove = void 0;
+    class Remove {
+        constructor() {
+            this.quantity = 2;
+        }
+        get particles_nb() {
+            return this.quantity;
+        }
+        set particles_nb(value) {
+            this.quantity = value;
+        }
+        load(data) {
+            var _a;
+            if (data === undefined) {
+                return;
+            }
+            const quantity = (_a = data.quantity) !== null && _a !== void 0 ? _a : data.particles_nb;
+            if (quantity !== undefined) {
+                this.quantity = quantity;
+            }
+        }
+    }
+    exports.Remove = Remove;
+});

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

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