@progress/kendo-charts 2.7.2-dev.202502101310 → 2.7.2-develop.1

package/dist/es/sankey/calculation.js

@@ -1,25 +1,25 @@
 import { deepExtend } from '../common';
 
-var max = function (array, mapFn) { return Math.max.apply(null, array.map(mapFn)); };
-var min = function (array, mapFn) { return Math.min.apply(null, array.map(mapFn)); };
-var sum = function (array, mapFn) { return array.map(mapFn).reduce(function (acc, curr) { return (acc + curr); }, 0); };
-var sortAsc = function (a, b) { return (a.y0 === b.y0 ? a.index - b.index : a.y0 + a.y1 - b.y0 - b.y1); };
-var sortSource = function (a, b) { return sortAsc(a.source, b.source); };
-var sortTarget = function (a, b) { return sortAsc(a.target, b.target); };
-var value = function (node) { return node.value; };
+const max = (array, mapFn) => Math.max.apply(null, array.map(mapFn));
+const min = (array, mapFn) => Math.min.apply(null, array.map(mapFn));
+const sum = (array, mapFn) => array.map(mapFn).reduce((acc, curr) => (acc + curr), 0);
+const sortAsc = (a, b) => (a.y0 === b.y0 ? a.index - b.index : a.y0 + a.y1 - b.y0 - b.y1);
+const sortSource = (a, b) => sortAsc(a.source, b.source);
+const sortTarget = (a, b) => sortAsc(a.target, b.target);
+const value = (node) => node.value;
 
 function sortLinks(nodes) {
-    nodes.forEach(function (node) {
-        node.targetLinks.forEach(function (link) {
+    nodes.forEach(node => {
+        node.targetLinks.forEach(link => {
             link.source.sourceLinks.sort(sortTarget);
         });
-        node.sourceLinks.forEach(function (link) {
+        node.sourceLinks.forEach(link => {
             link.target.targetLinks.sort(sortSource);
         });
     });
 }
 
-var calcLayer = function (node, maxDepth) {
+const calcLayer = (node, maxDepth) => {
     if (node.align === 'left') {
         return node.depth;
     }
@@ -31,351 +31,330 @@ var calcLayer = function (node, maxDepth) {
     return node.sourceLinks.length ? node.depth : maxDepth;
 };
 
-var Sankey = function Sankey(options) {
-    var ref = options.nodesOptions;
-    var offset = ref.offset; if ( offset === void 0 ) offset = {};
-    var align = ref.align;
-    this.data = {
-        nodes: options.nodes.map(function (node) { return deepExtend({}, { offset: offset, align: align }, node); }),
-        links: options.links.map(function (link) { return deepExtend({}, link); })
-    };
-
-    this.width = options.width;
-    this.height = options.height;
-    this.offsetX = options.offsetX || 0;
-    this.offsetY = options.offsetY || 0;
-    this.nodeWidth = options.nodesOptions.width;
-    this.nodePadding = options.nodesOptions.padding;
-    this.reverse = options.reverse;
-    this.targetColumnIndex = options.targetColumnIndex;
-    this.loops = options.loops;
-    this.autoLayout = options.autoLayout;
-};
-
-Sankey.prototype.calculate = function calculate () {
-    var ref = this.data;
-        var nodes = ref.nodes;
-        var links = ref.links;
-    this.connectLinksToNodes(nodes, links);
-    this.calculateNodeValues(nodes);
-
-    var circularLinks = this.calculateNodeHeights(nodes);
+class Sankey {
+    constructor(options) {
+        const { offset = {}, align } = options.nodesOptions;
+        this.data = {
+            nodes: options.nodes.map((node) => deepExtend({}, { offset, align }, node)),
+            links: options.links.map((link) => deepExtend({}, link))
+        };
 
-    if (circularLinks) {
-        return { nodes: [], links: [], columns: [], circularLinks: circularLinks };
+        this.width = options.width;
+        this.height = options.height;
+        this.offsetX = options.offsetX || 0;
+        this.offsetY = options.offsetY || 0;
+        this.nodeWidth = options.nodesOptions.width;
+        this.nodePadding = options.nodesOptions.padding;
+        this.reverse = options.reverse;
+        this.targetColumnIndex = options.targetColumnIndex;
+        this.loops = options.loops;
+        this.autoLayout = options.autoLayout;
     }
 
-    this.calculateNodeDepths(nodes);
-    var columns = this.calculateNodeColumns(nodes);
-    this.calculateNodeBreadths(columns);
-    this.applyNodesOffset(nodes);
-    this.calculateLinkBreadths(nodes);
+    calculate() {
+        const { nodes, links } = this.data;
+        this.connectLinksToNodes(nodes, links);
+        this.calculateNodeValues(nodes);
 
-    return Object.assign({}, this.data, {columns: columns});
-};
+        const circularLinks = this.calculateNodeHeights(nodes);
 
-Sankey.prototype.connectLinksToNodes = function connectLinksToNodes (nodes, links) {
-    var nodesMap = new Map();
+        if (circularLinks) {
+            return { nodes: [], links: [], columns: [], circularLinks };
+        }
 
-    nodes.forEach(function (node, i) {
-        node.index = i;
-        node.sourceLinks = [];
-        node.targetLinks = [];
-        node.id = node.id !== undefined ? node.id : node.label.text;
-        nodesMap.set(node.id, node);
-    });
+        this.calculateNodeDepths(nodes);
+        const columns = this.calculateNodeColumns(nodes);
+        this.calculateNodeBreadths(columns);
+        this.applyNodesOffset(nodes);
+        this.calculateLinkBreadths(nodes);
 
-    links.forEach(function (link) {
-        link.source = nodesMap.get(link.sourceId);
-        link.target = nodesMap.get(link.targetId);
-        link.source.sourceLinks.push(link);
-        link.target.targetLinks.push(link);
-    });
-};
+        return Object.assign({}, this.data, {columns});
+    }
 
-Sankey.prototype.calculateNodeValues = function calculateNodeValues (nodes) {
-    nodes.forEach(function (node) {
-        node.value = Math.max(
-            sum(node.sourceLinks, value),
-            sum(node.targetLinks, value)
-        );
-    });
-};
+    connectLinksToNodes(nodes, links) {
+        const nodesMap = new Map();
 
-Sankey.prototype.calculateNodeDepths = function calculateNodeDepths (nodes) {
-    var current = new Set(nodes);
-    var next = new Set();
-    var currDepth = 0;
-    while (current.size) {
-        var currentNodes = Array.from(current);
-        for (var n = 0; n < currentNodes.length; n++) {
-            var node = currentNodes[n];
-            node.depth = currDepth;
-            for (var l = 0; l < node.sourceLinks.length; l++) {
-                var link = node.sourceLinks[l];
-                next.add(link.target);
-            }
-        }
-        currDepth++;
-        current = next;
-        next = new Set();
+        nodes.forEach((node, i) => {
+            node.index = i;
+            node.sourceLinks = [];
+            node.targetLinks = [];
+            node.id = node.id !== undefined ? node.id : node.label.text;
+            nodesMap.set(node.id, node);
+        });
+
+        links.forEach((link) => {
+            link.source = nodesMap.get(link.sourceId);
+            link.target = nodesMap.get(link.targetId);
+            link.source.sourceLinks.push(link);
+            link.target.targetLinks.push(link);
+        });
     }
-};
 
-Sankey.prototype.calculateNodeHeights = function calculateNodeHeights (nodes) {
-    var nodesLength = nodes.length;
-    var current = new Set(nodes);
-    var next = new Set;
-    var currentHeight = 0;
-    var eachNode = function (node) {
-        node.height = currentHeight;
-        node.targetLinks.forEach(function (link) {
-            next.add(link.source);
+    calculateNodeValues(nodes) {
+        nodes.forEach((node) => {
+            node.value = Math.max(
+                sum(node.sourceLinks, value),
+                sum(node.targetLinks, value)
+            );
         });
-    };
-    while (current.size) {
-        current.forEach(eachNode);
-        currentHeight++;
-        if (currentHeight > nodesLength) {
-            return true;
-        }
-        current = next;
-        next = new Set;
     }
-    return false;
-};
 
-Sankey.prototype.calculateNodeColumns = function calculateNodeColumns (nodes) {
-        var this$1 = this;
-
-    var maxDepth = max(nodes, function (d) { return d.depth; });
-    var columnWidth = (this.width - this.offsetX - this.nodeWidth) / maxDepth;
-    var columns = new Array(maxDepth + 1);
-    for (var i = 0; i < nodes.length; i++) {
-        var node = nodes[i];
-        var layer = Math.max(0, Math.min(maxDepth, calcLayer(node, maxDepth)));
-        node.x0 = this$1.offsetX + layer * columnWidth;
-        node.x1 = node.x0 + this$1.nodeWidth;
-        node.layer = layer;
-        columns[layer] = columns[layer] || [];
-        columns[layer].push(node);
+    calculateNodeDepths(nodes) {
+        let current = new Set(nodes);
+        let next = new Set();
+        let currDepth = 0;
+        while (current.size) {
+            const currentNodes = Array.from(current);
+            for (let n = 0; n < currentNodes.length; n++) {
+                const node = currentNodes[n];
+                node.depth = currDepth;
+                for (let l = 0; l < node.sourceLinks.length; l++) {
+                    const link = node.sourceLinks[l];
+                    next.add(link.target);
+                }
+            }
+            currDepth++;
+            current = next;
+            next = new Set();
+        }
     }
 
-    return columns;
-};
+    calculateNodeHeights(nodes) {
+        const nodesLength = nodes.length;
+        let current = new Set(nodes);
+        let next = new Set;
+        let currentHeight = 0;
+        const eachNode = (node) => {
+            node.height = currentHeight;
+            node.targetLinks.forEach((link) => {
+                next.add(link.source);
+            });
+        };
+        while (current.size) {
+            current.forEach(eachNode);
+            currentHeight++;
+            if (currentHeight > nodesLength) {
+                return true;
+            }
+            current = next;
+            next = new Set;
+        }
+        return false;
+    }
 
-Sankey.prototype.calculateNodeBreadths = function calculateNodeBreadths (columns) {
-        var this$1 = this;
+    calculateNodeColumns(nodes) {
+        const maxDepth = max(nodes, (d) => d.depth);
+        const columnWidth = (this.width - this.offsetX - this.nodeWidth) / maxDepth;
+        const columns = new Array(maxDepth + 1);
+        for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+            const layer = Math.max(0, Math.min(maxDepth, calcLayer(node, maxDepth)));
+            node.x0 = this.offsetX + layer * columnWidth;
+            node.x1 = node.x0 + this.nodeWidth;
+            node.layer = layer;
+            columns[layer] = columns[layer] || [];
+            columns[layer].push(node);
+        }
 
-    var kSize = min(columns, function (c) { return (this$1.height - this$1.offsetY - (c.length - 1) * this$1.nodePadding) / sum(c, value); });
+        return columns;
+    }
 
-    columns.forEach(function (nodes) {
-        var y = this$1.offsetY;
-        nodes.forEach(function (node) {
-            node.y0 = y;
-            node.y1 = y + node.value * kSize;
-            y = node.y1 + this$1.nodePadding;
-            node.sourceLinks.forEach(function (link) {
-                link.width = link.value * kSize;
+    calculateNodeBreadths(columns) {
+        const kSize = min(columns, (c) => (this.height - this.offsetY - (c.length - 1) * this.nodePadding) / sum(c, value));
+
+        columns.forEach(nodes => {
+            let y = this.offsetY;
+            nodes.forEach((node) => {
+                node.y0 = y;
+                node.y1 = y + node.value * kSize;
+                y = node.y1 + this.nodePadding;
+                node.sourceLinks.forEach((link) => {
+                    link.width = link.value * kSize;
+                });
+            });
+            y = (this.height - y + this.nodePadding) / (nodes.length + 1);
+            nodes.forEach((node, i) => {
+                node.y0 += y * (i + 1);
+                node.y1 += y * (i + 1);
             });
         });
-        y = (this$1.height - y + this$1.nodePadding) / (nodes.length + 1);
-        nodes.forEach(function (node, i) {
-            node.y0 += y * (i + 1);
-            node.y1 += y * (i + 1);
-        });
-    });
 
-    if (this.autoLayout !== false) {
-        var loops = this.loops !== undefined ? this.loops : columns.length - 1;
-        var targetColumnIndex = this.targetColumnIndex || 1;
-
-        for (var i = 0; i < loops; i++) {
-            if (!this$1.reverse) {
-                this$1.uncurlLinksToLeft(columns, targetColumnIndex);
-                this$1.uncurlLinksToRight(columns, targetColumnIndex);
-            } else {
-                this$1.uncurlLinksToRight(columns, targetColumnIndex);
-                this$1.uncurlLinksToLeft(columns, targetColumnIndex);
+        if (this.autoLayout !== false) {
+            const loops = this.loops !== undefined ? this.loops : columns.length - 1;
+            const targetColumnIndex = this.targetColumnIndex || 1;
+
+            for (let i = 0; i < loops; i++) {
+                if (!this.reverse) {
+                    this.uncurlLinksToLeft(columns, targetColumnIndex);
+                    this.uncurlLinksToRight(columns, targetColumnIndex);
+                } else {
+                    this.uncurlLinksToRight(columns, targetColumnIndex);
+                    this.uncurlLinksToLeft(columns, targetColumnIndex);
+                }
             }
         }
-    }
-
-    columns.forEach(sortLinks);
-};
 
-Sankey.prototype.applyNodesOffset = function applyNodesOffset (nodes) {
-    nodes.forEach(function (node) {
-        var offsetX = (node.offset ? node.offset.left : 0) || 0;
-        var offsetY = (node.offset ? node.offset.top : 0) || 0;
-        node.x0 += offsetX;
-        node.x1 += offsetX;
-        node.y0 += offsetY;
-        node.y1 += offsetY;
-    });
-};
+        columns.forEach(sortLinks);
+    }
 
-Sankey.prototype.calculateLinkBreadths = function calculateLinkBreadths (nodes) {
-    nodes.forEach(function (node) {
-        var sourceLinks = node.sourceLinks;
-            var targetLinks = node.targetLinks;
-        var y = node.y0;
-        var y1 = y;
-        sourceLinks.forEach(function (link) {
-            link.x0 = link.source.x1;
-            link.y0 = y + link.width / 2;
-            y += link.width;
+    applyNodesOffset(nodes) {
+        nodes.forEach((node) => {
+            const offsetX = (node.offset ? node.offset.left : 0) || 0;
+            const offsetY = (node.offset ? node.offset.top : 0) || 0;
+            node.x0 += offsetX;
+            node.x1 += offsetX;
+            node.y0 += offsetY;
+            node.y1 += offsetY;
         });
-        targetLinks.forEach(function (link) {
-            link.x1 = link.target.x0;
-            link.y1 = y1 + link.width / 2;
-            y1 += link.width;
-        });
-    });
-};
+    }
 
-Sankey.prototype.uncurlLinksToRight = function uncurlLinksToRight (columns, targetColumnIndex) {
-        var this$1 = this;
-
-    var n = columns.length;
-    for (var i = targetColumnIndex; i < n; i++) {
-        var column = columns[i];
-        column.forEach(function (target) {
-            var y = 0;
-            var sum = 0;
-            target.targetLinks.forEach(function (link) {
-                var kValue = link.value * (target.layer - link.source.layer);
-                y += this$1.targetTopPos(link.source, target) * kValue;
-                sum += kValue;
+    calculateLinkBreadths(nodes) {
+        nodes.forEach((node) => {
+            const { sourceLinks, targetLinks } = node;
+            let y = node.y0;
+            let y1 = y;
+            sourceLinks.forEach((link) => {
+                link.x0 = link.source.x1;
+                link.y0 = y + link.width / 2;
+                y += link.width;
+            });
+            targetLinks.forEach((link) => {
+                link.x1 = link.target.x0;
+                link.y1 = y1 + link.width / 2;
+                y1 += link.width;
             });
-
-            var dy = y === 0 ? 0 : (y / sum - target.y0);
-            target.y0 += dy;
-            target.y1 += dy;
-            sortLinks([target]);
         });
-        column.sort(sortAsc);
-        this$1.arrangeNodesVertically(column);
     }
-};
 
-Sankey.prototype.uncurlLinksToLeft = function uncurlLinksToLeft (columns, targetColumnIndex) {
-        var this$1 = this;
-
-    var l = columns.length;
-    var startIndex = l - 1 - targetColumnIndex;
-    for (var i = startIndex; i >= 0; i--) {
-        var column = columns[i];
-        var loop = function ( j ) {
-            var source = column[j];
-            var y = 0;
-            var sum = 0;
-            source.sourceLinks.forEach(function (link) {
-                var kValue = link.value * (link.target.layer - source.layer);
-                y += this$1.sourceTopPos(source, link.target) * kValue;
-                sum += kValue;
+    uncurlLinksToRight(columns, targetColumnIndex) {
+        const n = columns.length;
+        for (let i = targetColumnIndex; i < n; i++) {
+            const column = columns[i];
+            column.forEach((target) => {
+                let y = 0;
+                let sum = 0;
+                target.targetLinks.forEach((link) => {
+                    let kValue = link.value * (target.layer - link.source.layer);
+                    y += this.targetTopPos(link.source, target) * kValue;
+                    sum += kValue;
+                });
+
+                let dy = y === 0 ? 0 : (y / sum - target.y0);
+                target.y0 += dy;
+                target.y1 += dy;
+                sortLinks([target]);
             });
-            var dy = y === 0 ? 0 : (y / sum - source.y0);
-            source.y0 += dy;
-            source.y1 += dy;
-            sortLinks([source]);
-        };
-
-            for (var j = 0; j < column.length; j++) loop( j );
-
-        column.sort(sortAsc);
-        this$1.arrangeNodesVertically(column);
+            column.sort(sortAsc);
+            this.arrangeNodesVertically(column);
+        }
     }
-};
-
-Sankey.prototype.arrangeNodesVertically = function arrangeNodesVertically (nodes) {
-    var startIndex = 0;
-    var endIndex = nodes.length - 1;
-
-    this.arrangeUp(nodes, this.height, endIndex);
-    this.arrangeDown(nodes, this.offsetY, startIndex);
-};
 
-Sankey.prototype.arrangeDown = function arrangeDown (nodes, yPos, index) {
-        var this$1 = this;
-
-    var currentY = yPos;
+    uncurlLinksToLeft(columns, targetColumnIndex) {
+        const l = columns.length;
+        const startIndex = l - 1 - targetColumnIndex;
+        for (let i = startIndex; i >= 0; i--) {
+            const column = columns[i];
+            for (let j = 0; j < column.length; j++) {
+                const source = column[j];
+                let y = 0;
+                let sum = 0;
+                source.sourceLinks.forEach((link) => {
+                    let kValue = link.value * (link.target.layer - source.layer);
+                    y += this.sourceTopPos(source, link.target) * kValue;
+                    sum += kValue;
+                });
+                let dy = y === 0 ? 0 : (y / sum - source.y0);
+                source.y0 += dy;
+                source.y1 += dy;
+                sortLinks([source]);
+            }
 
-    for (var i = index; i < nodes.length; i++) {
-        var node = nodes[i];
-        var dy = Math.max(0, currentY - node.y0);
-        node.y0 += dy;
-        node.y1 += dy;
-        currentY = node.y1 + this$1.nodePadding;
+            column.sort(sortAsc);
+            this.arrangeNodesVertically(column);
+        }
     }
-};
 
-Sankey.prototype.arrangeUp = function arrangeUp (nodes, yPos, index) {
-        var this$1 = this;
+    arrangeNodesVertically(nodes) {
+        const startIndex = 0;
+        const endIndex = nodes.length - 1;
 
-    var currentY = yPos;
-    for (var i = index; i >= 0; --i) {
-        var node = nodes[i];
-        var dy = Math.max(0, node.y1 - currentY);
-        node.y0 -= dy;
-        node.y1 -= dy;
-        currentY = node.y0 - this$1.nodePadding;
+        this.arrangeUp(nodes, this.height, endIndex);
+        this.arrangeDown(nodes, this.offsetY, startIndex);
     }
-};
 
-Sankey.prototype.sourceTopPos = function sourceTopPos (source, target) {
-        var this$1 = this;
+    arrangeDown(nodes, yPos, index) {
+        let currentY = yPos;
 
-    var y = target.y0 - ((target.targetLinks.length - 1) * this.nodePadding) / 2;
-    for (var i = 0; i < target.targetLinks.length; i++) {
-        var link = target.targetLinks[i];
-        if (link.source === source) {
-            break;
+        for (let i = index; i < nodes.length; i++) {
+            const node = nodes[i];
+            const dy = Math.max(0, currentY - node.y0);
+            node.y0 += dy;
+            node.y1 += dy;
+            currentY = node.y1 + this.nodePadding;
         }
-        y += link.width + this$1.nodePadding;
     }
-    for (var i$1 = 0; i$1 < source.sourceLinks.length; i$1++) {
-        var link$1 = source.sourceLinks[i$1];
-        if (link$1.target === target) {
-            break;
+
+    arrangeUp(nodes, yPos, index) {
+        let currentY = yPos;
+        for (let i = index; i >= 0; --i) {
+            const node = nodes[i];
+            const dy = Math.max(0, node.y1 - currentY);
+            node.y0 -= dy;
+            node.y1 -= dy;
+            currentY = node.y0 - this.nodePadding;
         }
-        y -= link$1.width;
     }
-    return y;
-};
 
-Sankey.prototype.targetTopPos = function targetTopPos (source, target) {
-        var this$1 = this;
-
-    var y = source.y0 - ((source.sourceLinks.length - 1) * this.nodePadding) / 2;
-    for (var i = 0; i < source.sourceLinks.length; i++) {
-        var link = source.sourceLinks[i];
-        if (link.target === target) {
-            break;
+    sourceTopPos(source, target) {
+        let y = target.y0 - ((target.targetLinks.length - 1) * this.nodePadding) / 2;
+        for (let i = 0; i < target.targetLinks.length; i++) {
+            const link = target.targetLinks[i];
+            if (link.source === source) {
+                break;
+            }
+            y += link.width + this.nodePadding;
         }
-        y += link.width + this$1.nodePadding;
+        for (let i = 0; i < source.sourceLinks.length; i++) {
+            const link = source.sourceLinks[i];
+            if (link.target === target) {
+                break;
+            }
+            y -= link.width;
+        }
+        return y;
     }
-    for (var i$1 = 0; i$1 < target.targetLinks.length; i$1++) {
-        var link$1 = target.targetLinks[i$1];
-        if (link$1.source === source) {
-            break;
+
+    targetTopPos(source, target) {
+        let y = source.y0 - ((source.sourceLinks.length - 1) * this.nodePadding) / 2;
+        for (let i = 0; i < source.sourceLinks.length; i++) {
+            const link = source.sourceLinks[i];
+            if (link.target === target) {
+                break;
+            }
+            y += link.width + this.nodePadding;
         }
-        y -= link$1.width;
+        for (let i = 0; i < target.targetLinks.length; i++) {
+            const link = target.targetLinks[i];
+            if (link.source === source) {
+                break;
+            }
+            y -= link.width;
+        }
+        return y;
     }
-    return y;
-};
+}
 
-export var calculateSankey = function (options) { return new Sankey(options).calculate(); };
+export const calculateSankey = (options) => new Sankey(options).calculate();
 
-export var crossesValue = function (links) {
-    var value = 0;
-    var linksLength = links.length;
+export const crossesValue = (links) => {
+    let value = 0;
+    const linksLength = links.length;
 
-    for (var i = 0; i < linksLength; i++) {
-        var link = links[i];
+    for (let i = 0; i < linksLength; i++) {
+        const link = links[i];
 
-        for (var lNext = i + 1; lNext < linksLength; lNext++) {
-            var nextLink = links[lNext];
+        for (let lNext = i + 1; lNext < linksLength; lNext++) {
+            const nextLink = links[lNext];
 
             if (intersect(link, nextLink)) {
                 value += Math.min(link.value, nextLink.value);
@@ -387,8 +366,8 @@ export var crossesValue = function (links) {
 };
 
 function rotationDirection(p1x, p1y, p2x, p2y, p3x, p3y) {
-    var expression1 = (p3y - p1y) * (p2x - p1x);
-    var expression2 = (p2y - p1y) * (p3x - p1x);
+    const expression1 = (p3y - p1y) * (p2x - p1x);
+    const expression2 = (p2y - p1y) * (p3x - p1x);
 
     if (expression1 > expression2) {
         return 1;
@@ -400,10 +379,10 @@ function rotationDirection(p1x, p1y, p2x, p2y, p3x, p3y) {
 }
 
 function intersect(link1, link2) {
-    var f1 = rotationDirection(link1.x0, link1.y0, link1.x1, link1.y1, link2.x1, link2.y1);
-    var f2 = rotationDirection(link1.x0, link1.y0, link1.x1, link1.y1, link2.x0, link2.y0);
-    var f3 = rotationDirection(link1.x0, link1.y0, link2.x0, link2.y0, link2.x1, link2.y1);
-    var f4 = rotationDirection(link1.x1, link1.y1, link2.x0, link2.y0, link2.x1, link2.y1);
+    const f1 = rotationDirection(link1.x0, link1.y0, link1.x1, link1.y1, link2.x1, link2.y1);
+    const f2 = rotationDirection(link1.x0, link1.y0, link1.x1, link1.y1, link2.x0, link2.y0);
+    const f3 = rotationDirection(link1.x0, link1.y0, link2.x0, link2.y0, link2.x1, link2.y1);
+    const f4 = rotationDirection(link1.x1, link1.y1, link2.x0, link2.y0, link2.x1, link2.y1);
 
     return f1 !== f2 && f3 !== f4;
 }