highcharts 9.2.2 → 9.3.0

package/modules/venn.src.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v9.2.2 (2021-08-24)
+ * @license Highcharts JS v9.3.0 (2021-10-21)
  *
  * (c) 2017-2021 Highsoft AS
  * Authors: Jon Arild Nygard
@@ -528,257 +528,137 @@
 
         return CircleUtilities;
     });
-    _registerModule(_modules, 'Mixins/NelderMead.js', [], function () {
+    _registerModule(_modules, 'Series/DrawPointComposition.js', [], function () {
         /* *
          *
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
-        /* eslint-disable valid-jsdoc */
-        var getCentroid = function (simplex) {
-                var arr = simplex.slice(0, -1),
-            length = arr.length,
-            result = [],
-            sum = function (data,
-            point) {
-                    data.sum += point[data.i];
-                return data;
-            };
-            for (var i = 0; i < length; i++) {
-                result[i] = arr.reduce(sum, { sum: 0, i: i }).sum / length;
-            }
-            return result;
-        };
-        /**
-         * Finds an optimal position for a given point.
-         * @todo add unit tests.
-         * @todo add constraints to optimize the algorithm.
-         * @private
-         * @param {Highcharts.NelderMeadTestFunction} fn
-         *        The function to test a point.
-         * @param {Highcharts.NelderMeadPointArray} initial
-         *        The initial point to optimize.
-         * @return {Highcharts.NelderMeadPointArray}
-         *         Returns the opimized position of a point.
-         */
-        var nelderMead = function nelderMead(fn,
-            initial) {
-                var maxIterations = 100,
-            sortByFx = function (a,
-            b) {
-                    return a.fx - b.fx;
-            }, pRef = 1, // Reflection parameter
-            pExp = 2, // Expansion parameter
-            pCon = -0.5, // Contraction parameter
-            pOCon = pCon * pRef, // Outwards contraction parameter
-            pShrink = 0.5; // Shrink parameter
+        /* *
+         *
+         *  Composition
+         *
+         * */
+        var DrawPointComposition;
+        (function (DrawPointComposition) {
+            /* *
+             *
+             *  Declarations
+             *
+             * */
+            /* *
+             *
+             *  Constants
+             *
+             * */
+            var composedClasses = [];
+            /* *
+             *
+             *  Functions
+             *
+             * */
+            /* eslint-disable valid-jsdoc */
             /**
              * @private
              */
-            var weightedSum = function weightedSum(weight1,
-                v1,
-                weight2,
-                v2) {
-                    return v1.map(function (x,
-                i) {
-                        return weight1 * x + weight2 * v2[i];
-                });
-            };
+            function compose(PointClass) {
+                if (composedClasses.indexOf(PointClass) === -1) {
+                    composedClasses.push(PointClass);
+                    var pointProto = PointClass.prototype;
+                    pointProto.draw = draw;
+                    if (!pointProto.shouldDraw) {
+                        pointProto.shouldDraw = shouldDraw;
+                    }
+                }
+                return PointClass;
+            }
+            DrawPointComposition.compose = compose;
             /**
+             * Handles the drawing of a component.
+             * Can be used for any type of component that reserves the graphic property,
+             * and provides a shouldDraw on its context.
+             *
              * @private
+             *
+             * @todo add type checking.
+             * @todo export this function to enable usage
              */
-            var getSimplex = function getSimplex(initial) {
-                    var n = initial.length,
-                simplex = new Array(n + 1);
-                // Initial point to the simplex.
-                simplex[0] = initial;
-                simplex[0].fx = fn(initial);
-                // Create a set of extra points based on the initial.
-                for (var i = 0; i < n; ++i) {
-                    var point = initial.slice();
-                    point[i] = point[i] ? point[i] * 1.05 : 0.001;
-                    point.fx = fn(point);
-                    simplex[i + 1] = point;
-                }
-                return simplex;
-            };
-            var updateSimplex = function (simplex,
-                point) {
-                    point.fx = fn(point);
-                simplex[simplex.length - 1] = point;
-                return simplex;
-            };
-            var shrinkSimplex = function (simplex) {
-                    var best = simplex[0];
-                return simplex.map(function (point) {
-                    var p = weightedSum(1 - pShrink,
-                        best,
-                        pShrink,
-                        point);
-                    p.fx = fn(p);
-                    return p;
-                });
-            };
-            var getPoint = function (centroid,
-                worst,
-                a,
-                b) {
-                    var point = weightedSum(a,
-                centroid,
-                b,
-                worst);
-                point.fx = fn(point);
-                return point;
-            };
-            // Create a simplex
-            var simplex = getSimplex(initial);
-            // Iterate from 0 to max iterations
-            for (var i = 0; i < maxIterations; i++) {
-                // Sort the simplex
-                simplex.sort(sortByFx);
-                // Create a centroid from the simplex
-                var worst = simplex[simplex.length - 1];
-                var centroid = getCentroid(simplex);
-                // Calculate the reflected point.
-                var reflected = getPoint(centroid,
-                    worst, 1 + pRef, -pRef);
-                if (reflected.fx < simplex[0].fx) {
-                    // If reflected point is the best, then possibly expand.
-                    var expanded = getPoint(centroid,
-                        worst, 1 + pExp, -pExp);
-                    simplex = updateSimplex(simplex, (expanded.fx < reflected.fx) ? expanded : reflected);
+            function draw(params) {
+                var _this = this;
+                var animatableAttribs = params.animatableAttribs,
+                    onComplete = params.onComplete,
+                    css = params.css,
+                    renderer = params.renderer;
+                var animation = (this.series && this.series.chart.hasRendered) ?
+                        // Chart-level animation on updates
+                        void 0 :
+                        // Series-level animation on new points
+                        (this.series &&
+                            this.series.options.animation);
+                var graphic = this.graphic;
+                params.attribs = params.attribs || {};
+                // Assigning class in dot notation does go well in IE8
+                // eslint-disable-next-line dot-notation
+                params.attribs['class'] = this.getClassName();
+                if (this.shouldDraw()) {
+                    if (!graphic) {
+                        this.graphic = graphic =
+                            renderer[params.shapeType](params.shapeArgs)
+                                .add(params.group);
+                    }
+                    graphic
+                        .css(css)
+                        .attr(params.attribs)
+                        .animate(animatableAttribs, params.isNew ? false : animation, onComplete);
                 }
-                else if (reflected.fx >= simplex[simplex.length - 2].fx) {
-                    // If the reflected point is worse than the second worse, then
-                    // contract.
-                    var contracted = void 0;
-                    if (reflected.fx > worst.fx) {
-                        // If the reflected is worse than the worst point, do a
-                        // contraction
-                        contracted = getPoint(centroid, worst, 1 + pCon, -pCon);
-                        if (contracted.fx < worst.fx) {
-                            simplex = updateSimplex(simplex, contracted);
-                        }
-                        else {
-                            simplex = shrinkSimplex(simplex);
+                else if (graphic) {
+                    var destroy_1 = function () {
+                            _this.graphic = graphic = (graphic && graphic.destroy());
+                        if (typeof onComplete === 'function') {
+                            onComplete();
                         }
+                    };
+                    // animate only runs complete callback if something was animated.
+                    if (Object.keys(animatableAttribs).length) {
+                        graphic.animate(animatableAttribs, void 0, function () {
+                            destroy_1();
+                        });
                     }
                     else {
-                        // Otherwise do an outwards contraction
-                        contracted = getPoint(centroid, worst, 1 - pOCon, pOCon);
-                        if (contracted.fx < reflected.fx) {
-                            simplex = updateSimplex(simplex, contracted);
-                        }
-                        else {
-                            simplex = shrinkSimplex(simplex);
-                        }
+                        destroy_1();
                     }
                 }
-                else {
-                    simplex = updateSimplex(simplex, reflected);
-                }
             }
-            return simplex[0];
-        };
-        var nelderMeadMixin = {
-                getCentroid: getCentroid,
-                nelderMead: nelderMead
-            };
-
-        return nelderMeadMixin;
-    });
-    _registerModule(_modules, 'Mixins/DrawPoint.js', [], function () {
+            /**
+             * @private
+             */
+            function shouldDraw() {
+                return !this.isNull;
+            }
+        })(DrawPointComposition || (DrawPointComposition = {}));
         /* *
          *
-         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+         *  Default Export
          *
          * */
-        var isFn = function (x) {
-                return typeof x === 'function';
-        };
-        /* eslint-disable no-invalid-this, valid-jsdoc */
-        /**
-         * Handles the drawing of a component.
-         * Can be used for any type of component that reserves the graphic property, and
-         * provides a shouldDraw on its context.
-         *
-         * @private
-         * @function draw
-         * @param {DrawPointParams} params
-         *        Parameters.
-         *
-         * @todo add type checking.
-         * @todo export this function to enable usage
-         */
-        var draw = function draw(params) {
-                var _this = this;
-            var animatableAttribs = params.animatableAttribs,
-                onComplete = params.onComplete,
-                css = params.css,
-                renderer = params.renderer;
-            var animation = (this.series && this.series.chart.hasRendered) ?
-                    // Chart-level animation on updates
-                    void 0 :
-                    // Series-level animation on new points
-                    (this.series &&
-                        this.series.options.animation);
-            var graphic = this.graphic;
-            if (this.shouldDraw()) {
-                if (!graphic) {
-                    this.graphic = graphic =
-                        renderer[params.shapeType](params.shapeArgs)
-                            .add(params.group);
-                }
-                graphic
-                    .css(css)
-                    .attr(params.attribs)
-                    .animate(animatableAttribs, params.isNew ? false : animation, onComplete);
-            }
-            else if (graphic) {
-                var destroy_1 = function () {
-                        _this.graphic = graphic = (graphic && graphic.destroy());
-                    if (isFn(onComplete)) {
-                        onComplete();
-                    }
-                };
-                // animate only runs complete callback if something was animated.
-                if (Object.keys(animatableAttribs).length) {
-                    graphic.animate(animatableAttribs, void 0, function () {
-                        destroy_1();
-                    });
-                }
-                else {
-                    destroy_1();
-                }
-            }
-        };
-        /**
-         * An extended version of draw customized for points.
-         * It calls additional methods that is expected when rendering a point.
-         * @private
-         * @param {Highcharts.Dictionary<any>} params Parameters
-         */
-        var drawPoint = function drawPoint(params) {
-                var point = this,
-            attribs = params.attribs = params.attribs || {};
-            // Assigning class in dot notation does go well in IE8
-            // eslint-disable-next-line dot-notation
-            attribs['class'] = point.getClassName();
-            // Call draw to render component
-            draw.call(point, params);
-        };
-        var drawPointModule = {
-                draw: draw,
-                drawPoint: drawPoint,
-                isFn: isFn
-            };
 
-        return drawPointModule;
+        return DrawPointComposition;
     });
-    _registerModule(_modules, 'Series/Venn/VennPoint.js', [_modules['Mixins/DrawPoint.js'], _modules['Core/Series/SeriesRegistry.js'], _modules['Core/Utilities.js']], function (DrawPointMixin, SeriesRegistry, U) {
+    _registerModule(_modules, 'Series/Venn/VennPoint.js', [_modules['Series/DrawPointComposition.js'], _modules['Core/Series/SeriesRegistry.js'], _modules['Core/Utilities.js']], function (DrawPointComposition, SeriesRegistry, U) {
         /* *
          *
-         *  Imports
+         *  Experimental Highcharts module which enables visualization of a Venn
+         *  diagram.
+         *
+         *  (c) 2016-2021 Highsoft AS
+         *  Authors: Jon Arild Nygard
+         *
+         *  Layout algorithm by Ben Frederickson:
+         *  https://www.benfrederickson.com/better-venn-diagrams/
+         *
+         *  License: www.highcharts.com/license
+         *
+         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
         var __extends = (this && this.__extends) || (function () {
@@ -830,15 +710,12 @@
                 return isNumber(this.value);
             };
             VennPoint.prototype.shouldDraw = function () {
-                var point = this;
                 // Only draw points with single sets.
-                return !!point.shapeArgs;
+                return !!this.shapeArgs;
             };
             return VennPoint;
         }(ScatterSeries.prototype.pointClass));
-        extend(VennPoint.prototype, {
-            draw: DrawPointMixin.drawPoint
-        });
+        DrawPointComposition.compose(VennPoint);
         /* *
          *
          *  Default Export
@@ -847,7 +724,7 @@
 
         return VennPoint;
     });
-    _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) {
+    _registerModule(_modules, 'Series/Venn/VennUtils.js', [_modules['Core/Geometry/CircleUtilities.js'], _modules['Core/Geometry/GeometryUtilities.js'], _modules['Core/Utilities.js']], function (CU, GU, U) {
         /* *
          *
          *  Experimental Highcharts module which enables visualization of a Venn
@@ -878,523 +755,657 @@
             isString = U.isString;
         /* *
          *
-         *  Namespace
+         *  Functions
          *
          * */
-        var VennUtils;
-        (function (VennUtils) {
-            /* *
-             *
-             *  Properties
-             *
-             * */
-            VennUtils.geometry = GU;
-            VennUtils.geometryCircles = CU;
-            VennUtils.nelderMead = NelderMeadMixin;
-            /* *
-             *
-             *  Functions
-             *
-             * */
-            /**
-             * Takes an array of relations and adds the properties `totalOverlap` and
-             * `overlapping` to each set. The property `totalOverlap` is the sum of
-             * value for each relation where this set is included. The property
-             * `overlapping` is a map of how much this set is overlapping another set.
-             * NOTE: This algorithm ignores relations consisting of more than 2 sets.
-             * @private
-             * @param {Array<Highcharts.VennRelationObject>} relations
-             * The list of relations that should be sorted.
-             * @return {Array<Highcharts.VennRelationObject>}
-             * Returns the modified input relations with added properties `totalOverlap`
-             * and `overlapping`.
-             */
-            function addOverlapToSets(relations) {
-                // 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) {
-                        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;
-                    });
-                    return map;
-                }, {});
-                relations
-                    // Filter out single sets
-                    .filter(isSet)
-                    // Extend the set with the calculated properties.
-                    .forEach(function (set) {
-                    var properties = mapOfIdToProps[set.sets[0]];
-                    extend(set, properties);
-                });
-                // Returns the modified relations.
-                return relations;
-            }
-            VennUtils.addOverlapToSets = addOverlapToSets;
-            /**
-             * Finds the root of a given function. The root is the input value needed
-             * for a function to return 0.
-             *
-             * See https://en.wikipedia.org/wiki/Bisection_method#Algorithm
-             *
-             * TODO: Add unit tests.
-             *
-             * @param {Function} f
-             * The function to find the root of.
-             * @param {number} a
-             * The lowest number in the search range.
-             * @param {number} b
-             * The highest number in the search range.
-             * @param {number} [tolerance=1e-10]
-             * The allowed difference between the returned value and root.
-             * @param {number} [maxIterations=100]
-             * The maximum iterations allowed.
-             * @return {number}
-             * Root number.
-             */
-            function bisect(f, a, b, tolerance, maxIterations) {
-                var fA = f(a),
-                    fB = f(b),
-                    nMax = maxIterations || 100,
-                    tol = tolerance || 1e-10,
-                    delta = b - a,
-                    n = 1,
-                    x,
-                    fX;
-                if (a >= b) {
-                    throw new Error('a must be smaller than b.');
-                }
-                else if (fA * fB > 0) {
-                    throw new Error('f(a) and f(b) must have opposite signs.');
-                }
-                if (fA === 0) {
-                    x = a;
-                }
-                else if (fB === 0) {
-                    x = b;
-                }
-                else {
-                    while (n++ <= nMax && fX !== 0 && delta > tol) {
-                        delta = (b - a) / 2;
-                        x = a + delta;
-                        fX = f(x);
-                        // Update low and high for next search interval.
-                        if (fA * fX > 0) {
-                            a = x;
-                        }
-                        else {
-                            b = x;
-                        }
+        /* eslint-disable valid-jsdoc */
+        /**
+         * Takes an array of relations and adds the properties `totalOverlap` and
+         * `overlapping` to each set. The property `totalOverlap` is the sum of
+         * value for each relation where this set is included. The property
+         * `overlapping` is a map of how much this set is overlapping another set.
+         * NOTE: This algorithm ignores relations consisting of more than 2 sets.
+         * @private
+         * @param {Array<Highcharts.VennRelationObject>} relations
+         * The list of relations that should be sorted.
+         * @return {Array<Highcharts.VennRelationObject>}
+         * Returns the modified input relations with added properties `totalOverlap`
+         * and `overlapping`.
+         */
+        function addOverlapToSets(relations) {
+            // 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) {
+                    relation.sets.forEach(function (set,
+                i,
+                arr) {
+                        if (!isObject(map[set])) {
+                            map[set] = {
+                                overlapping: {},
+                                totalOverlap: 0
+                            };
                     }
-                }
-                return x;
+                    map[set].totalOverlap += relation.value;
+                    map[set].overlapping[arr[1 - i]] = relation.value;
+                });
+                return map;
+            }, {});
+            relations
+                // Filter out single sets
+                .filter(isSet)
+                // Extend the set with the calculated properties.
+                .forEach(function (set) {
+                var properties = mapOfIdToProps[set.sets[0]];
+                extend(set, properties);
+            });
+            // Returns the modified relations.
+            return relations;
+        }
+        /**
+         * Finds the root of a given function. The root is the input value needed
+         * for a function to return 0.
+         *
+         * See https://en.wikipedia.org/wiki/Bisection_method#Algorithm
+         *
+         * TODO: Add unit tests.
+         *
+         * @param {Function} f
+         * The function to find the root of.
+         * @param {number} a
+         * The lowest number in the search range.
+         * @param {number} b
+         * The highest number in the search range.
+         * @param {number} [tolerance=1e-10]
+         * The allowed difference between the returned value and root.
+         * @param {number} [maxIterations=100]
+         * The maximum iterations allowed.
+         * @return {number}
+         * Root number.
+         */
+        function bisect(f, a, b, tolerance, maxIterations) {
+            var fA = f(a),
+                fB = f(b),
+                nMax = maxIterations || 100,
+                tol = tolerance || 1e-10,
+                delta = b - a,
+                n = 1,
+                x,
+                fX;
+            if (a >= b) {
+                throw new Error('a must be smaller than b.');
             }
-            /**
-             * Uses the bisection method to make a best guess of the ideal distance
-             * between two circles too get the desired overlap.
-             * Currently there is no known formula to calculate the distance from the
-             * area of overlap, which makes the bisection method preferred.
-             * @private
-             * @param {number} r1
-             * Radius of the first circle.
-             * @param {number} r2
-             * Radiues of the second circle.
-             * @param {number} overlap
-             * The wanted overlap between the two circles.
-             * @return {number}
-             * Returns the distance needed to get the wanted overlap between the two
-             * circles.
-             */
-            function getDistanceBetweenCirclesByOverlap(r1, r2, overlap) {
-                var maxDistance = r1 + r2,
-                    distance;
-                if (overlap <= 0) {
-                    // If overlap is below or equal to zero, then there is no overlap.
-                    distance = maxDistance;
-                }
-                else if (getAreaOfCircle(r1 < r2 ? r1 : r2) <= overlap) {
-                    // When area of overlap is larger than the area of the smallest
-                    // circle, then it is completely overlapping.
-                    distance = 0;
-                }
-                else {
-                    distance = bisect(function (x) {
-                        var actualOverlap = getOverlapBetweenCirclesByDistance(r1,
-                            r2,
-                            x);
-                        // Return the differance between wanted and actual overlap.
-                        return overlap - actualOverlap;
-                    }, 0, maxDistance);
-                }
-                return distance;
+            else if (fA * fB > 0) {
+                throw new Error('f(a) and f(b) must have opposite signs.');
             }
-            VennUtils.getDistanceBetweenCirclesByOverlap = getDistanceBetweenCirclesByOverlap;
-            /**
-             * Finds the available width for a label, by taking the label position and
-             * finding the largest distance, which is inside all internal circles, and
-             * outside all external circles.
-             *
-             * @private
-             * @param {Highcharts.PositionObject} pos
-             * The x and y coordinate of the label.
-             * @param {Array<Highcharts.CircleObject>} internal
-             * Internal circles.
-             * @param {Array<Highcharts.CircleObject>} external
-             * External circles.
-             * @return {number}
-             * Returns available width for the label.
-             */
-            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);
-                });
-                var findDistance = function (maxDistance,
-                    direction) {
-                        return bisect(function (x) {
-                            var testPos = {
-                                x: pos.x + (direction * x),
-                                y: pos.y
-                            },
-                    isValid = (isPointInsideAllCircles(testPos,
-                    internal) &&
-                                isPointOutsideAllCircles(testPos,
-                    filteredExternals));
-                        // If the position is valid, then we want to move towards the
-                        // max distance. If not, then we want to  away from the max
-                        // distance.
-                        return -(maxDistance - x) + (isValid ? 0 : Number.MAX_VALUE);
-                    }, 0, maxDistance);
-                };
-                // Find the smallest distance of left and right.
-                return Math.min(findDistance(radius, -1), findDistance(radius, 1)) * 2;
+            if (fA === 0) {
+                x = a;
             }
-            VennUtils.getLabelWidth = getLabelWidth;
-            /**
-             * Calculates a margin for a point based on the iternal and external
-             * circles. The margin describes if the point is well placed within the
-             * internal circles, and away from the external.
-             * @private
-             * @todo add unit tests.
-             * @param {Highcharts.PositionObject} point
-             * The point to evaluate.
-             * @param {Array<Highcharts.CircleObject>} internal
-             * The internal circles.
-             * @param {Array<Highcharts.CircleObject>} external
-             * The external circles.
-             * @return {number}
-             * Returns the margin.
-             */
-            function getMarginFromCircles(point, internal, external) {
-                var margin = internal.reduce(function (margin,
-                    circle) {
-                        var m = circle.r - getDistanceBetweenPoints(point,
-                    circle);
-                    return (m <= margin) ? m : margin;
-                }, Number.MAX_VALUE);
-                margin = external.reduce(function (margin, circle) {
-                    var m = getDistanceBetweenPoints(point,
-                        circle) - circle.r;
-                    return (m <= margin) ? m : margin;
-                }, margin);
-                return margin;
+            else if (fB === 0) {
+                x = b;
             }
-            VennUtils.getMarginFromCircles = getMarginFromCircles;
-            /**
-             * Calculates the area of overlap between a list of circles.
-             * @private
-             * @todo add support for calculating overlap between more than 2 circles.
-             * @param {Array<Highcharts.CircleObject>} circles
-             * List of circles with their given positions.
-             * @return {number}
-             * Returns the area of overlap between all the circles.
-             */
-            function getOverlapBetweenCircles(circles) {
-                var overlap = 0;
-                // When there is only two circles we can find the overlap by using their
-                // radiuses and the distance between them.
-                if (circles.length === 2) {
-                    var circle1 = circles[0];
-                    var circle2 = circles[1];
-                    overlap = getOverlapBetweenCirclesByDistance(circle1.r, circle2.r, getDistanceBetweenPoints(circle1, circle2));
+            else {
+                while (n++ <= nMax && fX !== 0 && delta > tol) {
+                    delta = (b - a) / 2;
+                    x = a + delta;
+                    fX = f(x);
+                    // Update low and high for next search interval.
+                    if (fA * fX > 0) {
+                        a = x;
+                    }
+                    else {
+                        b = x;
+                    }
                 }
-                return overlap;
             }
-            // eslint-disable-next-line require-jsdoc
-            function isSet(x) {
-                return isArray(x.sets) && x.sets.length === 1;
+            return x;
+        }
+        /**
+         * @private
+         */
+        function getCentroid(simplex) {
+            var arr = simplex.slice(0, -1),
+                length = arr.length,
+                result = [],
+                sum = function (data,
+                point) {
+                    data.sum += point[data.i];
+                return data;
+            };
+            for (var i = 0; i < length; i++) {
+                result[i] = arr.reduce(sum, { sum: 0, i: i }).sum / length;
+            }
+            return result;
+        }
+        /**
+         * Uses the bisection method to make a best guess of the ideal distance
+         * between two circles too get the desired overlap.
+         * Currently there is no known formula to calculate the distance from the
+         * area of overlap, which makes the bisection method preferred.
+         * @private
+         * @param {number} r1
+         * Radius of the first circle.
+         * @param {number} r2
+         * Radiues of the second circle.
+         * @param {number} overlap
+         * The wanted overlap between the two circles.
+         * @return {number}
+         * Returns the distance needed to get the wanted overlap between the two
+         * circles.
+         */
+        function getDistanceBetweenCirclesByOverlap(r1, r2, overlap) {
+            var maxDistance = r1 + r2,
+                distance;
+            if (overlap <= 0) {
+                // If overlap is below or equal to zero, then there is no overlap.
+                distance = maxDistance;
             }
-            VennUtils.isSet = isSet;
-            // eslint-disable-next-line require-jsdoc
-            function isValidRelation(x) {
-                var map = {};
-                return (isObject(x) &&
-                    (isNumber(x.value) && x.value > -1) &&
-                    (isArray(x.sets) && x.sets.length > 0) &&
-                    !x.sets.some(function (set) {
-                        var invalid = false;
-                        if (!map[set] && isString(set)) {
-                            map[set] = true;
-                        }
-                        else {
-                            invalid = true;
-                        }
-                        return invalid;
-                    }));
+            else if (getAreaOfCircle(r1 < r2 ? r1 : r2) <= overlap) {
+                // When area of overlap is larger than the area of the smallest
+                // circle, then it is completely overlapping.
+                distance = 0;
             }
-            // eslint-disable-next-line require-jsdoc
-            function isValidSet(x) {
-                return (isValidRelation(x) && isSet(x) && x.value > 0);
+            else {
+                distance = bisect(function (x) {
+                    var actualOverlap = getOverlapBetweenCirclesByDistance(r1,
+                        r2,
+                        x);
+                    // Return the differance between wanted and actual overlap.
+                    return overlap - actualOverlap;
+                }, 0, maxDistance);
             }
+            return distance;
+        }
+        /**
+         * Finds the available width for a label, by taking the label position and
+         * finding the largest distance, which is inside all internal circles, and
+         * outside all external circles.
+         *
+         * @private
+         * @param {Highcharts.PositionObject} pos
+         * The x and y coordinate of the label.
+         * @param {Array<Highcharts.CircleObject>} internal
+         * Internal circles.
+         * @param {Array<Highcharts.CircleObject>} external
+         * External circles.
+         * @return {number}
+         * Returns available width for the label.
+         */
+        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);
+            });
+            var findDistance = function (maxDistance,
+                direction) {
+                    return bisect(function (x) {
+                        var testPos = {
+                            x: pos.x + (direction * x),
+                            y: pos.y
+                        },
+                isValid = (isPointInsideAllCircles(testPos,
+                internal) &&
+                            isPointOutsideAllCircles(testPos,
+                filteredExternals));
+                    // If the position is valid, then we want to move towards the
+                    // max distance. If not, then we want to  away from the max
+                    // distance.
+                    return -(maxDistance - x) + (isValid ? 0 : Number.MAX_VALUE);
+                }, 0, maxDistance);
+            };
+            // Find the smallest distance of left and right.
+            return Math.min(findDistance(radius, -1), findDistance(radius, 1)) * 2;
+        }
+        /**
+         * Calculates a margin for a point based on the iternal and external
+         * circles. The margin describes if the point is well placed within the
+         * internal circles, and away from the external.
+         * @private
+         * @todo add unit tests.
+         * @param {Highcharts.PositionObject} point
+         * The point to evaluate.
+         * @param {Array<Highcharts.CircleObject>} internal
+         * The internal circles.
+         * @param {Array<Highcharts.CircleObject>} external
+         * The external circles.
+         * @return {number}
+         * Returns the margin.
+         */
+        function getMarginFromCircles(point, internal, external) {
+            var margin = internal.reduce(function (margin,
+                circle) {
+                    var m = circle.r - getDistanceBetweenPoints(point,
+                circle);
+                return (m <= margin) ? m : margin;
+            }, Number.MAX_VALUE);
+            margin = external.reduce(function (margin, circle) {
+                var m = getDistanceBetweenPoints(point,
+                    circle) - circle.r;
+                return (m <= margin) ? m : margin;
+            }, margin);
+            return margin;
+        }
+        /**
+         * Calculates the area of overlap between a list of circles.
+         * @private
+         * @todo add support for calculating overlap between more than 2 circles.
+         * @param {Array<Highcharts.CircleObject>} circles
+         * List of circles with their given positions.
+         * @return {number}
+         * Returns the area of overlap between all the circles.
+         */
+        function getOverlapBetweenCircles(circles) {
+            var overlap = 0;
+            // When there is only two circles we can find the overlap by using their
+            // radiuses and the distance between them.
+            if (circles.length === 2) {
+                var circle1 = circles[0];
+                var circle2 = circles[1];
+                overlap = getOverlapBetweenCirclesByDistance(circle1.r, circle2.r, getDistanceBetweenPoints(circle1, circle2));
+            }
+            return overlap;
+        }
+        // eslint-disable-next-line require-jsdoc
+        function isSet(x) {
+            return isArray(x.sets) && x.sets.length === 1;
+        }
+        // eslint-disable-next-line require-jsdoc
+        function isValidRelation(x) {
+            var map = {};
+            return (isObject(x) &&
+                (isNumber(x.value) && x.value > -1) &&
+                (isArray(x.sets) && x.sets.length > 0) &&
+                !x.sets.some(function (set) {
+                    var invalid = false;
+                    if (!map[set] && isString(set)) {
+                        map[set] = true;
+                    }
+                    else {
+                        invalid = true;
+                    }
+                    return invalid;
+                }));
+        }
+        // eslint-disable-next-line require-jsdoc
+        function isValidSet(x) {
+            return (isValidRelation(x) && isSet(x) && x.value > 0);
+        }
+        /**
+         * Uses a greedy approach to position all the sets. Works well with a small
+         * number of sets, and are in these cases a good choice aesthetically.
+         * @private
+         * @param {Array<object>} relations List of the overlap between two or more
+         * sets, or the size of a single set.
+         * @return {Array<object>} List of circles and their calculated positions.
+         */
+        function layoutGreedyVenn(relations) {
+            var positionedSets = [],
+                mapOfIdToCircles = {};
+            // Define a circle for each set.
+            relations
+                .filter(function (relation) {
+                return relation.sets.length === 1;
+            }).forEach(function (relation) {
+                mapOfIdToCircles[relation.sets[0]] = relation.circle = {
+                    x: Number.MAX_VALUE,
+                    y: Number.MAX_VALUE,
+                    r: Math.sqrt(relation.value / Math.PI)
+                };
+            });
             /**
-             * Uses a greedy approach to position all the sets. Works well with a small
-             * number of sets, and are in these cases a good choice aesthetically.
+             * Takes a set and updates the position, and add the set to the list of
+             * positioned sets.
              * @private
-             * @param {Array<object>} relations List of the overlap between two or more
-             * sets, or the size of a single set.
-             * @return {Array<object>} List of circles and their calculated positions.
+             * @param {object} set
+             * The set to add to its final position.
+             * @param {object} coordinates
+             * The coordinates to position the set at.
+             * @return {void}
              */
-            function layoutGreedyVenn(relations) {
-                var positionedSets = [],
-                    mapOfIdToCircles = {};
-                // Define a circle for each set.
-                relations
-                    .filter(function (relation) {
-                    return relation.sets.length === 1;
-                }).forEach(function (relation) {
-                    mapOfIdToCircles[relation.sets[0]] = relation.circle = {
-                        x: Number.MAX_VALUE,
-                        y: Number.MAX_VALUE,
-                        r: Math.sqrt(relation.value / Math.PI)
-                    };
-                });
-                /**
-                 * Takes a set and updates the position, and add the set to the list of
-                 * positioned sets.
-                 * @private
-                 * @param {object} set
-                 * The set to add to its final position.
-                 * @param {object} coordinates
-                 * The coordinates to position the set at.
-                 * @return {void}
-                 */
-                var positionSet = function positionSet(set,
-                    coordinates) {
-                        var circle = set.circle;
-                    circle.x = coordinates.x;
-                    circle.y = coordinates.y;
-                    positionedSets.push(set);
-                };
-                // Find overlap between sets. Ignore relations with more then 2 sets.
-                addOverlapToSets(relations);
-                // Sort sets by the sum of their size from large to small.
-                var sortedByOverlap = relations
-                        .filter(isSet)
-                        .sort(sortByTotalOverlap);
-                // Position the most overlapped set at 0,0.
-                positionSet(sortedByOverlap.shift(), { x: 0, y: 0 });
-                var relationsWithTwoSets = relations.filter(function (x) {
-                        return x.sets.length === 2;
-                });
-                // Iterate and position the remaining sets.
-                sortedByOverlap.forEach(function (set) {
-                    var circle = set.circle,
-                        radius = circle.r,
-                        overlapping = set.overlapping;
-                    var bestPosition = positionedSets.reduce(function (best,
-                        positionedSet,
-                        i) {
-                            var positionedCircle = positionedSet.circle,
-                        overlap = overlapping[positionedSet.sets[0]];
-                        // Calculate the distance between the sets to get the
-                        // correct overlap
-                        var distance = getDistanceBetweenCirclesByOverlap(radius,
-                            positionedCircle.r,
-                            overlap);
-                        // Create a list of possible coordinates calculated from
-                        // distance.
-                        var possibleCoordinates = [
-                                { x: positionedCircle.x + distance,
-                            y: positionedCircle.y },
-                                { x: positionedCircle.x - distance,
-                            y: positionedCircle.y },
-                                { x: positionedCircle.x,
-                            y: positionedCircle.y + distance },
-                                { x: positionedCircle.x,
-                            y: positionedCircle.y - distance }
-                            ];
-                        // If there are more circles overlapping, then add the
-                        // intersection points as possible positions.
-                        positionedSets.slice(i + 1).forEach(function (positionedSet2) {
-                            var positionedCircle2 = positionedSet2.circle,
-                                overlap2 = overlapping[positionedSet2.sets[0]],
-                                distance2 = getDistanceBetweenCirclesByOverlap(radius,
-                                positionedCircle2.r,
-                                overlap2);
-                            // Add intersections to list of coordinates.
-                            possibleCoordinates = possibleCoordinates.concat(getCircleCircleIntersection({
-                                x: positionedCircle.x,
-                                y: positionedCircle.y,
-                                r: distance
-                            }, {
-                                x: positionedCircle2.x,
-                                y: positionedCircle2.y,
-                                r: distance2
-                            }));
-                        });
-                        // Iterate all suggested coordinates and find the best one.
-                        possibleCoordinates.forEach(function (coordinates) {
-                            circle.x = coordinates.x;
-                            circle.y = coordinates.y;
-                            // Calculate loss for the suggested coordinates.
-                            var currentLoss = loss(mapOfIdToCircles,
-                                relationsWithTwoSets);
-                            // If the loss is better, then use these new coordinates
-                            if (currentLoss < best.loss) {
-                                best.loss = currentLoss;
-                                best.coordinates = coordinates;
-                            }
-                        });
-                        // Return resulting coordinates.
-                        return best;
-                    }, {
-                        loss: Number.MAX_VALUE,
-                        coordinates: void 0
+            var positionSet = function positionSet(set,
+                coordinates) {
+                    var circle = set.circle;
+                circle.x = coordinates.x;
+                circle.y = coordinates.y;
+                positionedSets.push(set);
+            };
+            // Find overlap between sets. Ignore relations with more then 2 sets.
+            addOverlapToSets(relations);
+            // Sort sets by the sum of their size from large to small.
+            var sortedByOverlap = relations
+                    .filter(isSet)
+                    .sort(sortByTotalOverlap);
+            // Position the most overlapped set at 0,0.
+            positionSet(sortedByOverlap.shift(), { x: 0, y: 0 });
+            var relationsWithTwoSets = relations.filter(function (x) {
+                    return x.sets.length === 2;
+            });
+            // Iterate and position the remaining sets.
+            sortedByOverlap.forEach(function (set) {
+                var circle = set.circle,
+                    radius = circle.r,
+                    overlapping = set.overlapping;
+                var bestPosition = positionedSets.reduce(function (best,
+                    positionedSet,
+                    i) {
+                        var positionedCircle = positionedSet.circle,
+                    overlap = overlapping[positionedSet.sets[0]];
+                    // Calculate the distance between the sets to get the
+                    // correct overlap
+                    var distance = getDistanceBetweenCirclesByOverlap(radius,
+                        positionedCircle.r,
+                        overlap);
+                    // Create a list of possible coordinates calculated from
+                    // distance.
+                    var possibleCoordinates = [
+                            { x: positionedCircle.x + distance,
+                        y: positionedCircle.y },
+                            { x: positionedCircle.x - distance,
+                        y: positionedCircle.y },
+                            { x: positionedCircle.x,
+                        y: positionedCircle.y + distance },
+                            { x: positionedCircle.x,
+                        y: positionedCircle.y - distance }
+                        ];
+                    // If there are more circles overlapping, then add the
+                    // intersection points as possible positions.
+                    positionedSets.slice(i + 1).forEach(function (positionedSet2) {
+                        var positionedCircle2 = positionedSet2.circle,
+                            overlap2 = overlapping[positionedSet2.sets[0]],
+                            distance2 = getDistanceBetweenCirclesByOverlap(radius,
+                            positionedCircle2.r,
+                            overlap2);
+                        // Add intersections to list of coordinates.
+                        possibleCoordinates = possibleCoordinates.concat(getCircleCircleIntersection({
+                            x: positionedCircle.x,
+                            y: positionedCircle.y,
+                            r: distance
+                        }, {
+                            x: positionedCircle2.x,
+                            y: positionedCircle2.y,
+                            r: distance2
+                        }));
                     });
-                    // Add the set to its final position.
-                    positionSet(set, bestPosition.coordinates);
+                    // Iterate all suggested coordinates and find the best one.
+                    possibleCoordinates.forEach(function (coordinates) {
+                        circle.x = coordinates.x;
+                        circle.y = coordinates.y;
+                        // Calculate loss for the suggested coordinates.
+                        var currentLoss = loss(mapOfIdToCircles,
+                            relationsWithTwoSets);
+                        // If the loss is better, then use these new coordinates
+                        if (currentLoss < best.loss) {
+                            best.loss = currentLoss;
+                            best.coordinates = coordinates;
+                        }
+                    });
+                    // Return resulting coordinates.
+                    return best;
+                }, {
+                    loss: Number.MAX_VALUE,
+                    coordinates: void 0
                 });
-                // Return the positions of each set.
-                return mapOfIdToCircles;
-            }
-            VennUtils.layoutGreedyVenn = layoutGreedyVenn;
+                // Add the set to its final position.
+                positionSet(set, bestPosition.coordinates);
+            });
+            // Return the positions of each set.
+            return mapOfIdToCircles;
+        }
+        /**
+         * Calculates the difference between the desired overlap and the actual
+         * overlap between two circles.
+         * @private
+         * @param {Dictionary<Highcharts.CircleObject>} mapOfIdToCircle
+         * Map from id to circle.
+         * @param {Array<Highcharts.VennRelationObject>} relations
+         * List of relations to calculate the loss of.
+         * @return {number}
+         * Returns the loss between positions of the circles for the given
+         * relations.
+         */
+        function loss(mapOfIdToCircle, relations) {
+            var precision = 10e10;
+            // Iterate all the relations and calculate their individual loss.
+            return relations.reduce(function (totalLoss, relation) {
+                var loss = 0;
+                if (relation.sets.length > 1) {
+                    var wantedOverlap = relation.value;
+                    // Calculate the actual overlap between the sets.
+                    var actualOverlap = getOverlapBetweenCircles(
+                        // Get the circles for the given sets.
+                        relation.sets.map(function (set) {
+                            return mapOfIdToCircle[set];
+                    }));
+                    var diff = wantedOverlap - actualOverlap;
+                    loss = Math.round((diff * diff) * precision) / precision;
+                }
+                // Add calculated loss to the sum.
+                return totalLoss + loss;
+            }, 0);
+        }
+        /**
+         * Finds an optimal position for a given point.
+         * @todo add unit tests.
+         * @todo add constraints to optimize the algorithm.
+         * @private
+         * @param {Highcharts.NelderMeadTestFunction} fn
+         *        The function to test a point.
+         * @param {Highcharts.NelderMeadPointArray} initial
+         *        The initial point to optimize.
+         * @return {Highcharts.NelderMeadPointArray}
+         *         Returns the opimized position of a point.
+         */
+        function nelderMead(fn, initial) {
+            var maxIterations = 100,
+                sortByFx = function (a,
+                b) {
+                    return a.fx - b.fx;
+            }, pRef = 1, // Reflection parameter
+            pExp = 2, // Expansion parameter
+            pCon = -0.5, // Contraction parameter
+            pOCon = pCon * pRef, // Outwards contraction parameter
+            pShrink = 0.5; // Shrink parameter
             /**
-             * Calculates the difference between the desired overlap and the actual
-             * overlap between two circles.
              * @private
-             * @param {Dictionary<Highcharts.CircleObject>} mapOfIdToCircle
-             * Map from id to circle.
-             * @param {Array<Highcharts.VennRelationObject>} relations
-             * List of relations to calculate the loss of.
-             * @return {number}
-             * Returns the loss between positions of the circles for the given
-             * relations.
              */
-            function loss(mapOfIdToCircle, relations) {
-                var precision = 10e10;
-                // Iterate all the relations and calculate their individual loss.
-                return relations.reduce(function (totalLoss, relation) {
-                    var loss = 0;
-                    if (relation.sets.length > 1) {
-                        var wantedOverlap = relation.value;
-                        // Calculate the actual overlap between the sets.
-                        var actualOverlap = getOverlapBetweenCircles(
-                            // Get the circles for the given sets.
-                            relation.sets.map(function (set) {
-                                return mapOfIdToCircle[set];
-                        }));
-                        var diff = wantedOverlap - actualOverlap;
-                        loss = Math.round((diff * diff) * precision) / precision;
-                    }
-                    // Add calculated loss to the sum.
-                    return totalLoss + loss;
-                }, 0);
-            }
-            VennUtils.loss = loss;
+            var weightedSum = function (weight1,
+                v1,
+                weight2,
+                v2) { return v1.map(function (x,
+                i) { return weight1 * x + weight2 * v2[i]; }); };
             /**
-             * Prepares the venn data so that it is usable for the layout function.
-             * Filter out sets, or intersections that includes sets, that are missing in
-             * the data or has (value < 1). Adds missing relations between sets in the
-             * data as value = 0.
              * @private
-             * @param {Array<object>} data The raw input data.
-             * @return {Array<object>} Returns an array of valid venn data.
              */
-            function processVennData(data) {
-                var d = isArray(data) ? data : [];
-                var validSets = d
-                        .reduce(function (arr,
-                    x) {
-                        // Check if x is a valid set, and that it is not an duplicate.
-                        if (isValidSet(x) && arr.indexOf(x.sets[0]) === -1) {
-                            arr.push(x.sets[0]);
-                    }
-                    return arr;
-                }, [])
-                    .sort();
-                var mapOfIdToRelation = d.reduce(function (mapOfIdToRelation,
-                    relation) {
-                        if (isValidRelation(relation) &&
-                            !relation.sets.some(function (set) {
-                                return validSets.indexOf(set) === -1;
-                        })) {
-                        mapOfIdToRelation[relation.sets.sort().join()] =
-                            relation;
+            var getSimplex = function (initial) {
+                    var n = initial.length,
+                simplex = new Array(n + 1);
+                // Initial point to the simplex.
+                simplex[0] = initial;
+                simplex[0].fx = fn(initial);
+                // Create a set of extra points based on the initial.
+                for (var i = 0; i < n; ++i) {
+                    var point = initial.slice();
+                    point[i] = point[i] ? point[i] * 1.05 : 0.001;
+                    point.fx = fn(point);
+                    simplex[i + 1] = point;
+                }
+                return simplex;
+            };
+            var updateSimplex = function (simplex,
+                point) {
+                    point.fx = fn(point);
+                simplex[simplex.length - 1] = point;
+                return simplex;
+            };
+            var shrinkSimplex = function (simplex) {
+                    var best = simplex[0];
+                return simplex.map(function (point) {
+                    var p = weightedSum(1 - pShrink,
+                        best,
+                        pShrink,
+                        point);
+                    p.fx = fn(p);
+                    return p;
+                });
+            };
+            var getPoint = function (centroid,
+                worst,
+                a,
+                b) {
+                    var point = weightedSum(a,
+                centroid,
+                b,
+                worst);
+                point.fx = fn(point);
+                return point;
+            };
+            // Create a simplex
+            var simplex = getSimplex(initial);
+            // Iterate from 0 to max iterations
+            for (var i = 0; i < maxIterations; i++) {
+                // Sort the simplex
+                simplex.sort(sortByFx);
+                // Create a centroid from the simplex
+                var worst = simplex[simplex.length - 1];
+                var centroid = getCentroid(simplex);
+                // Calculate the reflected point.
+                var reflected = getPoint(centroid,
+                    worst, 1 + pRef, -pRef);
+                if (reflected.fx < simplex[0].fx) {
+                    // If reflected point is the best, then possibly expand.
+                    var expanded = getPoint(centroid,
+                        worst, 1 + pExp, -pExp);
+                    simplex = updateSimplex(simplex, (expanded.fx < reflected.fx) ? expanded : reflected);
+                }
+                else if (reflected.fx >= simplex[simplex.length - 2].fx) {
+                    // If the reflected point is worse than the second worse, then
+                    // contract.
+                    var contracted = void 0;
+                    if (reflected.fx > worst.fx) {
+                        // If the reflected is worse than the worst point, do a
+                        // contraction
+                        contracted = getPoint(centroid, worst, 1 + pCon, -pCon);
+                        if (contracted.fx < worst.fx) {
+                            simplex = updateSimplex(simplex, contracted);
+                        }
+                        else {
+                            simplex = shrinkSimplex(simplex);
+                        }
                     }
-                    return mapOfIdToRelation;
-                }, {});
-                validSets.reduce(function (combinations, set, i, arr) {
-                    var remaining = arr.slice(i + 1);
-                    remaining.forEach(function (set2) {
-                        combinations.push(set + ',' + set2);
-                    });
-                    return combinations;
-                }, []).forEach(function (combination) {
-                    if (!mapOfIdToRelation[combination]) {
-                        var obj = {
-                                sets: combination.split(','),
-                                value: 0
-                            };
-                        mapOfIdToRelation[combination] = obj;
+                    else {
+                        // Otherwise do an outwards contraction
+                        contracted = getPoint(centroid, worst, 1 - pOCon, pOCon);
+                        if (contracted.fx < reflected.fx) {
+                            simplex = updateSimplex(simplex, contracted);
+                        }
+                        else {
+                            simplex = shrinkSimplex(simplex);
+                        }
                     }
-                });
-                // Transform map into array.
-                return Object
-                    .keys(mapOfIdToRelation)
-                    .map(function (id) {
-                    return mapOfIdToRelation[id];
-                });
-            }
-            VennUtils.processVennData = processVennData;
-            /**
-             * Takes two sets and finds the one with the largest total overlap.
-             * @private
-             * @param {object} a The first set to compare.
-             * @param {object} b The second set to compare.
-             * @return {number} Returns 0 if a and b are equal, <0 if a is greater, >0 if b
-             * is greater.
-             */
-            function sortByTotalOverlap(a, b) {
-                return b.totalOverlap - a.totalOverlap;
+                }
+                else {
+                    simplex = updateSimplex(simplex, reflected);
+                }
             }
-            VennUtils.sortByTotalOverlap = sortByTotalOverlap;
-        })(VennUtils || (VennUtils = {}));
+            return simplex[0];
+        }
+        /**
+         * Prepares the venn data so that it is usable for the layout function.
+         * Filter out sets, or intersections that includes sets, that are missing in
+         * the data or has (value < 1). Adds missing relations between sets in the
+         * data as value = 0.
+         * @private
+         * @param {Array<object>} data The raw input data.
+         * @return {Array<object>} Returns an array of valid venn data.
+         */
+        function processVennData(data) {
+            var d = isArray(data) ? data : [];
+            var validSets = d
+                    .reduce(function (arr,
+                x) {
+                    // Check if x is a valid set, and that it is not an duplicate.
+                    if (isValidSet(x) && arr.indexOf(x.sets[0]) === -1) {
+                        arr.push(x.sets[0]);
+                }
+                return arr;
+            }, [])
+                .sort();
+            var mapOfIdToRelation = d.reduce(function (mapOfIdToRelation,
+                relation) {
+                    if (isValidRelation(relation) &&
+                        !relation.sets.some(function (set) {
+                            return validSets.indexOf(set) === -1;
+                    })) {
+                    mapOfIdToRelation[relation.sets.sort().join()] =
+                        relation;
+                }
+                return mapOfIdToRelation;
+            }, {});
+            validSets.reduce(function (combinations, set, i, arr) {
+                var remaining = arr.slice(i + 1);
+                remaining.forEach(function (set2) {
+                    combinations.push(set + ',' + set2);
+                });
+                return combinations;
+            }, []).forEach(function (combination) {
+                if (!mapOfIdToRelation[combination]) {
+                    var obj = {
+                            sets: combination.split(','),
+                            value: 0
+                        };
+                    mapOfIdToRelation[combination] = obj;
+                }
+            });
+            // Transform map into array.
+            return Object
+                .keys(mapOfIdToRelation)
+                .map(function (id) {
+                return mapOfIdToRelation[id];
+            });
+        }
+        /**
+         * Takes two sets and finds the one with the largest total overlap.
+         * @private
+         * @param {object} a The first set to compare.
+         * @param {object} b The second set to compare.
+         * @return {number} Returns 0 if a and b are equal, <0 if a is greater, >0 if b
+         * is greater.
+         */
+        function sortByTotalOverlap(a, b) {
+            return b.totalOverlap - a.totalOverlap;
+        }
         /* *
          *
          *  Default Export
          *
          * */
+        var VennUtils = {
+                geometry: GU,
+                geometryCircles: CU,
+                addOverlapToSets: addOverlapToSets,
+                getCentroid: getCentroid,
+                getDistanceBetweenCirclesByOverlap: getDistanceBetweenCirclesByOverlap,
+                getLabelWidth: getLabelWidth,
+                getMarginFromCircles: getMarginFromCircles,
+                isSet: isSet,
+                layoutGreedyVenn: layoutGreedyVenn,
+                loss: loss,
+                nelderMead: nelderMead,
+                processVennData: processVennData,
+                sortByTotalOverlap: sortByTotalOverlap
+            };
 
         return VennUtils;
     });
-    _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) {
+    _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['Core/Series/SeriesRegistry.js'], _modules['Series/Venn/VennPoint.js'], _modules['Series/Venn/VennUtils.js'], _modules['Core/Utilities.js']], function (A, Color, CU, GU, SeriesRegistry, VennPoint, VennUtils, U) {
         /* *
          *
          *  Experimental Highcharts module which enables visualization of a Venn
@@ -1435,7 +1446,6 @@
             isPointInsideAllCircles = CU.isPointInsideAllCircles,
             isPointOutsideAllCircles = CU.isPointOutsideAllCircles;
         var getCenterOfPoints = GU.getCenterOfPoints;
-        var nelderMead = NelderMeadMixin.nelderMead;
         var ScatterSeries = SeriesRegistry.seriesTypes.scatter;
         var addEvent = U.addEvent,
             extend = U.extend,
@@ -1530,7 +1540,7 @@
                     margin: -Number.MAX_VALUE
                 }).point;
                 // Use nelder mead to optimize the initial label position.
-                var optimal = nelderMead(function (p) {
+                var optimal = VennUtils.nelderMead(function (p) {
                         return -(VennUtils.getMarginFromCircles({ x: p[0],
                     y: p[1] },
                     internal,
@@ -1923,7 +1933,7 @@
              * @optionparent plotOptions.venn
              */
             VennSeries.defaultOptions = merge(ScatterSeries.defaultOptions, {
-                borderColor: palette.neutralColor20,
+                borderColor: "#cccccc" /* neutralColor20 */,
                 borderDashStyle: 'solid',
                 borderWidth: 1,
                 brighten: 0,
@@ -1950,14 +1960,14 @@
                      */
                     hover: {
                         opacity: 1,
-                        borderColor: palette.neutralColor80
+                        borderColor: "#333333" /* neutralColor80 */
                     },
                     /**
                      * @excluding halo
                      */
                     select: {
-                        color: palette.neutralColor20,
-                        borderColor: palette.neutralColor100,
+                        color: "#cccccc" /* neutralColor20 */,
+                        borderColor: "#000000" /* neutralColor100 */,
                         animation: false
                     },
                     inactive: {