tsparticles 1.40.2 → 1.41.3

package/umd/Core/Utils/Vector.js

@@ -0,0 +1,106 @@
+(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.Vector = void 0;
+    class Vector {
+        constructor(x, y) {
+            let defX, defY;
+            if (y === undefined) {
+                if (typeof x === "number") {
+                    throw new Error("tsParticles - Vector not initialized correctly");
+                }
+                const coords = x;
+                [defX, defY] = [coords.x, coords.y];
+            }
+            else {
+                [defX, defY] = [x, y];
+            }
+            this.x = defX;
+            this.y = defY;
+        }
+        static clone(source) {
+            return Vector.create(source.x, source.y);
+        }
+        static create(x, y) {
+            return new Vector(x, y);
+        }
+        static get origin() {
+            return Vector.create(0, 0);
+        }
+        get angle() {
+            return Math.atan2(this.y, this.x);
+        }
+        set angle(angle) {
+            this.updateFromAngle(angle, this.length);
+        }
+        get length() {
+            return Math.sqrt(this.x ** 2 + this.y ** 2);
+        }
+        set length(length) {
+            this.updateFromAngle(this.angle, length);
+        }
+        add(v) {
+            return Vector.create(this.x + v.x, this.y + v.y);
+        }
+        addTo(v) {
+            this.x += v.x;
+            this.y += v.y;
+        }
+        sub(v) {
+            return Vector.create(this.x - v.x, this.y - v.y);
+        }
+        subFrom(v) {
+            this.x -= v.x;
+            this.y -= v.y;
+        }
+        mult(n) {
+            return Vector.create(this.x * n, this.y * n);
+        }
+        multTo(n) {
+            this.x *= n;
+            this.y *= n;
+        }
+        div(n) {
+            return Vector.create(this.x / n, this.y / n);
+        }
+        divTo(n) {
+            this.x /= n;
+            this.y /= n;
+        }
+        distanceTo(v) {
+            return this.sub(v).length;
+        }
+        getLengthSq() {
+            return this.x ** 2 + this.y ** 2;
+        }
+        distanceToSq(v) {
+            return this.sub(v).getLengthSq();
+        }
+        manhattanDistanceTo(v) {
+            return Math.abs(v.x - this.x) + Math.abs(v.y - this.y);
+        }
+        copy() {
+            return Vector.clone(this);
+        }
+        setTo(velocity) {
+            this.x = velocity.x;
+            this.y = velocity.y;
+        }
+        rotate(angle) {
+            return Vector.create(this.x * Math.cos(angle) - this.y * Math.sin(angle), this.x * Math.sin(angle) + this.y * Math.cos(angle));
+        }
+        updateFromAngle(angle, length) {
+            this.x = Math.cos(angle) * length;
+            this.y = Math.sin(angle) * length;
+        }
+    }
+    exports.Vector = Vector;
+});

package/umd/Core/Utils/Vector3d.d.ts

@@ -0,0 +1,18 @@
+import type { ICoordinates3d } from "../Interfaces";
+import { Vector } from "./Vector";
+export declare class Vector3d extends Vector implements ICoordinates3d {
+    static clone(source: Vector3d): Vector3d;
+    static create(x: number | ICoordinates3d, y?: number, z?: number): Vector3d;
+    z: number;
+    protected constructor(x: number | ICoordinates3d, y?: number, z?: number);
+    add(v: Vector): Vector;
+    addTo(v: Vector): void;
+    sub(v: Vector): Vector;
+    subFrom(v: Vector): void;
+    mult(n: number): Vector;
+    multTo(n: number): void;
+    div(n: number): Vector;
+    divTo(n: number): void;
+    copy(): Vector3d;
+    setTo(v: Vector): void;
+}

package/umd/Core/Utils/Vector3d.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", "./Vector"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Vector3d = void 0;
+    const Vector_1 = require("./Vector");
+    class Vector3d extends Vector_1.Vector {
+        constructor(x, y, z) {
+            super(x, y);
+            this.z = z === undefined ? x.z : z;
+        }
+        static clone(source) {
+            return Vector3d.create(source.x, source.y, source.z);
+        }
+        static create(x, y, z) {
+            return new Vector3d(x, y, z);
+        }
+        add(v) {
+            return v instanceof Vector3d ? Vector3d.create(this.x + v.x, this.y + v.y, this.z + v.z) : super.add(v);
+        }
+        addTo(v) {
+            super.addTo(v);
+            if (v instanceof Vector3d) {
+                this.z += v.z;
+            }
+        }
+        sub(v) {
+            return v instanceof Vector3d ? Vector3d.create(this.x - v.x, this.y - v.y, this.z - v.z) : super.sub(v);
+        }
+        subFrom(v) {
+            super.subFrom(v);
+            if (v instanceof Vector3d) {
+                this.z -= v.z;
+            }
+        }
+        mult(n) {
+            return Vector3d.create(this.x * n, this.y * n, this.z * n);
+        }
+        multTo(n) {
+            super.multTo(n);
+            this.z *= n;
+        }
+        div(n) {
+            return Vector3d.create(this.x / n, this.y / n, this.z / n);
+        }
+        divTo(n) {
+            super.divTo(n);
+            this.z /= n;
+        }
+        copy() {
+            return Vector3d.clone(this);
+        }
+        setTo(v) {
+            super.setTo(v);
+            if (v instanceof Vector3d) {
+                this.z = v.z;
+            }
+        }
+    }
+    exports.Vector3d = Vector3d;
+});

package/umd/Core/Utils/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./Circle";
+export * from "./CircleWarp";
+export * from "./Constants";
+export * from "./EventListeners";
+export * from "./ExternalInteractorBase";
+export * from "./FrameManager";
+export * from "./InteractionManager";
+export * from "./ParticlesInteractorBase";
+export * from "./ParticlesMover";
+export * from "./Plugins";
+export * from "./Point";
+export * from "./QuadTree";
+export * from "./Range";
+export * from "./Rectangle";
+export * from "./Vector";
+export * from "./Vector3d";

package/umd/Core/Utils/index.js

@@ -0,0 +1,38 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+(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", "./Circle", "./CircleWarp", "./Constants", "./EventListeners", "./ExternalInteractorBase", "./FrameManager", "./InteractionManager", "./ParticlesInteractorBase", "./ParticlesMover", "./Plugins", "./Point", "./QuadTree", "./Range", "./Rectangle", "./Vector", "./Vector3d"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require("./Circle"), exports);
+    __exportStar(require("./CircleWarp"), exports);
+    __exportStar(require("./Constants"), exports);
+    __exportStar(require("./EventListeners"), exports);
+    __exportStar(require("./ExternalInteractorBase"), exports);
+    __exportStar(require("./FrameManager"), exports);
+    __exportStar(require("./InteractionManager"), exports);
+    __exportStar(require("./ParticlesInteractorBase"), exports);
+    __exportStar(require("./ParticlesMover"), exports);
+    __exportStar(require("./Plugins"), exports);
+    __exportStar(require("./Point"), exports);
+    __exportStar(require("./QuadTree"), exports);
+    __exportStar(require("./Range"), exports);
+    __exportStar(require("./Rectangle"), exports);
+    __exportStar(require("./Vector"), exports);
+    __exportStar(require("./Vector3d"), exports);
+});

package/umd/Core/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./Canvas";
+export * from "./Container";
+export * from "./Loader";
+export * from "./Particle";
+export * from "./Particles";
+export * from "./Retina";
+export * from "./Interfaces";
+export * from "./Utils";

package/umd/Core/index.js

@@ -0,0 +1,30 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+(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", "./Canvas", "./Container", "./Loader", "./Particle", "./Particles", "./Retina", "./Interfaces", "./Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require("./Canvas"), exports);
+    __exportStar(require("./Container"), exports);
+    __exportStar(require("./Loader"), exports);
+    __exportStar(require("./Particle"), exports);
+    __exportStar(require("./Particles"), exports);
+    __exportStar(require("./Retina"), exports);
+    __exportStar(require("./Interfaces"), exports);
+    __exportStar(require("./Utils"), exports);
+});

package/umd/Enums/AnimationStatus.d.ts

@@ -0,0 +1,4 @@
+export declare const enum AnimationStatus {
+    increasing = 0,
+    decreasing = 1
+}

package/umd/Enums/AnimationStatus.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Enums/Directions/MoveDirection.d.ts

@@ -0,0 +1,12 @@
+export declare const enum MoveDirection {
+    bottom = "bottom",
+    bottomLeft = "bottom-left",
+    bottomRight = "bottom-right",
+    left = "left",
+    none = "none",
+    right = "right",
+    top = "top",
+    topLeft = "top-left",
+    topRight = "top-right"
+}
+export declare type MoveDirectionAlt = "bottom-left" | "bottom-right" | "top-left" | "top-right";

package/umd/Enums/Directions/MoveDirection.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Enums/Directions/OutModeDirection.d.ts

@@ -0,0 +1,6 @@
+export declare const enum OutModeDirection {
+    bottom = "bottom",
+    left = "left",
+    right = "right",
+    top = "top"
+}

package/umd/Enums/Directions/OutModeDirection.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Enums/Directions/RotateDirection.d.ts

@@ -0,0 +1,6 @@
+export declare const enum RotateDirection {
+    clockwise = "clockwise",
+    counterClockwise = "counter-clockwise",
+    random = "random"
+}
+export declare type RotateDirectionAlt = "counter-clockwise";

package/umd/Enums/Directions/RotateDirection.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Enums/Directions/TiltDirection.d.ts

@@ -0,0 +1,6 @@
+export declare const enum TiltDirection {
+    clockwise = "clockwise",
+    counterClockwise = "counter-clockwise",
+    random = "random"
+}
+export declare type TiltDirectionAlt = "counter-clockwise";

package/umd/Enums/Directions/TiltDirection.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Enums/Directions/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./MoveDirection";
+export * from "./RotateDirection";
+export * from "./OutModeDirection";
+export * from "./TiltDirection";

package/umd/Enums/Directions/index.js

@@ -0,0 +1,26 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+(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", "./MoveDirection", "./RotateDirection", "./OutModeDirection", "./TiltDirection"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require("./MoveDirection"), exports);
+    __exportStar(require("./RotateDirection"), exports);
+    __exportStar(require("./OutModeDirection"), exports);
+    __exportStar(require("./TiltDirection"), exports);
+});

package/umd/Enums/InteractivityDetect.d.ts

@@ -0,0 +1,5 @@
+export declare const enum InteractivityDetect {
+    canvas = "canvas",
+    parent = "parent",
+    window = "window"
+}

package/umd/Enums/InteractivityDetect.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Enums/Modes/ClickMode.d.ts

@@ -0,0 +1,9 @@
+export declare const enum ClickMode {
+    attract = "attract",
+    bubble = "bubble",
+    push = "push",
+    remove = "remove",
+    repulse = "repulse",
+    pause = "pause",
+    trail = "trail"
+}

package/umd/Enums/Modes/ClickMode.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Enums/Modes/CollisionMode.d.ts

@@ -0,0 +1,5 @@
+export declare const enum CollisionMode {
+    absorb = "absorb",
+    bounce = "bounce",
+    destroy = "destroy"
+}

package/umd/Enums/Modes/CollisionMode.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Enums/Modes/DestroyMode.d.ts

@@ -0,0 +1,4 @@
+export declare const enum DestroyMode {
+    none = "none",
+    split = "split"
+}

package/umd/Enums/Modes/DestroyMode.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Enums/Modes/DivMode.d.ts

@@ -0,0 +1,5 @@
+export declare const enum DivMode {
+    bounce = "bounce",
+    bubble = "bubble",
+    repulse = "repulse"
+}

package/umd/Enums/Modes/DivMode.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Enums/Modes/HoverMode.d.ts

@@ -0,0 +1,11 @@
+export declare const enum HoverMode {
+    attract = "attract",
+    bounce = "bounce",
+    bubble = "bubble",
+    connect = "connect",
+    grab = "grab",
+    light = "light",
+    repulse = "repulse",
+    slow = "slow",
+    trail = "trail"
+}

package/umd/Enums/Modes/HoverMode.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Enums/Modes/OutMode.d.ts

@@ -0,0 +1,10 @@
+export declare const enum OutMode {
+    bounce = "bounce",
+    bounceHorizontal = "bounce-horizontal",
+    bounceVertical = "bounce-vertical",
+    none = "none",
+    out = "out",
+    destroy = "destroy",
+    split = "split"
+}
+export declare type OutModeAlt = "bounce-horizontal" | "bounce-vertical";

package/umd/Enums/Modes/OutMode.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Enums/Modes/ResponsiveMode.d.ts

@@ -0,0 +1,4 @@
+export declare const enum ResponsiveMode {
+    screen = "screen",
+    canvas = "canvas"
+}

package/umd/Enums/Modes/ResponsiveMode.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Enums/Modes/RollMode.d.ts

@@ -0,0 +1,5 @@
+export declare const enum RollMode {
+    both = "both",
+    horizontal = "horizontal",
+    vertical = "vertical"
+}

package/umd/Enums/Modes/RollMode.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Enums/Modes/SizeMode.d.ts

@@ -0,0 +1,4 @@
+export declare const enum SizeMode {
+    precise = "precise",
+    percent = "percent"
+}

package/umd/Enums/Modes/SizeMode.js

@@ -0,0 +1,12 @@
+(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 });
+});