highcharts 10.2.0 → 10.2.1

package/es-modules/Series/Networkgraph/{Layouts.js → ReingoldFruchtermanLayout.js}

@@ -10,27 +10,52 @@
  *
  * */
 'use strict';
-import Chart from '../../Core/Chart/Chart.js';
-import A from '../../Core/Animation/AnimationUtilities.js';
-var setAnimation = A.setAnimation;
+import EulerIntegration from './EulerIntegration.js';
 import H from '../../Core/Globals.js';
+var win = H.win;
+import GraphLayout from '../GraphLayoutComposition.js';
+import QuadTree from './QuadTree.js';
 import U from '../../Core/Utilities.js';
-var addEvent = U.addEvent, clamp = U.clamp, defined = U.defined, extend = U.extend, isFunction = U.isFunction, pick = U.pick;
-import './Integrations.js';
-import './QuadTree.js';
-/* eslint-disable no-invalid-this, valid-jsdoc */
-H.layouts = {
-    'reingold-fruchterman': function () {
-    }
-};
-extend(
+var clamp = U.clamp, defined = U.defined, isFunction = U.isFunction, pick = U.pick;
+import VerletIntegration from './VerletIntegration.js';
+/* *
+ *
+ *  Class
+ *
+ * */
 /**
  * Reingold-Fruchterman algorithm from
  * "Graph Drawing by Force-directed Placement" paper.
  * @private
  */
-H.layouts['reingold-fruchterman'].prototype, {
-    init: function (options) {
+var ReingoldFruchtermanLayout = /** @class */ (function () {
+    function ReingoldFruchtermanLayout() {
+        /* *
+         *
+         *  Static Functions
+         *
+         * */
+        this.attractiveForce = void 0;
+        this.box = {};
+        this.currentStep = 0;
+        this.initialRendering = true;
+        this.integration = void 0;
+        this.links = [];
+        this.nodes = [];
+        this.options = void 0;
+        this.quadTree = void 0;
+        this.repulsiveForce = void 0;
+        this.series = [];
+        this.simulation = false;
+    }
+    ReingoldFruchtermanLayout.compose = function (ChartClass) {
+        GraphLayout.compose(ChartClass);
+        GraphLayout.integrations.euler = EulerIntegration;
+        GraphLayout.integrations.verlet = VerletIntegration;
+        GraphLayout.layouts['reingold-fruchterman'] =
+            ReingoldFruchtermanLayout;
+    };
+    ReingoldFruchtermanLayout.prototype.init = function (options) {
         this.options = options;
         this.nodes = [];
         this.links = [];
@@ -43,16 +68,16 @@ H.layouts['reingold-fruchterman'].prototype, {
         };
         this.setInitialRendering(true);
         this.integration =
-            H.networkgraphIntegrations[options.integration];
+            GraphLayout.integrations[options.integration];
         this.enableSimulation = options.enableSimulation;
         this.attractiveForce = pick(options.attractiveForce, this.integration.attractiveForceFunction);
         this.repulsiveForce = pick(options.repulsiveForce, this.integration.repulsiveForceFunction);
         this.approximation = options.approximation;
-    },
-    updateSimulation: function (enable) {
+    };
+    ReingoldFruchtermanLayout.prototype.updateSimulation = function (enable) {
         this.enableSimulation = pick(enable, this.options.enableSimulation);
-    },
-    start: function () {
+    };
+    ReingoldFruchtermanLayout.prototype.start = function () {
         var layout = this, series = this.series, options = this.options;
         layout.currentStep = 0;
         layout.forces = series[0] && series[0].forces || [];
@@ -70,91 +95,93 @@ H.layouts['reingold-fruchterman'].prototype, {
         if (layout.enableSimulation) {
             layout.step();
         }
-    },
-    step: function () {
-        var layout = this, series = this.series, options = this.options;
+    };
+    ReingoldFruchtermanLayout.prototype.step = function () {
+        var _this = this;
+        var anyLayout = this, allSeries = this.series;
         // Algorithm:
-        layout.currentStep++;
-        if (layout.approximation === 'barnes-hut') {
-            layout.createQuadTree();
-            layout.quadTree.calculateMassAndCenter();
+        this.currentStep++;
+        if (this.approximation === 'barnes-hut') {
+            this.createQuadTree();
+            this.quadTree.calculateMassAndCenter();
+        }
+        for (var _i = 0, _a = this.forces || []; _i < _a.length; _i++) {
+            var forceName = _a[_i];
+            anyLayout[forceName + 'Forces'](this.temperature);
         }
-        layout.forces.forEach(function (forceName) {
-            layout[forceName + 'Forces'](layout.temperature);
-        });
         // Limit to the plotting area and cool down:
-        layout.applyLimits(layout.temperature);
+        this.applyLimits();
         // Cool down the system:
-        layout.temperature = layout.coolDown(layout.startTemperature, layout.diffTemperature, layout.currentStep);
-        layout.prevSystemTemperature = layout.systemTemperature;
-        layout.systemTemperature = layout.getSystemTemperature();
-        if (layout.enableSimulation) {
-            series.forEach(function (s) {
+        this.temperature = this.coolDown(this.startTemperature, this.diffTemperature, this.currentStep);
+        this.prevSystemTemperature = this.systemTemperature;
+        this.systemTemperature = this.getSystemTemperature();
+        if (this.enableSimulation) {
+            for (var _b = 0, allSeries_1 = allSeries; _b < allSeries_1.length; _b++) {
+                var series = allSeries_1[_b];
                 // Chart could be destroyed during the simulation
-                if (s.chart) {
-                    s.render();
+                if (series.chart) {
+                    series.render();
                 }
-            });
-            if (layout.maxIterations-- &&
-                isFinite(layout.temperature) &&
-                !layout.isStable()) {
-                if (layout.simulation) {
-                    H.win.cancelAnimationFrame(layout.simulation);
+            }
+            if (this.maxIterations-- &&
+                isFinite(this.temperature) &&
+                !this.isStable()) {
+                if (this.simulation) {
+                    win.cancelAnimationFrame(this.simulation);
                 }
-                layout.simulation = H.win.requestAnimationFrame(function () {
-                    layout.step();
-                });
+                this.simulation = win.requestAnimationFrame(function () { return _this.step(); });
             }
             else {
-                layout.simulation = false;
+                this.simulation = false;
             }
         }
-    },
-    stop: function () {
+    };
+    ReingoldFruchtermanLayout.prototype.stop = function () {
         if (this.simulation) {
-            H.win.cancelAnimationFrame(this.simulation);
+            win.cancelAnimationFrame(this.simulation);
         }
-    },
-    setArea: function (x, y, w, h) {
+    };
+    ReingoldFruchtermanLayout.prototype.setArea = function (x, y, w, h) {
         this.box = {
             left: x,
             top: y,
             width: w,
             height: h
         };
-    },
-    setK: function () {
+    };
+    ReingoldFruchtermanLayout.prototype.setK = function () {
         // Optimal distance between nodes,
         // available space around the node:
         this.k = this.options.linkLength || this.integration.getK(this);
-    },
-    addElementsToCollection: function (elements, collection) {
-        elements.forEach(function (elem) {
-            if (collection.indexOf(elem) === -1) {
-                collection.push(elem);
+    };
+    ReingoldFruchtermanLayout.prototype.addElementsToCollection = function (elements, collection) {
+        for (var _i = 0, elements_1 = elements; _i < elements_1.length; _i++) {
+            var element = elements_1[_i];
+            if (collection.indexOf(element) === -1) {
+                collection.push(element);
             }
-        });
-    },
-    removeElementFromCollection: function (element, collection) {
+        }
+    };
+    ReingoldFruchtermanLayout.prototype.removeElementFromCollection = function (element, collection) {
         var index = collection.indexOf(element);
         if (index !== -1) {
             collection.splice(index, 1);
         }
-    },
-    clear: function () {
+    };
+    ReingoldFruchtermanLayout.prototype.clear = function () {
         this.nodes.length = 0;
         this.links.length = 0;
         this.series.length = 0;
         this.resetSimulation();
-    },
-    resetSimulation: function () {
+    };
+    ReingoldFruchtermanLayout.prototype.resetSimulation = function () {
         this.forcedStop = false;
         this.systemTemperature = 0;
         this.setMaxIterations();
         this.setTemperature();
         this.setDiffTemperature();
-    },
-    restartSimulation: function () {
+    };
+    ReingoldFruchtermanLayout.prototype.restartSimulation = function () {
         if (!this.simulation) {
             // When dragging nodes, we don't need to calculate
             // initial positions and rendering nodes:
@@ -177,30 +204,31 @@ H.layouts['reingold-fruchterman'].prototype, {
             // Extend current simulation:
             this.resetSimulation();
         }
-    },
-    setMaxIterations: function (maxIterations) {
+    };
+    ReingoldFruchtermanLayout.prototype.setMaxIterations = function (maxIterations) {
         this.maxIterations = pick(maxIterations, this.options.maxIterations);
-    },
-    setTemperature: function () {
+    };
+    ReingoldFruchtermanLayout.prototype.setTemperature = function () {
         this.temperature = this.startTemperature =
             Math.sqrt(this.nodes.length);
-    },
-    setDiffTemperature: function () {
+    };
+    ReingoldFruchtermanLayout.prototype.setDiffTemperature = function () {
         this.diffTemperature = this.startTemperature /
             (this.options.maxIterations + 1);
-    },
-    setInitialRendering: function (enable) {
+    };
+    ReingoldFruchtermanLayout.prototype.setInitialRendering = function (enable) {
         this.initialRendering = enable;
-    },
-    createQuadTree: function () {
-        this.quadTree = new H.QuadTree(this.box.left, this.box.top, this.box.width, this.box.height);
+    };
+    ReingoldFruchtermanLayout.prototype.createQuadTree = function () {
+        this.quadTree = new QuadTree(this.box.left, this.box.top, this.box.width, this.box.height);
         this.quadTree.insertNodes(this.nodes);
-    },
-    initPositions: function () {
+    };
+    ReingoldFruchtermanLayout.prototype.initPositions = function () {
         var initialPositions = this.options.initialPositions;
         if (isFunction(initialPositions)) {
             initialPositions.call(this);
-            this.nodes.forEach(function (node) {
+            for (var _i = 0, _a = this.nodes; _i < _a.length; _i++) {
+                var node = _a[_i];
                 if (!defined(node.prevX)) {
                     node.prevX = node.plotX;
                 }
@@ -209,7 +237,7 @@ H.layouts['reingold-fruchterman'].prototype, {
                 }
                 node.dispX = 0;
                 node.dispY = 0;
-            });
+            }
         }
         else if (initialPositions === 'circle') {
             this.setCircularPositions();
@@ -217,85 +245,94 @@ H.layouts['reingold-fruchterman'].prototype, {
         else {
             this.setRandomPositions();
         }
-    },
-    setCircularPositions: function () {
+    };
+    ReingoldFruchtermanLayout.prototype.setCircularPositions = function () {
         var box = this.box, nodes = this.nodes, nodesLength = nodes.length + 1, angle = 2 * Math.PI / nodesLength, rootNodes = nodes.filter(function (node) {
             return node.linksTo.length === 0;
-        }), sortedNodes = [], visitedNodes = {}, radius = this.options.initialPositionRadius;
-        /**
-         * @private
-         */
-        function addToNodes(node) {
-            node.linksFrom.forEach(function (link) {
+        }), visitedNodes = {}, radius = this.options.initialPositionRadius, addToNodes = function (node) {
+            for (var _i = 0, _a = node.linksFrom || []; _i < _a.length; _i++) {
+                var link = _a[_i];
                 if (!visitedNodes[link.toNode.id]) {
                     visitedNodes[link.toNode.id] = true;
                     sortedNodes.push(link.toNode);
                     addToNodes(link.toNode);
                 }
-            });
-        }
+            }
+        };
+        var sortedNodes = [];
         // Start with identified root nodes an sort the nodes by their
         // hierarchy. In trees, this ensures that branches don't cross
         // eachother.
-        rootNodes.forEach(function (rootNode) {
+        for (var _i = 0, rootNodes_1 = rootNodes; _i < rootNodes_1.length; _i++) {
+            var rootNode = rootNodes_1[_i];
             sortedNodes.push(rootNode);
             addToNodes(rootNode);
-        });
+        }
         // Cyclic tree, no root node found
         if (!sortedNodes.length) {
             sortedNodes = nodes;
             // Dangling, cyclic trees
         }
         else {
-            nodes.forEach(function (node) {
-                if (sortedNodes.indexOf(node) === -1) {
-                    sortedNodes.push(node);
+            for (var _a = 0, nodes_1 = nodes; _a < nodes_1.length; _a++) {
+                var node_1 = nodes_1[_a];
+                if (sortedNodes.indexOf(node_1) === -1) {
+                    sortedNodes.push(node_1);
                 }
-            });
+            }
         }
+        var node;
         // Initial positions are laid out along a small circle, appearing
         // as a cluster in the middle
-        sortedNodes.forEach(function (node, index) {
-            node.plotX = node.prevX = pick(node.plotX, box.width / 2 + radius * Math.cos(index * angle));
-            node.plotY = node.prevY = pick(node.plotY, box.height / 2 + radius * Math.sin(index * angle));
+        for (var i = 0, iEnd = sortedNodes.length; i < iEnd; ++i) {
+            node = sortedNodes[i];
+            node.plotX = node.prevX = pick(node.plotX, box.width / 2 + radius * Math.cos(i * angle));
+            node.plotY = node.prevY = pick(node.plotY, box.height / 2 + radius * Math.sin(i * angle));
             node.dispX = 0;
             node.dispY = 0;
-        });
-    },
-    setRandomPositions: function () {
-        var box = this.box, nodes = this.nodes, nodesLength = nodes.length + 1;
+        }
+    };
+    ReingoldFruchtermanLayout.prototype.setRandomPositions = function () {
+        var box = this.box, nodes = this.nodes, nodesLength = nodes.length + 1, 
         /**
          * Return a repeatable, quasi-random number based on an integer
          * input. For the initial positions
          * @private
          */
-        function unrandom(n) {
+        unrandom = function (n) {
             var rand = n * n / Math.PI;
             rand = rand - Math.floor(rand);
             return rand;
-        }
+        };
+        var node;
         // Initial positions:
-        nodes.forEach(function (node, index) {
-            node.plotX = node.prevX = pick(node.plotX, box.width * unrandom(index));
-            node.plotY = node.prevY = pick(node.plotY, box.height * unrandom(nodesLength + index));
+        for (var i = 0, iEnd = nodes.length; i < iEnd; ++i) {
+            node = nodes[i];
+            node.plotX = node.prevX = pick(node.plotX, box.width * unrandom(i));
+            node.plotY = node.prevY = pick(node.plotY, box.height * unrandom(nodesLength + i));
             node.dispX = 0;
             node.dispY = 0;
-        });
-    },
-    force: function (name) {
-        this.integration[name].apply(this, Array.prototype.slice.call(arguments, 1));
-    },
-    barycenterForces: function () {
+        }
+    };
+    ReingoldFruchtermanLayout.prototype.force = function (name) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        this.integration[name].apply(this, args);
+    };
+    ReingoldFruchtermanLayout.prototype.barycenterForces = function () {
         this.getBarycenter();
         this.force('barycenter');
-    },
-    getBarycenter: function () {
+    };
+    ReingoldFruchtermanLayout.prototype.getBarycenter = function () {
         var systemMass = 0, cx = 0, cy = 0;
-        this.nodes.forEach(function (node) {
+        for (var _i = 0, _a = this.nodes; _i < _a.length; _i++) {
+            var node = _a[_i];
             cx += node.plotX * node.mass;
             cy += node.plotY * node.mass;
             systemMass += node.mass;
-        });
+        }
         this.barycenter = {
             x: cx,
             y: cy,
@@ -303,18 +340,19 @@ H.layouts['reingold-fruchterman'].prototype, {
             yFactor: cy / systemMass
         };
         return this.barycenter;
-    },
-    barnesHutApproximation: function (node, quadNode) {
-        var layout = this, distanceXY = layout.getDistXY(node, quadNode), distanceR = layout.vectorLength(distanceXY), goDeeper, force;
+    };
+    ReingoldFruchtermanLayout.prototype.barnesHutApproximation = function (node, quadNode) {
+        var distanceXY = this.getDistXY(node, quadNode), distanceR = this.vectorLength(distanceXY);
+        var goDeeper, force;
         if (node !== quadNode && distanceR !== 0) {
             if (quadNode.isInternal) {
                 // Internal node:
                 if (quadNode.boxSize / distanceR <
-                    layout.options.theta &&
+                    this.options.theta &&
                     distanceR !== 0) {
                     // Treat as an external node:
-                    force = layout.repulsiveForce(distanceR, layout.k);
-                    layout.force('repulsive', node, force * quadNode.mass, distanceXY, distanceR);
+                    force = this.repulsiveForce(distanceR, this.k);
+                    this.force('repulsive', node, force * quadNode.mass, distanceXY, distanceR);
                     goDeeper = false;
                 }
                 else {
@@ -324,75 +362,82 @@ H.layouts['reingold-fruchterman'].prototype, {
             }
             else {
                 // External node, direct force:
-                force = layout.repulsiveForce(distanceR, layout.k);
-                layout.force('repulsive', node, force * quadNode.mass, distanceXY, distanceR);
+                force = this.repulsiveForce(distanceR, this.k);
+                this.force('repulsive', node, force * quadNode.mass, distanceXY, distanceR);
             }
         }
         return goDeeper;
-    },
-    repulsiveForces: function () {
-        var layout = this;
-        if (layout.approximation === 'barnes-hut') {
-            layout.nodes.forEach(function (node) {
-                layout.quadTree.visitNodeRecursive(null, function (quadNode) {
-                    return layout.barnesHutApproximation(node, quadNode);
-                });
-            });
+    };
+    ReingoldFruchtermanLayout.prototype.repulsiveForces = function () {
+        var _this = this;
+        if (this.approximation === 'barnes-hut') {
+            var _loop_1 = function (node) {
+                this_1.quadTree.visitNodeRecursive(null, function (quadNode) { return (_this.barnesHutApproximation(node, quadNode)); });
+            };
+            var this_1 = this;
+            for (var _i = 0, _a = this.nodes; _i < _a.length; _i++) {
+                var node = _a[_i];
+                _loop_1(node);
+            }
         }
         else {
-            layout.nodes.forEach(function (node) {
-                layout.nodes.forEach(function (repNode) {
-                    var force, distanceR, distanceXY;
+            var force = void 0, distanceR = void 0, distanceXY = void 0;
+            for (var _b = 0, _c = this.nodes; _b < _c.length; _b++) {
+                var node = _c[_b];
+                for (var _d = 0, _e = this.nodes; _d < _e.length; _d++) {
+                    var repNode = _e[_d];
                     if (
-                    // Node can not repulse itself:
+                    // Node cannot repulse itself:
                     node !== repNode &&
                         // Only close nodes affect each other:
                         // layout.getDistR(node, repNode) < 2 * k &&
                         // Not dragged:
                         !node.fixedPosition) {
-                        distanceXY = layout.getDistXY(node, repNode);
-                        distanceR = layout.vectorLength(distanceXY);
+                        distanceXY = this.getDistXY(node, repNode);
+                        distanceR = this.vectorLength(distanceXY);
                         if (distanceR !== 0) {
-                            force = layout.repulsiveForce(distanceR, layout.k);
-                            layout.force('repulsive', node, force * repNode.mass, distanceXY, distanceR);
+                            force = this.repulsiveForce(distanceR, this.k);
+                            this.force('repulsive', node, force * repNode.mass, distanceXY, distanceR);
                         }
                     }
-                });
-            });
+                }
+            }
         }
-    },
-    attractiveForces: function () {
-        var layout = this, distanceXY, distanceR, force;
-        layout.links.forEach(function (link) {
+    };
+    ReingoldFruchtermanLayout.prototype.attractiveForces = function () {
+        var distanceXY, distanceR, force;
+        for (var _i = 0, _a = this.links; _i < _a.length; _i++) {
+            var link = _a[_i];
             if (link.fromNode && link.toNode) {
-                distanceXY = layout.getDistXY(link.fromNode, link.toNode);
-                distanceR = layout.vectorLength(distanceXY);
+                distanceXY = this.getDistXY(link.fromNode, link.toNode);
+                distanceR = this.vectorLength(distanceXY);
                 if (distanceR !== 0) {
-                    force = layout.attractiveForce(distanceR, layout.k);
-                    layout.force('attractive', link, force, distanceXY, distanceR);
+                    force = this.attractiveForce(distanceR, this.k);
+                    this.force('attractive', link, force, distanceXY, distanceR);
                 }
             }
-        });
-    },
-    applyLimits: function () {
-        var layout = this, nodes = layout.nodes;
-        nodes.forEach(function (node) {
+        }
+    };
+    ReingoldFruchtermanLayout.prototype.applyLimits = function () {
+        var nodes = this.nodes;
+        for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) {
+            var node = nodes_2[_i];
             if (node.fixedPosition) {
                 return;
             }
-            layout.integration.integrate(layout, node);
-            layout.applyLimitBox(node, layout.box);
+            this.integration.integrate(this, node);
+            this.applyLimitBox(node, this.box);
             // Reset displacement:
             node.dispX = 0;
             node.dispY = 0;
-        });
-    },
+        }
+    };
     /**
      * External box that nodes should fall. When hitting an edge, node
      * should stop or bounce.
      * @private
      */
-    applyLimitBox: function (node, box) {
+    ReingoldFruchtermanLayout.prototype.applyLimitBox = function (node, box) {
         var radius = node.radius;
         /*
         TO DO: Consider elastic collision instead of stopping.
@@ -400,7 +445,7 @@ H.layouts['reingold-fruchterman'].prototype, {
 
         - "inelastic":
         o
-         \
+            \
         ______
         |  o'
         |   \
@@ -408,7 +453,7 @@ H.layouts['reingold-fruchterman'].prototype, {
 
         - "elastic"/"bounced":
         o
-         \
+            \
         ______
         |  ^
         | / \
@@ -430,13 +475,13 @@ H.layouts['reingold-fruchterman'].prototype, {
         node.plotX = clamp(node.plotX, box.left + radius, box.width - radius);
         // Limit Y-coordinates:
         node.plotY = clamp(node.plotY, box.top + radius, box.height - radius);
-    },
+    };
     /**
      * From "A comparison of simulated annealing cooling strategies" by
      * Nourani and Andresen work.
      * @private
      */
-    coolDown: function (temperature, temperatureStep, currentStep) {
+    ReingoldFruchtermanLayout.prototype.coolDown = function (temperature, temperatureStep, currentStep) {
         // Logarithmic:
         /*
         return Math.sqrt(this.nodes.length) -
@@ -452,24 +497,27 @@ H.layouts['reingold-fruchterman'].prototype, {
         */
         // Linear:
         return temperature - temperatureStep * currentStep;
-    },
-    isStable: function () {
+    };
+    ReingoldFruchtermanLayout.prototype.isStable = function () {
         return Math.abs(this.systemTemperature -
             this.prevSystemTemperature) < 0.00001 || this.temperature <= 0;
-    },
-    getSystemTemperature: function () {
-        return this.nodes.reduce(function (value, node) {
-            return value + node.temperature;
-        }, 0);
-    },
-    vectorLength: function (vector) {
+    };
+    ReingoldFruchtermanLayout.prototype.getSystemTemperature = function () {
+        var value = 0;
+        for (var _i = 0, _a = this.nodes; _i < _a.length; _i++) {
+            var node = _a[_i];
+            value += node.temperature;
+        }
+        return value;
+    };
+    ReingoldFruchtermanLayout.prototype.vectorLength = function (vector) {
         return Math.sqrt(vector.x * vector.x + vector.y * vector.y);
-    },
-    getDistR: function (nodeA, nodeB) {
+    };
+    ReingoldFruchtermanLayout.prototype.getDistR = function (nodeA, nodeB) {
         var distance = this.getDistXY(nodeA, nodeB);
         return this.vectorLength(distance);
-    },
-    getDistXY: function (nodeA, nodeB) {
+    };
+    ReingoldFruchtermanLayout.prototype.getDistXY = function (nodeA, nodeB) {
         var xDist = nodeA.plotX - nodeB.plotX, yDist = nodeA.plotY - nodeB.plotY;
         return {
             x: xDist,
@@ -477,79 +525,12 @@ H.layouts['reingold-fruchterman'].prototype, {
             absX: Math.abs(xDist),
             absY: Math.abs(yDist)
         };
-    }
-});
-/* ************************************************************************** *
- * Multiple series support:
- * ************************************************************************** */
-// Clear previous layouts
-addEvent(Chart, 'predraw', function () {
-    if (this.graphLayoutsLookup) {
-        this.graphLayoutsLookup.forEach(function (layout) {
-            layout.stop();
-        });
-    }
-});
-addEvent(Chart, 'render', function () {
-    var systemsStable, afterRender = false;
-    /**
-     * @private
-     */
-    function layoutStep(layout) {
-        if (layout.maxIterations-- &&
-            isFinite(layout.temperature) &&
-            !layout.isStable() &&
-            !layout.enableSimulation) {
-            // Hook similar to build-in addEvent, but instead of
-            // creating whole events logic, use just a function.
-            // It's faster which is important for rAF code.
-            // Used e.g. in packed-bubble series for bubble radius
-            // calculations
-            if (layout.beforeStep) {
-                layout.beforeStep();
-            }
-            layout.step();
-            systemsStable = false;
-            afterRender = true;
-        }
-    }
-    if (this.graphLayoutsLookup) {
-        setAnimation(false, this);
-        // Start simulation
-        this.graphLayoutsLookup.forEach(function (layout) {
-            layout.start();
-        });
-        // Just one sync step, to run different layouts similar to
-        // async mode.
-        while (!systemsStable) {
-            systemsStable = true;
-            this.graphLayoutsLookup.forEach(layoutStep);
-        }
-        if (afterRender) {
-            this.series.forEach(function (s) {
-                if (s && s.layout) {
-                    s.render();
-                }
-            });
-        }
-    }
-});
-// disable simulation before print if enabled
-addEvent(Chart, 'beforePrint', function () {
-    if (this.graphLayoutsLookup) {
-        this.graphLayoutsLookup.forEach(function (layout) {
-            layout.updateSimulation(false);
-        });
-        this.redraw();
-    }
-});
-// re-enable simulation after print
-addEvent(Chart, 'afterPrint', function () {
-    if (this.graphLayoutsLookup) {
-        this.graphLayoutsLookup.forEach(function (layout) {
-            // return to default simulation
-            layout.updateSimulation();
-        });
-    }
-    this.redraw();
-});
+    };
+    return ReingoldFruchtermanLayout;
+}());
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default ReingoldFruchtermanLayout;