highcharts 9.2.2 → 9.3.3

package/modules/wordcloud.src.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v9.2.2 (2021-08-24)
+ * @license Highcharts JS v9.3.3 (2022-02-01)
  *
  * (c) 2016-2021 Highsoft AS
  * Authors: Jon Arild Nygard
@@ -27,417 +27,123 @@
             obj[path] = fn.apply(null, args);
         }
     }
-    _registerModule(_modules, 'Mixins/Polygon.js', [_modules['Core/Globals.js'], _modules['Core/Utilities.js']], function (H, U) {
+    _registerModule(_modules, 'Series/DrawPointComposition.js', [], function () {
         /* *
          *
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          *
          * */
-        /**
-         * @private
-         * @interface Highcharts.PolygonPointObject
-         */ /**
-        * @name Highcharts.PolygonPointObject#0
-        * @type {number}
-        */ /**
-        * @name Highcharts.PolygonPointObject#1
-        * @type {number}
-        */
-        /**
-         * @private
-         * @interface Highcharts.PolygonObject
-         * @extends Array<Highcharts.PolygonPointObject>
-         */ /**
-        * @name Highcharts.PolygonObject#axes
-        * @type {Array<PolygonPointObject>}
-        */
-        var find = U.find,
-            isArray = U.isArray,
-            isNumber = U.isNumber;
-        var deg2rad = H.deg2rad;
-        /* eslint-disable no-invalid-this, valid-jsdoc */
-        /**
-         * Alternative solution to correctFloat.
-         * E.g Highcharts.correctFloat(123, 2) returns 120, when it should be 123.
-         *
-         * @private
-         * @function correctFloat
-         * @param {number} number
-         * @param {number} [precision]
-         * @return {number}
-         */
-        var correctFloat = function (number,
-            precision) {
-                var p = isNumber(precision) ? precision : 14,
-            magnitude = Math.pow(10,
-            p);
-            return Math.round(number * magnitude) / magnitude;
-        };
-        /**
-         * Calculates the normals to a line between two points.
-         *
-         * @private
-         * @function getNormals
-         * @param {Highcharts.PolygonPointObject} p1
-         *        Start point for the line. Array of x and y value.
-         * @param {Highcharts.PolygonPointObject} p2
-         *        End point for the line. Array of x and y value.
-         * @return {Highcharts.PolygonObject}
-         *         Returns the two normals in an array.
-         */
-        var getNormals = function getNormal(p1,
-            p2) {
-                var dx = p2[0] - p1[0], // x2 - x1
-                dy = p2[1] - p1[1]; // y2 - y1
-                return [
-                    [-dy,
-            dx],
-                    [dy, -dx]
-                ];
-        };
-        /**
-         * Calculates the dot product of two coordinates. The result is a scalar value.
-         *
-         * @private
-         * @function dotProduct
-         * @param {Highcharts.PolygonPointObject} a
-         *        The x and y coordinates of the first point.
-         *
-         * @param {Highcharts.PolygonPointObject} b
-         *        The x and y coordinates of the second point.
-         *
-         * @return {number}
-         *         Returns the dot product of a and b.
-         */
-        var dotProduct = function dotProduct(a,
-            b) {
-                var ax = a[0],
-            ay = a[1],
-            bx = b[0],
-            by = b[1];
-            return ax * bx + ay * by;
-        };
-        /**
-         * Projects a polygon onto a coordinate.
-         *
-         * @private
-         * @function project
-         * @param {Highcharts.PolygonObject} polygon
-         *        Array of points in a polygon.
-         * @param {Highcharts.PolygonPointObject} target
-         *        The coordinate of pr
-         * @return {Highcharts.RangeObject}
-         */
-        var project = function project(polygon,
-            target) {
-                var products = polygon.map(function (point) {
-                    return dotProduct(point,
-            target);
-            });
-            return {
-                min: Math.min.apply(this, products),
-                max: Math.max.apply(this, products)
-            };
-        };
-        /**
-         * Rotates a point clockwise around the origin.
-         *
-         * @private
-         * @function rotate2DToOrigin
-         * @param {Highcharts.PolygonPointObject} point
-         *        The x and y coordinates for the point.
-         * @param {number} angle
-         *        The angle of rotation.
-         * @return {Highcharts.PolygonPointObject}
-         *         The x and y coordinate for the rotated point.
-         */
-        var rotate2DToOrigin = function (point,
-            angle) {
-                var x = point[0],
-            y = point[1],
-            rad = deg2rad * -angle,
-            cosAngle = Math.cos(rad),
-            sinAngle = Math.sin(rad);
-            return [
-                correctFloat(x * cosAngle - y * sinAngle),
-                correctFloat(x * sinAngle + y * cosAngle)
-            ];
-        };
-        /**
-         * Rotate a point clockwise around another point.
-         *
-         * @private
-         * @function rotate2DToPoint
-         * @param {Highcharts.PolygonPointObject} point
-         *        The x and y coordinates for the point.
-         * @param {Highcharts.PolygonPointObject} origin
-         *        The point to rotate around.
-         * @param {number} angle
-         *        The angle of rotation.
-         * @return {Highcharts.PolygonPointObject}
-         *         The x and y coordinate for the rotated point.
-         */
-        var rotate2DToPoint = function (point,
-            origin,
-            angle) {
-                var x = point[0] - origin[0],
-            y = point[1] - origin[1],
-            rotated = rotate2DToOrigin([x,
-            y],
-            angle);
-            return [
-                rotated[0] + origin[0],
-                rotated[1] + origin[1]
-            ];
-        };
-        /**
-         * @private
-         */
-        var isAxesEqual = function (axis1,
-            axis2) {
-                return (axis1[0] === axis2[0] &&
-                    axis1[1] === axis2[1]);
-        };
-        /**
-         * @private
-         */
-        var getAxesFromPolygon = function (polygon) {
-                var points,
-            axes = polygon.axes;
-            if (!isArray(axes)) {
-                axes = [];
-                points = points = polygon.concat([polygon[0]]);
-                points.reduce(function findAxis(p1, p2) {
-                    var normals = getNormals(p1,
-                        p2),
-                        axis = normals[0]; // Use the left normal as axis.
-                        // Check that the axis is unique.
-                        if (!find(axes,
-                        function (existing) {
-                            return isAxesEqual(existing,
-                        axis);
-                    })) {
-                        axes.push(axis);
-                    }
-                    // Return p2 to be used as p1 in next iteration.
-                    return p2;
-                });
-                polygon.axes = axes;
-            }
-            return axes;
-        };
-        /**
-         * @private
-         */
-        var getAxes = function (polygon1,
-            polygon2) {
-                // Get the axis from both polygons.
-                var axes1 = getAxesFromPolygon(polygon1),
-            axes2 = getAxesFromPolygon(polygon2);
-            return axes1.concat(axes2);
-        };
-        /**
-         * @private
-         */
-        var getPolygon = function (x,
-            y,
-            width,
-            height,
-            rotation) {
-                var origin = [x,
-            y],
-            left = x - (width / 2),
-            right = x + (width / 2),
-            top = y - (height / 2),
-            bottom = y + (height / 2),
-            polygon = [
-                    [left,
-            top],
-                    [right,
-            top],
-                    [right,
-            bottom],
-                    [left,
-            bottom]
-                ];
-            return polygon.map(function (point) {
-                return rotate2DToPoint(point, origin, -rotation);
-            });
-        };
-        /**
-         * @private
-         */
-        var getBoundingBoxFromPolygon = function (points) {
-                return points.reduce(function (obj,
-            point) {
-                    var x = point[0],
-            y = point[1];
-                obj.left = Math.min(x, obj.left);
-                obj.right = Math.max(x, obj.right);
-                obj.bottom = Math.max(y, obj.bottom);
-                obj.top = Math.min(y, obj.top);
-                return obj;
-            }, {
-                left: Number.MAX_VALUE,
-                right: -Number.MAX_VALUE,
-                bottom: -Number.MAX_VALUE,
-                top: Number.MAX_VALUE
-            });
-        };
-        /**
-         * @private
-         */
-        var isPolygonsOverlappingOnAxis = function (axis,
-            polygon1,
-            polygon2) {
-                var projection1 = project(polygon1,
-            axis),
-            projection2 = project(polygon2,
-            axis),
-            isOverlapping = !(projection2.min > projection1.max ||
-                    projection2.max < projection1.min);
-            return !isOverlapping;
-        };
-        /**
-         * Checks wether two convex polygons are colliding by using the Separating Axis
-         * Theorem.
-         *
-         * @private
-         * @function isPolygonsColliding
-         * @param {Highcharts.PolygonObject} polygon1
-         *        First polygon.
-         *
-         * @param {Highcharts.PolygonObject} polygon2
-         *        Second polygon.
-         *
-         * @return {boolean}
-         *         Returns true if they are colliding, otherwise false.
-         */
-        var isPolygonsColliding = function isPolygonsColliding(polygon1,
-            polygon2) {
-                var axes = getAxes(polygon1,
-            polygon2),
-            overlappingOnAllAxes = !find(axes,
-            function (axis) {
-                    return isPolygonsOverlappingOnAxis(axis,
-            polygon1,
-            polygon2);
-            });
-            return overlappingOnAllAxes;
-        };
-        /**
-         * @private
-         */
-        var movePolygon = function (deltaX,
-            deltaY,
-            polygon) {
-                return polygon.map(function (point) {
-                    return [
-                        point[0] + deltaX,
-                        point[1] + deltaY
-                    ];
-            });
-        };
-        var collision = {
-                getBoundingBoxFromPolygon: getBoundingBoxFromPolygon,
-                getPolygon: getPolygon,
-                isPolygonsColliding: isPolygonsColliding,
-                movePolygon: movePolygon,
-                rotate2DToOrigin: rotate2DToOrigin,
-                rotate2DToPoint: rotate2DToPoint
-            };
-
-        return collision;
-    });
-    _registerModule(_modules, 'Mixins/DrawPoint.js', [], function () {
         /* *
          *
-         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+         *  Composition
          *
          * */
-        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);
+        var DrawPointComposition;
+        (function (DrawPointComposition) {
+            /* *
+             *
+             *  Declarations
+             *
+             * */
+            /* *
+             *
+             *  Constants
+             *
+             * */
+            var composedClasses = [];
+            /* *
+             *
+             *  Functions
+             *
+             * */
+            /* eslint-disable valid-jsdoc */
+            /**
+             * @private
+             */
+            function compose(PointClass) {
+                if (composedClasses.indexOf(PointClass) === -1) {
+                    composedClasses.push(PointClass);
+                    var pointProto = PointClass.prototype;
+                    pointProto.draw = draw;
+                    if (!pointProto.shouldDraw) {
+                        pointProto.shouldDraw = shouldDraw;
+                    }
                 }
-                graphic
-                    .css(css)
-                    .attr(params.attribs)
-                    .animate(animatableAttribs, params.isNew ? false : animation, onComplete);
+                return PointClass;
             }
-            else if (graphic) {
-                var destroy_1 = function () {
-                        _this.graphic = graphic = (graphic && graphic.destroy());
-                    if (isFn(onComplete)) {
-                        onComplete();
+            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
+             */
+            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);
                     }
-                };
-                // animate only runs complete callback if something was animated.
-                if (Object.keys(animatableAttribs).length) {
-                    graphic.animate(animatableAttribs, void 0, function () {
-                        destroy_1();
-                    });
+                    graphic
+                        .css(css)
+                        .attr(params.attribs)
+                        .animate(animatableAttribs, params.isNew ? false : animation, onComplete);
                 }
-                else {
-                    destroy_1();
+                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 {
+                        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
-            };
+            /**
+             * @private
+             */
+            function shouldDraw() {
+                return !this.isNull;
+            }
+        })(DrawPointComposition || (DrawPointComposition = {}));
+        /* *
+         *
+         *  Default Export
+         *
+         * */
 
-        return drawPointModule;
+        return DrawPointComposition;
     });
-    _registerModule(_modules, 'Series/Wordcloud/WordcloudPoint.js', [_modules['Mixins/DrawPoint.js'], _modules['Core/Series/SeriesRegistry.js'], _modules['Core/Utilities.js']], function (DrawPointMixin, SeriesRegistry, U) {
+    _registerModule(_modules, 'Series/Wordcloud/WordcloudPoint.js', [_modules['Series/DrawPointComposition.js'], _modules['Core/Series/SeriesRegistry.js'], _modules['Core/Utilities.js']], function (DrawPointComposition, SeriesRegistry, U) {
         /* *
          *
          *  Experimental Highcharts module which enables visualization of a word cloud.
@@ -489,23 +195,24 @@
              * Functions
              *
              * */
-            WordcloudPoint.prototype.shouldDraw = function () {
-                var point = this;
-                return !point.isNull;
-            };
             WordcloudPoint.prototype.isValid = function () {
                 return true;
             };
             return WordcloudPoint;
         }(ColumnSeries.prototype.pointClass));
         extend(WordcloudPoint.prototype, {
-            draw: DrawPointMixin.drawPoint,
             weight: 1
         });
+        DrawPointComposition.compose(WordcloudPoint);
+        /* *
+         *
+         *  Default Export
+         *
+         * */
 
         return WordcloudPoint;
     });
-    _registerModule(_modules, 'Series/Wordcloud/WordcloudUtils.js', [_modules['Mixins/Polygon.js'], _modules['Core/Utilities.js']], function (PolygonMixin, U) {
+    _registerModule(_modules, 'Series/Wordcloud/WordcloudUtils.js', [_modules['Core/Globals.js'], _modules['Core/Utilities.js']], function (H, U) {
         /* *
          *
          *  Experimental Highcharts module which enables visualization of a word cloud.
@@ -517,574 +224,796 @@
          *
          *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
          * */
-        var isPolygonsColliding = PolygonMixin.isPolygonsColliding,
-            movePolygon = PolygonMixin.movePolygon;
+        var deg2rad = H.deg2rad;
         var extend = U.extend,
             find = U.find,
             isNumber = U.isNumber,
             isObject = U.isObject,
             merge = U.merge;
         /* *
-          *
-          * Namespace
-          *
-          * */
-        var WordcloudUtils;
-        (function (WordcloudUtils) {
-            /* *
-             *
-             * Functions
-             *
-             * */
-            /**
-             * Detects if there is a collision between two rectangles.
-             *
-             * @private
-             * @function isRectanglesIntersecting
-             *
-             * @param {Highcharts.PolygonBoxObject} r1
-             * First rectangle.
-             *
-             * @param {Highcharts.PolygonBoxObject} r2
-             * Second rectangle.
-             *
-             * @return {boolean}
-             * Returns true if the rectangles overlap.
-             */
-            function isRectanglesIntersecting(r1, r2) {
-                return !(r2.left > r1.right ||
-                    r2.right < r1.left ||
-                    r2.top > r1.bottom ||
-                    r2.bottom < r1.top);
-            }
-            WordcloudUtils.isRectanglesIntersecting = isRectanglesIntersecting;
-            /**
-             * Detects if a word collides with any previously placed words.
-             *
-             * @private
-             * @function intersectsAnyWord
-             *
-             * @param {Highcharts.Point} point
-             * Point which the word is connected to.
-             *
-             * @param {Array<Highcharts.Point>} points
-             * Previously placed points to check against.
-             *
-             * @return {boolean}
-             * Returns true if there is collision.
-             */
-            function intersectsAnyWord(point, points) {
-                var intersects = false,
-                    rect = point.rect,
-                    polygon = point.polygon,
-                    lastCollidedWith = point.lastCollidedWith,
-                    isIntersecting = function (p) {
-                        var result = isRectanglesIntersecting(rect,
-                    p.rect);
-                    if (result &&
-                        (point.rotation % 90 || p.rotation % 90)) {
-                        result = isPolygonsColliding(polygon, p.polygon);
-                    }
-                    return result;
-                };
-                // If the point has already intersected a different point, chances are
-                // they are still intersecting. So as an enhancement we check this
-                // first.
-                if (lastCollidedWith) {
-                    intersects = isIntersecting(lastCollidedWith);
-                    // If they no longer intersects, remove the cache from the point.
-                    if (!intersects) {
-                        delete point.lastCollidedWith;
-                    }
-                }
-                // If not already found, then check if we can find a point that is
-                // intersecting.
-                if (!intersects) {
-                    intersects = !!find(points, function (p) {
-                        var result = isIntersecting(p);
-                        if (result) {
-                            point.lastCollidedWith = p;
-                        }
-                        return result;
-                    });
-                }
-                return intersects;
-            }
-            WordcloudUtils.intersectsAnyWord = intersectsAnyWord;
-            /**
-             * Gives a set of cordinates for an Archimedian Spiral.
-             *
-             * @private
-             * @function archimedeanSpiral
-             *
-             * @param {number} attempt
-             * How far along the spiral we have traversed.
-             *
-             * @param {Highcharts.WordcloudSpiralParamsObject} [params]
-             * Additional parameters.
-             *
-             * @return {boolean|Highcharts.PositionObject}
-             * Resulting coordinates, x and y. False if the word should be dropped from
-             * the visualization.
-             */
-            function archimedeanSpiral(attempt, params) {
-                var field = params.field,
-                    result = false,
-                    maxDelta = (field.width * field.width) + (field.height * field.height),
-                    t = attempt * 0.8; // 0.2 * 4 = 0.8. Enlarging the spiral.
-                    // Emergency brake. TODO make spiralling logic more foolproof.
-                    if (attempt <= 10000) {
-                        result = {
-                            x: t * Math.cos(t),
-                            y: t * Math.sin(t)
-                        };
-                    if (!(Math.min(Math.abs(result.x), Math.abs(result.y)) < maxDelta)) {
-                        result = false;
+         *
+         * Functions
+         *
+         * */
+        /* eslint-disable valid-jsdoc */
+        /**
+         * Detects if there is a collision between two rectangles.
+         *
+         * @private
+         * @function isRectanglesIntersecting
+         *
+         * @param {Highcharts.PolygonBoxObject} r1
+         * First rectangle.
+         *
+         * @param {Highcharts.PolygonBoxObject} r2
+         * Second rectangle.
+         *
+         * @return {boolean}
+         * Returns true if the rectangles overlap.
+         */
+        function isRectanglesIntersecting(r1, r2) {
+            return !(r2.left > r1.right ||
+                r2.right < r1.left ||
+                r2.top > r1.bottom ||
+                r2.bottom < r1.top);
+        }
+        /**
+         * Calculates the normals to a line between two points.
+         *
+         * @private
+         * @function getNormals
+         * @param {Highcharts.PolygonPointObject} p1
+         *        Start point for the line. Array of x and y value.
+         * @param {Highcharts.PolygonPointObject} p2
+         *        End point for the line. Array of x and y value.
+         * @return {Highcharts.PolygonObject}
+         *         Returns the two normals in an array.
+         */
+        function getNormals(p1, p2) {
+            var dx = p2[0] - p1[0], // x2 - x1
+                dy = p2[1] - p1[1]; // y2 - y1
+                return [
+                    [-dy,
+                dx],
+                    [dy, -dx]
+                ];
+        }
+        /**
+         * @private
+         */
+        function getAxesFromPolygon(polygon) {
+            var points,
+                axes = polygon.axes || [];
+            if (!axes.length) {
+                axes = [];
+                points = points = polygon.concat([polygon[0]]);
+                points.reduce(function findAxis(p1, p2) {
+                    var normals = getNormals(p1,
+                        p2),
+                        axis = normals[0]; // Use the left normal as axis.
+                        // Check that the axis is unique.
+                        if (!find(axes,
+                        function (existing) {
+                            return existing[0] === axis[0] &&
+                                existing[1] === axis[1];
+                    })) {
+                        axes.push(axis);
                     }
+                    // Return p2 to be used as p1 in next iteration.
+                    return p2;
+                });
+                polygon.axes = axes;
+            }
+            return axes;
+        }
+        /**
+         * Projects a polygon onto a coordinate.
+         *
+         * @private
+         * @function project
+         * @param {Highcharts.PolygonObject} polygon
+         * Array of points in a polygon.
+         * @param {Highcharts.PolygonPointObject} target
+         * The coordinate of pr
+         */
+        function project(polygon, target) {
+            var products = polygon.map(function (point) {
+                    var ax = point[0],
+                ay = point[1],
+                bx = target[0],
+                by = target[1];
+                return ax * bx + ay * by;
+            });
+            return {
+                min: Math.min.apply(this, products),
+                max: Math.max.apply(this, products)
+            };
+        }
+        /**
+         * @private
+         */
+        function isPolygonsOverlappingOnAxis(axis, polygon1, polygon2) {
+            var projection1 = project(polygon1,
+                axis),
+                projection2 = project(polygon2,
+                axis),
+                isOverlapping = !(projection2.min > projection1.max ||
+                    projection2.max < projection1.min);
+            return !isOverlapping;
+        }
+        /**
+         * Checks wether two convex polygons are colliding by using the Separating
+         * Axis Theorem.
+         *
+         * @private
+         * @function isPolygonsColliding
+         * @param {Highcharts.PolygonObject} polygon1
+         *        First polygon.
+         *
+         * @param {Highcharts.PolygonObject} polygon2
+         *        Second polygon.
+         *
+         * @return {boolean}
+         *         Returns true if they are colliding, otherwise false.
+         */
+        function isPolygonsColliding(polygon1, polygon2) {
+            // Get the axis from both polygons.
+            var axes1 = getAxesFromPolygon(polygon1),
+                axes2 = getAxesFromPolygon(polygon2),
+                axes = axes1.concat(axes2),
+                overlappingOnAllAxes = !find(axes,
+                function (axis) { return isPolygonsOverlappingOnAxis(axis,
+                polygon1,
+                polygon2); });
+            return overlappingOnAllAxes;
+        }
+        /**
+         * Detects if a word collides with any previously placed words.
+         *
+         * @private
+         * @function intersectsAnyWord
+         *
+         * @param {Highcharts.Point} point
+         * Point which the word is connected to.
+         *
+         * @param {Array<Highcharts.Point>} points
+         * Previously placed points to check against.
+         *
+         * @return {boolean}
+         * Returns true if there is collision.
+         */
+        function intersectsAnyWord(point, points) {
+            var intersects = false,
+                rect = point.rect,
+                polygon = point.polygon,
+                lastCollidedWith = point.lastCollidedWith,
+                isIntersecting = function (p) {
+                    var result = isRectanglesIntersecting(rect,
+                p.rect);
+                if (result &&
+                    (point.rotation % 90 || p.rotation % 90)) {
+                    result = isPolygonsColliding(polygon, p.polygon);
                 }
                 return result;
+            };
+            // If the point has already intersected a different point, chances are
+            // they are still intersecting. So as an enhancement we check this
+            // first.
+            if (lastCollidedWith) {
+                intersects = isIntersecting(lastCollidedWith);
+                // If they no longer intersects, remove the cache from the point.
+                if (!intersects) {
+                    delete point.lastCollidedWith;
+                }
             }
-            WordcloudUtils.archimedeanSpiral = archimedeanSpiral;
-            /**
-             * Gives a set of cordinates for an rectangular spiral.
-             *
-             * @private
-             * @function squareSpiral
-             *
-             * @param {number} attempt
-             * How far along the spiral we have traversed.
-             *
-             * @param {Highcharts.WordcloudSpiralParamsObject} [params]
-             * Additional parameters.
-             *
-             * @return {boolean|Highcharts.PositionObject}
-             * Resulting coordinates, x and y. False if the word should be dropped from
-             * the visualization.
-             */
-            function squareSpiral(attempt, params) {
-                var a = attempt * 4,
-                    k = Math.ceil((Math.sqrt(a) - 1) / 2),
-                    t = 2 * k + 1,
-                    m = Math.pow(t, 2),
-                    isBoolean = function (x) {
-                        return typeof x === 'boolean';
-                }, result = false;
-                t -= 1;
+            // If not already found, then check if we can find a point that is
+            // intersecting.
+            if (!intersects) {
+                intersects = !!find(points, function (p) {
+                    var result = isIntersecting(p);
+                    if (result) {
+                        point.lastCollidedWith = p;
+                    }
+                    return result;
+                });
+            }
+            return intersects;
+        }
+        /**
+         * Gives a set of cordinates for an Archimedian Spiral.
+         *
+         * @private
+         * @function archimedeanSpiral
+         *
+         * @param {number} attempt
+         * How far along the spiral we have traversed.
+         *
+         * @param {Highcharts.WordcloudSpiralParamsObject} [params]
+         * Additional parameters.
+         *
+         * @return {boolean|Highcharts.PositionObject}
+         * Resulting coordinates, x and y. False if the word should be dropped from
+         * the visualization.
+         */
+        function archimedeanSpiral(attempt, params) {
+            var field = params.field,
+                result = false,
+                maxDelta = (field.width * field.width) + (field.height * field.height),
+                t = attempt * 0.8; // 0.2 * 4 = 0.8. Enlarging the spiral.
+                // Emergency brake. TODO make spiralling logic more foolproof.
                 if (attempt <= 10000) {
-                    if (isBoolean(result) && a >= m - t) {
+                    result = {
+                        x: t * Math.cos(t),
+                        y: t * Math.sin(t)
+                    };
+                if (!(Math.min(Math.abs(result.x), Math.abs(result.y)) < maxDelta)) {
+                    result = false;
+                }
+            }
+            return result;
+        }
+        /**
+         * Gives a set of cordinates for an rectangular spiral.
+         *
+         * @private
+         * @function squareSpiral
+         *
+         * @param {number} attempt
+         * How far along the spiral we have traversed.
+         *
+         * @param {Highcharts.WordcloudSpiralParamsObject} [params]
+         * Additional parameters.
+         *
+         * @return {boolean|Highcharts.PositionObject}
+         * Resulting coordinates, x and y. False if the word should be dropped from
+         * the visualization.
+         */
+        function squareSpiral(attempt, params) {
+            var a = attempt * 4,
+                k = Math.ceil((Math.sqrt(a) - 1) / 2),
+                t = 2 * k + 1,
+                m = Math.pow(t, 2),
+                isBoolean = function (x) {
+                    return typeof x === 'boolean';
+            }, result = false;
+            t -= 1;
+            if (attempt <= 10000) {
+                if (isBoolean(result) && a >= m - t) {
+                    result = {
+                        x: k - (m - a),
+                        y: -k
+                    };
+                }
+                m -= t;
+                if (isBoolean(result) && a >= m - t) {
+                    result = {
+                        x: -k,
+                        y: -k + (m - a)
+                    };
+                }
+                m -= t;
+                if (isBoolean(result)) {
+                    if (a >= m - t) {
                         result = {
-                            x: k - (m - a),
-                            y: -k
+                            x: -k + (m - a),
+                            y: k
                         };
                     }
-                    m -= t;
-                    if (isBoolean(result) && a >= m - t) {
+                    else {
                         result = {
-                            x: -k,
-                            y: -k + (m - a)
+                            x: k,
+                            y: k - (m - a - t)
                         };
                     }
-                    m -= t;
-                    if (isBoolean(result)) {
-                        if (a >= m - t) {
-                            result = {
-                                x: -k + (m - a),
-                                y: k
-                            };
-                        }
-                        else {
-                            result = {
-                                x: k,
-                                y: k - (m - a - t)
-                            };
-                        }
-                    }
-                    result.x *= 5;
-                    result.y *= 5;
                 }
-                return result;
+                result.x *= 5;
+                result.y *= 5;
             }
-            WordcloudUtils.squareSpiral = squareSpiral;
-            /**
-             * Gives a set of cordinates for an rectangular spiral.
-             *
-             * @private
-             * @function rectangularSpiral
-             *
-             * @param {number} attempt
-             * How far along the spiral we have traversed.
-             *
-             * @param {Highcharts.WordcloudSpiralParamsObject} [params]
-             * Additional parameters.
-             *
-             * @return {boolean|Higcharts.PositionObject}
-             * Resulting coordinates, x and y. False if the word should be dropped from
-             * the visualization.
-             */
-            function rectangularSpiral(attempt, params) {
-                var result = squareSpiral(attempt,
-                    params),
-                    field = params.field;
-                if (result) {
-                    result.x *= field.ratioX;
-                    result.y *= field.ratioY;
-                }
-                return result;
+            return result;
+        }
+        /**
+         * Gives a set of cordinates for an rectangular spiral.
+         *
+         * @private
+         * @function rectangularSpiral
+         *
+         * @param {number} attempt
+         * How far along the spiral we have traversed.
+         *
+         * @param {Highcharts.WordcloudSpiralParamsObject} [params]
+         * Additional parameters.
+         *
+         * @return {boolean|Higcharts.PositionObject}
+         * Resulting coordinates, x and y. False if the word should be dropped from
+         * the visualization.
+         */
+        function rectangularSpiral(attempt, params) {
+            var result = squareSpiral(attempt,
+                params),
+                field = params.field;
+            if (result) {
+                result.x *= field.ratioX;
+                result.y *= field.ratioY;
             }
-            WordcloudUtils.rectangularSpiral = rectangularSpiral;
+            return result;
+        }
+        /**
+         * @private
+         * @function getRandomPosition
+         *
+         * @param {number} size
+         * Random factor.
+         *
+         * @return {number}
+         * Random position.
+         */
+        function getRandomPosition(size) {
+            return Math.round((size * (Math.random() + 0.5)) / 2);
+        }
+        /**
+         * Calculates the proper scale to fit the cloud inside the plotting area.
+         *
+         * @private
+         * @function getScale
+         *
+         * @param {number} targetWidth
+         * Width of target area.
+         *
+         * @param {number} targetHeight
+         * Height of target area.
+         *
+         * @param {Object} field
+         * The playing field.
+         *
+         * @param {Highcharts.Series} series
+         * Series object.
+         *
+         * @return {number}
+         * Returns the value to scale the playing field up to the size of the target
+         * area.
+         */
+        function getScale(targetWidth, targetHeight, field) {
+            var height = Math.max(Math.abs(field.top),
+                Math.abs(field.bottom)) * 2,
+                width = Math.max(Math.abs(field.left),
+                Math.abs(field.right)) * 2,
+                scaleX = width > 0 ? 1 / width * targetWidth : 1,
+                scaleY = height > 0 ? 1 / height * targetHeight : 1;
+            return Math.min(scaleX, scaleY);
+        }
+        /**
+         * Calculates what is called the playing field. The field is the area which
+         * all the words are allowed to be positioned within. The area is
+         * proportioned to match the target aspect ratio.
+         *
+         * @private
+         * @function getPlayingField
+         *
+         * @param {number} targetWidth
+         * Width of the target area.
+         *
+         * @param {number} targetHeight
+         * Height of the target area.
+         *
+         * @param {Array<Highcharts.Point>} data
+         * Array of points.
+         *
+         * @param {Object} data.dimensions
+         * The height and width of the word.
+         *
+         * @return {Object}
+         * The width and height of the playing field.
+         */
+        function getPlayingField(targetWidth, targetHeight, data) {
+            var info = data.reduce(function (obj,
+                point) {
+                    var dimensions = point.dimensions,
+                x = Math.max(dimensions.width,
+                dimensions.height);
+                // Find largest height.
+                obj.maxHeight = Math.max(obj.maxHeight, dimensions.height);
+                // Find largest width.
+                obj.maxWidth = Math.max(obj.maxWidth, dimensions.width);
+                // Sum up the total maximum area of all the words.
+                obj.area += x * x;
+                return obj;
+            }, {
+                maxHeight: 0,
+                maxWidth: 0,
+                area: 0
+            }), 
             /**
-             * @private
-             * @function getRandomPosition
-             *
-             * @param {number} size
-             * Random factor.
-             *
-             * @return {number}
-             * Random position.
+             * Use largest width, largest height, or root of total area to give
+             * size to the playing field.
              */
-            function getRandomPosition(size) {
-                return Math.round((size * (Math.random() + 0.5)) / 2);
+            x = Math.max(info.maxHeight, // Have enough space for the tallest word
+            info.maxWidth, // Have enough space for the broadest word
+            // Adjust 15% to account for close packing of words
+            Math.sqrt(info.area) * 0.85), ratioX = targetWidth > targetHeight ? targetWidth / targetHeight : 1, ratioY = targetHeight > targetWidth ? targetHeight / targetWidth : 1;
+            return {
+                width: x * ratioX,
+                height: x * ratioY,
+                ratioX: ratioX,
+                ratioY: ratioY
+            };
+        }
+        /**
+         * Calculates a number of degrees to rotate, based upon a number of
+         * orientations within a range from-to.
+         *
+         * @private
+         * @function getRotation
+         *
+         * @param {number} [orientations]
+         * Number of orientations.
+         *
+         * @param {number} [index]
+         * Index of point, used to decide orientation.
+         *
+         * @param {number} [from]
+         * The smallest degree of rotation.
+         *
+         * @param {number} [to]
+         * The largest degree of rotation.
+         *
+         * @return {boolean|number}
+         * Returns the resulting rotation for the word. Returns false if invalid
+         * input parameters.
+         */
+        function getRotation(orientations, index, from, to) {
+            var result = false, // Default to false
+                range,
+                intervals,
+                orientation;
+            // Check if we have valid input parameters.
+            if (isNumber(orientations) &&
+                isNumber(index) &&
+                isNumber(from) &&
+                isNumber(to) &&
+                orientations > 0 &&
+                index > -1 &&
+                to > from) {
+                range = to - from;
+                intervals = range / (orientations - 1 || 1);
+                orientation = index % orientations;
+                result = from + (orientation * intervals);
             }
-            WordcloudUtils.getRandomPosition = getRandomPosition;
-            /**
-             * Calculates the proper scale to fit the cloud inside the plotting area.
-             *
-             * @private
-             * @function getScale
-             *
-             * @param {number} targetWidth
-             * Width of target area.
-             *
-             * @param {number} targetHeight
-             * Height of target area.
-             *
-             * @param {object} field
-             * The playing field.
-             *
-             * @param {Highcharts.Series} series
-             * Series object.
-             *
-             * @return {number}
-             * Returns the value to scale the playing field up to the size of the target
-             * area.
-             */
-            function getScale(targetWidth, targetHeight, field) {
-                var height = Math.max(Math.abs(field.top),
-                    Math.abs(field.bottom)) * 2,
-                    width = Math.max(Math.abs(field.left),
-                    Math.abs(field.right)) * 2,
-                    scaleX = width > 0 ? 1 / width * targetWidth : 1,
-                    scaleY = height > 0 ? 1 / height * targetHeight : 1;
-                return Math.min(scaleX, scaleY);
+            return result;
+        }
+        /**
+         * Calculates the spiral positions and store them in scope for quick access.
+         *
+         * @private
+         * @function getSpiral
+         *
+         * @param {Function} fn
+         * The spiral function.
+         *
+         * @param {Object} params
+         * Additional parameters for the spiral.
+         *
+         * @return {Function}
+         * Function with access to spiral positions.
+         */
+        function getSpiral(fn, params) {
+            var length = 10000,
+                i,
+                arr = [];
+            for (i = 1; i < length; i++) {
+                // @todo unnecessary amount of precaclulation
+                arr.push(fn(i, params));
             }
-            WordcloudUtils.getScale = getScale;
-            /**
-             * Calculates what is called the playing field. The field is the area which
-             * all the words are allowed to be positioned within. The area is
-             * proportioned to match the target aspect ratio.
-             *
-             * @private
-             * @function getPlayingField
-             *
-             * @param {number} targetWidth
-             * Width of the target area.
-             *
-             * @param {number} targetHeight
-             * Height of the target area.
-             *
-             * @param {Array<Highcharts.Point>} data
-             * Array of points.
-             *
-             * @param {object} data.dimensions
-             * The height and width of the word.
-             *
-             * @return {object}
-             * The width and height of the playing field.
-             */
-            function getPlayingField(targetWidth, targetHeight, data) {
-                var info = data.reduce(function (obj,
-                    point) {
-                        var dimensions = point.dimensions,
-                    x = Math.max(dimensions.width,
-                    dimensions.height);
-                    // Find largest height.
-                    obj.maxHeight = Math.max(obj.maxHeight, dimensions.height);
-                    // Find largest width.
-                    obj.maxWidth = Math.max(obj.maxWidth, dimensions.width);
-                    // Sum up the total maximum area of all the words.
-                    obj.area += x * x;
-                    return obj;
-                }, {
-                    maxHeight: 0,
-                    maxWidth: 0,
-                    area: 0
-                }), 
-                /**
-                 * Use largest width, largest height, or root of total area to give
-                 * size to the playing field.
-                 */
-                x = Math.max(info.maxHeight, // Have enough space for the tallest word
-                info.maxWidth, // Have enough space for the broadest word
-                // Adjust 15% to account for close packing of words
-                Math.sqrt(info.area) * 0.85), ratioX = targetWidth > targetHeight ? targetWidth / targetHeight : 1, ratioY = targetHeight > targetWidth ? targetHeight / targetWidth : 1;
-                return {
-                    width: x * ratioX,
-                    height: x * ratioY,
-                    ratioX: ratioX,
-                    ratioY: ratioY
+            return function (attempt) {
+                return attempt <= length ? arr[attempt - 1] : false;
+            };
+        }
+        /**
+         * Detects if a word is placed outside the playing field.
+         *
+         * @private
+         * @function outsidePlayingField
+         *
+         * @param {Highcharts.PolygonBoxObject} rect
+         * The word box.
+         *
+         * @param {Highcharts.WordcloudFieldObject} field
+         * The width and height of the playing field.
+         *
+         * @return {boolean}
+         * Returns true if the word is placed outside the field.
+         */
+        function outsidePlayingField(rect, field) {
+            var playingField = {
+                    left: -(field.width / 2),
+                    right: field.width / 2,
+                    top: -(field.height / 2),
+                    bottom: field.height / 2
                 };
-            }
-            WordcloudUtils.getPlayingField = getPlayingField;
-            /**
-             * Calculates a number of degrees to rotate, based upon a number of
-             * orientations within a range from-to.
-             *
-             * @private
-             * @function getRotation
-             *
-             * @param {number} [orientations]
-             * Number of orientations.
-             *
-             * @param {number} [index]
-             * Index of point, used to decide orientation.
-             *
-             * @param {number} [from]
-             * The smallest degree of rotation.
-             *
-             * @param {number} [to]
-             * The largest degree of rotation.
-             *
-             * @return {boolean|number}
-             * Returns the resulting rotation for the word. Returns false if invalid
-             * input parameters.
-             */
-            function getRotation(orientations, index, from, to) {
-                var result = false, // Default to false
-                    range,
-                    intervals,
-                    orientation;
-                // Check if we have valid input parameters.
-                if (isNumber(orientations) &&
-                    isNumber(index) &&
-                    isNumber(from) &&
-                    isNumber(to) &&
-                    orientations > 0 &&
-                    index > -1 &&
-                    to > from) {
-                    range = to - from;
-                    intervals = range / (orientations - 1 || 1);
-                    orientation = index % orientations;
-                    result = from + (orientation * intervals);
+            return !(playingField.left < rect.left &&
+                playingField.right > rect.right &&
+                playingField.top < rect.top &&
+                playingField.bottom > rect.bottom);
+        }
+        /**
+         * @private
+         */
+        function movePolygon(deltaX, deltaY, polygon) {
+            return polygon.map(function (point) {
+                return [
+                    point[0] + deltaX,
+                    point[1] + deltaY
+                ];
+            });
+        }
+        /**
+         * Check if a point intersects with previously placed words, or if it goes
+         * outside the field boundaries. If a collision, then try to adjusts the
+         * position.
+         *
+         * @private
+         * @function intersectionTesting
+         *
+         * @param {Highcharts.Point} point
+         * Point to test for intersections.
+         *
+         * @param {Highcharts.WordcloudTestOptionsObject} options
+         * Options object.
+         *
+         * @return {boolean|Highcharts.PositionObject}
+         * Returns an object with how much to correct the positions. Returns false
+         * if the word should not be placed at all.
+         */
+        function intersectionTesting(point, options) {
+            var placed = options.placed,
+                field = options.field,
+                rectangle = options.rectangle,
+                polygon = options.polygon,
+                spiral = options.spiral,
+                attempt = 1,
+                delta = {
+                    x: 0,
+                    y: 0
+                }, 
+                // Make a copy to update values during intersection testing.
+                rect = point.rect = extend({},
+                rectangle);
+            point.polygon = polygon;
+            point.rotation = options.rotation;
+            /* while w intersects any previously placed words:
+                do {
+                move w a little bit along a spiral path
+                } while any part of w is outside the playing field and
+                        the spiral radius is still smallish */
+            while (delta !== false &&
+                (intersectsAnyWord(point, placed) ||
+                    outsidePlayingField(rect, field))) {
+                delta = spiral(attempt);
+                if (isObject(delta)) {
+                    // Update the DOMRect with new positions.
+                    rect.left = rectangle.left + delta.x;
+                    rect.right = rectangle.right + delta.x;
+                    rect.top = rectangle.top + delta.y;
+                    rect.bottom = rectangle.bottom + delta.y;
+                    point.polygon = movePolygon(delta.x, delta.y, polygon);
                 }
-                return result;
+                attempt++;
             }
-            WordcloudUtils.getRotation = getRotation;
-            /**
-             * Calculates the spiral positions and store them in scope for quick access.
-             *
-             * @private
-             * @function getSpiral
-             *
-             * @param {Function} fn
-             * The spiral function.
-             *
-             * @param {object} params
-             * Additional parameters for the spiral.
-             *
-             * @return {Function}
-             * Function with access to spiral positions.
-             */
-            function getSpiral(fn, params) {
-                var length = 10000,
-                    i,
-                    arr = [];
-                for (i = 1; i < length; i++) {
-                    // @todo unnecessary amount of precaclulation
-                    arr.push(fn(i, params));
-                }
-                return function (attempt) {
-                    return attempt <= length ? arr[attempt - 1] : false;
-                };
+            return delta;
+        }
+        /**
+         * Extends the playing field to have enough space to fit a given word.
+         *
+         * @private
+         * @function extendPlayingField
+         *
+         * @param {Highcharts.WordcloudFieldObject} field
+         * The width, height and ratios of a playing field.
+         *
+         * @param {Highcharts.PolygonBoxObject} rectangle
+         * The bounding box of the word to add space for.
+         *
+         * @return {Highcharts.WordcloudFieldObject}
+         * Returns the extended playing field with updated height and width.
+         */
+        function extendPlayingField(field, rectangle) {
+            var height,
+                width,
+                ratioX,
+                ratioY,
+                x,
+                extendWidth,
+                extendHeight,
+                result;
+            if (isObject(field) && isObject(rectangle)) {
+                height = (rectangle.bottom - rectangle.top);
+                width = (rectangle.right - rectangle.left);
+                ratioX = field.ratioX;
+                ratioY = field.ratioY;
+                // Use the same variable to extend both the height and width.
+                x = ((width * ratioX) > (height * ratioY)) ? width : height;
+                // Multiply variable with ratios to preserve aspect ratio.
+                extendWidth = x * ratioX;
+                extendHeight = x * ratioY;
+                // Calculate the size of the new field after adding
+                // space for the word.
+                result = merge(field, {
+                    // Add space on the left and right.
+                    width: field.width + (extendWidth * 2),
+                    // Add space on the top and bottom.
+                    height: field.height + (extendHeight * 2)
+                });
             }
-            WordcloudUtils.getSpiral = getSpiral;
-            /**
-             * Detects if a word is placed outside the playing field.
-             *
-             * @private
-             * @function outsidePlayingField
-             *
-             * @param {Highcharts.PolygonBoxObject} rect
-             * The word box.
-             *
-             * @param {Highcharts.WordcloudFieldObject} field
-             * The width and height of the playing field.
-             *
-             * @return {boolean}
-             * Returns true if the word is placed outside the field.
-             */
-            function outsidePlayingField(rect, field) {
-                var playingField = {
-                        left: -(field.width / 2),
-                        right: field.width / 2,
-                        top: -(field.height / 2),
-                        bottom: field.height / 2
-                    };
-                return !(playingField.left < rect.left &&
-                    playingField.right > rect.right &&
-                    playingField.top < rect.top &&
-                    playingField.bottom > rect.bottom);
+            else {
+                result = field;
             }
-            WordcloudUtils.outsidePlayingField = outsidePlayingField;
-            /**
-             * Check if a point intersects with previously placed words, or if it goes
-             * outside the field boundaries. If a collision, then try to adjusts the
-             * position.
-             *
-             * @private
-             * @function intersectionTesting
-             *
-             * @param {Highcharts.Point} point
-             * Point to test for intersections.
-             *
-             * @param {Highcharts.WordcloudTestOptionsObject} options
-             * Options object.
-             *
-             * @return {boolean|Highcharts.PositionObject}
-             * Returns an object with how much to correct the positions. Returns false
-             * if the word should not be placed at all.
-             */
-            function intersectionTesting(point, options) {
-                var placed = options.placed,
-                    field = options.field,
-                    rectangle = options.rectangle,
-                    polygon = options.polygon,
-                    spiral = options.spiral,
-                    attempt = 1,
-                    delta = {
-                        x: 0,
-                        y: 0
-                    }, 
-                    // Make a copy to update values during intersection testing.
-                    rect = point.rect = extend({},
-                    rectangle);
-                point.polygon = polygon;
-                point.rotation = options.rotation;
-                /* while w intersects any previously placed words:
-                    do {
-                    move w a little bit along a spiral path
-                    } while any part of w is outside the playing field and
-                            the spiral radius is still smallish */
-                while (delta !== false &&
-                    (intersectsAnyWord(point, placed) ||
-                        outsidePlayingField(rect, field))) {
-                    delta = spiral(attempt);
-                    if (isObject(delta)) {
-                        // Update the DOMRect with new positions.
-                        rect.left = rectangle.left + delta.x;
-                        rect.right = rectangle.right + delta.x;
-                        rect.top = rectangle.top + delta.y;
-                        rect.bottom = rectangle.bottom + delta.y;
-                        point.polygon = movePolygon(delta.x, delta.y, polygon);
-                    }
-                    attempt++;
-                }
-                return delta;
+            // Return the new extended field.
+            return result;
+        }
+        /**
+         * If a rectangle is outside a give field, then the boundaries of the field
+         * is adjusted accordingly. Modifies the field object which is passed as the
+         * first parameter.
+         *
+         * @private
+         * @function updateFieldBoundaries
+         *
+         * @param {Highcharts.WordcloudFieldObject} field
+         * The bounding box of a playing field.
+         *
+         * @param {Highcharts.PolygonBoxObject} rectangle
+         * The bounding box for a placed point.
+         *
+         * @return {Highcharts.WordcloudFieldObject}
+         * Returns a modified field object.
+         */
+        function updateFieldBoundaries(field, rectangle) {
+            // @todo improve type checking.
+            if (!isNumber(field.left) || field.left > rectangle.left) {
+                field.left = rectangle.left;
             }
-            WordcloudUtils.intersectionTesting = intersectionTesting;
-            /**
-             * Extends the playing field to have enough space to fit a given word.
-             *
-             * @private
-             * @function extendPlayingField
-             *
-             * @param {Highcharts.WordcloudFieldObject} field
-             * The width, height and ratios of a playing field.
-             *
-             * @param {Highcharts.PolygonBoxObject} rectangle
-             * The bounding box of the word to add space for.
-             *
-             * @return {Highcharts.WordcloudFieldObject}
-             * Returns the extended playing field with updated height and width.
-             */
-            function extendPlayingField(field, rectangle) {
-                var height,
-                    width,
-                    ratioX,
-                    ratioY,
-                    x,
-                    extendWidth,
-                    extendHeight,
-                    result;
-                if (isObject(field) && isObject(rectangle)) {
-                    height = (rectangle.bottom - rectangle.top);
-                    width = (rectangle.right - rectangle.left);
-                    ratioX = field.ratioX;
-                    ratioY = field.ratioY;
-                    // Use the same variable to extend both the height and width.
-                    x = ((width * ratioX) > (height * ratioY)) ? width : height;
-                    // Multiply variable with ratios to preserve aspect ratio.
-                    extendWidth = x * ratioX;
-                    extendHeight = x * ratioY;
-                    // Calculate the size of the new field after adding
-                    // space for the word.
-                    result = merge(field, {
-                        // Add space on the left and right.
-                        width: field.width + (extendWidth * 2),
-                        // Add space on the top and bottom.
-                        height: field.height + (extendHeight * 2)
-                    });
-                }
-                else {
-                    result = field;
-                }
-                // Return the new extended field.
-                return result;
+            if (!isNumber(field.right) || field.right < rectangle.right) {
+                field.right = rectangle.right;
             }
-            WordcloudUtils.extendPlayingField = extendPlayingField;
-            /**
-             * If a rectangle is outside a give field, then the boundaries of the field
-             * is adjusted accordingly. Modifies the field object which is passed as the
-             * first parameter.
-             *
-             * @private
-             * @function updateFieldBoundaries
-             *
-             * @param {Highcharts.WordcloudFieldObject} field
-             * The bounding box of a playing field.
-             *
-             * @param {Highcharts.PolygonBoxObject} rectangle
-             * The bounding box for a placed point.
-             *
-             * @return {Highcharts.WordcloudFieldObject}
-             * Returns a modified field object.
-             */
-            function updateFieldBoundaries(field, rectangle) {
-                // @todo improve type checking.
-                if (!isNumber(field.left) || field.left > rectangle.left) {
-                    field.left = rectangle.left;
-                }
-                if (!isNumber(field.right) || field.right < rectangle.right) {
-                    field.right = rectangle.right;
-                }
-                if (!isNumber(field.top) || field.top > rectangle.top) {
-                    field.top = rectangle.top;
-                }
-                if (!isNumber(field.bottom) || field.bottom < rectangle.bottom) {
-                    field.bottom = rectangle.bottom;
-                }
-                return field;
+            if (!isNumber(field.top) || field.top > rectangle.top) {
+                field.top = rectangle.top;
+            }
+            if (!isNumber(field.bottom) || field.bottom < rectangle.bottom) {
+                field.bottom = rectangle.bottom;
             }
-            WordcloudUtils.updateFieldBoundaries = updateFieldBoundaries;
-        })(WordcloudUtils || (WordcloudUtils = {}));
+            return field;
+        }
+        /**
+         * Alternative solution to correctFloat.
+         * E.g Highcharts.correctFloat(123, 2) returns 120, when it should be 123.
+         *
+         * @private
+         * @function correctFloat
+         */
+        function correctFloat(number, precision) {
+            var p = isNumber(precision) ? precision : 14,
+                magnitude = Math.pow(10,
+                p);
+            return Math.round(number * magnitude) / magnitude;
+        }
+        /**
+         * @private
+         */
+        function getBoundingBoxFromPolygon(points) {
+            return points.reduce(function (obj, point) {
+                var x = point[0],
+                    y = point[1];
+                obj.left = Math.min(x, obj.left);
+                obj.right = Math.max(x, obj.right);
+                obj.bottom = Math.max(y, obj.bottom);
+                obj.top = Math.min(y, obj.top);
+                return obj;
+            }, {
+                left: Number.MAX_VALUE,
+                right: -Number.MAX_VALUE,
+                bottom: -Number.MAX_VALUE,
+                top: Number.MAX_VALUE
+            });
+        }
+        /**
+         * @private
+         */
+        function getPolygon(x, y, width, height, rotation) {
+            var origin = [x,
+                y],
+                left = x - (width / 2),
+                right = x + (width / 2),
+                top = y - (height / 2),
+                bottom = y + (height / 2),
+                polygon = [
+                    [left,
+                top],
+                    [right,
+                top],
+                    [right,
+                bottom],
+                    [left,
+                bottom]
+                ];
+            return polygon.map(function (point) {
+                return rotate2DToPoint(point, origin, -rotation);
+            });
+        }
+        /**
+         * Rotates a point clockwise around the origin.
+         *
+         * @private
+         * @function rotate2DToOrigin
+         * @param {Highcharts.PolygonPointObject} point
+         *        The x and y coordinates for the point.
+         * @param {number} angle
+         *        The angle of rotation.
+         * @return {Highcharts.PolygonPointObject}
+         *         The x and y coordinate for the rotated point.
+         */
+        function rotate2DToOrigin(point, angle) {
+            var x = point[0],
+                y = point[1],
+                rad = deg2rad * -angle,
+                cosAngle = Math.cos(rad),
+                sinAngle = Math.sin(rad);
+            return [
+                correctFloat(x * cosAngle - y * sinAngle),
+                correctFloat(x * sinAngle + y * cosAngle)
+            ];
+        }
+        /**
+         * Rotate a point clockwise around another point.
+         *
+         * @private
+         * @function rotate2DToPoint
+         * @param {Highcharts.PolygonPointObject} point
+         *        The x and y coordinates for the point.
+         * @param {Highcharts.PolygonPointObject} origin
+         *        The point to rotate around.
+         * @param {number} angle
+         *        The angle of rotation.
+         * @return {Highcharts.PolygonPointObject}
+         *         The x and y coordinate for the rotated point.
+         */
+        function rotate2DToPoint(point, origin, angle) {
+            var x = point[0] - origin[0],
+                y = point[1] - origin[1],
+                rotated = rotate2DToOrigin([x,
+                y],
+                angle);
+            return [
+                rotated[0] + origin[0],
+                rotated[1] + origin[1]
+            ];
+        }
         /* *
          *
          * Default export
          *
          * */
+        var WordcloudUtils = {
+                archimedeanSpiral: archimedeanSpiral,
+                extendPlayingField: extendPlayingField,
+                getBoundingBoxFromPolygon: getBoundingBoxFromPolygon,
+                getPlayingField: getPlayingField,
+                getPolygon: getPolygon,
+                getRandomPosition: getRandomPosition,
+                getRotation: getRotation,
+                getScale: getScale,
+                getSpiral: getSpiral,
+                intersectionTesting: intersectionTesting,
+                isPolygonsColliding: isPolygonsColliding,
+                isRectanglesIntersecting: isRectanglesIntersecting,
+                rectangularSpiral: rectangularSpiral,
+                rotate2DToOrigin: rotate2DToOrigin,
+                rotate2DToPoint: rotate2DToPoint,
+                squareSpiral: squareSpiral,
+                updateFieldBoundaries: updateFieldBoundaries
+            };
 
         return WordcloudUtils;
     });
-    _registerModule(_modules, 'Series/Wordcloud/WordcloudSeries.js', [_modules['Core/Globals.js'], _modules['Mixins/Polygon.js'], _modules['Core/Series/Series.js'], _modules['Core/Series/SeriesRegistry.js'], _modules['Core/Utilities.js'], _modules['Series/Wordcloud/WordcloudPoint.js'], _modules['Series/Wordcloud/WordcloudUtils.js']], function (H, PolygonMixin, Series, SeriesRegistry, U, WordcloudPoint, WordcloudUtils) {
+    _registerModule(_modules, 'Series/Wordcloud/WordcloudSeries.js', [_modules['Core/Globals.js'], _modules['Core/Series/Series.js'], _modules['Core/Series/SeriesRegistry.js'], _modules['Core/Utilities.js'], _modules['Series/Wordcloud/WordcloudPoint.js'], _modules['Series/Wordcloud/WordcloudUtils.js']], function (H, Series, SeriesRegistry, U, WordcloudPoint, WordcloudUtils) {
         /* *
          *
          *  Experimental Highcharts module which enables visualization of a word cloud.
@@ -1113,18 +1042,33 @@
             };
         })();
         var noop = H.noop;
-        var getBoundingBoxFromPolygon = PolygonMixin.getBoundingBoxFromPolygon,
-            getPolygon = PolygonMixin.getPolygon,
-            isPolygonsColliding = PolygonMixin.isPolygonsColliding,
-            rotate2DToOrigin = PolygonMixin.rotate2DToOrigin,
-            rotate2DToPoint = PolygonMixin.rotate2DToPoint;
         var ColumnSeries = SeriesRegistry.seriesTypes.column;
         var extend = U.extend,
-            find = U.find,
             isArray = U.isArray,
             isNumber = U.isNumber,
             isObject = U.isObject,
             merge = U.merge;
+        var archimedeanSpiral = WordcloudUtils.archimedeanSpiral,
+            extendPlayingField = WordcloudUtils.extendPlayingField,
+            getBoundingBoxFromPolygon = WordcloudUtils.getBoundingBoxFromPolygon,
+            getPlayingField = WordcloudUtils.getPlayingField,
+            getPolygon = WordcloudUtils.getPolygon,
+            getRandomPosition = WordcloudUtils.getRandomPosition,
+            getRotation = WordcloudUtils.getRotation,
+            getScale = WordcloudUtils.getScale,
+            getSpiral = WordcloudUtils.getSpiral,
+            intersectionTesting = WordcloudUtils.intersectionTesting,
+            isPolygonsColliding = WordcloudUtils.isPolygonsColliding,
+            rectangularSpiral = WordcloudUtils.rectangularSpiral,
+            rotate2DToOrigin = WordcloudUtils.rotate2DToOrigin,
+            rotate2DToPoint = WordcloudUtils.rotate2DToPoint,
+            squareSpiral = WordcloudUtils.squareSpiral,
+            updateFieldBoundaries = WordcloudUtils.updateFieldBoundaries;
+        /* *
+         *
+         *  Class
+         *
+         * */
         /**
          * @private
          * @class
@@ -1262,8 +1206,8 @@
                     };
                 });
                 // Calculate the playing field.
-                field = WordcloudUtils.getPlayingField(xAxis.len, yAxis.len, data);
-                spiral = WordcloudUtils.getSpiral(series.spirals[options.spiral], {
+                field = getPlayingField(xAxis.len, yAxis.len, data);
+                spiral = getSpiral(series.spirals[options.spiral], {
                     field: field
                 });
                 // Draw all the points.
@@ -1299,7 +1243,7 @@
                         point.dimensions.height,
                         placement.rotation),
                         rectangle = getBoundingBoxFromPolygon(polygon),
-                        delta = WordcloudUtils.intersectionTesting(point, {
+                        delta = intersectionTesting(point, {
                             rectangle: rectangle,
                             polygon: polygon,
                             field: field,
@@ -1311,9 +1255,9 @@
                     // If there is no space for the word, extend the playing field.
                     if (!delta && allowExtendPlayingField) {
                         // Extend the playing field to fit the word.
-                        field = WordcloudUtils.extendPlayingField(field, rectangle);
+                        field = extendPlayingField(field, rectangle);
                         // Run intersection testing one more time to place the word.
-                        delta = WordcloudUtils.intersectionTesting(point, {
+                        delta = intersectionTesting(point, {
                             rectangle: rectangle,
                             polygon: polygon,
                             field: field,
@@ -1331,7 +1275,7 @@
                         rectangle.right += delta.x;
                         rectangle.top += delta.y;
                         rectangle.bottom += delta.y;
-                        field = WordcloudUtils.updateFieldBoundaries(field, rectangle);
+                        field = updateFieldBoundaries(field, rectangle);
                         placed.push(point);
                         point.isNull = false;
                         point.isInside = true; // #15447
@@ -1369,7 +1313,7 @@
                 // Destroy the element after use.
                 testElement = testElement.destroy();
                 // Scale the series group to fit within the plotArea.
-                scale = WordcloudUtils.getScale(xAxis.len, yAxis.len, field);
+                scale = getScale(xAxis.len, yAxis.len, field);
                 series.group.attr({
                     scaleX: scale,
                     scaleY: scale
@@ -1455,7 +1399,7 @@
                  * cloud. Read more about it in our
                  * [documentation](https://www.highcharts.com/docs/chart-and-series-types/word-cloud-series#custom-placement-strategies)
                  *
-                 * @validvalue: ["center", "random"]
+                 * @validvalue ["center", "random"]
                  */
                 placementStrategy: 'center',
                 /**
@@ -1488,7 +1432,7 @@
                  * algorithms for use in word cloud. Read more about it in our
                  * [documentation](https://www.highcharts.com/docs/chart-and-series-types/word-cloud-series#custom-spiralling-algorithm)
                  *
-                 * @validvalue: ["archimedean", "rectangular", "square"]
+                 * @validvalue ["archimedean", "rectangular", "square"]
                  */
                 spiral: 'rectangular',
                 /**
@@ -1513,7 +1457,7 @@
             return WordcloudSeries;
         }(ColumnSeries));
         extend(WordcloudSeries.prototype, {
-            animate: Series.prototype.animate,
+            animate: noop,
             animateDrilldown: noop,
             animateDrillupFrom: noop,
             pointClass: WordcloudPoint,
@@ -1526,9 +1470,9 @@
                     var field = options.field,
                         r = options.rotation;
                     return {
-                        x: WordcloudUtils.getRandomPosition(field.width) - (field.width / 2),
-                        y: WordcloudUtils.getRandomPosition(field.height) - (field.height / 2),
-                        rotation: WordcloudUtils.getRotation(r.orientations, point.index, r.from, r.to)
+                        x: getRandomPosition(field.width) - (field.width / 2),
+                        y: getRandomPosition(field.height) - (field.height / 2),
+                        rotation: getRotation(r.orientations, point.index, r.from, r.to)
                     };
                 },
                 center: function (point, options) {
@@ -1536,7 +1480,7 @@
                     return {
                         x: 0,
                         y: 0,
-                        rotation: WordcloudUtils.getRotation(r.orientations, point.index, r.from, r.to)
+                        rotation: getRotation(r.orientations, point.index, r.from, r.to)
                     };
                 }
             },
@@ -1545,13 +1489,13 @@
             // collision with either another word or the borders. To implement a custom
             // spiral, look at the function archimedeanSpiral for example.
             spirals: {
-                'archimedean': WordcloudUtils.archimedeanSpiral,
-                'rectangular': WordcloudUtils.rectangularSpiral,
-                'square': WordcloudUtils.squareSpiral
+                'archimedean': archimedeanSpiral,
+                'rectangular': rectangularSpiral,
+                'square': squareSpiral
             },
             utils: {
-                extendPlayingField: WordcloudUtils.extendPlayingField,
-                getRotation: WordcloudUtils.getRotation,
+                extendPlayingField: extendPlayingField,
+                getRotation: getRotation,
                 isPolygonsColliding: isPolygonsColliding,
                 rotate2DToOrigin: rotate2DToOrigin,
                 rotate2DToPoint: rotate2DToPoint