@tsparticles/interaction-particles-links 4.0.0-alpha.5 → 4.0.0-beta.0

package/13.min.js

@@ -0,0 +1 @@
+"use strict";(this.webpackChunk_tsparticles_interaction_particles_links=this.webpackChunk_tsparticles_interaction_particles_links||[]).push([[13],{13(n,i,t){t.r(i),t.d(i,{LinksPlugin:()=>e});class e{id="links";_engine;constructor(n){this._engine=n}async getPlugin(n){let{LinkInstance:i}=await t.e(823).then(t.bind(t,823));return new i(n,this._engine)}loadOptions(){}needsPlugin(){return!0}}}}]);

package/342.min.js

@@ -0,0 +1 @@
+"use strict";(this.webpackChunk_tsparticles_interaction_particles_links=this.webpackChunk_tsparticles_interaction_particles_links||[]).push([[342],{342(i,t,n){n.d(t,{Linker:()=>a});var s=n(303);class e extends s.Circle{canvasSize;constructor(i,t,n,s){super(i,t,n),this.canvasSize=s}contains(i){if(super.contains(i))return!0;let{width:t,height:n}=this.canvasSize,{x:s,y:e}=i;return super.contains({x:s-t,y:e})||super.contains({x:s+t,y:e})||super.contains({x:s,y:e-n})||super.contains({x:s,y:e+n})||super.contains({x:s-t,y:e-n})||super.contains({x:s+t,y:e+n})||super.contains({x:s-t,y:e+n})||super.contains({x:s+t,y:e-n})}intersects(i){if(super.intersects(i))return!0;let{width:t,height:n}=this.canvasSize,e=i.position;for(let r of[{x:-t,y:0},{x:t,y:0},{x:0,y:-n},{x:0,y:n},{x:-t,y:-n},{x:t,y:n},{x:-t,y:n},{x:t,y:-n}]){let t,n={x:e.x+r.x,y:e.y+r.y};if(t=i instanceof s.Circle?new s.Circle(n.x,n.y,i.radius):new s.Rectangle(n.x,n.y,i.size.width,i.size.height),super.intersects(t))return!0}return!1}}var r=n(348),o=n(702);class a extends o.ParticlesInteractorBase{_engine;_maxDistance;constructor(i,t){super(i),this._engine=t,this._maxDistance=0}get maxDistance(){return this._maxDistance}clear(){}init(){this.container.particles.linksColor=void 0,this.container.particles.linksColors=new Map}interact(i){if(!i.options.links)return;i.links=[],i.linksDistance&&i.linksDistance>this._maxDistance&&(this._maxDistance=i.linksDistance);let t=i.getPosition(),n=this.container,r=n.canvas.size;if(t.x<s.originPoint.x||t.y<s.originPoint.y||t.x>r.width||t.y>r.height)return;let o=i.options.links,a=o.opacity,l=i.retina.linksDistance??0,c=o.warp,p=c?new e(t.x,t.y,l,r):new s.Circle(t.x,t.y,l);for(let e of n.particles.grid.query(p)){let n=e.options.links;if(i===e||!n?.enable||o.id!==n.id||e.spawning||e.destroyed||!e.links||i.links.some(i=>i.destination===e)||e.links.some(t=>t.destination===i))continue;let p=e.getPosition();if(p.x<s.originPoint.x||p.y<s.originPoint.y||p.x>r.width||p.y>r.height)continue;let h=(0,s.getDistances)(t,p).distance,x=c&&n.warp?function(i,t,n){let{dx:e,dy:r}=(0,s.getDistances)(i,t),o={x:Math.abs(e),y:Math.abs(r)},a={x:Math.min(o.x,n.width-o.x),y:Math.min(o.y,n.height-o.y)};return Math.hypot(a.x,a.y)}(t,p,r):h,k=Math.min(h,x);if(k>l)continue;let u=(1-k/l)*a;this._setColor(i),i.links.push({destination:e,opacity:u,color:this._getLinkColor(i,e),isWarped:x<h})}}isEnabled(i){return!!i.options.links?.enable}loadParticlesOptions(i,...t){for(let n of(i.links??=new r.q,t))i.links.load(n?.links)}reset(){}_getLinkColor(i,t){let n=this.container,e=i.options.links;if(!e)return;let r=void 0!==e.id?n.particles.linksColors.get(e.id):n.particles.linksColor;return(0,s.getLinkColor)(i,t,r)}_setColor(i){if(!i.options.links)return;let t=this.container,n=i.options.links,e=void 0===n.id?t.particles.linksColor:t.particles.linksColors.get(n.id);e||(e=(0,s.getLinkRandomColor)(this._engine,n.color,n.blink,n.consent),void 0===n.id?t.particles.linksColor=e:t.particles.linksColors.set(n.id,e))}}}}]);

package/823.min.js

@@ -0,0 +1 @@
+"use strict";(this.webpackChunk_tsparticles_interaction_particles_links=this.webpackChunk_tsparticles_interaction_particles_links||[]).push([[823],{823(e,i,t){t.d(i,{LinkInstance:()=>s});var n=t(303);function l(e,i){let t=[...e.map(e=>e.id)].sort((e,i)=>e-i).join("_"),l=i.get(t);return void 0===l&&(l=(0,n.getRandom)(),i.set(t,l)),l}class s{_colorCache=new Map;_container;_engine;_freqs;constructor(e,i){this._container=e,this._engine=i,this._freqs={links:new Map,triangles:new Map}}drawParticle(e,i){let{links:t,options:l}=i;if(!t?.length||!l.links)return;let s=l.links,o=i.retina.linksWidth??0,a=i.getPosition(),r=i.options.twinkle?.links,c=s.triangles.enable,h=c?new Set(t.map(e=>e.destination.id)):null,g=e.globalAlpha,d="",_=-1,k=-1,p=!1,y=()=>{p&&(e.stroke(),p=!1)};for(let g of t){if(s.frequency<1&&this._getLinkFrequency(i,g.destination)>s.frequency)continue;let t=g.destination.getPosition();if(c&&!g.isWarped&&h&&(y(),this._drawTriangles(l,i,g,h,a,t,e)),g.opacity<=0||o<=0||!s.enable)continue;let f=g.opacity,u=g.color,b=r?.enable&&(0,n.getRandom)()<r.frequency?(0,n.rangeColorToRgb)(this._engine,r.color):void 0;if(r&&b&&(u=b,f=(0,n.getRangeValue)(r.opacity)),!u){let e=void 0!==s.id?this._container.particles.linksColors.get(s.id):this._container.particles.linksColor;u=(0,n.getLinkColor)(i,g.destination,e)}if(!u)continue;let q=this._getCachedStyle(u);if((q!==d||o!==_||f!==k)&&(y(),e.strokeStyle=q,e.lineWidth=o,e.globalAlpha=f,d=q,_=o,k=f,e.beginPath(),p=!0),g.isWarped){let i=this._container.canvas.size,l=t.x-a.x,s=t.y-a.y,o=n.originPoint.x,r=n.originPoint.y;Math.abs(l)>i.width*n.half&&(o=l>0?-i.width:i.width),Math.abs(s)>i.height*n.half&&(r=s>0?-i.height:i.height),e.moveTo(a.x,a.y),e.lineTo(t.x+o,t.y+r),e.moveTo(a.x-o,a.y-r),e.lineTo(t.x,t.y)}else e.moveTo(a.x,a.y),e.lineTo(t.x,t.y)}y(),e.globalAlpha=g}init(){return this._freqs.links.clear(),this._freqs.triangles.clear(),this._colorCache.clear(),Promise.resolve()}particleCreated(e){if(e.links=[],!e.options.links)return;e.linksDistance=e.options.links.distance,e.linksWidth=e.options.links.width;let i=this._container.retina.pixelRatio;e.retina.linksDistance=e.linksDistance*i,e.retina.linksWidth=e.linksWidth*i}particleDestroyed(e){e.links=[]}_drawTriangles(e,i,t,l,s,o,a){let r=t.destination,c=e.links?.triangles;if(!c?.enable||!r.options.links?.triangles.enable)return;let h=r.links;if(h?.length)for(let g of h){if(g.isWarped||this._getLinkFrequency(r,g.destination)>r.options.links.frequency||!l.has(g.destination.id))continue;let h=g.destination;if(this._getTriangleFrequency(i,r,h)>(e.links?.triangles.frequency??0))continue;let d=c.opacity??(t.opacity+g.opacity)*n.half,_=(0,n.rangeColorToRgb)(this._engine,c.color)??t.color;if(!_||d<=0)continue;let k=h.getPosition();a.save(),a.fillStyle=this._getCachedStyle(_),a.globalAlpha=d,a.beginPath(),a.moveTo(s.x,s.y),a.lineTo(o.x,o.y),a.lineTo(k.x,k.y),a.closePath(),a.fill(),a.restore()}}_getCachedStyle(e){let i=`${e.r},${e.g},${e.b}`,t=this._colorCache.get(i);return t||(t=(0,n.getStyleFromRgb)(e,this._container.hdr),this._colorCache.set(i,t)),t}_getLinkFrequency(e,i){return l([e,i],this._freqs.links)}_getTriangleFrequency(e,i,t){return l([e,i,t],this._freqs.triangles)}}}}]);

package/README.md

@@ -27,6 +27,7 @@ Once the scripts are loaded you can set up `tsParticles` and the interaction plu
 
 ```javascript
 (async () => {
+  await loadInteractivityPlugin(tsParticles);
   await loadParticlesLinksInteraction(tsParticles);
 
   await tsParticles.load({
@@ -56,9 +57,11 @@ Then you need to import it in the app, like this:
 
 ```javascript
 const { tsParticles } = require("@tsparticles/engine");
+const { loadInteractivityPlugin } = require("@tsparticles/plugin-interactivity");
 const { loadParticlesLinksInteraction } = require("@tsparticles/interaction-particles-links");
 
 (async () => {
+  await loadInteractivityPlugin(tsParticles);
   await loadParticlesLinksInteraction(tsParticles);
 })();
 ```
@@ -67,9 +70,11 @@ or
 
 ```javascript
 import { tsParticles } from "@tsparticles/engine";
+import { loadInteractivityPlugin } from "@tsparticles/plugin-interactivity";
 import { loadParticlesLinksInteraction } from "@tsparticles/interaction-particles-links";
 
 (async () => {
+  await loadInteractivityPlugin(tsParticles);
   await loadParticlesLinksInteraction(tsParticles);
 })();
 ```

package/browser/CircleWarp.js

@@ -1,32 +1,48 @@
-import { Circle, Rectangle, double } from "@tsparticles/engine";
+import { Circle, Rectangle } from "@tsparticles/engine";
 export class CircleWarp extends Circle {
+    canvasSize;
     constructor(x, y, radius, canvasSize) {
         super(x, y, radius);
         this.canvasSize = canvasSize;
-        this.canvasSize = { ...canvasSize };
     }
     contains(point) {
+        if (super.contains(point))
+            return true;
         const { width, height } = this.canvasSize, { x, y } = point;
-        return (super.contains(point) ||
-            super.contains({ x: x - width, y }) ||
+        return (super.contains({ x: x - width, y }) ||
+            super.contains({ x: x + width, y }) ||
+            super.contains({ x, y: y - height }) ||
+            super.contains({ x, y: y + height }) ||
             super.contains({ x: x - width, y: y - height }) ||
-            super.contains({ x, y: y - height }));
+            super.contains({ x: x + width, y: y + height }) ||
+            super.contains({ x: x - width, y: y + height }) ||
+            super.contains({ x: x + width, y: y - height }));
     }
     intersects(range) {
-        if (super.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 (Object.hasOwn(circle, "radius")) {
-            const biggerCircle = new Circle(newPos.x, newPos.y, circle.radius * double);
-            return super.intersects(biggerCircle);
-        }
-        else if (Object.hasOwn(rect, "size")) {
-            const rectSW = new Rectangle(newPos.x, newPos.y, rect.size.width * double, rect.size.height * double);
-            return super.intersects(rectSW);
+        const { width, height } = this.canvasSize, pos = range.position, shifts = [
+            { x: -width, y: 0 },
+            { x: width, y: 0 },
+            { x: 0, y: -height },
+            { x: 0, y: height },
+            { x: -width, y: -height },
+            { x: width, y: height },
+            { x: -width, y: height },
+            { x: width, y: -height },
+        ];
+        for (const shift of shifts) {
+            const shiftedPos = { x: pos.x + shift.x, y: pos.y + shift.y };
+            let shiftedRange;
+            if (range instanceof Circle) {
+                shiftedRange = new Circle(shiftedPos.x, shiftedPos.y, range.radius);
+            }
+            else {
+                const rect = range;
+                shiftedRange = new Rectangle(shiftedPos.x, shiftedPos.y, rect.size.width, rect.size.height);
+            }
+            if (super.intersects(shiftedRange))
+                return true;
         }
         return false;
     }

package/browser/LinkInstance.js

@@ -1,156 +1,163 @@
-import { getDistance, getLinkColor, getRandom, getRangeValue, half, rangeColorToRgb, } from "@tsparticles/engine";
-import { drawLinkLine, drawLinkTriangle, setLinkFrequency } from "./Utils.js";
-const minOpacity = 0, minWidth = 0, minDistance = 0, maxFrequency = 1;
+import { getLinkColor as engineGetLinkColor, getRandom, getRangeValue, getStyleFromRgb, half, originPoint, rangeColorToRgb, } from "@tsparticles/engine";
+import { setLinkFrequency } from "./Utils.js";
+const minOpacity = 0, minWidth = 0, minDistance = 0, maxFrequency = 1, defaultFrequency = 0;
 export class LinkInstance {
+    _colorCache = new Map();
+    _container;
+    _engine;
+    _freqs;
     constructor(container, engine) {
-        this._drawLinkLine = (p1, link) => {
-            const p1LinksOptions = p1.options.links;
-            if (!p1LinksOptions?.enable) {
-                return;
+        this._container = container;
+        this._engine = engine;
+        this._freqs = { links: new Map(), triangles: new Map() };
+    }
+    drawParticle(context, particle) {
+        const { links, options } = particle;
+        if (!links?.length || !options.links) {
+            return;
+        }
+        const linkOpts = options.links, width = particle.retina.linksWidth ?? minWidth, pos1 = particle.getPosition(), twinkle = particle.options["twinkle"]?.links, trianglesEnabled = linkOpts.triangles.enable, p1Destinations = trianglesEnabled ? new Set(links.map(l => l.destination.id)) : null, originalAlpha = context.globalAlpha;
+        let currentColorStyle = "", currentWidth = -1, currentAlpha = -1, pathOpen = false;
+        const flushLines = () => {
+            if (pathOpen) {
+                context.stroke();
+                pathOpen = false;
             }
-            const container = this._container, p2 = link.destination, pos1 = p1.getPosition(), pos2 = p2.getPosition();
-            let opacity = link.opacity;
-            container.canvas.draw(ctx => {
-                let colorLine;
-                const twinkle = p1.options["twinkle"]?.lines;
-                if (twinkle?.enable) {
-                    const twinkleFreq = twinkle.frequency, twinkleRgb = rangeColorToRgb(this._engine, twinkle.color), twinkling = getRandom() < twinkleFreq;
-                    if (twinkling && twinkleRgb) {
-                        colorLine = twinkleRgb;
-                        opacity = getRangeValue(twinkle.opacity);
-                    }
-                }
-                if (!colorLine) {
-                    const linkColor = p1LinksOptions.id !== undefined
-                        ? container.particles.linksColors.get(p1LinksOptions.id)
-                        : container.particles.linksColor;
-                    colorLine = getLinkColor(p1, p2, linkColor);
-                }
-                if (!colorLine) {
-                    return;
-                }
-                const width = p1.retina.linksWidth ?? minWidth, maxDistance = p1.retina.linksDistance ?? minDistance;
-                drawLinkLine({
-                    context: ctx,
-                    width,
-                    begin: pos1,
-                    end: pos2,
-                    engine: this._engine,
-                    maxDistance,
-                    canvasSize: container.canvas.size,
-                    links: p1LinksOptions,
-                    colorLine,
-                    opacity,
-                    hdr: container.hdr,
-                });
-            });
         };
-        this._drawLinkTriangle = (p1, link1, link2) => {
-            const linksOptions = p1.options.links;
-            if (!linksOptions?.enable) {
-                return;
+        for (const link of links) {
+            if (linkOpts.frequency < maxFrequency &&
+                this._getLinkFrequency(particle, link.destination) > linkOpts.frequency) {
+                continue;
             }
-            const triangleOptions = linksOptions.triangles;
-            if (!triangleOptions.enable) {
-                return;
+            const pos2 = link.destination.getPosition();
+            if (trianglesEnabled && !link.isWarped && p1Destinations) {
+                flushLines();
+                this._drawTriangles(options, particle, link, p1Destinations, pos1, pos2, context);
             }
-            const container = this._container, p2 = link1.destination, p3 = link2.destination, opacityTriangle = triangleOptions.opacity ?? (link1.opacity + link2.opacity) * half;
-            if (opacityTriangle <= minOpacity) {
-                return;
+            if (link.opacity <= minOpacity || width <= minWidth) {
+                continue;
             }
-            container.canvas.draw(ctx => {
-                const pos1 = p1.getPosition(), pos2 = p2.getPosition(), pos3 = p3.getPosition(), linksDistance = p1.retina.linksDistance ?? minDistance;
-                if (getDistance(pos1, pos2) > linksDistance ||
-                    getDistance(pos3, pos2) > linksDistance ||
-                    getDistance(pos3, pos1) > linksDistance) {
-                    return;
-                }
-                let colorTriangle = rangeColorToRgb(this._engine, triangleOptions.color);
-                if (!colorTriangle) {
-                    const linkColor = linksOptions.id !== undefined
-                        ? container.particles.linksColors.get(linksOptions.id)
-                        : container.particles.linksColor;
-                    colorTriangle = getLinkColor(p1, p2, linkColor);
-                }
-                if (!colorTriangle) {
-                    return;
-                }
-                drawLinkTriangle({
-                    context: ctx,
-                    pos1,
-                    pos2,
-                    pos3,
-                    colorTriangle,
-                    opacityTriangle,
-                    hdr: container.hdr,
-                });
-            });
-        };
-        this._drawTriangles = (options, p1, link, p1Links) => {
-            const p2 = link.destination;
-            if (!(options.links?.triangles.enable && p2.options.links?.triangles.enable)) {
-                return;
+            if (!linkOpts.enable) {
+                continue;
+            }
+            let opacity = link.opacity, colorLine = link.color;
+            const twinkleRgb = twinkle?.enable && getRandom() < twinkle.frequency ? rangeColorToRgb(this._engine, twinkle.color) : undefined;
+            if (twinkle && twinkleRgb) {
+                colorLine = twinkleRgb;
+                opacity = getRangeValue(twinkle.opacity);
+            }
+            if (!colorLine) {
+                const linkColor = linkOpts.id !== undefined
+                    ? this._container.particles.linksColors.get(linkOpts.id)
+                    : this._container.particles.linksColor;
+                colorLine = engineGetLinkColor(particle, link.destination, linkColor);
             }
-            const vertices = p2.links?.filter(t => {
-                const linkFreq = this._getLinkFrequency(p2, t.destination), minCount = 0;
-                return (p2.options.links &&
-                    linkFreq <= p2.options.links.frequency &&
-                    p1Links.findIndex(l => l.destination === t.destination) >= minCount);
-            });
-            if (!vertices?.length) {
-                return;
+            if (!colorLine) {
+                continue;
             }
-            for (const vertex of vertices) {
-                const p3 = vertex.destination, triangleFreq = this._getTriangleFrequency(p1, p2, p3);
-                if (triangleFreq > options.links.triangles.frequency) {
-                    continue;
+            const colorStyle = this._getCachedStyle(colorLine);
+            if (colorStyle !== currentColorStyle || width !== currentWidth || opacity !== currentAlpha) {
+                flushLines();
+                context.strokeStyle = colorStyle;
+                context.lineWidth = width;
+                context.globalAlpha = opacity;
+                currentColorStyle = colorStyle;
+                currentWidth = width;
+                currentAlpha = opacity;
+                context.beginPath();
+                pathOpen = true;
+            }
+            if (link.isWarped) {
+                const canvasSize = this._container.canvas.size, dx = pos2.x - pos1.x, dy = pos2.y - pos1.y;
+                let sx = originPoint.x, sy = originPoint.y;
+                if (Math.abs(dx) > canvasSize.width * half) {
+                    sx = dx > minDistance ? -canvasSize.width : canvasSize.width;
+                }
+                if (Math.abs(dy) > canvasSize.height * half) {
+                    sy = dy > minDistance ? -canvasSize.height : canvasSize.height;
                 }
-                this._drawLinkTriangle(p1, link, vertex);
+                context.moveTo(pos1.x, pos1.y);
+                context.lineTo(pos2.x + sx, pos2.y + sy);
+                context.moveTo(pos1.x - sx, pos1.y - sy);
+                context.lineTo(pos2.x, pos2.y);
             }
-        };
-        this._getLinkFrequency = (p1, p2) => {
-            return setLinkFrequency([p1, p2], this._freqs.links);
-        };
-        this._getTriangleFrequency = (p1, p2, p3) => {
-            return setLinkFrequency([p1, p2, p3], this._freqs.triangles);
-        };
-        this._container = container;
-        this._engine = engine;
-        this._freqs = {
-            links: new Map(),
-            triangles: new Map(),
-        };
-    }
-    drawParticle(_context, particle) {
-        const { links, options } = particle;
-        if (!links?.length) {
-            return;
-        }
-        const p1Links = links.filter(l => options.links &&
-            (options.links.frequency >= maxFrequency ||
-                this._getLinkFrequency(particle, l.destination) <= options.links.frequency));
-        for (const link of p1Links) {
-            this._drawTriangles(options, particle, link, p1Links);
-            if (link.opacity > minOpacity && (particle.retina.linksWidth ?? minWidth) > minWidth) {
-                this._drawLinkLine(particle, link);
+            else {
+                context.moveTo(pos1.x, pos1.y);
+                context.lineTo(pos2.x, pos2.y);
             }
         }
+        flushLines();
+        context.globalAlpha = originalAlpha;
     }
-    async init() {
-        this._freqs.links = new Map();
-        this._freqs.triangles = new Map();
-        await Promise.resolve();
+    init() {
+        this._freqs.links.clear();
+        this._freqs.triangles.clear();
+        this._colorCache.clear();
+        return Promise.resolve();
     }
     particleCreated(particle) {
         particle.links = [];
         if (!particle.options.links) {
             return;
         }
-        const ratio = this._container.retina.pixelRatio, { retina } = particle, { distance, width } = particle.options.links;
-        retina.linksDistance = distance * ratio;
-        retina.linksWidth = width * ratio;
+        particle.linksDistance = particle.options.links.distance;
+        particle.linksWidth = particle.options.links.width;
+        const ratio = this._container.retina.pixelRatio;
+        particle.retina.linksDistance = particle.linksDistance * ratio;
+        particle.retina.linksWidth = particle.linksWidth * ratio;
     }
     particleDestroyed(particle) {
         particle.links = [];
     }
+    _drawTriangles(options, p1, link, p1Destinations, pos1, pos2, context) {
+        const p2 = link.destination, triangleOptions = options.links?.triangles;
+        if (!triangleOptions?.enable || !p2.options.links?.triangles.enable) {
+            return;
+        }
+        const p2Links = p2.links;
+        if (!p2Links?.length) {
+            return;
+        }
+        for (const vertex of p2Links) {
+            if (vertex.isWarped ||
+                this._getLinkFrequency(p2, vertex.destination) > p2.options.links.frequency ||
+                !p1Destinations.has(vertex.destination.id)) {
+                continue;
+            }
+            const p3 = vertex.destination;
+            if (this._getTriangleFrequency(p1, p2, p3) > (options.links?.triangles.frequency ?? defaultFrequency)) {
+                continue;
+            }
+            const opacityTriangle = triangleOptions.opacity ?? (link.opacity + vertex.opacity) * half, colorTriangle = rangeColorToRgb(this._engine, triangleOptions.color) ?? link.color;
+            if (!colorTriangle || opacityTriangle <= minOpacity) {
+                continue;
+            }
+            const pos3 = p3.getPosition();
+            context.save();
+            context.fillStyle = this._getCachedStyle(colorTriangle);
+            context.globalAlpha = opacityTriangle;
+            context.beginPath();
+            context.moveTo(pos1.x, pos1.y);
+            context.lineTo(pos2.x, pos2.y);
+            context.lineTo(pos3.x, pos3.y);
+            context.closePath();
+            context.fill();
+            context.restore();
+        }
+    }
+    _getCachedStyle(rgb) {
+        const key = `${rgb.r},${rgb.g},${rgb.b}`;
+        let style = this._colorCache.get(key);
+        if (!style) {
+            style = getStyleFromRgb(rgb, this._container.hdr);
+            this._colorCache.set(key, style);
+        }
+        return style;
+    }
+    _getLinkFrequency(p1, p2) {
+        return setLinkFrequency([p1, p2], this._freqs.links);
+    }
+    _getTriangleFrequency(p1, p2, p3) {
+        return setLinkFrequency([p1, p2, p3], this._freqs.triangles);
+    }
 }

package/browser/Linker.js

@@ -1,46 +1,25 @@
-import { Circle, getDistances, getLinkRandomColor, originPoint, } from "@tsparticles/engine";
+import { Circle, getDistances, getLinkColor, getLinkRandomColor, originPoint, } from "@tsparticles/engine";
 import { CircleWarp } from "./CircleWarp.js";
 import { Links } from "./Options/Classes/Links.js";
 import { ParticlesInteractorBase } from "@tsparticles/plugin-interactivity";
-const squarePower = 2, opacityOffset = 1, minDistance = 0;
-function getLinkDistance(pos1, pos2, optDistance, canvasSize, warp) {
-    const { dx, dy, distance } = getDistances(pos1, pos2);
-    if (!warp || distance <= optDistance) {
-        return distance;
-    }
-    const absDiffs = {
-        x: Math.abs(dx),
-        y: Math.abs(dy),
-    }, warpDistances = {
+const opacityOffset = 1, minDistance = 0;
+function getWarpDistance(pos1, pos2, canvasSize) {
+    const { dx, dy } = getDistances(pos1, pos2), absDiffs = { x: Math.abs(dx), y: Math.abs(dy) }, warpDistances = {
         x: Math.min(absDiffs.x, canvasSize.width - absDiffs.x),
         y: Math.min(absDiffs.y, canvasSize.height - absDiffs.y),
     };
-    return Math.sqrt(warpDistances.x ** squarePower + warpDistances.y ** squarePower);
+    return Math.hypot(warpDistances.x, warpDistances.y);
 }
 export class Linker extends ParticlesInteractorBase {
+    _engine;
+    _maxDistance;
     constructor(container, engine) {
         super(container);
-        this._setColor = p1 => {
-            if (!p1.options.links) {
-                return;
-            }
-            const container = this.container, 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 = getLinkRandomColor(this._engine, optColor, linksOptions.blink, linksOptions.consent);
-            if (linksOptions.id === undefined) {
-                container.particles.linksColor = linkColor;
-            }
-            else {
-                container.particles.linksColors.set(linksOptions.id, linkColor);
-            }
-        };
         this._engine = engine;
+        this._maxDistance = 0;
+    }
+    get maxDistance() {
+        return this._maxDistance;
     }
     clear() {
     }
@@ -53,22 +32,14 @@ export class Linker extends ParticlesInteractorBase {
             return;
         }
         p1.links = [];
+        if (p1.linksDistance && p1.linksDistance > this._maxDistance) {
+            this._maxDistance = p1.linksDistance;
+        }
         const pos1 = p1.getPosition(), container = this.container, canvasSize = container.canvas.size;
-        if (pos1.x < originPoint.x ||
-            pos1.y < originPoint.y ||
-            pos1.x > canvasSize.width ||
-            pos1.y > canvasSize.height) {
+        if (pos1.x < originPoint.x || pos1.y < originPoint.y || pos1.x > canvasSize.width || pos1.y > canvasSize.height) {
             return;
         }
-        const linkOpt1 = p1.options.links, optOpacity = linkOpt1.opacity, optDistance = p1.retina.linksDistance ?? minDistance, warp = linkOpt1.warp;
-        let range;
-        if (warp) {
-            range = new CircleWarp(pos1.x, pos1.y, optDistance, canvasSize);
-        }
-        else {
-            range = new Circle(pos1.x, pos1.y, optDistance);
-        }
-        const query = container.particles.quadTree.query(range);
+        const linkOpt1 = p1.options.links, optOpacity = linkOpt1.opacity, optDistance = p1.retina.linksDistance ?? minDistance, warp = linkOpt1.warp, range = warp ? new CircleWarp(pos1.x, pos1.y, optDistance, canvasSize) : new Circle(pos1.x, pos1.y, optDistance), query = container.particles.grid.query(range);
         for (const p2 of query) {
             const linkOpt2 = p2.options.links;
             if (p1 === p2 ||
@@ -82,13 +53,10 @@ export class Linker extends ParticlesInteractorBase {
                 continue;
             }
             const pos2 = p2.getPosition();
-            if (pos2.x < originPoint.x ||
-                pos2.y < originPoint.y ||
-                pos2.x > canvasSize.width ||
-                pos2.y > canvasSize.height) {
+            if (pos2.x < originPoint.x || pos2.y < originPoint.y || pos2.x > canvasSize.width || pos2.y > canvasSize.height) {
                 continue;
             }
-            const distance = getLinkDistance(pos1, pos2, optDistance, canvasSize, warp && linkOpt2.warp);
+            const distDirect = getDistances(pos1, pos2).distance, distWarp = warp && linkOpt2.warp ? getWarpDistance(pos1, pos2, canvasSize) : distDirect, distance = Math.min(distDirect, distWarp);
             if (distance > optDistance) {
                 continue;
             }
@@ -97,6 +65,8 @@ export class Linker extends ParticlesInteractorBase {
             p1.links.push({
                 destination: p2,
                 opacity: opacityLine,
+                color: this._getLinkColor(p1, p2),
+                isWarped: distWarp < distDirect,
             });
         }
     }
@@ -111,4 +81,33 @@ export class Linker extends ParticlesInteractorBase {
     }
     reset() {
     }
+    _getLinkColor(p1, p2) {
+        const container = this.container, linksOptions = p1.options.links;
+        if (!linksOptions) {
+            return;
+        }
+        const linkColor = linksOptions.id !== undefined
+            ? container.particles.linksColors.get(linksOptions.id)
+            : container.particles.linksColor;
+        return getLinkColor(p1, p2, linkColor);
+    }
+    _setColor(p1) {
+        if (!p1.options.links) {
+            return;
+        }
+        const container = this.container, linksOptions = p1.options.links;
+        let linkColor = linksOptions.id === undefined
+            ? container.particles.linksColor
+            : container.particles.linksColors.get(linksOptions.id);
+        if (linkColor) {
+            return;
+        }
+        linkColor = getLinkRandomColor(this._engine, linksOptions.color, linksOptions.blink, linksOptions.consent);
+        if (linksOptions.id === undefined) {
+            container.particles.linksColor = linkColor;
+        }
+        else {
+            container.particles.linksColors.set(linksOptions.id, linkColor);
+        }
+    }
 }

package/browser/LinksPlugin.js

@@ -1,6 +1,7 @@
 export class LinksPlugin {
+    id = "links";
+    _engine;
     constructor(engine) {
-        this.id = "links";
         this._engine = engine;
     }
     async getPlugin(container) {

package/browser/Options/Classes/Links.js

@@ -2,6 +2,18 @@ import { OptionsColor, isNull } from "@tsparticles/engine";
 import { LinksShadow } from "./LinksShadow.js";
 import { LinksTriangle } from "./LinksTriangle.js";
 export class Links {
+    blink;
+    color;
+    consent;
+    distance;
+    enable;
+    frequency;
+    id;
+    opacity;
+    shadow;
+    triangles;
+    warp;
+    width;
     constructor() {
         this.blink = false;
         this.color = new OptionsColor();

package/browser/Options/Classes/LinksShadow.js

@@ -1,5 +1,8 @@
 import { OptionsColor, isNull } from "@tsparticles/engine";
 export class LinksShadow {
+    blur;
+    color;
+    enable;
     constructor() {
         this.blur = 5;
         this.color = new OptionsColor();

package/browser/Options/Classes/LinksTriangle.js

@@ -1,5 +1,9 @@
 import { OptionsColor, isNull } from "@tsparticles/engine";
 export class LinksTriangle {
+    color;
+    enable;
+    frequency;
+    opacity;
     constructor() {
         this.enable = false;
         this.frequency = 1;