highcharts 9.1.1 → 9.2.2

package/modules/venn.src.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v9.1.1 (2021-06-04)
+ * @license Highcharts JS v9.2.2 (2021-08-24)
  *
  * (c) 2017-2021 Highsoft AS
  * Authors: Jon Arild Nygard
@@ -27,70 +27,98 @@
             obj[path] = fn.apply(null, args);
         }
     }
-    _registerModule(_modules, 'Mixins/Geometry.js', [], function () {
+    _registerModule(_modules, 'Core/Geometry/GeometryUtilities.js', [], function () {
         /* *
+         *
+         *  (c) 2010-2021 Highsoft AS
+         *
+         *  License: www.highcharts.com/license
          *
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
-        /**
-         * Calculates the center between a list of points.
-         * @private
-         * @param {Array<Highcharts.PositionObject>} points
-         *        A list of points to calculate the center of.
-         * @return {Highcharts.PositionObject}
-         *         Calculated center
-         */
-        var getCenterOfPoints = function getCenterOfPoints(points) {
+        /* *
+         *
+         *  Namespace
+         *
+         * */
+        var GeometryUtilities;
+        (function (GeometryUtilities) {
+            /* *
+             *
+             *  Functions
+             *
+             * */
+            /**
+             * Calculates the center between a list of points.
+             *
+             * @private
+             *
+             * @param {Array<Highcharts.PositionObject>} points
+             * A list of points to calculate the center of.
+             *
+             * @return {Highcharts.PositionObject}
+             * Calculated center
+             */
+            function getCenterOfPoints(points) {
                 var sum = points.reduce(function (sum,
-            point) {
-                    sum.x += point.x;
-                sum.y += point.y;
-                return sum;
-            }, { x: 0, y: 0 });
-            return {
-                x: sum.x / points.length,
-                y: sum.y / points.length
-            };
-        };
-        /**
-         * Calculates the distance between two points based on their x and y
-         * coordinates.
-         * @private
-         * @param {Highcharts.PositionObject} p1
-         *        The x and y coordinates of the first point.
-         * @param {Highcharts.PositionObject} p2
-         *        The x and y coordinates of the second point.
-         * @return {number}
-         *         Returns the distance between the points.
-         */
-        var getDistanceBetweenPoints = function getDistanceBetweenPoints(p1,
-            p2) {
+                    point) {
+                        sum.x += point.x;
+                    sum.y += point.y;
+                    return sum;
+                }, { x: 0, y: 0 });
+                return {
+                    x: sum.x / points.length,
+                    y: sum.y / points.length
+                };
+            }
+            GeometryUtilities.getCenterOfPoints = getCenterOfPoints;
+            /**
+             * Calculates the distance between two points based on their x and y
+             * coordinates.
+             *
+             * @private
+             *
+             * @param {Highcharts.PositionObject} p1
+             * The x and y coordinates of the first point.
+             *
+             * @param {Highcharts.PositionObject} p2
+             * The x and y coordinates of the second point.
+             *
+             * @return {number}
+             * Returns the distance between the points.
+             */
+            function getDistanceBetweenPoints(p1, p2) {
                 return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
-        };
-        /**
-         * Calculates the angle between two points.
-         * @todo add unit tests.
-         * @private
-         * @param {Highcharts.PositionObject} p1 The first point.
-         * @param {Highcharts.PositionObject} p2 The second point.
-         * @return {number} Returns the angle in radians.
-         */
-        var getAngleBetweenPoints = function getAngleBetweenPoints(p1,
-            p2) {
-                return Math.atan2(p2.x - p1.x,
-            p2.y - p1.y);
-        };
-        var geometry = {
-                getAngleBetweenPoints: getAngleBetweenPoints,
-                getCenterOfPoints: getCenterOfPoints,
-                getDistanceBetweenPoints: getDistanceBetweenPoints
-            };
+            }
+            GeometryUtilities.getDistanceBetweenPoints = getDistanceBetweenPoints;
+            /**
+             * Calculates the angle between two points.
+             * @todo add unit tests.
+             * @private
+             * @param {Highcharts.PositionObject} p1 The first point.
+             * @param {Highcharts.PositionObject} p2 The second point.
+             * @return {number} Returns the angle in radians.
+             */
+            function getAngleBetweenPoints(p1, p2) {
+                return Math.atan2(p2.x - p1.x, p2.y - p1.y);
+            }
+            GeometryUtilities.getAngleBetweenPoints = getAngleBetweenPoints;
+        })(GeometryUtilities || (GeometryUtilities = {}));
+        /* *
+         *
+         *  Default Export
+         *
+         * */
 
-        return geometry;
+        return GeometryUtilities;
     });
-    _registerModule(_modules, 'Mixins/GeometryCircles.js', [_modules['Mixins/Geometry.js']], function (Geometry) {
+    _registerModule(_modules, 'Core/Geometry/CircleUtilities.js', [_modules['Core/Geometry/GeometryUtilities.js']], function (Geometry) {
         /* *
+         *
+         *  (c) 2010-2021 Highsoft AS
+         *
+         *  License: www.highcharts.com/license
          *
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
@@ -98,345 +126,407 @@
         var getAngleBetweenPoints = Geometry.getAngleBetweenPoints,
             getCenterOfPoints = Geometry.getCenterOfPoints,
             getDistanceBetweenPoints = Geometry.getDistanceBetweenPoints;
-        /**
-         * @private
-         * @param {number} x
-         *        Number to round
-         * @param {number} decimals
-         *        Number of decimals to round to
-         * @return {number}
-         *         Rounded number
-         */
-        function round(x, decimals) {
-            var a = Math.pow(10,
-                decimals);
-            return Math.round(x * a) / a;
-        }
-        /**
-         * Calculates the area of a circle based on its radius.
-         * @private
-         * @param {number} r
-         *        The radius of the circle.
-         * @return {number}
-         *         Returns the area of the circle.
-         */
-        function getAreaOfCircle(r) {
-            if (r <= 0) {
-                throw new Error('radius of circle must be a positive number.');
+        /* *
+         *
+         *  Namespace
+         *
+         * */
+        var CircleUtilities;
+        (function (CircleUtilities) {
+            /* *
+             *
+             *  Functions
+             *
+             * */
+            /**
+             * @private
+             *
+             * @param {number} x
+             * Number to round
+             *
+             * @param {number} decimals
+             * Number of decimals to round to
+             *
+             * @return {number}
+             * Rounded number
+             */
+            function round(x, decimals) {
+                var a = Math.pow(10,
+                    decimals);
+                return Math.round(x * a) / a;
             }
-            return Math.PI * r * r;
-        }
-        /**
-         * Calculates the area of a circular segment based on the radius of the circle
-         * and the height of the segment.
-         * See http://mathworld.wolfram.com/CircularSegment.html
-         * @private
-         * @param {number} r
-         *        The radius of the circle.
-         * @param {number} h
-         *        The height of the circular segment.
-         * @return {number}
-         *         Returns the area of the circular segment.
-         */
-        function getCircularSegmentArea(r, h) {
-            return r * r * Math.acos(1 - h / r) - (r - h) * Math.sqrt(h * (2 * r - h));
-        }
-        /**
-         * Calculates the area of overlap between two circles based on their radiuses
-         * and the distance between them.
-         * See http://mathworld.wolfram.com/Circle-CircleIntersection.html
-         * @private
-         * @param {number} r1
-         *        Radius of the first circle.
-         * @param {number} r2
-         *        Radius of the second circle.
-         * @param {number} d
-         *        The distance between the two circles.
-         * @return {number}
-         *         Returns the area of overlap between the two circles.
-         */
-        function getOverlapBetweenCircles(r1, r2, d) {
-            var overlap = 0;
-            // If the distance is larger than the sum of the radiuses then the circles
-            // does not overlap.
-            if (d < r1 + r2) {
-                if (d <= Math.abs(r2 - r1)) {
-                    // If the circles are completely overlapping, then the overlap
-                    // equals the area of the smallest circle.
-                    overlap = getAreaOfCircle(r1 < r2 ? r1 : r2);
+            CircleUtilities.round = round;
+            /**
+             * Calculates the area of a circle based on its radius.
+             *
+             * @private
+             *
+             * @param {number} r
+             * The radius of the circle.
+             *
+             * @return {number}
+             * Returns the area of the circle.
+             */
+            function getAreaOfCircle(r) {
+                if (r <= 0) {
+                    throw new Error('radius of circle must be a positive number.');
                 }
-                else {
-                    // Height of first triangle segment.
-                    var d1 = (r1 * r1 - r2 * r2 + d * d) / (2 * d), 
-                        // Height of second triangle segment.
-                        d2 = d - d1;
-                    overlap = (getCircularSegmentArea(r1, r1 - d1) +
-                        getCircularSegmentArea(r2, r2 - d2));
+                return Math.PI * r * r;
+            }
+            CircleUtilities.getAreaOfCircle = getAreaOfCircle;
+            /**
+             * Calculates the area of a circular segment based on the radius of the
+             * circle and the height of the segment.
+             *
+             * @see http://mathworld.wolfram.com/CircularSegment.html
+             *
+             * @private
+             *
+             * @param {number} r
+             * The radius of the circle.
+             *
+             * @param {number} h
+             * The height of the circular segment.
+             *
+             * @return {number}
+             * Returns the area of the circular segment.
+             */
+            function getCircularSegmentArea(r, h) {
+                return r * r * Math.acos(1 - h / r) - (r - h) * Math.sqrt(h * (2 * r - h));
+            }
+            CircleUtilities.getCircularSegmentArea = getCircularSegmentArea;
+            /**
+             * Calculates the area of overlap between two circles based on their
+             * radiuses and the distance between them.
+             *
+             * @see http://mathworld.wolfram.com/Circle-CircleIntersection.html
+             *
+             * @private
+             *
+             * @param {number} r1
+             * Radius of the first circle.
+             *
+             * @param {number} r2
+             * Radius of the second circle.
+             *
+             * @param {number} d
+             * The distance between the two circles.
+             *
+             * @return {number}
+             * Returns the area of overlap between the two circles.
+             */
+            function getOverlapBetweenCircles(r1, r2, d) {
+                var overlap = 0;
+                // If the distance is larger than the sum of the radiuses then the
+                // circles does not overlap.
+                if (d < r1 + r2) {
+                    if (d <= Math.abs(r2 - r1)) {
+                        // If the circles are completely overlapping, then the overlap
+                        // equals the area of the smallest circle.
+                        overlap = getAreaOfCircle(r1 < r2 ? r1 : r2);
+                    }
+                    else {
+                        // Height of first triangle segment.
+                        var d1 = (r1 * r1 - r2 * r2 + d * d) / (2 * d), 
+                            // Height of second triangle segment.
+                            d2 = d - d1;
+                        overlap = (getCircularSegmentArea(r1, r1 - d1) +
+                            getCircularSegmentArea(r2, r2 - d2));
+                    }
+                    // Round the result to two decimals.
+                    overlap = round(overlap, 14);
                 }
-                // Round the result to two decimals.
-                overlap = round(overlap, 14);
+                return overlap;
             }
-            return overlap;
-        }
-        /**
-         * Calculates the intersection points of two circles.
-         *
-         * NOTE: does not handle floating errors well.
-         * @private
-         * @param {Highcharts.CircleObject} c1
-         *        The first circle.
-         * @param {Highcharts.CircleObject} c2
-         *        The second sircle.
-         * @return {Array<Highcharts.PositionObject>}
-         *         Returns the resulting intersection points.
-         */
-        function getCircleCircleIntersection(c1, c2) {
-            var d = getDistanceBetweenPoints(c1,
-                c2),
-                r1 = c1.r,
-                r2 = c2.r;
-            var points = [];
-            if (d < r1 + r2 && d > Math.abs(r1 - r2)) {
-                // If the circles are overlapping, but not completely overlapping, then
-                // it exists intersecting points.
-                var r1Square = r1 * r1,
-                    r2Square = r2 * r2, 
-                    // d^2 - r^2 + R^2 / 2d
-                    x = (r1Square - r2Square + d * d) / (2 * d), 
-                    // y^2 = R^2 - x^2
-                    y = Math.sqrt(r1Square - x * x),
-                    x1 = c1.x,
-                    x2 = c2.x,
-                    y1 = c1.y,
-                    y2 = c2.y,
-                    x0 = x1 + x * (x2 - x1) / d,
-                    y0 = y1 + x * (y2 - y1) / d,
-                    rx = -(y2 - y1) * (y / d),
-                    ry = -(x2 - x1) * (y / d);
-                points = [
-                    { x: round(x0 + rx, 14), y: round(y0 - ry, 14) },
-                    { x: round(x0 - rx, 14), y: round(y0 + ry, 14) }
-                ];
+            CircleUtilities.getOverlapBetweenCircles = getOverlapBetweenCircles;
+            /**
+             * Calculates the intersection points of two circles.
+             *
+             * NOTE: does not handle floating errors well.
+             *
+             * @private
+             *
+             * @param {Highcharts.CircleObject} c1
+             * The first circle.
+             *
+             * @param {Highcharts.CircleObject} c2
+             * The second sircle.
+             *
+             * @return {Array<Highcharts.PositionObject>}
+             * Returns the resulting intersection points.
+             */
+            function getCircleCircleIntersection(c1, c2) {
+                var d = getDistanceBetweenPoints(c1,
+                    c2),
+                    r1 = c1.r,
+                    r2 = c2.r;
+                var points = [];
+                if (d < r1 + r2 && d > Math.abs(r1 - r2)) {
+                    // If the circles are overlapping, but not completely overlapping,
+                    // then it exists intersecting points.
+                    var r1Square = r1 * r1,
+                        r2Square = r2 * r2, 
+                        // d^2 - r^2 + R^2 / 2d
+                        x = (r1Square - r2Square + d * d) / (2 * d), 
+                        // y^2 = R^2 - x^2
+                        y = Math.sqrt(r1Square - x * x),
+                        x1 = c1.x,
+                        x2 = c2.x,
+                        y1 = c1.y,
+                        y2 = c2.y,
+                        x0 = x1 + x * (x2 - x1) / d,
+                        y0 = y1 + x * (y2 - y1) / d,
+                        rx = -(y2 - y1) * (y / d),
+                        ry = -(x2 - x1) * (y / d);
+                    points = [
+                        { x: round(x0 + rx, 14), y: round(y0 - ry, 14) },
+                        { x: round(x0 - rx, 14), y: round(y0 + ry, 14) }
+                    ];
+                }
+                return points;
             }
-            return points;
-        }
-        /**
-         * Calculates all the intersection points for between a list of circles.
-         * @private
-         * @param {Array<Highcharts.CircleObject>} circles
-         *        The circles to calculate the points from.
-         * @return {Array<Highcharts.GeometryObject>}
-         *         Returns a list of intersection points.
-         */
-        function getCirclesIntersectionPoints(circles) {
-            return circles.reduce(function (points, c1, i, arr) {
-                var additional = arr.slice(i + 1)
-                        .reduce(function (points,
-                    c2,
-                    j) {
-                        var indexes = [i,
-                    j + i + 1];
-                    return points.concat(getCircleCircleIntersection(c1, c2)
-                        .map(function (p) {
-                        p.indexes = indexes;
-                        return p;
-                    }));
+            CircleUtilities.getCircleCircleIntersection = getCircleCircleIntersection;
+            /**
+             * Calculates all the intersection points for between a list of circles.
+             *
+             * @private
+             *
+             * @param {Array<Highcharts.CircleObject>} circles
+             * The circles to calculate the points from.
+             *
+             * @return {Array<Highcharts.GeometryObject>}
+             * Returns a list of intersection points.
+             */
+            function getCirclesIntersectionPoints(circles) {
+                return circles.reduce(function (points, c1, i, arr) {
+                    var additional = arr
+                            .slice(i + 1)
+                            .reduce(function (points,
+                        c2,
+                        j,
+                        arr) {
+                            var indexes = [i,
+                        j + i + 1];
+                        return points.concat(getCircleCircleIntersection(c1, c2).map(function (p) {
+                            p.indexes = indexes;
+                            return p;
+                        }));
+                    }, []);
+                    return points.concat(additional);
                 }, []);
-                return points.concat(additional);
-            }, []);
-        }
-        /**
-         * Tests wether the first circle is completely overlapping the second circle.
-         *
-         * @private
-         * @param {Highcharts.CircleObject} circle1 The first circle.
-         * @param {Highcharts.CircleObject} circle2 The The second circle.
-         * @return {boolean} Returns true if circle1 is completely overlapping circle2,
-         * false if not.
-         */
-        function isCircle1CompletelyOverlappingCircle2(circle1, circle2) {
-            return getDistanceBetweenPoints(circle1, circle2) + circle2.r <
-                circle1.r + 1e-10;
-        }
-        /**
-         * Tests wether a point lies within a given circle.
-         * @private
-         * @param {Highcharts.PositionObject} point
-         *        The point to test for.
-         * @param {Highcharts.CircleObject} circle
-         *        The circle to test if the point is within.
-         * @return {boolean}
-         *         Returns true if the point is inside, false if outside.
-         */
-        function isPointInsideCircle(point, circle) {
-            return getDistanceBetweenPoints(point, circle) <= circle.r + 1e-10;
-        }
-        /**
-         * Tests wether a point lies within a set of circles.
-         * @private
-         * @param {Highcharts.PositionObject} point
-         *        The point to test.
-         * @param {Array<Highcharts.CircleObject>} circles
-         *        The list of circles to test against.
-         * @return {boolean}
-         *         Returns true if the point is inside all the circles, false if not.
-         */
-        function isPointInsideAllCircles(point, circles) {
-            return !circles.some(function (circle) {
-                return !isPointInsideCircle(point, circle);
-            });
-        }
-        /**
-         * Tests wether a point lies outside a set of circles.
-         *
-         * TODO: add unit tests.
-         * @private
-         * @param {Highcharts.PositionObject} point
-         *        The point to test.
-         * @param {Array<Highcharts.CircleObject>} circles
-         *        The list of circles to test against.
-         * @return {boolean}
-         *         Returns true if the point is outside all the circles, false if not.
-         */
-        function isPointOutsideAllCircles(point, circles) {
-            return !circles.some(function (circle) {
-                return isPointInsideCircle(point, circle);
-            });
-        }
-        /**
-         * Calculates the points for the polygon of the intersection area between a set
-         * of circles.
-         *
-         * @private
-         * @param {Array<Highcharts.CircleObject>} circles
-         *        List of circles to calculate polygon of.
-         * @return {Array<Highcharts.GeometryObject>} Return list of points in the
-         * intersection polygon.
-         */
-        function getCirclesIntersectionPolygon(circles) {
-            return getCirclesIntersectionPoints(circles)
-                .filter(function (p) {
-                return isPointInsideAllCircles(p, circles);
-            });
-        }
-        /**
-         * Calculate the path for the area of overlap between a set of circles.
-         * @todo handle cases with only 1 or 0 arcs.
-         * @private
-         * @param {Array<Highcharts.CircleObject>} circles
-         *        List of circles to calculate area of.
-         * @return {Highcharts.GeometryIntersectionObject|undefined}
-         *         Returns the path for the area of overlap. Returns an empty string if
-         *         there are no intersection between all the circles.
-         */
-        function getAreaOfIntersectionBetweenCircles(circles) {
-            var intersectionPoints = getCirclesIntersectionPolygon(circles),
-                result;
-            if (intersectionPoints.length > 1) {
-                // Calculate the center of the intersection points.
-                var center_1 = getCenterOfPoints(intersectionPoints);
-                intersectionPoints = intersectionPoints
-                    // Calculate the angle between the center and the points.
-                    .map(function (p) {
-                    p.angle = getAngleBetweenPoints(center_1, p);
-                    return p;
-                })
-                    // Sort the points by the angle to the center.
-                    .sort(function (a, b) {
-                    return b.angle - a.angle;
+            }
+            CircleUtilities.getCirclesIntersectionPoints = getCirclesIntersectionPoints;
+            /**
+             * Tests wether the first circle is completely overlapping the second
+             * circle.
+             *
+             * @private
+             *
+             * @param {Highcharts.CircleObject} circle1
+             * The first circle.
+             *
+             * @param {Highcharts.CircleObject} circle2
+             * The The second circle.
+             *
+             * @return {boolean}
+             * Returns true if circle1 is completely overlapping circle2, false if not.
+             */
+            function isCircle1CompletelyOverlappingCircle2(circle1, circle2) {
+                return getDistanceBetweenPoints(circle1, circle2) + circle2.r < circle1.r + 1e-10;
+            }
+            CircleUtilities.isCircle1CompletelyOverlappingCircle2 = isCircle1CompletelyOverlappingCircle2;
+            /**
+             * Tests wether a point lies within a given circle.
+             * @private
+             * @param {Highcharts.PositionObject} point
+             * The point to test for.
+             *
+             * @param {Highcharts.CircleObject} circle
+             * The circle to test if the point is within.
+             *
+             * @return {boolean}
+             * Returns true if the point is inside, false if outside.
+             */
+            function isPointInsideCircle(point, circle) {
+                return getDistanceBetweenPoints(point, circle) <= circle.r + 1e-10;
+            }
+            CircleUtilities.isPointInsideCircle = isPointInsideCircle;
+            /**
+             * Tests wether a point lies within a set of circles.
+             *
+             * @private
+             *
+             * @param {Highcharts.PositionObject} point
+             * The point to test.
+             *
+             * @param {Array<Highcharts.CircleObject>} circles
+             * The list of circles to test against.
+             *
+             * @return {boolean}
+             * Returns true if the point is inside all the circles, false if not.
+             */
+            function isPointInsideAllCircles(point, circles) {
+                return !circles.some(function (circle) {
+                    return !isPointInsideCircle(point, circle);
                 });
-                var startPoint = intersectionPoints[intersectionPoints.length - 1];
-                var arcs = intersectionPoints
-                        .reduce(function (data,
-                    p1) {
-                        var startPoint = data.startPoint,
-                    midPoint = getCenterOfPoints([startPoint,
-                    p1]);
-                    // Calculate the arc from the intersection points and their
-                    // circles.
-                    var arc = p1.indexes
-                            // Filter out circles that are not included in both
-                            // intersection points.
-                            .filter(function (index) {
-                            return startPoint.indexes.indexOf(index) > -1;
+            }
+            CircleUtilities.isPointInsideAllCircles = isPointInsideAllCircles;
+            /**
+             * Tests wether a point lies outside a set of circles.
+             *
+             * TODO: add unit tests.
+             *
+             * @private
+             *
+             * @param {Highcharts.PositionObject} point
+             * The point to test.
+             *
+             * @param {Array<Highcharts.CircleObject>} circles
+             * The list of circles to test against.
+             *
+             * @return {boolean}
+             * Returns true if the point is outside all the circles, false if not.
+             */
+            function isPointOutsideAllCircles(point, circles) {
+                return !circles.some(function (circle) {
+                    return isPointInsideCircle(point, circle);
+                });
+            }
+            CircleUtilities.isPointOutsideAllCircles = isPointOutsideAllCircles;
+            /**
+             * Calculates the points for the polygon of the intersection area between
+             * a set of circles.
+             *
+             * @private
+             *
+             * @param {Array<Highcharts.CircleObject>} circles
+             * List of circles to calculate polygon of.
+             *
+             * @return {Array<Highcharts.GeometryObject>}
+             * Return list of points in the intersection polygon.
+             */
+            function getCirclesIntersectionPolygon(circles) {
+                return getCirclesIntersectionPoints(circles)
+                    .filter(function (p) {
+                    return isPointInsideAllCircles(p, circles);
+                });
+            }
+            CircleUtilities.getCirclesIntersectionPolygon = getCirclesIntersectionPolygon;
+            /**
+             * Calculate the path for the area of overlap between a set of circles.
+             *
+             * @todo handle cases with only 1 or 0 arcs.
+             *
+             * @private
+             *
+             * @param {Array<Highcharts.CircleObject>} circles
+             * List of circles to calculate area of.
+             *
+             * @return {Highcharts.GeometryIntersectionObject|undefined}
+             * Returns the path for the area of overlap. Returns an empty string if
+             * there are no intersection between all the circles.
+             */
+            function getAreaOfIntersectionBetweenCircles(circles) {
+                var intersectionPoints = getCirclesIntersectionPolygon(circles),
+                    result;
+                if (intersectionPoints.length > 1) {
+                    // Calculate the center of the intersection points.
+                    var center_1 = getCenterOfPoints(intersectionPoints);
+                    intersectionPoints = intersectionPoints
+                        // Calculate the angle between the center and the points.
+                        .map(function (p) {
+                        p.angle = getAngleBetweenPoints(center_1, p);
+                        return p;
                     })
-                        // Iterate the circles of the intersection points and
-                        // calculate arcs.
-                        .reduce(function (arc, index) {
-                        var circle = circles[index],
-                            angle1 = getAngleBetweenPoints(circle,
-                            p1),
-                            angle2 = getAngleBetweenPoints(circle,
-                            startPoint),
-                            angleDiff = angle2 - angle1 +
-                                (angle2 < angle1 ? 2 * Math.PI : 0),
-                            angle = angle2 - angleDiff / 2;
-                        var width = getDistanceBetweenPoints(midPoint, {
-                                x: circle.x + circle.r * Math.sin(angle),
-                                y: circle.y + circle.r * Math.cos(angle)
-                            });
-                        var r = circle.r;
-                        // Width can sometimes become to large due to floating
-                        // point errors
-                        if (width > r * 2) {
-                            width = r * 2;
-                        }
-                        // Get the arc with the smallest width.
-                        if (!arc || arc.width > width) {
-                            arc = {
-                                r: r,
-                                largeArc: width > r ? 1 : 0,
-                                width: width,
-                                x: p1.x,
-                                y: p1.y
-                            };
+                        // Sort the points by the angle to the center.
+                        .sort(function (a, b) {
+                        return b.angle - a.angle;
+                    });
+                    var startPoint = intersectionPoints[intersectionPoints.length - 1];
+                    var arcs = intersectionPoints
+                            .reduce(function (data,
+                        p1) {
+                            var startPoint = data.startPoint,
+                        midPoint = getCenterOfPoints([startPoint,
+                        p1]);
+                        // Calculate the arc from the intersection points and their
+                        // circles.
+                        var arc = p1.indexes
+                                // Filter out circles that are not included in both
+                                // intersection points.
+                                .filter(function (index) {
+                                return startPoint.indexes.indexOf(index) > -1;
+                        })
+                            // Iterate the circles of the intersection points and
+                            // calculate arcs.
+                            .reduce(function (arc, index) {
+                            var circle = circles[index],
+                                angle1 = getAngleBetweenPoints(circle,
+                                p1),
+                                angle2 = getAngleBetweenPoints(circle,
+                                startPoint),
+                                angleDiff = angle2 - angle1 +
+                                    (angle2 < angle1 ? 2 * Math.PI : 0),
+                                angle = angle2 - angleDiff / 2;
+                            var width = getDistanceBetweenPoints(midPoint, {
+                                    x: circle.x + circle.r * Math.sin(angle),
+                                    y: circle.y + circle.r * Math.cos(angle)
+                                });
+                            var r = circle.r;
+                            // Width can sometimes become to large due to
+                            // floating point errors
+                            if (width > r * 2) {
+                                width = r * 2;
+                            }
+                            // Get the arc with the smallest width.
+                            if (!arc || arc.width > width) {
+                                arc = {
+                                    r: r,
+                                    largeArc: width > r ? 1 : 0,
+                                    width: width,
+                                    x: p1.x,
+                                    y: p1.y
+                                };
+                            }
+                            // Return the chosen arc.
+                            return arc;
+                        }, null);
+                        // If we find an arc then add it to the list and update p2.
+                        if (arc) {
+                            var r = arc.r;
+                            data.arcs.push(['A', r, r, 0, arc.largeArc, 1, arc.x, arc.y]);
+                            data.startPoint = p1;
                         }
-                        // Return the chosen arc.
-                        return arc;
-                    }, null);
-                    // If we find an arc then add it to the list and update p2.
-                    if (arc) {
-                        var r = arc.r;
-                        data.arcs.push(['A', r, r, 0, arc.largeArc, 1, arc.x, arc.y]);
-                        data.startPoint = p1;
+                        return data;
+                    }, {
+                        startPoint: startPoint,
+                        arcs: []
+                    }).arcs;
+                    if (arcs.length === 0) {
+                        // empty
+                    }
+                    else if (arcs.length === 1) {
+                        // empty
+                    }
+                    else {
+                        arcs.unshift(['M', startPoint.x, startPoint.y]);
+                        result = {
+                            center: center_1,
+                            d: arcs
+                        };
                     }
-                    return data;
-                }, {
-                    startPoint: startPoint,
-                    arcs: []
-                }).arcs;
-                if (arcs.length === 0) {
-                    // empty
-                }
-                else if (arcs.length === 1) {
-                    // empty
-                }
-                else {
-                    arcs.unshift(['M', startPoint.x, startPoint.y]);
-                    result = {
-                        center: center_1,
-                        d: arcs
-                    };
                 }
+                return result;
             }
-            return result;
-        }
-        var geometryCircles = {
-                getAreaOfCircle: getAreaOfCircle,
-                getAreaOfIntersectionBetweenCircles: getAreaOfIntersectionBetweenCircles,
-                getCircleCircleIntersection: getCircleCircleIntersection,
-                getCirclesIntersectionPoints: getCirclesIntersectionPoints,
-                getCirclesIntersectionPolygon: getCirclesIntersectionPolygon,
-                getCircularSegmentArea: getCircularSegmentArea,
-                getOverlapBetweenCircles: getOverlapBetweenCircles,
-                isCircle1CompletelyOverlappingCircle2: isCircle1CompletelyOverlappingCircle2,
-                isPointInsideCircle: isPointInsideCircle,
-                isPointInsideAllCircles: isPointInsideAllCircles,
-                isPointOutsideAllCircles: isPointOutsideAllCircles,
-                round: round
-            };
+            CircleUtilities.getAreaOfIntersectionBetweenCircles = getAreaOfIntersectionBetweenCircles;
+        })(CircleUtilities || (CircleUtilities = {}));
+        /* *
+         *
+         *  Default Export
+         *
+         * */
 
-        return geometryCircles;
+        return CircleUtilities;
     });
     _registerModule(_modules, 'Mixins/NelderMead.js', [], function () {
         /* *
@@ -757,7 +847,7 @@
 
         return VennPoint;
     });
-    _registerModule(_modules, 'Series/Venn/VennUtils.js', [_modules['Mixins/GeometryCircles.js'], _modules['Mixins/Geometry.js'], _modules['Mixins/NelderMead.js'], _modules['Core/Utilities.js']], function (GeometryCirclesModule, GeometryMixin, NelderMeadMixin, U) {
+    _registerModule(_modules, 'Series/Venn/VennUtils.js', [_modules['Core/Geometry/CircleUtilities.js'], _modules['Core/Geometry/GeometryUtilities.js'], _modules['Mixins/NelderMead.js'], _modules['Core/Utilities.js']], function (CU, GU, NelderMeadMixin, U) {
         /* *
          *
          *  Experimental Highcharts module which enables visualization of a Venn
@@ -774,13 +864,13 @@
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
-        var getAreaOfCircle = GeometryCirclesModule.getAreaOfCircle,
-            getCircleCircleIntersection = GeometryCirclesModule.getCircleCircleIntersection,
-            getOverlapBetweenCirclesByDistance = GeometryCirclesModule.getOverlapBetweenCircles,
-            isPointInsideAllCircles = GeometryCirclesModule.isPointInsideAllCircles,
-            isPointInsideCircle = GeometryCirclesModule.isPointInsideCircle,
-            isPointOutsideAllCircles = GeometryCirclesModule.isPointOutsideAllCircles;
-        var getDistanceBetweenPoints = GeometryMixin.getDistanceBetweenPoints;
+        var getAreaOfCircle = CU.getAreaOfCircle,
+            getCircleCircleIntersection = CU.getCircleCircleIntersection,
+            getOverlapBetweenCirclesByDistance = CU.getOverlapBetweenCircles,
+            isPointInsideAllCircles = CU.isPointInsideAllCircles,
+            isPointInsideCircle = CU.isPointInsideCircle,
+            isPointOutsideAllCircles = CU.isPointOutsideAllCircles;
+        var getDistanceBetweenPoints = GU.getDistanceBetweenPoints;
         var extend = U.extend,
             isArray = U.isArray,
             isNumber = U.isNumber,
@@ -798,8 +888,8 @@
              *  Properties
              *
              * */
-            VennUtils.geometry = GeometryMixin;
-            VennUtils.geometryCircles = GeometryCirclesModule;
+            VennUtils.geometry = GU;
+            VennUtils.geometryCircles = CU;
             VennUtils.nelderMead = NelderMeadMixin;
             /* *
              *
@@ -823,18 +913,18 @@
                 // Calculate the amount of overlap per set.
                 var mapOfIdToProps = relations
                         // Filter out relations consisting of 2 sets.
-                        .filter(function (relation) {
-                        return relation.sets.length === 2;
-                })
-                    // Sum up the amount of overlap for each set.
-                    .reduce(function (map, relation) {
-                    var sets = relation.sets;
-                    sets.forEach(function (set, i, arr) {
-                        if (!isObject(map[set])) {
-                            map[set] = {
-                                overlapping: {},
-                                totalOverlap: 0
-                            };
+                        .filter(function (relation) { return (relation.sets.length === 2); })
+                        // Sum up the amount of overlap for each set.
+                        .reduce(function (map,
+                    relation) {
+                        relation.sets.forEach(function (set,
+                    i,
+                    arr) {
+                            if (!isObject(map[set])) {
+                                map[set] = {
+                                    overlapping: {},
+                                    totalOverlap: 0
+                                };
                         }
                         map[set].totalOverlap += relation.value;
                         map[set].overlapping[arr[1 - i]] = relation.value;
@@ -968,13 +1058,13 @@
              */
             function getLabelWidth(pos, internal, external) {
                 var radius = internal.reduce(function (min,
-                    circle) {
-                        return Math.min(circle.r,
-                    min);
-                }, Infinity), 
-                // Filter out external circles that are completely overlapping.
-                filteredExternals = external.filter(function (circle) {
-                    return !isPointInsideCircle(pos, circle);
+                    circle) { return Math.min(circle.r,
+                    min); },
+                    Infinity), 
+                    // Filter out external circles that are completely overlapping.
+                    filteredExternals = external.filter(function (circle) {
+                        return !isPointInsideCircle(pos,
+                    circle);
                 });
                 var findDistance = function (maxDistance,
                     direction) {
@@ -1128,8 +1218,7 @@
                     var circle = set.circle,
                         radius = circle.r,
                         overlapping = set.overlapping;
-                    var bestPosition = positionedSets
-                            .reduce(function (best,
+                    var bestPosition = positionedSets.reduce(function (best,
                         positionedSet,
                         i) {
                             var positionedCircle = positionedSet.circle,
@@ -1305,7 +1394,7 @@
 
         return VennUtils;
     });
-    _registerModule(_modules, 'Series/Venn/VennSeries.js', [_modules['Core/Animation/AnimationUtilities.js'], _modules['Core/Color/Color.js'], _modules['Mixins/Geometry.js'], _modules['Mixins/GeometryCircles.js'], _modules['Mixins/NelderMead.js'], _modules['Core/Color/Palette.js'], _modules['Core/Series/SeriesRegistry.js'], _modules['Series/Venn/VennPoint.js'], _modules['Series/Venn/VennUtils.js'], _modules['Core/Utilities.js']], function (A, Color, GeometryMixin, GeometryCirclesModule, NelderMeadMixin, palette, SeriesRegistry, VennPoint, VennUtils, U) {
+    _registerModule(_modules, 'Series/Venn/VennSeries.js', [_modules['Core/Animation/AnimationUtilities.js'], _modules['Core/Color/Color.js'], _modules['Core/Geometry/CircleUtilities.js'], _modules['Core/Geometry/GeometryUtilities.js'], _modules['Mixins/NelderMead.js'], _modules['Core/Color/Palette.js'], _modules['Core/Series/SeriesRegistry.js'], _modules['Series/Venn/VennPoint.js'], _modules['Series/Venn/VennUtils.js'], _modules['Core/Utilities.js']], function (A, Color, CU, GU, NelderMeadMixin, palette, SeriesRegistry, VennPoint, VennUtils, U) {
         /* *
          *
          *  Experimental Highcharts module which enables visualization of a Venn
@@ -1340,17 +1429,12 @@
         })();
         var animObject = A.animObject;
         var color = Color.parse;
-        var getCenterOfPoints = GeometryMixin.getCenterOfPoints,
-            getDistanceBetweenPoints = GeometryMixin.getDistanceBetweenPoints;
-        var getAreaOfCircle = GeometryCirclesModule.getAreaOfCircle,
-            getAreaOfIntersectionBetweenCircles = GeometryCirclesModule.getAreaOfIntersectionBetweenCircles,
-            getCircleCircleIntersection = GeometryCirclesModule.getCircleCircleIntersection,
-            getCirclesIntersectionPolygon = GeometryCirclesModule.getCirclesIntersectionPolygon,
-            getOverlapBetweenCirclesByDistance = GeometryCirclesModule.getOverlapBetweenCircles,
-            isCircle1CompletelyOverlappingCircle2 = GeometryCirclesModule.isCircle1CompletelyOverlappingCircle2,
-            isPointInsideAllCircles = GeometryCirclesModule.isPointInsideAllCircles,
-            isPointInsideCircle = GeometryCirclesModule.isPointInsideCircle,
-            isPointOutsideAllCircles = GeometryCirclesModule.isPointOutsideAllCircles;
+        var getAreaOfIntersectionBetweenCircles = CU.getAreaOfIntersectionBetweenCircles,
+            getCirclesIntersectionPolygon = CU.getCirclesIntersectionPolygon,
+            isCircle1CompletelyOverlappingCircle2 = CU.isCircle1CompletelyOverlappingCircle2,
+            isPointInsideAllCircles = CU.isPointInsideAllCircles,
+            isPointOutsideAllCircles = CU.isPointOutsideAllCircles;
+        var getCenterOfPoints = GU.getCenterOfPoints;
         var nelderMead = NelderMeadMixin.nelderMead;
         var ScatterSeries = SeriesRegistry.seriesTypes.scatter;
         var addEvent = U.addEvent,