tsparticles 1.40.2 → 1.41.3

package/umd/Interactions/Particles/Links/index.js

@@ -0,0 +1,20 @@
+(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", "./interaction", "./plugin"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadParticlesLinksInteraction = void 0;
+    const interaction_1 = require("./interaction");
+    const plugin_1 = require("./plugin");
+    async function loadParticlesLinksInteraction(engine) {
+        await (0, interaction_1.loadInteraction)(engine);
+        await (0, plugin_1.loadPlugin)(engine);
+    }
+    exports.loadParticlesLinksInteraction = loadParticlesLinksInteraction;
+});

package/umd/Interactions/Particles/Links/interaction.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "../../../engine";
+export declare function loadInteraction(engine: Engine): Promise<void>;

package/umd/Interactions/Particles/Links/interaction.js

@@ -0,0 +1,18 @@
+(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", "./Linker"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadInteraction = void 0;
+    const Linker_1 = require("./Linker");
+    async function loadInteraction(engine) {
+        await engine.addInteractor("particlesLinks", (container) => new Linker_1.Linker(container));
+    }
+    exports.loadInteraction = loadInteraction;
+});

package/umd/Interactions/Particles/Links/plugin.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "../../../engine";
+export declare function loadPlugin(engine: Engine): Promise<void>;

package/umd/Interactions/Particles/Links/plugin.js

@@ -0,0 +1,32 @@
+(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", "./LinkInstance"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadPlugin = void 0;
+    const LinkInstance_1 = require("./LinkInstance");
+    class LinksPlugin {
+        constructor() {
+            this.id = "links";
+        }
+        getPlugin(container) {
+            return new LinkInstance_1.LinkInstance(container);
+        }
+        needsPlugin() {
+            return true;
+        }
+        loadOptions() {
+        }
+    }
+    async function loadPlugin(engine) {
+        const plugin = new LinksPlugin();
+        await engine.addPlugin(plugin);
+    }
+    exports.loadPlugin = loadPlugin;
+});

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

@@ -0,0 +1,11 @@
+import type { RecursivePartial, SingleOrMultiple } from "../../Types";
+import { HslAnimation } from "./HslAnimation";
+import type { IAnimatableColor } from "../Interfaces/IAnimatableColor";
+import type { IOptionLoader } from "../Interfaces/IOptionLoader";
+import { OptionsColor } from "./OptionsColor";
+export declare class AnimatableColor extends OptionsColor implements IAnimatableColor, IOptionLoader<IAnimatableColor> {
+    animation: HslAnimation;
+    constructor();
+    static create(source?: AnimatableColor, data?: SingleOrMultiple<string> | RecursivePartial<IAnimatableColor>): AnimatableColor;
+    load(data?: RecursivePartial<IAnimatableColor>): void;
+}

package/umd/Options/Classes/AnimatableColor.js

@@ -0,0 +1,50 @@
+(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", "./HslAnimation", "./OptionsColor"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AnimatableColor = void 0;
+    const HslAnimation_1 = require("./HslAnimation");
+    const OptionsColor_1 = require("./OptionsColor");
+    class AnimatableColor extends OptionsColor_1.OptionsColor {
+        constructor() {
+            super();
+            this.animation = new HslAnimation_1.HslAnimation();
+        }
+        static create(source, data) {
+            const color = new AnimatableColor();
+            color.load(source);
+            if (data !== undefined) {
+                if (typeof data === "string" || data instanceof Array) {
+                    color.load({ value: data });
+                }
+                else {
+                    color.load(data);
+                }
+            }
+            return color;
+        }
+        load(data) {
+            super.load(data);
+            if (!data) {
+                return;
+            }
+            const colorAnimation = data.animation;
+            if (colorAnimation !== undefined) {
+                if (colorAnimation.enable !== undefined) {
+                    this.animation.h.load(colorAnimation);
+                }
+                else {
+                    this.animation.load(data.animation);
+                }
+            }
+        }
+    }
+    exports.AnimatableColor = AnimatableColor;
+});

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

@@ -0,0 +1,53 @@
+import { GradientType, RotateDirection, RotateDirectionAlt, StartValueType } from "../../Enums";
+import type { IAnimatableGradientColor, IGradientColorOpacityAnimation } from "../Interfaces/IOptionsGradient";
+import type { IGradientAngle, IGradientColorOpacity } from "../../Core";
+import type { RangeValue, RecursivePartial } from "../../Types";
+import { AnimatableColor } from "./AnimatableColor";
+import type { IAnimatable } from "../Interfaces/IAnimatable";
+import type { IAnimatableGradient } from "../Interfaces/IAnimatableGradient";
+import type { IAnimation } from "../Interfaces/IAnimation";
+import type { IOptionLoader } from "../Interfaces/IOptionLoader";
+export declare class AnimatableGradient implements IAnimatableGradient, IOptionLoader<IAnimatableGradient> {
+    angle: GradientAngle;
+    colors: AnimatableGradientColor[];
+    type: GradientType;
+    constructor();
+    load(data?: RecursivePartial<IAnimatableGradient>): void;
+}
+export declare class GradientAngle implements IGradientAngle, IAnimatable<IAnimation>, IOptionLoader<IGradientAngle & IAnimatable<IAnimation>> {
+    animation: GradientAngleAnimation;
+    value: number;
+    direction: RotateDirection | keyof typeof RotateDirection | RotateDirectionAlt;
+    constructor();
+    load(data?: RecursivePartial<IGradientAngle & IAnimatable<IAnimation>>): void;
+}
+export declare class GradientColorOpacity implements IGradientColorOpacity, IAnimatable<GradientColorOpacityAnimation>, IOptionLoader<IGradientColorOpacity & IAnimatable<IGradientColorOpacityAnimation>> {
+    animation: GradientColorOpacityAnimation;
+    value: RangeValue;
+    constructor();
+    load(data?: RecursivePartial<IGradientColorOpacity & IAnimatable<IAnimation>>): void;
+}
+export declare class AnimatableGradientColor implements IAnimatableGradientColor, IOptionLoader<IAnimatableGradientColor> {
+    stop: number;
+    value: AnimatableColor;
+    opacity?: GradientColorOpacity;
+    constructor();
+    load(data?: RecursivePartial<IAnimatableGradientColor>): void;
+}
+export declare class GradientAngleAnimation implements IAnimation, IOptionLoader<IAnimation> {
+    count: number;
+    enable: boolean;
+    speed: number;
+    sync: boolean;
+    constructor();
+    load(data?: RecursivePartial<IAnimation>): void;
+}
+export declare class GradientColorOpacityAnimation implements IGradientColorOpacityAnimation, IOptionLoader<IGradientColorOpacityAnimation> {
+    count: number;
+    enable: boolean;
+    speed: number;
+    sync: boolean;
+    startValue: StartValueType | keyof typeof StartValueType;
+    constructor();
+    load(data?: RecursivePartial<IGradientColorOpacityAnimation>): void;
+}

package/umd/Options/Classes/AnimatableGradient.js

@@ -0,0 +1,156 @@
+(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", "./AnimatableColor", "../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.GradientColorOpacityAnimation = exports.GradientAngleAnimation = exports.AnimatableGradientColor = exports.GradientColorOpacity = exports.GradientAngle = exports.AnimatableGradient = void 0;
+    const AnimatableColor_1 = require("./AnimatableColor");
+    const Utils_1 = require("../../Utils");
+    class AnimatableGradient {
+        constructor() {
+            this.angle = new GradientAngle();
+            this.colors = [];
+            this.type = "random";
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            this.angle.load(data.angle);
+            if (data.colors !== undefined) {
+                this.colors = data.colors.map((s) => {
+                    const tmp = new AnimatableGradientColor();
+                    tmp.load(s);
+                    return tmp;
+                });
+            }
+            if (data.type !== undefined) {
+                this.type = data.type;
+            }
+        }
+    }
+    exports.AnimatableGradient = AnimatableGradient;
+    class GradientAngle {
+        constructor() {
+            this.value = 0;
+            this.animation = new GradientAngleAnimation();
+            this.direction = "clockwise";
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            this.animation.load(data.animation);
+            if (data.value !== undefined) {
+                this.value = data.value;
+            }
+            if (data.direction !== undefined) {
+                this.direction = data.direction;
+            }
+        }
+    }
+    exports.GradientAngle = GradientAngle;
+    class GradientColorOpacity {
+        constructor() {
+            this.value = 0;
+            this.animation = new GradientColorOpacityAnimation();
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            this.animation.load(data.animation);
+            if (data.value !== undefined) {
+                this.value = (0, Utils_1.setRangeValue)(data.value);
+            }
+        }
+    }
+    exports.GradientColorOpacity = GradientColorOpacity;
+    class AnimatableGradientColor {
+        constructor() {
+            this.stop = 0;
+            this.value = new AnimatableColor_1.AnimatableColor();
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (data.stop !== undefined) {
+                this.stop = data.stop;
+            }
+            this.value = AnimatableColor_1.AnimatableColor.create(this.value, data.value);
+            if (data.opacity !== undefined) {
+                this.opacity = new GradientColorOpacity();
+                if (typeof data.opacity === "number") {
+                    this.opacity.value = data.opacity;
+                }
+                else {
+                    this.opacity.load(data.opacity);
+                }
+            }
+        }
+    }
+    exports.AnimatableGradientColor = AnimatableGradientColor;
+    class GradientAngleAnimation {
+        constructor() {
+            this.count = 0;
+            this.enable = false;
+            this.speed = 0;
+            this.sync = false;
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (data.count !== undefined) {
+                this.count = data.count;
+            }
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            if (data.speed !== undefined) {
+                this.speed = data.speed;
+            }
+            if (data.sync !== undefined) {
+                this.sync = data.sync;
+            }
+        }
+    }
+    exports.GradientAngleAnimation = GradientAngleAnimation;
+    class GradientColorOpacityAnimation {
+        constructor() {
+            this.count = 0;
+            this.enable = false;
+            this.speed = 0;
+            this.sync = false;
+            this.startValue = "random";
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (data.count !== undefined) {
+                this.count = data.count;
+            }
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            if (data.speed !== undefined) {
+                this.speed = data.speed;
+            }
+            if (data.sync !== undefined) {
+                this.sync = data.sync;
+            }
+            if (data.startValue !== undefined) {
+                this.startValue = data.startValue;
+            }
+        }
+    }
+    exports.GradientColorOpacityAnimation = GradientColorOpacityAnimation;
+});

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

@@ -0,0 +1,11 @@
+import { IAnimation } from "../Interfaces/IAnimation";
+import { IOptionLoader } from "../Interfaces/IOptionLoader";
+import { RecursivePartial } from "../../Types";
+export declare class AnimationOptions implements IAnimation, IOptionLoader<IAnimation> {
+    count: number;
+    enable: boolean;
+    speed: number;
+    sync: boolean;
+    constructor();
+    load(data?: RecursivePartial<IAnimation>): void;
+}

package/umd/Options/Classes/AnimationOptions.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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AnimationOptions = void 0;
+    class AnimationOptions {
+        constructor() {
+            this.count = 0;
+            this.enable = false;
+            this.speed = 1;
+            this.sync = false;
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (data.count !== undefined) {
+                this.count = data.count;
+            }
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            if (data.speed !== undefined) {
+                this.speed = data.speed;
+            }
+            if (data.sync !== undefined) {
+                this.sync = data.sync;
+            }
+        }
+    }
+    exports.AnimationOptions = AnimationOptions;
+});

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

@@ -0,0 +1,14 @@
+import type { IBackground } from "../../Interfaces/Background/IBackground";
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import { OptionsColor } from "../OptionsColor";
+import type { RecursivePartial } from "../../../Types";
+export declare class Background implements IBackground, IOptionLoader<IBackground> {
+    color: OptionsColor;
+    image: string;
+    position: string;
+    repeat: string;
+    size: string;
+    opacity: number;
+    constructor();
+    load(data?: RecursivePartial<IBackground>): void;
+}

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

@@ -0,0 +1,49 @@
+(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.Background = void 0;
+    const OptionsColor_1 = require("../OptionsColor");
+    class Background {
+        constructor() {
+            this.color = new OptionsColor_1.OptionsColor();
+            this.color.value = "";
+            this.image = "";
+            this.position = "";
+            this.repeat = "";
+            this.size = "";
+            this.opacity = 1;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.color !== undefined) {
+                this.color = OptionsColor_1.OptionsColor.create(this.color, data.color);
+            }
+            if (data.image !== undefined) {
+                this.image = data.image;
+            }
+            if (data.position !== undefined) {
+                this.position = data.position;
+            }
+            if (data.repeat !== undefined) {
+                this.repeat = data.repeat;
+            }
+            if (data.size !== undefined) {
+                this.size = data.size;
+            }
+            if (data.opacity !== undefined) {
+                this.opacity = data.opacity;
+            }
+        }
+    }
+    exports.Background = Background;
+});

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

@@ -0,0 +1,11 @@
+import { BackgroundMaskCover } from "./BackgroundMaskCover";
+import type { IBackgroundMask } from "../../Interfaces/BackgroundMask/IBackgroundMask";
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../Types";
+export declare class BackgroundMask implements IBackgroundMask, IOptionLoader<IBackgroundMask> {
+    composite: string;
+    cover: BackgroundMaskCover;
+    enable: boolean;
+    constructor();
+    load(data?: RecursivePartial<IBackgroundMask>): void;
+}

package/umd/Options/Classes/BackgroundMask/BackgroundMask.js

@@ -0,0 +1,38 @@
+(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", "./BackgroundMaskCover"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BackgroundMask = void 0;
+    const BackgroundMaskCover_1 = require("./BackgroundMaskCover");
+    class BackgroundMask {
+        constructor() {
+            this.composite = "destination-out";
+            this.cover = new BackgroundMaskCover_1.BackgroundMaskCover();
+            this.enable = false;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.composite !== undefined) {
+                this.composite = data.composite;
+            }
+            if (data.cover !== undefined) {
+                const cover = data.cover;
+                const color = (typeof data.cover === "string" ? { color: data.cover } : data.cover);
+                this.cover.load(cover.color !== undefined ? cover : { color: color });
+            }
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+        }
+    }
+    exports.BackgroundMask = BackgroundMask;
+});

package/umd/Options/Classes/BackgroundMask/BackgroundMaskCover.d.ts

@@ -0,0 +1,10 @@
+import type { IBackgroundMaskCover } from "../../Interfaces/BackgroundMask/IBackgroundMaskCover";
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import { OptionsColor } from "../OptionsColor";
+import type { RecursivePartial } from "../../../Types";
+export declare class BackgroundMaskCover implements IBackgroundMaskCover, IOptionLoader<IBackgroundMaskCover> {
+    color: OptionsColor;
+    opacity: number;
+    constructor();
+    load(data?: RecursivePartial<IBackgroundMaskCover> | undefined): void;
+}

package/umd/Options/Classes/BackgroundMask/BackgroundMaskCover.js

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

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

@@ -0,0 +1,12 @@
+import type { RangeValue, RecursivePartial } from "../../Types";
+import type { IColorAnimation } from "../Interfaces/IColorAnimation";
+import type { IOptionLoader } from "../Interfaces/IOptionLoader";
+export declare class ColorAnimation implements IColorAnimation, IOptionLoader<IColorAnimation> {
+    count: number;
+    enable: boolean;
+    offset: RangeValue;
+    speed: number;
+    sync: boolean;
+    constructor();
+    load(data?: RecursivePartial<IColorAnimation>): void;
+}

package/umd/Options/Classes/ColorAnimation.js

@@ -0,0 +1,44 @@
+(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", "../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ColorAnimation = void 0;
+    const Utils_1 = require("../../Utils");
+    class ColorAnimation {
+        constructor() {
+            this.count = 0;
+            this.enable = false;
+            this.offset = 0;
+            this.speed = 1;
+            this.sync = true;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.count !== undefined) {
+                this.count = data.count;
+            }
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            if (data.offset !== undefined) {
+                this.offset = (0, Utils_1.setRangeValue)(data.offset);
+            }
+            if (data.speed !== undefined) {
+                this.speed = data.speed;
+            }
+            if (data.sync !== undefined) {
+                this.sync = data.sync;
+            }
+        }
+    }
+    exports.ColorAnimation = ColorAnimation;
+});

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

@@ -0,0 +1,9 @@
+import type { IFullScreen } from "../../Interfaces/FullScreen/IFullScreen";
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../Types";
+export declare class FullScreen implements IFullScreen, IOptionLoader<IFullScreen> {
+    enable: boolean;
+    zIndex: number;
+    constructor();
+    load(data?: RecursivePartial<IFullScreen>): void;
+}

package/umd/Options/Classes/FullScreen/FullScreen.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.FullScreen = void 0;
+    class FullScreen {
+        constructor() {
+            this.enable = true;
+            this.zIndex = 0;
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            if (data.zIndex !== undefined) {
+                this.zIndex = data.zIndex;
+            }
+        }
+    }
+    exports.FullScreen = FullScreen;
+});