highcharts 9.1.1 → 9.2.2

package/es-modules/Core/Renderer/HTML/AST.js

@@ -43,11 +43,21 @@ var hasValidDOMParser = (function () {
  * Either an HTML string or an ASTNode list to populate the tree.
  */
 var AST = /** @class */ (function () {
+    /* *
+     *
+     *  Constructor
+     *
+     * */
     // Construct an AST from HTML markup, or wrap an array of existing AST nodes
     function AST(source) {
         this.nodes = typeof source === 'string' ?
             this.parseMarkup(source) : source;
     }
+    /* *
+     *
+     *  Static Functions
+     *
+     * */
     /**
      * Filter an object of SVG or HTML attributes against the allow list.
      *
@@ -84,11 +94,13 @@ var AST = /** @class */ (function () {
      * `innerHTML` in all cases where the content is not fully trusted.
      *
      * @static
-     *
      * @function Highcharts.AST#setElementHTML
      *
-     * @param {SVGDOMElement|HTMLDOMElement} el The node to set content of
-     * @param {string} html The markup string
+     * @param {SVGDOMElement|HTMLDOMElement} el
+     * Node to set content of.
+     *
+     * @param {string} html
+     * Markup string
      */
     AST.setElementHTML = function (el, html) {
         el.innerHTML = ''; // Clear previous
@@ -97,6 +109,11 @@ var AST = /** @class */ (function () {
             ast.addToDOM(el);
         }
     };
+    /* *
+     *
+     *  Functions
+     *
+     * */
     /**
      * Add the tree defined as a hierarchical JS structure to the DOM
      *
@@ -181,6 +198,7 @@ var AST = /** @class */ (function () {
      */
     AST.prototype.parseMarkup = function (markup) {
         var nodes = [];
+        markup = markup.trim();
         var doc;
         var body;
         if (hasValidDOMParser) {
@@ -198,12 +216,7 @@ var AST = /** @class */ (function () {
                 tagName: tagName
             };
             if (tagName === '#text') {
-                var textContent = node.textContent || '';
-                // Whitespace text node, don't append it to the AST
-                if (/^[\s]*$/.test(textContent)) {
-                    return;
-                }
-                astNode.textContent = textContent;
+                astNode.textContent = node.textContent || '';
             }
             var parsedAttributes = node.attributes;
             // Add attributes
@@ -232,80 +245,11 @@ var AST = /** @class */ (function () {
         }
         return nodes;
     };
-    /**
-     * The list of allowed SVG or HTML tags, used for sanitizing potentially
-     * harmful content from the chart configuration before adding to the DOM.
+    /* *
      *
-     * @example
-     * // Allow a custom, trusted tag
-     * Highcharts.AST.allowedTags.push('blink'); // ;)
+     *  Static Properties
      *
-     * @name Highcharts.AST.allowedTags
-     * @static
-     */
-    AST.allowedTags = [
-        'a',
-        'b',
-        'br',
-        'button',
-        'caption',
-        'circle',
-        'clipPath',
-        'code',
-        'dd',
-        'defs',
-        'div',
-        'dl',
-        'dt',
-        'em',
-        'feComponentTransfer',
-        'feFuncA',
-        'feFuncB',
-        'feFuncG',
-        'feFuncR',
-        'feGaussianBlur',
-        'feOffset',
-        'feMerge',
-        'feMergeNode',
-        'filter',
-        'h1',
-        'h2',
-        'h3',
-        'h4',
-        'h5',
-        'h6',
-        'hr',
-        'i',
-        'img',
-        'li',
-        'linearGradient',
-        'marker',
-        'ol',
-        'p',
-        'path',
-        'pattern',
-        'pre',
-        'rect',
-        'small',
-        'span',
-        'stop',
-        'strong',
-        'style',
-        'sub',
-        'sup',
-        'svg',
-        'table',
-        'text',
-        'thead',
-        'tbody',
-        'tspan',
-        'td',
-        'th',
-        'tr',
-        'u',
-        'ul',
-        '#text'
-    ];
+     * */
     /**
      * The list of allowed SVG or HTML attributes, used for sanitizing
      * potentially harmful content from the chart configuration before adding to
@@ -409,6 +353,80 @@ var AST = /** @class */ (function () {
         './',
         '#'
     ];
+    /**
+     * The list of allowed SVG or HTML tags, used for sanitizing potentially
+     * harmful content from the chart configuration before adding to the DOM.
+     *
+     * @example
+     * // Allow a custom, trusted tag
+     * Highcharts.AST.allowedTags.push('blink'); // ;)
+     *
+     * @name Highcharts.AST.allowedTags
+     * @static
+     */
+    AST.allowedTags = [
+        'a',
+        'b',
+        'br',
+        'button',
+        'caption',
+        'circle',
+        'clipPath',
+        'code',
+        'dd',
+        'defs',
+        'div',
+        'dl',
+        'dt',
+        'em',
+        'feComponentTransfer',
+        'feFuncA',
+        'feFuncB',
+        'feFuncG',
+        'feFuncR',
+        'feGaussianBlur',
+        'feOffset',
+        'feMerge',
+        'feMergeNode',
+        'filter',
+        'h1',
+        'h2',
+        'h3',
+        'h4',
+        'h5',
+        'h6',
+        'hr',
+        'i',
+        'img',
+        'li',
+        'linearGradient',
+        'marker',
+        'ol',
+        'p',
+        'path',
+        'pattern',
+        'pre',
+        'rect',
+        'small',
+        'span',
+        'stop',
+        'strong',
+        'style',
+        'sub',
+        'sup',
+        'svg',
+        'table',
+        'text',
+        'thead',
+        'tbody',
+        'tspan',
+        'td',
+        'th',
+        'tr',
+        'u',
+        'ul',
+        '#text'
+    ];
     return AST;
 }());
 /* *
@@ -439,4 +457,4 @@ export default AST;
 * @name Highcharts.ASTNode#textContent
 * @type {string|undefined}
 */
-''; // detach doclets above
+(''); // keeps doclets above in file

package/es-modules/Core/Renderer/HTML/HTMLElement.js

@@ -28,7 +28,7 @@ import U from '../../Utilities.js';
 var css = U.css, defined = U.defined, extend = U.extend, pick = U.pick, pInt = U.pInt;
 /* *
  *
- *  Composition
+ *  Class
  *
  * */
 /* eslint-disable valid-jsdoc */
@@ -47,12 +47,16 @@ var HTMLElement = /** @class */ (function (_super) {
      * @private
      */
     HTMLElement.compose = function (SVGElementClass) {
-        var svgElementProto = SVGElementClass.prototype, htmlElementProto = HTMLElement.prototype;
-        svgElementProto.getSpanCorrection = htmlElementProto.getSpanCorrection;
-        svgElementProto.htmlCss = htmlElementProto.htmlCss;
-        svgElementProto.htmlGetBBox = htmlElementProto.htmlGetBBox;
-        svgElementProto.htmlUpdateTransform = htmlElementProto.htmlUpdateTransform;
-        svgElementProto.setSpanRotation = htmlElementProto.setSpanRotation;
+        if (HTMLElement.composedClasses.indexOf(SVGElementClass) === -1) {
+            HTMLElement.composedClasses.push(SVGElementClass);
+            var htmlElementProto = HTMLElement.prototype, svgElementProto = SVGElementClass.prototype;
+            svgElementProto.getSpanCorrection = htmlElementProto.getSpanCorrection;
+            svgElementProto.htmlCss = htmlElementProto.htmlCss;
+            svgElementProto.htmlGetBBox = htmlElementProto.htmlGetBBox;
+            svgElementProto.htmlUpdateTransform = htmlElementProto.htmlUpdateTransform;
+            svgElementProto.setSpanRotation = htmlElementProto.setSpanRotation;
+        }
+        return SVGElementClass;
     };
     /* *
      *
@@ -234,6 +238,12 @@ var HTMLElement = /** @class */ (function (_super) {
             css(this.element, rotationStyle);
         }
     };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    HTMLElement.composedClasses = [];
     return HTMLElement;
 }(SVGElement));
 /* *

package/es-modules/Core/Renderer/HTML/HTMLRenderer.js

@@ -28,7 +28,7 @@ import U from '../../Utilities.js';
 var attr = U.attr, createElement = U.createElement, extend = U.extend, pick = U.pick;
 /* *
  *
- *  Composition
+ *  Class
  *
  * */
 /* eslint-disable valid-jsdoc */
@@ -40,14 +40,23 @@ var HTMLRenderer = /** @class */ (function (_super) {
     }
     /* *
      *
-     *  Functions
+     *  Static Functions
      *
      * */
     /** @private */
     HTMLRenderer.compose = function (SVGRendererClass) {
-        var svgRendererProto = SVGRendererClass.prototype, htmlRendererProto = HTMLRenderer.prototype;
-        svgRendererProto.html = htmlRendererProto.html;
+        if (HTMLRenderer.composedClasses.indexOf(SVGRendererClass) === -1) {
+            HTMLRenderer.composedClasses.push(SVGRendererClass);
+            var htmlRendererProto = HTMLRenderer.prototype, svgRendererProto = SVGRendererClass.prototype;
+            svgRendererProto.html = htmlRendererProto.html;
+        }
+        return SVGRendererClass;
     };
+    /* *
+     *
+     *  Functions
+     *
+     * */
     /**
      * Create HTML text node. This is used by the VML renderer as well as the
      * SVG renderer through the useHTML option.
@@ -145,7 +154,8 @@ var HTMLRenderer = /** @class */ (function (_super) {
         // This is specific for HTML within SVG
         if (isSVG) {
             wrapper.add = function (svgGroupWrapper) {
-                var htmlGroup, container = renderer.box.parentNode, parentGroup, parents = [];
+                var container = renderer.box.parentNode, parents = [];
+                var htmlGroup, parentGroup;
                 this.parentGroup = svgGroupWrapper;
                 // Create a mock group to hold the HTML elements
                 if (svgGroupWrapper) {
@@ -162,7 +172,7 @@ var HTMLRenderer = /** @class */ (function (_super) {
                         // Ensure dynamically updating position when any parent
                         // is translated
                         parents.reverse().forEach(function (parentGroup) {
-                            var htmlGroupStyle, cls = attr(parentGroup.element, 'class');
+                            var cls = attr(parentGroup.element, 'class');
                             /**
                              * Common translate setter for X and Y on the HTML
                              * group. Reverted the fix for #6957 du to
@@ -195,11 +205,12 @@ var HTMLRenderer = /** @class */ (function (_super) {
                                         display: parentGroup.display,
                                         opacity: parentGroup.opacity,
                                         cursor: parentGroupStyles.cursor,
-                                        pointerEvents: parentGroupStyles.pointerEvents // #5595
+                                        pointerEvents: parentGroupStyles.pointerEvents,
+                                        visibility: parentGroup.visibility
                                         // the top group is appended to container
                                     }, htmlGroup || container);
                             // Shortcut
-                            htmlGroupStyle = htmlGroup.style;
+                            var htmlGroupStyle = htmlGroup.style;
                             // Set listeners to update the HTML div's position
                             // whenever the SVG group position is changed.
                             extend(parentGroup, {
@@ -215,7 +226,7 @@ var HTMLRenderer = /** @class */ (function (_super) {
                                     if (parents[0].div) { // #6418
                                         wrapper.on.apply({
                                             element: parents[0].div,
-                                            onEvents: wrapper.onEvents
+                                            onEvents: parentGroup.onEvents
                                         }, arguments);
                                     }
                                     return parentGroup;
@@ -243,6 +254,12 @@ var HTMLRenderer = /** @class */ (function (_super) {
         }
         return wrapper;
     };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    HTMLRenderer.composedClasses = [];
     return HTMLRenderer;
 }(SVGRenderer));
 /* *

package/es-modules/Core/Renderer/RendererRegistry.js

@@ -18,14 +18,19 @@ var RendererRegistry;
 (function (RendererRegistry) {
     /* *
      *
-     *  Static Properties
+     *  Constants
      *
      * */
-    var defaultRenderer;
     RendererRegistry.rendererTypes = {};
     /* *
      *
-     *  Static Functions
+     *  Variables
+     *
+     * */
+    var defaultRenderer;
+    /* *
+     *
+     *  Functions
      *
      * */
     /**
@@ -66,7 +71,7 @@ var RendererRegistry;
 })(RendererRegistry || (RendererRegistry = {}));
 /* *
  *
- *  Export
+ *  Default Export
  *
  * */
 export default RendererRegistry;

package/es-modules/Core/Renderer/RendererUtilities.js

@@ -0,0 +1,159 @@
+/* *
+ *
+ *  (c) 2010-2021 Torstein Honsi
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+/* *
+ *
+ *  Imports
+ *
+ * */
+import U from '../Utilities.js';
+var clamp = U.clamp, pick = U.pick, stableSort = U.stableSort;
+/* *
+ *
+ *  Namespace
+ *
+ * */
+var RendererUtilities;
+(function (RendererUtilities) {
+    /* *
+     *
+     *  Declarations
+     *
+     * */
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /* eslint-disable valid-jsdoc */
+    /**
+     * General distribution algorithm for distributing labels of differing size
+     * along a confined length in two dimensions. The algorithm takes an array
+     * of objects containing a size, a target and a rank. It will place the
+     * labels as close as possible to their targets, skipping the lowest ranked
+     * labels if necessary.
+     * @private
+     */
+    function distribute(boxes, len, maxDistance) {
+        var origBoxes = boxes, // Original array will be altered with added .pos
+        reducedLen = origBoxes.reducedLen || len, sortByRank = function (a, b) {
+            return (b.rank || 0) - (a.rank || 0);
+        }, sortByTarget = function (a, b) {
+            return a.target - b.target;
+        };
+        var i, overlapping = true, restBoxes = [], // The outranked overshoot
+        box, target, total = 0;
+        // If the total size exceeds the len, remove those boxes with the lowest
+        // rank
+        i = boxes.length;
+        while (i--) {
+            total += boxes[i].size;
+        }
+        // Sort by rank, then slice away overshoot
+        if (total > reducedLen) {
+            stableSort(boxes, sortByRank);
+            i = 0;
+            total = 0;
+            while (total <= reducedLen) {
+                total += boxes[i].size;
+                i++;
+            }
+            restBoxes = boxes.splice(i - 1, boxes.length);
+        }
+        // Order by target
+        stableSort(boxes, sortByTarget);
+        // So far we have been mutating the original array. Now
+        // create a copy with target arrays
+        boxes = boxes.map(function (box) { return ({
+            size: box.size,
+            targets: [box.target],
+            align: pick(box.align, 0.5)
+        }); });
+        while (overlapping) {
+            // Initial positions: target centered in box
+            i = boxes.length;
+            while (i--) {
+                box = boxes[i];
+                // Composite box, average of targets
+                target = (Math.min.apply(0, box.targets) +
+                    Math.max.apply(0, box.targets)) / 2;
+                box.pos = clamp(target - box.size * box.align, 0, len - box.size);
+            }
+            // Detect overlap and join boxes
+            i = boxes.length;
+            overlapping = false;
+            while (i--) {
+                // Overlap
+                if (i > 0 &&
+                    boxes[i - 1].pos + boxes[i - 1].size >
+                        boxes[i].pos) {
+                    // Add this size to the previous box
+                    boxes[i - 1].size += boxes[i].size;
+                    boxes[i - 1].targets = boxes[i - 1]
+                        .targets
+                        .concat(boxes[i].targets);
+                    boxes[i - 1].align = 0.5;
+                    // Overlapping right, push left
+                    if (boxes[i - 1].pos + boxes[i - 1].size > len) {
+                        boxes[i - 1].pos = len - boxes[i - 1].size;
+                    }
+                    boxes.splice(i, 1); // Remove this item
+                    overlapping = true;
+                }
+            }
+        }
+        // Add the rest (hidden boxes)
+        origBoxes.push.apply(origBoxes, restBoxes);
+        // Now the composite boxes are placed, we need to put the original boxes
+        // within them
+        i = 0;
+        boxes.some(function (box) {
+            var posInCompositeBox = 0;
+            // Exceeded maxDistance => abort
+            return (box.targets || []).some(function () {
+                origBoxes[i].pos = box.pos + posInCompositeBox;
+                // If the distance between the position and the target exceeds
+                // maxDistance, abort the loop and decrease the length in
+                // increments of 10% to recursively reduce the  number of
+                // visible boxes by rank. Once all boxes are within the
+                // maxDistance, we're good.
+                if (typeof maxDistance !== 'undefined' &&
+                    Math.abs(origBoxes[i].pos - origBoxes[i].target) > maxDistance) {
+                    // Reset the positions that are already set
+                    origBoxes
+                        .slice(0, i + 1)
+                        .forEach(function (box) { return delete box.pos; });
+                    // Try with a smaller length
+                    origBoxes.reducedLen =
+                        (origBoxes.reducedLen || len) - (len * 0.1);
+                    // Recurse
+                    if (origBoxes.reducedLen > len * 0.1) {
+                        distribute(origBoxes, len, maxDistance);
+                    }
+                    // Exceeded maxDistance => abort
+                    return true;
+                }
+                posInCompositeBox += origBoxes[i].size;
+                i++;
+                return false;
+            });
+        });
+        // Add the rest (hidden) boxes and sort by target
+        stableSort(origBoxes, sortByTarget);
+        return origBoxes;
+    }
+    RendererUtilities.distribute = distribute;
+})(RendererUtilities || (RendererUtilities = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default RendererUtilities;

package/es-modules/Core/Renderer/SVG/SVGElement.js

@@ -7,13 +7,14 @@
  *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
  *
  * */
+'use strict';
 import A from '../../Animation/AnimationUtilities.js';
-import AST from '../HTML/AST.js';
 var animate = A.animate, animObject = A.animObject, stop = A.stop;
+import AST from '../HTML/AST.js';
 import Color from '../../Color/Color.js';
 import H from '../../Globals.js';
-var deg2rad = H.deg2rad, doc = H.doc, hasTouch = H.hasTouch, noop = H.noop, svg = H.svg, SVG_NS = H.SVG_NS, win = H.win;
-import palette from '../../Color/Palette.js';
+var deg2rad = H.deg2rad, doc = H.doc, noop = H.noop, svg = H.svg, SVG_NS = H.SVG_NS, win = H.win;
+import Palette from '../../Color/Palette.js';
 import U from '../../Utilities.js';
 var addEvent = U.addEvent, attr = U.attr, createElement = U.createElement, css = U.css, defined = U.defined, erase = U.erase, extend = U.extend, fireEvent = U.fireEvent, isArray = U.isArray, isFunction = U.isFunction, isNumber = U.isNumber, isString = U.isString, merge = U.merge, objectEach = U.objectEach, pick = U.pick, pInt = U.pInt, syncTimeout = U.syncTimeout, uniqueKey = U.uniqueKey;
 /* *
@@ -1152,7 +1153,7 @@ var SVGElement = /** @class */ (function () {
             }
             // Cache it. When loading a chart in a hidden iframe in Firefox and
             // IE/Edge, the bounding box height is 0, so don't cache it (#5620).
-            if (cacheKey && bBox.height > 0) {
+            if (cacheKey && (textStr === '' || bBox.height > 0)) {
                 // Rotate (#4681)
                 while (cacheKeys.length > 250) {
                     delete cache[cacheKeys.shift()];
@@ -1550,7 +1551,7 @@ var SVGElement = /** @class */ (function () {
      */
     SVGElement.prototype.shadow = function (shadowOptions, group, cutOff) {
         var shadows = [], element = this.element, oldShadowOptions = this.oldShadowOptions, defaultShadowOptions = {
-            color: palette.neutralColor100,
+            color: Palette.neutralColor100,
             offsetX: this.parentInverted ? -1 : 1,
             offsetY: this.parentInverted ? -1 : 1,
             opacity: 0.15,
@@ -1593,7 +1594,7 @@ var SVGElement = /** @class */ (function () {
                 strokeWidth = (options.width * 2) + 1 - (2 * i);
                 attr(shadow, {
                     stroke: (shadowOptions.color ||
-                        palette.neutralColor100),
+                        Palette.neutralColor100),
                     'stroke-opacity': shadowElementOpacity * i,
                     'stroke-width': strokeWidth,
                     transform: transform,
@@ -2013,6 +2014,11 @@ SVGElement.prototype.matrixSetter =
                                     this[key] = value;
                                     this.doTransform = true;
                                 };
+/* *
+ *
+ *  Default Export
+ *
+ * */
 export default SVGElement;
 /* *
  *
@@ -2176,4 +2182,4 @@ export default SVGElement;
  *
  * @typedef {"bottom"|"middle"|"top"} Highcharts.VerticalAlignValue
  */
-''; // detach doclets above
+''; // keeps doclets above in JS file

package/es-modules/Core/Renderer/SVG/SVGLabel.js

@@ -39,7 +39,7 @@ var SVGLabel = /** @class */ (function (_super) {
     __extends(SVGLabel, _super);
     /* *
      *
-     *  Constructors
+     *  Constructor
      *
      * */
     function SVGLabel(renderer, str, x, y, shape, anchorX, anchorY, useHTML, baseline, className) {
@@ -60,7 +60,9 @@ var SVGLabel = /** @class */ (function (_super) {
         if (className) {
             _this.addClass('highcharts-' + className);
         }
-        _this.text = renderer.text('', 0, 0, useHTML).attr({ zIndex: 1 });
+        // Create the text element. An undefined text content prevents redundant
+        // box calculation (#16121)
+        _this.text = renderer.text(void 0, 0, 0, useHTML).attr({ zIndex: 1 });
         // Validate the shape argument
         var hasBGImage;
         if (typeof shape === 'string') {
@@ -195,33 +197,6 @@ var SVGLabel = /** @class */ (function (_super) {
     SVGLabel.prototype.heightSetter = function (value) {
         this.heightSetting = value;
     };
-    // Event handling. In case of useHTML, we need to make sure that events
-    // are captured on the span as well, and that mouseenter/mouseleave
-    // between the SVG group and the HTML span are not treated as real
-    // enter/leave events. #13310.
-    SVGLabel.prototype.on = function (eventType, handler) {
-        var label = this;
-        var text = label.text;
-        var span = text && text.element.tagName === 'SPAN' ? text : void 0;
-        var selectiveHandler;
-        if (span) {
-            selectiveHandler = function (e) {
-                if ((eventType === 'mouseenter' ||
-                    eventType === 'mouseleave') &&
-                    e.relatedTarget instanceof Element &&
-                    (
-                    // #14110
-                    label.element.compareDocumentPosition(e.relatedTarget) & Node.DOCUMENT_POSITION_CONTAINED_BY ||
-                        span.element.compareDocumentPosition(e.relatedTarget) & Node.DOCUMENT_POSITION_CONTAINED_BY)) {
-                    return;
-                }
-                handler.call(label.element, e);
-            };
-            span.on(eventType, selectiveHandler);
-        }
-        SVGElement.prototype.on.call(label, eventType, selectiveHandler || handler);
-        return label;
-    };
     /*
      * After the text element is added, get the desired size of the border
      * box and add it before the text in the DOM.
@@ -416,4 +391,9 @@ var SVGLabel = /** @class */ (function (_super) {
     ];
     return SVGLabel;
 }(SVGElement));
+/* *
+ *
+ *  Default Export
+ *
+ * */
 export default SVGLabel;