@tsparticles/interaction-particles-links 3.0.0-alpha.0

package/cjs/CircleWarp.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircleWarp = void 0;
+const engine_1 = require("@tsparticles/engine");
+class CircleWarp extends engine_1.Circle {
+    constructor(x, y, radius, canvasSize) {
+        super(x, y, radius);
+        this.canvasSize = canvasSize;
+        this.canvasSize = Object.assign({}, canvasSize);
+    }
+    contains(point) {
+        if (super.contains(point)) {
+            return true;
+        }
+        const posNE = {
+            x: point.x - this.canvasSize.width,
+            y: point.y,
+        };
+        if (super.contains(posNE)) {
+            return true;
+        }
+        const posSE = {
+            x: point.x - this.canvasSize.width,
+            y: point.y - this.canvasSize.height,
+        };
+        if (super.contains(posSE)) {
+            return true;
+        }
+        const posSW = {
+            x: point.x,
+            y: point.y - this.canvasSize.height,
+        };
+        return super.contains(posSW);
+    }
+    intersects(range) {
+        if (super.intersects(range)) {
+            return true;
+        }
+        const rect = range, circle = range, newPos = {
+            x: range.position.x - this.canvasSize.width,
+            y: range.position.y - this.canvasSize.height,
+        };
+        if (circle.radius !== undefined) {
+            const biggerCircle = new engine_1.Circle(newPos.x, newPos.y, circle.radius * 2);
+            return super.intersects(biggerCircle);
+        }
+        else if (rect.size !== undefined) {
+            const rectSW = new engine_1.Rectangle(newPos.x, newPos.y, rect.size.width * 2, rect.size.height * 2);
+            return super.intersects(rectSW);
+        }
+        return false;
+    }
+}
+exports.CircleWarp = CircleWarp;

package/cjs/ILink.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/LinkContainer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/LinkInstance.js

@@ -0,0 +1,158 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkInstance = void 0;
+const Utils_1 = require("./Utils");
+const engine_1 = require("@tsparticles/engine");
+function getLinkKey(ids) {
+    ids.sort((a, b) => a - b);
+    return ids.join("_");
+}
+function setLinkFrequency(particles, dictionary) {
+    const key = getLinkKey(particles.map((t) => t.id));
+    let res = dictionary.get(key);
+    if (res === undefined) {
+        res = (0, engine_1.getRandom)();
+        dictionary.set(key, res);
+    }
+    return res;
+}
+class LinkInstance {
+    constructor(container) {
+        this.container = container;
+        this._freqs = {
+            links: new Map(),
+            triangles: new Map(),
+        };
+    }
+    drawParticle(context, particle) {
+        var _a;
+        const pOptions = particle.options;
+        if (!particle.links || particle.links.length <= 0) {
+            return;
+        }
+        const p1Links = particle.links.filter((l) => pOptions.links && this.getLinkFrequency(particle, l.destination) <= pOptions.links.frequency);
+        for (const link of p1Links) {
+            this.drawTriangles(pOptions, particle, link, p1Links);
+            if (link.opacity > 0 && ((_a = particle.retina.linksWidth) !== null && _a !== void 0 ? _a : 0) > 0) {
+                this.drawLinkLine(particle, link);
+            }
+        }
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._freqs.links = new Map();
+            this._freqs.triangles = new Map();
+        });
+    }
+    particleCreated(particle) {
+        particle.links = [];
+        if (!particle.options.links) {
+            return;
+        }
+        const ratio = this.container.retina.pixelRatio;
+        particle.retina.linksDistance = particle.options.links.distance * ratio;
+        particle.retina.linksWidth = particle.options.links.width * ratio;
+    }
+    particleDestroyed(particle) {
+        particle.links = [];
+    }
+    drawLinkLine(p1, link) {
+        const container = this.container, options = container.actualOptions, p2 = link.destination, pos1 = p1.getPosition(), pos2 = p2.getPosition();
+        let opacity = link.opacity;
+        container.canvas.draw((ctx) => {
+            var _a, _b, _c;
+            if (!p1.options.links) {
+                return;
+            }
+            let colorLine;
+            const twinkle = (_a = p1.options.twinkle) === null || _a === void 0 ? void 0 : _a.lines;
+            if (twinkle === null || twinkle === void 0 ? void 0 : twinkle.enable) {
+                const twinkleFreq = twinkle.frequency, twinkleRgb = (0, engine_1.rangeColorToRgb)(twinkle.color), twinkling = (0, engine_1.getRandom)() < twinkleFreq;
+                if (twinkling && twinkleRgb) {
+                    colorLine = twinkleRgb;
+                    opacity = (0, engine_1.getRangeValue)(twinkle.opacity);
+                }
+            }
+            if (!colorLine) {
+                const linksOptions = p1.options.links, linkColor = (linksOptions === null || linksOptions === void 0 ? void 0 : linksOptions.id) !== undefined
+                    ? container.particles.linksColors.get(linksOptions.id)
+                    : container.particles.linksColor;
+                colorLine = (0, engine_1.getLinkColor)(p1, p2, linkColor);
+            }
+            if (!colorLine) {
+                return;
+            }
+            const width = (_b = p1.retina.linksWidth) !== null && _b !== void 0 ? _b : 0, maxDistance = (_c = p1.retina.linksDistance) !== null && _c !== void 0 ? _c : 0;
+            (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);
+        });
+    }
+    drawLinkTriangle(p1, link1, link2) {
+        var _a;
+        if (!p1.options.links) {
+            return;
+        }
+        const container = this.container, options = container.actualOptions, p2 = link1.destination, p3 = link2.destination, triangleOptions = p1.options.links.triangles, opacityTriangle = (_a = triangleOptions.opacity) !== null && _a !== void 0 ? _a : (link1.opacity + link2.opacity) / 2;
+        if (opacityTriangle <= 0) {
+            return;
+        }
+        container.canvas.draw((ctx) => {
+            var _a;
+            const pos1 = p1.getPosition(), pos2 = p2.getPosition(), pos3 = p3.getPosition(), linksDistance = (_a = p1.retina.linksDistance) !== null && _a !== void 0 ? _a : 0;
+            if ((0, engine_1.getDistance)(pos1, pos2) > linksDistance ||
+                (0, engine_1.getDistance)(pos3, pos2) > linksDistance ||
+                (0, engine_1.getDistance)(pos3, pos1) > linksDistance) {
+                return;
+            }
+            let colorTriangle = (0, engine_1.rangeColorToRgb)(triangleOptions.color);
+            if (!colorTriangle) {
+                const linksOptions = p1.options.links, linkColor = (linksOptions === null || linksOptions === void 0 ? void 0 : linksOptions.id) !== undefined
+                    ? container.particles.linksColors.get(linksOptions.id)
+                    : container.particles.linksColor;
+                colorTriangle = (0, engine_1.getLinkColor)(p1, p2, linkColor);
+            }
+            if (!colorTriangle) {
+                return;
+            }
+            (0, Utils_1.drawLinkTriangle)(ctx, pos1, pos2, pos3, options.backgroundMask.enable, options.backgroundMask.composite, colorTriangle, opacityTriangle);
+        });
+    }
+    drawTriangles(options, p1, link, p1Links) {
+        var _a, _b, _c;
+        const p2 = link.destination;
+        if (!(((_a = options.links) === null || _a === void 0 ? void 0 : _a.triangles.enable) && ((_b = p2.options.links) === null || _b === void 0 ? void 0 : _b.triangles.enable))) {
+            return;
+        }
+        const vertices = (_c = p2.links) === null || _c === void 0 ? void 0 : _c.filter((t) => {
+            const linkFreq = this.getLinkFrequency(p2, t.destination);
+            return (p2.options.links &&
+                linkFreq <= p2.options.links.frequency &&
+                p1Links.findIndex((l) => l.destination === t.destination) >= 0);
+        });
+        if (!(vertices === null || vertices === void 0 ? void 0 : vertices.length)) {
+            return;
+        }
+        for (const vertex of vertices) {
+            const p3 = vertex.destination, triangleFreq = this.getTriangleFrequency(p1, p2, p3);
+            if (triangleFreq > options.links.triangles.frequency) {
+                continue;
+            }
+            this.drawLinkTriangle(p1, link, vertex);
+        }
+    }
+    getLinkFrequency(p1, p2) {
+        return setLinkFrequency([p1, p2], this._freqs.links);
+    }
+    getTriangleFrequency(p1, p2, p3) {
+        return setLinkFrequency([p1, p2, p3], this._freqs.triangles);
+    }
+}
+exports.LinkInstance = LinkInstance;

package/cjs/LinkParticle.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/Linker.js

@@ -0,0 +1,134 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Linker = void 0;
+const engine_1 = require("@tsparticles/engine");
+const CircleWarp_1 = require("./CircleWarp");
+const Links_1 = require("./Options/Classes/Links");
+function getLinkDistance(pos1, pos2, optDistance, canvasSize, warp) {
+    let distance = (0, engine_1.getDistance)(pos1, pos2);
+    if (!warp || distance <= optDistance) {
+        return distance;
+    }
+    const pos2NE = {
+        x: pos2.x - canvasSize.width,
+        y: pos2.y,
+    };
+    distance = (0, engine_1.getDistance)(pos1, pos2NE);
+    if (distance <= optDistance) {
+        return distance;
+    }
+    const pos2SE = {
+        x: pos2.x - canvasSize.width,
+        y: pos2.y - canvasSize.height,
+    };
+    distance = (0, engine_1.getDistance)(pos1, pos2SE);
+    if (distance <= optDistance) {
+        return distance;
+    }
+    const pos2SW = {
+        x: pos2.x,
+        y: pos2.y - canvasSize.height,
+    };
+    distance = (0, engine_1.getDistance)(pos1, pos2SW);
+    return distance;
+}
+class Linker extends engine_1.ParticlesInteractorBase {
+    constructor(container) {
+        super(container);
+        this.linkContainer = container;
+    }
+    clear() {
+    }
+    init() {
+        this.linkContainer.particles.linksColor = undefined;
+        this.linkContainer.particles.linksColors = new Map();
+    }
+    interact(p1) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!p1.options.links) {
+                return;
+            }
+            p1.links = [];
+            const pos1 = p1.getPosition(), container = this.container, 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, optOpacity = linkOpt1.opacity, optDistance = (_a = p1.retina.linksDistance) !== null && _a !== void 0 ? _a : 0, warp = linkOpt1.warp, range = warp
+                ? new CircleWarp_1.CircleWarp(pos1.x, pos1.y, optDistance, canvasSize)
+                : new engine_1.Circle(pos1.x, pos1.y, optDistance), query = container.particles.quadTree.query(range);
+            for (const p2 of query) {
+                const linkOpt2 = p2.options.links;
+                if (p1 === p2 ||
+                    !(linkOpt2 === null || linkOpt2 === void 0 ? void 0 : linkOpt2.enable) ||
+                    linkOpt1.id !== linkOpt2.id ||
+                    p2.spawning ||
+                    p2.destroyed ||
+                    !p2.links ||
+                    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,
+                });
+            }
+        });
+    }
+    isEnabled(particle) {
+        var _a;
+        return !!((_a = particle.options.links) === null || _a === void 0 ? void 0 : _a.enable);
+    }
+    loadParticlesOptions(options, ...sources) {
+        var _a, _b;
+        if (!options.links) {
+            options.links = new Links_1.Links();
+        }
+        for (const source of sources) {
+            options.links.load((_b = (_a = source === null || source === void 0 ? void 0 : source.links) !== null && _a !== void 0 ? _a : source === null || source === void 0 ? void 0 : source.lineLinked) !== null && _b !== void 0 ? _b : source === null || source === void 0 ? void 0 : source.line_linked);
+        }
+    }
+    reset() {
+    }
+    setColor(p1) {
+        if (!p1.options.links) {
+            return;
+        }
+        const container = this.linkContainer, linksOptions = p1.options.links;
+        let linkColor = linksOptions.id === undefined
+            ? container.particles.linksColor
+            : container.particles.linksColors.get(linksOptions.id);
+        if (linkColor) {
+            return;
+        }
+        const optColor = linksOptions.color;
+        linkColor = (0, engine_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/cjs/Options/Classes/Links.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Links = void 0;
+const LinksShadow_1 = require("./LinksShadow");
+const LinksTriangle_1 = require("./LinksTriangle");
+const engine_1 = require("@tsparticles/engine");
+class Links {
+    constructor() {
+        this.blink = false;
+        this.color = new engine_1.OptionsColor();
+        this.color.value = "#fff";
+        this.consent = false;
+        this.distance = 100;
+        this.enable = false;
+        this.frequency = 1;
+        this.opacity = 1;
+        this.shadow = new LinksShadow_1.LinksShadow();
+        this.triangles = new LinksTriangle_1.LinksTriangle();
+        this.width = 1;
+        this.warp = false;
+    }
+    load(data) {
+        if (!data) {
+            return;
+        }
+        if (data.id !== undefined) {
+            this.id = data.id;
+        }
+        if (data.blink !== undefined) {
+            this.blink = data.blink;
+        }
+        this.color = engine_1.OptionsColor.create(this.color, data.color);
+        if (data.consent !== undefined) {
+            this.consent = data.consent;
+        }
+        if (data.distance !== undefined) {
+            this.distance = data.distance;
+        }
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
+        if (data.frequency !== undefined) {
+            this.frequency = data.frequency;
+        }
+        if (data.opacity !== undefined) {
+            this.opacity = data.opacity;
+        }
+        this.shadow.load(data.shadow);
+        this.triangles.load(data.triangles);
+        if (data.width !== undefined) {
+            this.width = data.width;
+        }
+        if (data.warp !== undefined) {
+            this.warp = data.warp;
+        }
+    }
+}
+exports.Links = Links;

package/cjs/Options/Classes/LinksShadow.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinksShadow = void 0;
+const engine_1 = require("@tsparticles/engine");
+class LinksShadow {
+    constructor() {
+        this.blur = 5;
+        this.color = new engine_1.OptionsColor();
+        this.color.value = "#000";
+        this.enable = false;
+    }
+    load(data) {
+        if (!data) {
+            return;
+        }
+        if (data.blur !== undefined) {
+            this.blur = data.blur;
+        }
+        this.color = engine_1.OptionsColor.create(this.color, data.color);
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
+    }
+}
+exports.LinksShadow = LinksShadow;

package/cjs/Options/Classes/LinksTriangle.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinksTriangle = void 0;
+const engine_1 = require("@tsparticles/engine");
+class LinksTriangle {
+    constructor() {
+        this.enable = false;
+        this.frequency = 1;
+    }
+    load(data) {
+        if (!data) {
+            return;
+        }
+        if (data.color !== undefined) {
+            this.color = engine_1.OptionsColor.create(this.color, data.color);
+        }
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
+        if (data.frequency !== undefined) {
+            this.frequency = data.frequency;
+        }
+        if (data.opacity !== undefined) {
+            this.opacity = data.opacity;
+        }
+    }
+}
+exports.LinksTriangle = LinksTriangle;

package/cjs/Options/Classes/ParticlesLinkOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/Options/Interfaces/ILinks.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/Options/Interfaces/ILinksShadow.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/Options/Interfaces/ILinksTriangle.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/Options/Interfaces/IParticlesLinkOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/Utils.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drawLinkTriangle = exports.drawLinkLine = void 0;
+const engine_1 = require("@tsparticles/engine");
+function drawLinkLine(context, width, begin, end, maxDistance, canvasSize, warp, backgroundMask, composite, colorLine, opacity, shadow) {
+    let drawn = false;
+    if ((0, engine_1.getDistance)(begin, end) <= maxDistance) {
+        (0, engine_1.drawLine)(context, begin, end);
+        drawn = true;
+    }
+    else if (warp) {
+        let pi1;
+        let pi2;
+        const endNE = {
+            x: end.x - canvasSize.width,
+            y: end.y,
+        };
+        const d1 = (0, engine_1.getDistances)(begin, endNE);
+        if (d1.distance <= maxDistance) {
+            const yi = begin.y - (d1.dy / d1.dx) * begin.x;
+            pi1 = { x: 0, y: yi };
+            pi2 = { x: canvasSize.width, y: yi };
+        }
+        else {
+            const endSW = {
+                x: end.x,
+                y: end.y - canvasSize.height,
+            };
+            const d2 = (0, engine_1.getDistances)(begin, endSW);
+            if (d2.distance <= maxDistance) {
+                const yi = begin.y - (d2.dy / d2.dx) * begin.x;
+                const xi = -yi / (d2.dy / d2.dx);
+                pi1 = { x: xi, y: 0 };
+                pi2 = { x: xi, y: canvasSize.height };
+            }
+            else {
+                const endSE = {
+                    x: end.x - canvasSize.width,
+                    y: end.y - canvasSize.height,
+                };
+                const d3 = (0, engine_1.getDistances)(begin, endSE);
+                if (d3.distance <= maxDistance) {
+                    const yi = begin.y - (d3.dy / d3.dx) * begin.x;
+                    const xi = -yi / (d3.dy / d3.dx);
+                    pi1 = { x: xi, y: yi };
+                    pi2 = { x: pi1.x + canvasSize.width, y: pi1.y + canvasSize.height };
+                }
+            }
+        }
+        if (pi1 && pi2) {
+            (0, engine_1.drawLine)(context, begin, pi1);
+            (0, engine_1.drawLine)(context, end, pi2);
+            drawn = true;
+        }
+    }
+    if (!drawn) {
+        return;
+    }
+    context.lineWidth = width;
+    if (backgroundMask) {
+        context.globalCompositeOperation = composite;
+    }
+    context.strokeStyle = (0, engine_1.getStyleFromRgb)(colorLine, opacity);
+    if (shadow.enable) {
+        const shadowColor = (0, engine_1.rangeColorToRgb)(shadow.color);
+        if (shadowColor) {
+            context.shadowBlur = shadow.blur;
+            context.shadowColor = (0, engine_1.getStyleFromRgb)(shadowColor);
+        }
+    }
+    context.stroke();
+}
+exports.drawLinkLine = drawLinkLine;
+function drawLinkTriangle(context, pos1, pos2, pos3, backgroundMask, composite, colorTriangle, opacityTriangle) {
+    (0, engine_1.drawTriangle)(context, pos1, pos2, pos3);
+    if (backgroundMask) {
+        context.globalCompositeOperation = composite;
+    }
+    context.fillStyle = (0, engine_1.getStyleFromRgb)(colorTriangle, opacityTriangle);
+    context.fill();
+}
+exports.drawLinkTriangle = drawLinkTriangle;

package/cjs/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadParticlesLinksInteraction = void 0;
+const interaction_1 = require("./interaction");
+const plugin_1 = require("./plugin");
+function loadParticlesLinksInteraction(engine) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield (0, interaction_1.loadInteraction)(engine);
+        yield (0, plugin_1.loadPlugin)(engine);
+    });
+}
+exports.loadParticlesLinksInteraction = loadParticlesLinksInteraction;
+__exportStar(require("./Options/Classes/Links"), exports);
+__exportStar(require("./Options/Classes/LinksShadow"), exports);
+__exportStar(require("./Options/Classes/LinksTriangle"), exports);
+__exportStar(require("./Options/Interfaces/ILinks"), exports);
+__exportStar(require("./Options/Interfaces/ILinksShadow"), exports);
+__exportStar(require("./Options/Interfaces/ILinksTriangle"), exports);

package/cjs/interaction.js

@@ -0,0 +1,19 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadInteraction = void 0;
+const Linker_1 = require("./Linker");
+function loadInteraction(engine) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield engine.addInteractor("particlesLinks", (container) => new Linker_1.Linker(container));
+    });
+}
+exports.loadInteraction = loadInteraction;

package/cjs/plugin.js

@@ -0,0 +1,33 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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);
+    }
+    loadOptions() {
+    }
+    needsPlugin() {
+        return true;
+    }
+}
+function loadPlugin(engine) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const plugin = new LinksPlugin();
+        yield engine.addPlugin(plugin);
+    });
+}
+exports.loadPlugin = loadPlugin;