tsparticles 1.40.1 → 1.41.2

package/umd/Interactions/External/Trail/TrailMaker.d.ts

@@ -0,0 +1,10 @@
+import type { Container, IDelta } from "../../../Core";
+import { ExternalInteractorBase } from "../../../Core";
+export declare class TrailMaker extends ExternalInteractorBase {
+    private delay;
+    private lastPosition?;
+    constructor(container: Container);
+    interact(delta: IDelta): Promise<void>;
+    isEnabled(): boolean;
+    reset(): void;
+}

package/umd/Interactions/External/Trail/TrailMaker.js

@@ -0,0 +1,63 @@
+(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", "../../../Core", "../../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TrailMaker = void 0;
+    const Core_1 = require("../../../Core");
+    const Utils_1 = require("../../../Utils");
+    class TrailMaker extends Core_1.ExternalInteractorBase {
+        constructor(container) {
+            super(container);
+            this.delay = 0;
+        }
+        async interact(delta) {
+            var _a, _b, _c, _d;
+            if (!this.container.retina.reduceFactor) {
+                return;
+            }
+            const container = this.container, options = container.actualOptions, trailOptions = options.interactivity.modes.trail, optDelay = (trailOptions.delay * 1000) / this.container.retina.reduceFactor;
+            if (this.delay < optDelay) {
+                this.delay += delta.value;
+            }
+            if (this.delay < optDelay) {
+                return;
+            }
+            let canEmit = true;
+            if (trailOptions.pauseOnStop) {
+                if (container.interactivity.mouse.position === this.lastPosition ||
+                    (((_a = container.interactivity.mouse.position) === null || _a === void 0 ? void 0 : _a.x) === ((_b = this.lastPosition) === null || _b === void 0 ? void 0 : _b.x) &&
+                        ((_c = container.interactivity.mouse.position) === null || _c === void 0 ? void 0 : _c.y) === ((_d = this.lastPosition) === null || _d === void 0 ? void 0 : _d.y))) {
+                    canEmit = false;
+                }
+            }
+            if (container.interactivity.mouse.position) {
+                this.lastPosition = {
+                    x: container.interactivity.mouse.position.x,
+                    y: container.interactivity.mouse.position.y,
+                };
+            }
+            else {
+                delete this.lastPosition;
+            }
+            if (canEmit) {
+                container.particles.push(trailOptions.quantity, container.interactivity.mouse, trailOptions.particles);
+            }
+            this.delay -= optDelay;
+        }
+        isEnabled() {
+            const container = this.container, options = container.actualOptions, mouse = container.interactivity.mouse, events = options.interactivity.events;
+            return ((mouse.clicking && mouse.inside && !!mouse.position && (0, Utils_1.isInArray)("trail", events.onClick.mode)) ||
+                (mouse.inside && !!mouse.position && (0, Utils_1.isInArray)("trail", events.onHover.mode)));
+        }
+        reset() {
+        }
+    }
+    exports.TrailMaker = TrailMaker;
+});

package/umd/Interactions/External/Trail/index.d.ts

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

package/umd/Interactions/External/Trail/index.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", "./TrailMaker"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadExternalTrailInteraction = void 0;
+    const TrailMaker_1 = require("./TrailMaker");
+    async function loadExternalTrailInteraction(engine) {
+        await engine.addInteractor("externalTrail", (container) => new TrailMaker_1.TrailMaker(container));
+    }
+    exports.loadExternalTrailInteraction = loadExternalTrailInteraction;
+});

package/umd/Interactions/Particles/Attract/Attractor.d.ts

@@ -0,0 +1,8 @@
+import type { Container, IParticle, Particle } from "../../../Core";
+import { ParticlesInteractorBase } from "../../../Core";
+export declare class Attractor extends ParticlesInteractorBase {
+    constructor(container: Container);
+    interact(p1: IParticle): Promise<void>;
+    isEnabled(particle: Particle): boolean;
+    reset(): void;
+}

package/umd/Interactions/Particles/Attract/Attractor.js

@@ -0,0 +1,40 @@
+(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", "../../../Core", "../../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Attractor = void 0;
+    const Core_1 = require("../../../Core");
+    const Utils_1 = require("../../../Utils");
+    class Attractor extends Core_1.ParticlesInteractorBase {
+        constructor(container) {
+            super(container);
+        }
+        async interact(p1) {
+            var _a;
+            const container = this.container, distance = (_a = p1.retina.attractDistance) !== null && _a !== void 0 ? _a : container.retina.attractDistance, pos1 = p1.getPosition(), query = container.particles.quadTree.queryCircle(pos1, distance);
+            for (const p2 of query) {
+                if (p1 === p2 || !p2.options.move.attract.enable || p2.destroyed || p2.spawning) {
+                    continue;
+                }
+                const pos2 = p2.getPosition(), { dx, dy } = (0, Utils_1.getDistances)(pos1, pos2), rotate = p1.options.move.attract.rotate, ax = dx / (rotate.x * 1000), ay = dy / (rotate.y * 1000), p1Factor = p2.size.value / p1.size.value, p2Factor = 1 / p1Factor;
+                p1.velocity.x -= ax * p1Factor;
+                p1.velocity.y -= ay * p1Factor;
+                p2.velocity.x += ax * p2Factor;
+                p2.velocity.y += ay * p2Factor;
+            }
+        }
+        isEnabled(particle) {
+            return particle.options.move.attract.enable;
+        }
+        reset() {
+        }
+    }
+    exports.Attractor = Attractor;
+});

package/umd/Interactions/Particles/Attract/index.d.ts

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

package/umd/Interactions/Particles/Attract/index.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", "./Attractor"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadParticlesAttractInteraction = void 0;
+    const Attractor_1 = require("./Attractor");
+    async function loadParticlesAttractInteraction(engine) {
+        await engine.addInteractor("particlesAttract", (container) => new Attractor_1.Attractor(container));
+    }
+    exports.loadParticlesAttractInteraction = loadParticlesAttractInteraction;
+});

package/umd/Interactions/Particles/Collisions/Collider.d.ts

@@ -0,0 +1,10 @@
+import type { Container, Particle } from "../../../Core";
+import { ParticlesInteractorBase } from "../../../Core";
+export declare class Collider extends ParticlesInteractorBase {
+    constructor(container: Container);
+    isEnabled(particle: Particle): boolean;
+    reset(): void;
+    interact(p1: Particle): Promise<void>;
+    private resolveCollision;
+    private absorb;
+}

package/umd/Interactions/Particles/Collisions/Collider.js

@@ -0,0 +1,119 @@
+(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", "../../../Core"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Collider = void 0;
+    const Utils_1 = require("../../../Utils");
+    const Core_1 = require("../../../Core");
+    function bounce(p1, p2) {
+        (0, Utils_1.circleBounce)((0, Utils_1.circleBounceDataFromParticle)(p1), (0, Utils_1.circleBounceDataFromParticle)(p2));
+    }
+    function destroy(p1, p2) {
+        if (!p1.unbreakable && !p2.unbreakable) {
+            bounce(p1, p2);
+        }
+        if (p1.getRadius() === undefined && p2.getRadius() !== undefined) {
+            p1.destroy();
+        }
+        else if (p1.getRadius() !== undefined && p2.getRadius() === undefined) {
+            p2.destroy();
+        }
+        else if (p1.getRadius() !== undefined && p2.getRadius() !== undefined) {
+            if (p1.getRadius() >= p2.getRadius()) {
+                p2.destroy();
+            }
+            else {
+                p1.destroy();
+            }
+        }
+    }
+    class Collider extends Core_1.ParticlesInteractorBase {
+        constructor(container) {
+            super(container);
+        }
+        isEnabled(particle) {
+            return particle.options.collisions.enable;
+        }
+        reset() {
+        }
+        async interact(p1) {
+            const container = this.container;
+            const pos1 = p1.getPosition();
+            const radius1 = p1.getRadius();
+            const query = container.particles.quadTree.queryCircle(pos1, radius1 * 2);
+            for (const p2 of query) {
+                if (p1 === p2 ||
+                    !p2.options.collisions.enable ||
+                    p1.options.collisions.mode !== p2.options.collisions.mode ||
+                    p2.destroyed ||
+                    p2.spawning) {
+                    continue;
+                }
+                const pos2 = p2.getPosition();
+                if (Math.round(pos1.z) !== Math.round(pos2.z)) {
+                    continue;
+                }
+                const dist = (0, Utils_1.getDistance)(pos1, pos2);
+                const radius2 = p2.getRadius();
+                const distP = radius1 + radius2;
+                if (dist <= distP) {
+                    this.resolveCollision(p1, p2);
+                }
+            }
+        }
+        resolveCollision(p1, p2) {
+            switch (p1.options.collisions.mode) {
+                case "absorb": {
+                    this.absorb(p1, p2);
+                    break;
+                }
+                case "bounce": {
+                    bounce(p1, p2);
+                    break;
+                }
+                case "destroy": {
+                    destroy(p1, p2);
+                    break;
+                }
+            }
+        }
+        absorb(p1, p2) {
+            const container = this.container;
+            const fps = container.fpsLimit / 1000;
+            if (p1.getRadius() === undefined && p2.getRadius() !== undefined) {
+                p1.destroy();
+            }
+            else if (p1.getRadius() !== undefined && p2.getRadius() === undefined) {
+                p2.destroy();
+            }
+            else if (p1.getRadius() !== undefined && p2.getRadius() !== undefined) {
+                if (p1.getRadius() >= p2.getRadius()) {
+                    const factor = (0, Utils_1.clamp)(p1.getRadius() / p2.getRadius(), 0, p2.getRadius()) * fps;
+                    p1.size.value += factor;
+                    p2.size.value -= factor;
+                    if (p2.getRadius() <= container.retina.pixelRatio) {
+                        p2.size.value = 0;
+                        p2.destroy();
+                    }
+                }
+                else {
+                    const factor = (0, Utils_1.clamp)(p2.getRadius() / p1.getRadius(), 0, p1.getRadius()) * fps;
+                    p1.size.value -= factor;
+                    p2.size.value += factor;
+                    if (p1.getRadius() <= container.retina.pixelRatio) {
+                        p1.size.value = 0;
+                        p1.destroy();
+                    }
+                }
+            }
+        }
+    }
+    exports.Collider = Collider;
+});

package/umd/Interactions/Particles/Collisions/index.d.ts

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

package/umd/Interactions/Particles/Collisions/index.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", "./Collider"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadParticlesCollisionsInteraction = void 0;
+    const Collider_1 = require("./Collider");
+    async function loadParticlesCollisionsInteraction(engine) {
+        await engine.addInteractor("particlesCollisions", (container) => new Collider_1.Collider(container));
+    }
+    exports.loadParticlesCollisionsInteraction = loadParticlesCollisionsInteraction;
+});

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

@@ -0,0 +1,9 @@
+import type { LinkParticle } from "./LinkParticle";
+export interface ILink {
+    destination: LinkParticle;
+    opacity: number;
+}
+export interface ILinkTriangle {
+    vertices: LinkParticle[];
+    opacity: number;
+}

package/umd/Interactions/Particles/Links/ILink.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/Interactions/Particles/Links/LinkInstance.d.ts

@@ -0,0 +1,10 @@
+import type { Container, IContainerPlugin, Particle } from "../../../Core";
+export declare class LinkInstance implements IContainerPlugin {
+    private readonly container;
+    constructor(container: Container);
+    particleCreated(particle: Particle): void;
+    particleDestroyed(particle: Particle): void;
+    drawParticle(context: CanvasRenderingContext2D, particle: Particle): void;
+    private drawLinkTriangle;
+    private drawLinkLine;
+}

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

@@ -0,0 +1,134 @@
+(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.LinkInstance = void 0;
+    const Utils_1 = require("../../../Utils");
+    class LinkInstance {
+        constructor(container) {
+            this.container = container;
+        }
+        particleCreated(particle) {
+            const linkParticle = particle;
+            linkParticle.links = [];
+        }
+        particleDestroyed(particle) {
+            const linkParticle = particle;
+            linkParticle.links = [];
+        }
+        drawParticle(context, particle) {
+            const linkParticle = particle;
+            const container = this.container;
+            const particles = container.particles;
+            const pOptions = particle.options;
+            if (linkParticle.links.length > 0) {
+                context.save();
+                const p1Links = linkParticle.links.filter((l) => {
+                    const linkFreq = container.particles.getLinkFrequency(linkParticle, l.destination);
+                    return linkFreq <= pOptions.links.frequency;
+                });
+                for (const link of p1Links) {
+                    const p2 = link.destination;
+                    if (pOptions.links.triangles.enable) {
+                        const links = p1Links.map((l) => l.destination);
+                        const vertices = p2.links.filter((t) => {
+                            const linkFreq = container.particles.getLinkFrequency(p2, t.destination);
+                            return linkFreq <= p2.options.links.frequency && links.indexOf(t.destination) >= 0;
+                        });
+                        if (vertices.length) {
+                            for (const vertex of vertices) {
+                                const p3 = vertex.destination;
+                                const triangleFreq = particles.getTriangleFrequency(linkParticle, p2, p3);
+                                if (triangleFreq > pOptions.links.triangles.frequency) {
+                                    continue;
+                                }
+                                this.drawLinkTriangle(linkParticle, link, vertex);
+                            }
+                        }
+                    }
+                    if (link.opacity > 0 && container.retina.linksWidth > 0) {
+                        this.drawLinkLine(linkParticle, link);
+                    }
+                }
+                context.restore();
+            }
+        }
+        drawLinkTriangle(p1, link1, link2) {
+            var _a;
+            const container = this.container;
+            const options = container.actualOptions;
+            const p2 = link1.destination;
+            const p3 = link2.destination;
+            const triangleOptions = p1.options.links.triangles;
+            const opacityTriangle = (_a = triangleOptions.opacity) !== null && _a !== void 0 ? _a : (link1.opacity + link2.opacity) / 2;
+            if (opacityTriangle <= 0) {
+                return;
+            }
+            const pos1 = p1.getPosition();
+            const pos2 = p2.getPosition();
+            const pos3 = p3.getPosition();
+            container.canvas.draw((ctx) => {
+                if ((0, Utils_1.getDistance)(pos1, pos2) > container.retina.linksDistance ||
+                    (0, Utils_1.getDistance)(pos3, pos2) > container.retina.linksDistance ||
+                    (0, Utils_1.getDistance)(pos3, pos1) > container.retina.linksDistance) {
+                    return;
+                }
+                let colorTriangle = (0, Utils_1.colorToRgb)(triangleOptions.color);
+                if (!colorTriangle) {
+                    const linksOptions = p1.options.links;
+                    const linkColor = linksOptions.id !== undefined
+                        ? container.particles.linksColors.get(linksOptions.id)
+                        : container.particles.linksColor;
+                    colorTriangle = (0, Utils_1.getLinkColor)(p1, p2, linkColor);
+                }
+                if (!colorTriangle) {
+                    return;
+                }
+                (0, Utils_1.drawLinkTriangle)(ctx, pos1, pos2, pos3, options.backgroundMask.enable, options.backgroundMask.composite, colorTriangle, opacityTriangle);
+            });
+        }
+        drawLinkLine(p1, link) {
+            const container = this.container;
+            const options = container.actualOptions;
+            const p2 = link.destination;
+            let opacity = link.opacity;
+            const pos1 = p1.getPosition();
+            const pos2 = p2.getPosition();
+            container.canvas.draw((ctx) => {
+                var _a, _b;
+                let colorLine;
+                const twinkle = p1.options.twinkle.lines;
+                if (twinkle.enable) {
+                    const twinkleFreq = twinkle.frequency;
+                    const twinkleRgb = (0, Utils_1.colorToRgb)(twinkle.color);
+                    const twinkling = Math.random() < twinkleFreq;
+                    if (twinkling && twinkleRgb !== undefined) {
+                        colorLine = twinkleRgb;
+                        opacity = twinkle.opacity;
+                    }
+                }
+                if (!colorLine) {
+                    const linksOptions = p1.options.links;
+                    const linkColor = linksOptions.id !== undefined
+                        ? container.particles.linksColors.get(linksOptions.id)
+                        : container.particles.linksColor;
+                    colorLine = (0, Utils_1.getLinkColor)(p1, p2, linkColor);
+                }
+                if (!colorLine) {
+                    return;
+                }
+                const width = (_a = p1.retina.linksWidth) !== null && _a !== void 0 ? _a : container.retina.linksWidth;
+                const maxDistance = (_b = p1.retina.linksDistance) !== null && _b !== void 0 ? _b : container.retina.linksDistance;
+                (0, Utils_1.drawLinkLine)(ctx, width, pos1, pos2, maxDistance, container.canvas.size, p1.options.links.warp, options.backgroundMask.enable, options.backgroundMask.composite, colorLine, opacity, p1.options.links.shadow);
+            });
+        }
+    }
+    exports.LinkInstance = LinkInstance;
+});

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

@@ -0,0 +1,5 @@
+import type { ILink } from "./ILink";
+import type { Particle } from "../../../Core";
+export declare type LinkParticle = Particle & {
+    links: ILink[];
+};

package/umd/Interactions/Particles/Links/LinkParticle.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/Interactions/Particles/Links/Linker.d.ts

@@ -0,0 +1,10 @@
+import { ParticlesInteractorBase } from "../../../Core";
+import type { Container, Particle } from "../../../Core";
+import type { LinkParticle } from "./LinkParticle";
+export declare class Linker extends ParticlesInteractorBase {
+    constructor(container: Container);
+    isEnabled(particle: Particle): boolean;
+    reset(): void;
+    interact(p1: LinkParticle): Promise<void>;
+    private setColor;
+}

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

@@ -0,0 +1,115 @@
+(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", "../../../Core", "../../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Linker = void 0;
+    const Core_1 = require("../../../Core");
+    const Utils_1 = require("../../../Utils");
+    function getLinkDistance(pos1, pos2, optDistance, canvasSize, warp) {
+        let distance = (0, Utils_1.getDistance)(pos1, pos2);
+        if (!warp || distance <= optDistance) {
+            return distance;
+        }
+        const pos2NE = {
+            x: pos2.x - canvasSize.width,
+            y: pos2.y,
+        };
+        distance = (0, Utils_1.getDistance)(pos1, pos2NE);
+        if (distance <= optDistance) {
+            return distance;
+        }
+        const pos2SE = {
+            x: pos2.x - canvasSize.width,
+            y: pos2.y - canvasSize.height,
+        };
+        distance = (0, Utils_1.getDistance)(pos1, pos2SE);
+        if (distance <= optDistance) {
+            return distance;
+        }
+        const pos2SW = {
+            x: pos2.x,
+            y: pos2.y - canvasSize.height,
+        };
+        distance = (0, Utils_1.getDistance)(pos1, pos2SW);
+        return distance;
+    }
+    class Linker extends Core_1.ParticlesInteractorBase {
+        constructor(container) {
+            super(container);
+        }
+        isEnabled(particle) {
+            return particle.options.links.enable;
+        }
+        reset() {
+        }
+        async interact(p1) {
+            var _a;
+            p1.links = [];
+            const pos1 = p1.getPosition();
+            const container = this.container;
+            const canvasSize = container.canvas.size;
+            if (pos1.x < 0 || pos1.y < 0 || pos1.x > canvasSize.width || pos1.y > canvasSize.height) {
+                return;
+            }
+            const linkOpt1 = p1.options.links;
+            const optOpacity = linkOpt1.opacity;
+            const optDistance = (_a = p1.retina.linksDistance) !== null && _a !== void 0 ? _a : container.retina.linksDistance;
+            const warp = linkOpt1.warp;
+            const range = warp
+                ? new Core_1.CircleWarp(pos1.x, pos1.y, optDistance, canvasSize)
+                : new Core_1.Circle(pos1.x, pos1.y, optDistance);
+            const query = container.particles.quadTree.query(range);
+            for (const p2 of query) {
+                const linkOpt2 = p2.options.links;
+                if (p1 === p2 ||
+                    !linkOpt2.enable ||
+                    linkOpt1.id !== linkOpt2.id ||
+                    p2.spawning ||
+                    p2.destroyed ||
+                    p1.links.map((t) => t.destination).indexOf(p2) !== -1 ||
+                    p2.links.map((t) => t.destination).indexOf(p1) !== -1) {
+                    continue;
+                }
+                const pos2 = p2.getPosition();
+                if (pos2.x < 0 || pos2.y < 0 || pos2.x > canvasSize.width || pos2.y > canvasSize.height) {
+                    continue;
+                }
+                const distance = getLinkDistance(pos1, pos2, optDistance, canvasSize, warp && linkOpt2.warp);
+                if (distance > optDistance) {
+                    return;
+                }
+                const opacityLine = (1 - distance / optDistance) * optOpacity;
+                this.setColor(p1);
+                p1.links.push({
+                    destination: p2,
+                    opacity: opacityLine,
+                });
+            }
+        }
+        setColor(p1) {
+            const container = this.container;
+            const linksOptions = p1.options.links;
+            let linkColor = linksOptions.id === undefined
+                ? container.particles.linksColor
+                : container.particles.linksColors.get(linksOptions.id);
+            if (!linkColor) {
+                const optColor = linksOptions.color;
+                linkColor = (0, Utils_1.getLinkRandomColor)(optColor, linksOptions.blink, linksOptions.consent);
+                if (linksOptions.id === undefined) {
+                    container.particles.linksColor = linkColor;
+                }
+                else {
+                    container.particles.linksColors.set(linksOptions.id, linkColor);
+                }
+            }
+        }
+    }
+    exports.Linker = Linker;
+});

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

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