highcharts 8.2.0 → 8.2.2

package/es-modules/Core/Color/Color.js

@@ -0,0 +1,419 @@
+/* *
+ *
+ *  (c) 2010-2020 Torstein Honsi
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+import H from '../Globals.js';
+import U from '../Utilities.js';
+var isNumber = U.isNumber, merge = U.merge, pInt = U.pInt;
+/**
+ * A valid color to be parsed and handled by Highcharts. Highcharts internally
+ * supports hex colors like `#ffffff`, rgb colors like `rgb(255,255,255)` and
+ * rgba colors like `rgba(255,255,255,1)`. Other colors may be supported by the
+ * browsers and displayed correctly, but Highcharts is not able to process them
+ * and apply concepts like opacity and brightening.
+ *
+ * @typedef {string} Highcharts.ColorString
+ */
+/**
+ * A valid color type than can be parsed and handled by Highcharts. It can be a
+ * color string, a gradient object, or a pattern object.
+ *
+ * @typedef {Highcharts.ColorString|Highcharts.GradientColorObject|Highcharts.PatternObject} Highcharts.ColorType
+ */
+/**
+ * Gradient options instead of a solid color.
+ *
+ * @example
+ * // Linear gradient used as a color option
+ * color: {
+ *     linearGradient: { x1: 0, x2: 0, y1: 0, y2: 1 },
+ *     stops: [
+ *         [0, '#003399'], // start
+ *         [0.5, '#ffffff'], // middle
+ *         [1, '#3366AA'] // end
+ *     ]
+ * }
+ *
+ * @interface Highcharts.GradientColorObject
+ */ /**
+* Holds an object that defines the start position and the end position relative
+* to the shape.
+* @name Highcharts.GradientColorObject#linearGradient
+* @type {Highcharts.LinearGradientColorObject|undefined}
+*/ /**
+* Holds an object that defines the center position and the radius.
+* @name Highcharts.GradientColorObject#radialGradient
+* @type {Highcharts.RadialGradientColorObject|undefined}
+*/ /**
+* The first item in each tuple is the position in the gradient, where 0 is the
+* start of the gradient and 1 is the end of the gradient. Multiple stops can be
+* applied. The second item is the color for each stop. This color can also be
+* given in the rgba format.
+* @name Highcharts.GradientColorObject#stops
+* @type {Array<Highcharts.GradientColorStopObject>}
+*/
+/**
+ * Color stop tuple.
+ *
+ * @see Highcharts.GradientColorObject
+ *
+ * @interface Highcharts.GradientColorStopObject
+ */ /**
+* @name Highcharts.GradientColorStopObject#0
+* @type {number}
+*/ /**
+* @name Highcharts.GradientColorStopObject#1
+* @type {Highcharts.ColorString}
+*/ /**
+* @name Highcharts.GradientColorStopObject#color
+* @type {Highcharts.Color|undefined}
+*/
+/**
+ * Defines the start position and the end position for a gradient relative
+ * to the shape. Start position (x1, y1) and end position (x2, y2) are relative
+ * to the shape, where 0 means top/left and 1 is bottom/right.
+ *
+ * @interface Highcharts.LinearGradientColorObject
+ */ /**
+* Start horizontal position of the gradient. Float ranges 0-1.
+* @name Highcharts.LinearGradientColorObject#x1
+* @type {number}
+*/ /**
+* End horizontal position of the gradient. Float ranges 0-1.
+* @name Highcharts.LinearGradientColorObject#x2
+* @type {number}
+*/ /**
+* Start vertical position of the gradient. Float ranges 0-1.
+* @name Highcharts.LinearGradientColorObject#y1
+* @type {number}
+*/ /**
+* End vertical position of the gradient. Float ranges 0-1.
+* @name Highcharts.LinearGradientColorObject#y2
+* @type {number}
+*/
+/**
+ * Defines the center position and the radius for a gradient.
+ *
+ * @interface Highcharts.RadialGradientColorObject
+ */ /**
+* Center horizontal position relative to the shape. Float ranges 0-1.
+* @name Highcharts.RadialGradientColorObject#cx
+* @type {number}
+*/ /**
+* Center vertical position relative to the shape. Float ranges 0-1.
+* @name Highcharts.RadialGradientColorObject#cy
+* @type {number}
+*/ /**
+* Radius relative to the shape. Float ranges 0-1.
+* @name Highcharts.RadialGradientColorObject#r
+* @type {number}
+*/
+''; // detach doclets above
+/* *
+ *
+ *  Class
+ *
+ * */
+/* eslint-disable no-invalid-this, valid-jsdoc */
+/**
+ * Handle color operations. Some object methods are chainable.
+ *
+ * @class
+ * @name Highcharts.Color
+ *
+ * @param {Highcharts.ColorType} input
+ * The input color in either rbga or hex format
+ */
+var Color = /** @class */ (function () {
+    /* *
+     *
+     *  Constructors
+     *
+     * */
+    function Color(input) {
+        // Collection of parsers. This can be extended from the outside by pushing
+        // parsers to Highcharts.Color.prototype.parsers.
+        this.parsers = [{
+                // RGBA color
+                // eslint-disable-next-line max-len
+                regex: /rgba\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]?(?:\.[0-9]+)?)\s*\)/,
+                parse: function (result) {
+                    return [
+                        pInt(result[1]),
+                        pInt(result[2]),
+                        pInt(result[3]),
+                        parseFloat(result[4], 10)
+                    ];
+                }
+            }, {
+                // RGB color
+                regex: /rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/,
+                parse: function (result) {
+                    return [pInt(result[1]), pInt(result[2]), pInt(result[3]), 1];
+                }
+            }];
+        this.rgba = [];
+        // Backwards compatibility, allow class overwrite
+        if (H.Color !== Color) {
+            return new H.Color(input);
+        }
+        // Backwards compatibility, allow instanciation without new (#13053)
+        if (!(this instanceof Color)) {
+            return new Color(input);
+        }
+        this.init(input);
+    }
+    /* *
+     *
+     *  Static Functions
+     *
+     * */
+    /**
+     * Creates a color instance out of a color string or object.
+     *
+     * @function Highcharts.Color.parse
+     *
+     * @param {Highcharts.ColorType} input
+     * The input color in either rbga or hex format.
+     *
+     * @return {Highcharts.Color}
+     * Color instance.
+     */
+    Color.parse = function (input) {
+        return new Color(input);
+    };
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Parse the input color to rgba array
+     *
+     * @private
+     * @function Highcharts.Color#init
+     *
+     * @param {Highcharts.ColorType} input
+     *        The input color in either rbga or hex format
+     *
+     * @return {void}
+     */
+    Color.prototype.init = function (input) {
+        var result, rgba, i, parser, len;
+        this.input = input = Color.names[input && input.toLowerCase ?
+            input.toLowerCase() :
+            ''] || input;
+        // Gradients
+        if (input && input.stops) {
+            this.stops = input.stops.map(function (stop) {
+                return new Color(stop[1]);
+            });
+            // Solid colors
+        }
+        else {
+            // Bitmasking as input[0] is not working for legacy IE.
+            if (input &&
+                input.charAt &&
+                input.charAt() === '#') {
+                len = input.length;
+                input = parseInt(input.substr(1), 16);
+                // Handle long-form, e.g. #AABBCC
+                if (len === 7) {
+                    rgba = [
+                        (input & 0xFF0000) >> 16,
+                        (input & 0xFF00) >> 8,
+                        (input & 0xFF),
+                        1
+                    ];
+                    // Handle short-form, e.g. #ABC
+                    // In short form, the value is assumed to be the same
+                    // for both nibbles for each component. e.g. #ABC = #AABBCC
+                }
+                else if (len === 4) {
+                    rgba = [
+                        (((input & 0xF00) >> 4) |
+                            (input & 0xF00) >> 8),
+                        (((input & 0xF0) >> 4) |
+                            (input & 0xF0)),
+                        ((input & 0xF) << 4) | (input & 0xF),
+                        1
+                    ];
+                }
+            }
+            // Otherwise, check regex parsers
+            if (!rgba) {
+                i = this.parsers.length;
+                while (i-- && !rgba) {
+                    parser = this.parsers[i];
+                    result = parser.regex.exec(input);
+                    if (result) {
+                        rgba = parser.parse(result);
+                    }
+                }
+            }
+        }
+        this.rgba = rgba || [];
+    };
+    /**
+     * Return the color or gradient stops in the specified format
+     *
+     * @function Highcharts.Color#get
+     *
+     * @param {string} [format]
+     *        Possible values are 'a', 'rgb', 'rgba' (default).
+     *
+     * @return {Highcharts.ColorType}
+     *         This color as a string or gradient stops.
+     */
+    Color.prototype.get = function (format) {
+        var input = this.input, rgba = this.rgba, ret;
+        if (typeof this.stops !== 'undefined') {
+            ret = merge(input);
+            ret.stops = [].concat(ret.stops);
+            this.stops.forEach(function (stop, i) {
+                ret.stops[i] = [
+                    ret.stops[i][0],
+                    stop.get(format)
+                ];
+            });
+            // it's NaN if gradient colors on a column chart
+        }
+        else if (rgba && isNumber(rgba[0])) {
+            if (format === 'rgb' || (!format && rgba[3] === 1)) {
+                ret = 'rgb(' + rgba[0] + ',' + rgba[1] + ',' + rgba[2] + ')';
+            }
+            else if (format === 'a') {
+                ret = rgba[3];
+            }
+            else {
+                ret = 'rgba(' + rgba.join(',') + ')';
+            }
+        }
+        else {
+            ret = input;
+        }
+        return ret;
+    };
+    /**
+     * Brighten the color instance.
+     *
+     * @function Highcharts.Color#brighten
+     *
+     * @param {number} alpha
+     *        The alpha value.
+     *
+     * @return {Highcharts.Color}
+     *         This color with modifications.
+     */
+    Color.prototype.brighten = function (alpha) {
+        var i, rgba = this.rgba;
+        if (this.stops) {
+            this.stops.forEach(function (stop) {
+                stop.brighten(alpha);
+            });
+        }
+        else if (isNumber(alpha) && alpha !== 0) {
+            for (i = 0; i < 3; i++) {
+                rgba[i] += pInt(alpha * 255);
+                if (rgba[i] < 0) {
+                    rgba[i] = 0;
+                }
+                if (rgba[i] > 255) {
+                    rgba[i] = 255;
+                }
+            }
+        }
+        return this;
+    };
+    /**
+     * Set the color's opacity to a given alpha value.
+     *
+     * @function Highcharts.Color#setOpacity
+     *
+     * @param {number} alpha
+     *        Opacity between 0 and 1.
+     *
+     * @return {Highcharts.Color}
+     *         Color with modifications.
+     */
+    Color.prototype.setOpacity = function (alpha) {
+        this.rgba[3] = alpha;
+        return this;
+    };
+    /**
+     * Return an intermediate color between two colors.
+     *
+     * @function Highcharts.Color#tweenTo
+     *
+     * @param {Highcharts.Color} to
+     *        The color object to tween to.
+     *
+     * @param {number} pos
+     *        The intermediate position, where 0 is the from color (current
+     *        color item), and 1 is the `to` color.
+     *
+     * @return {Highcharts.ColorString}
+     *         The intermediate color in rgba notation.
+     */
+    Color.prototype.tweenTo = function (to, pos) {
+        // Check for has alpha, because rgba colors perform worse due to lack of
+        // support in WebKit.
+        var fromRgba = this.rgba, toRgba = to.rgba, hasAlpha, ret;
+        // Unsupported color, return to-color (#3920, #7034)
+        if (!toRgba.length || !fromRgba || !fromRgba.length) {
+            ret = to.input || 'none';
+            // Interpolate
+        }
+        else {
+            hasAlpha = (toRgba[3] !== 1 || fromRgba[3] !== 1);
+            ret = (hasAlpha ? 'rgba(' : 'rgb(') +
+                Math.round(toRgba[0] + (fromRgba[0] - toRgba[0]) * (1 - pos)) +
+                ',' +
+                Math.round(toRgba[1] + (fromRgba[1] - toRgba[1]) * (1 - pos)) +
+                ',' +
+                Math.round(toRgba[2] + (fromRgba[2] - toRgba[2]) * (1 - pos)) +
+                (hasAlpha ?
+                    (',' +
+                        (toRgba[3] + (fromRgba[3] - toRgba[3]) * (1 - pos))) :
+                    '') +
+                ')';
+        }
+        return ret;
+    };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    // Collection of named colors. Can be extended from the outside by adding
+    // colors to Highcharts.Color.names.
+    Color.names = {
+        white: '#ffffff',
+        black: '#000000'
+    };
+    return Color;
+}());
+H.Color = Color;
+/**
+ * Creates a color instance out of a color string.
+ *
+ * @function Highcharts.color
+ *
+ * @param {Highcharts.ColorType} input
+ *        The input color in either rbga or hex format
+ *
+ * @return {Highcharts.Color}
+ *         Color instance
+ */
+H.color = Color.parse;
+/* *
+ *
+ *  Export
+ *
+ * */
+export default Color;

package/es-modules/Core/Color/ColorType.js

@@ -0,0 +1,9 @@
+/* *
+ *
+ *  (c) 2010-2020 Torstein Honsi
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */

package/es-modules/Core/Dynamics.js

@@ -8,17 +8,20 @@
  *
  * */
 'use strict';
+import A from './Animation/AnimationUtilities.js';
+var animate = A.animate, setAnimation = A.setAnimation;
 import Axis from './Axis/Axis.js';
+import BaseSeries from './Series/Series.js';
+var seriesTypes = BaseSeries.seriesTypes;
 import Chart from './Chart/Chart.js';
 import H from './Globals.js';
+import LineSeries from '../Series/LineSeries.js';
 import O from './Options.js';
 var time = O.time;
 import Point from '../Core/Series/Point.js';
 import Time from './Time.js';
 import U from './Utilities.js';
-var addEvent = U.addEvent, animate = U.animate, createElement = U.createElement, css = U.css, defined = U.defined, erase = U.erase, error = U.error, extend = U.extend, fireEvent = U.fireEvent, isArray = U.isArray, isNumber = U.isNumber, isObject = U.isObject, isString = U.isString, merge = U.merge, objectEach = U.objectEach, pick = U.pick, relativeLength = U.relativeLength, setAnimation = U.setAnimation, splat = U.splat;
-import './Series/Series.js';
-var Series = H.Series, seriesTypes = H.seriesTypes;
+var addEvent = U.addEvent, createElement = U.createElement, css = U.css, defined = U.defined, erase = U.erase, error = U.error, extend = U.extend, fireEvent = U.fireEvent, isArray = U.isArray, isNumber = U.isNumber, isObject = U.isObject, isString = U.isString, merge = U.merge, objectEach = U.objectEach, pick = U.pick, relativeLength = U.relativeLength, splat = U.splat;
 /* eslint-disable valid-jsdoc */
 /**
  * Remove settings that have not changed, to avoid unnecessary rendering or
@@ -472,14 +475,20 @@ extend(Chart.prototype, /** @lends Highcharts.Chart.prototype */ {
         if (!chart.styledMode && options.colors) {
             this.options.colors = options.colors;
         }
-        if (options.plotOptions) {
-            merge(true, this.options.plotOptions, options.plotOptions);
-        }
-        // Maintaining legacy global time. If the chart is instanciated first
-        // with global time, then updated with time options, we need to create a
-        // new Time instance to avoid mutating the global time (#10536).
-        if (options.time && this.time === time) {
-            this.time = new Time(options.time);
+        if (options.time) {
+            // Maintaining legacy global time. If the chart is instanciated
+            // first with global time, then updated with time options, we need
+            // to create a new Time instance to avoid mutating the global time
+            // (#10536).
+            if (this.time === time) {
+                this.time = new Time(options.time);
+            }
+            // If we're updating, the time class is different from other chart
+            // classes (chart.legend, chart.tooltip etc) in that it doesn't know
+            // about the chart. The other chart[something].update functions also
+            // set the chart.options[something]. For the time class however we
+            // need to update the chart options separately. #14230.
+            merge(true, chart.options.time, options.time);
         }
         // Some option stuctures correspond one-to-one to chart objects that
         // have update methods, for example
@@ -499,6 +508,12 @@ extend(Chart.prototype, /** @lends Highcharts.Chart.prototype */ {
             }
             else if (typeof chart[adders[key]] === 'function') {
                 chart[adders[key]](val);
+                // Else, just merge the options. For nodes like loading, noData,
+                // plotOptions
+            }
+            else if (key !== 'color' &&
+                chart.collectionsWithUpdate.indexOf(key) === -1) {
+                merge(true, chart.options[key], options[key]);
             }
             if (key !== 'chart' &&
                 chart.propsRequireUpdateSeries.indexOf(key) !== -1) {
@@ -593,10 +608,6 @@ extend(Chart.prototype, /** @lends Highcharts.Chart.prototype */ {
                 }
             }, this);
         }
-        // For loading, just update the options, do not redraw
-        if (options.loading) {
-            merge(true, chart.options.loading, options.loading);
-        }
         // Update size. Redraw is forced.
         newWidth = optionsChart && optionsChart.width;
         newHeight = optionsChart && optionsChart.height;
@@ -793,7 +804,7 @@ extend(Point.prototype, /** @lends Highcharts.Point.prototype */ {
     }
 });
 // Extend the series prototype for dynamic methods
-extend(Series.prototype, /** @lends Series.prototype */ {
+extend(LineSeries.prototype, /** @lends Series.prototype */ {
     /**
      * Add a point to the series after render time. The point can be added at
      * the end, or by giving it an X value, to the start or in the middle of the
@@ -1040,21 +1051,23 @@ extend(Series.prototype, /** @lends Series.prototype */ {
         var series = this, chart = series.chart, 
         // must use user options when changing type because series.options
         // is merged in with type specific plotOptions
-        oldOptions = series.userOptions, seriesOptions, initialType = series.initialType || series.type, newType = (options.type ||
+        oldOptions = series.userOptions, seriesOptions, initialType = series.initialType || series.type, plotOptions = chart.options.plotOptions, newType = (options.type ||
             oldOptions.type ||
             chart.options.chart.type), keepPoints = !(
         // Indicators, histograms etc recalculate the data. It should be
         // possible to omit this.
         this.hasDerivedData ||
-            // Changes to data grouping requires new points in new groups
-            options.dataGrouping ||
             // New type requires new point classes
             (newType && newType !== this.type) ||
             // New options affecting how the data points are built
             typeof options.pointStart !== 'undefined' ||
-            options.pointInterval ||
-            options.pointIntervalUnit ||
-            options.keys), initialSeriesProto = seriesTypes[initialType].prototype, n, groups = [
+            typeof options.pointInterval !== 'undefined' ||
+            // Changes to data grouping requires new points in new group
+            series.hasOptionChanged('dataGrouping') ||
+            series.hasOptionChanged('pointStart') ||
+            series.hasOptionChanged('pointInterval') ||
+            series.hasOptionChanged('pointIntervalUnit') ||
+            series.hasOptionChanged('keys')), initialSeriesProto = seriesTypes[initialType].prototype, n, groups = [
             'group',
             'markerGroup',
             'dataLabelsGroup',
@@ -1097,7 +1110,7 @@ extend(Series.prototype, /** @lends Series.prototype */ {
                 series.index : oldOptions.index,
             pointStart: pick(
             // when updating from blank (#7933)
-            oldOptions.pointStart, 
+            plotOptions && plotOptions.series && plotOptions.series.pointStart, oldOptions.pointStart, 
             // when updating after addPoint
             series.xData[0])
         }, (!keepPoints && { data: series.options.data }), options);
@@ -1187,6 +1200,24 @@ extend(Series.prototype, /** @lends Series.prototype */ {
     setName: function (name) {
         this.name = this.options.name = this.userOptions.name = name;
         this.chart.isDirtyLegend = true;
+    },
+    /**
+     * Check if the option has changed.
+     *
+     * @private
+     * @function Highcharts.Series#hasOptionChanged
+     *
+     * @param {string} option
+     *
+     * @return {boolean}
+     */
+    hasOptionChanged: function (optionName) {
+        var chart = this.chart, option = this.options[optionName], plotOptions = chart.options.plotOptions, oldOption = this.userOptions[optionName];
+        if (oldOption) {
+            return option !== oldOption;
+        }
+        return option !==
+            pick(plotOptions && plotOptions[this.type] && plotOptions[this.type][optionName], plotOptions && plotOptions.series && plotOptions.series[optionName], option);
     }
 });
 // Extend the Axis.prototype for dynamic methods

package/es-modules/Core/Globals.js

@@ -31,7 +31,7 @@ typeof win !== 'undefined' ?
 );
 var H = {
     product: 'Highcharts',
-    version: '8.2.0',
+    version: '8.2.2',
     deg2rad: Math.PI * 2 / 360,
     doc: doc,
     hasBidiBug: hasBidiBug,

package/es-modules/Core/Interaction.js

@@ -8,9 +8,13 @@
  *
  * */
 'use strict';
+import BaseSeries from './Series/Series.js';
+var seriesTypes = BaseSeries.seriesTypes;
 import Chart from './Chart/Chart.js';
 import H from './Globals.js';
+var hasTouch = H.hasTouch, svg = H.svg;
 import Legend from './Legend.js';
+import LineSeries from '../Series/LineSeries.js';
 import O from './Options.js';
 var defaultOptions = O.defaultOptions;
 import Point from '../Core/Series/Point.js';
@@ -64,8 +68,7 @@ var addEvent = U.addEvent, createElement = U.createElement, css = U.css, defined
  * @param {Highcharts.PointInteractionEventObject} event
  *        Event that occured.
  */
-import './Series/Series.js';
-var hasTouch = H.hasTouch, Series = H.Series, seriesTypes = H.seriesTypes, svg = H.svg, TrackerMixin;
+''; // detach doclets above
 /* eslint-disable valid-jsdoc */
 /**
  * TrackerMixin for points and graphs.
@@ -73,7 +76,7 @@ var hasTouch = H.hasTouch, Series = H.Series, seriesTypes = H.seriesTypes, svg =
  * @private
  * @mixin Highcharts.TrackerMixin
  */
-TrackerMixin = H.TrackerMixin = {
+var TrackerMixin = H.TrackerMixin = {
     /**
      * Draw the tracker for a point.
      *
@@ -515,11 +518,11 @@ extend(Chart.prototype, /** @lends Chart.prototype */ {
                         }
                     }
                 });
-                paddedMin = Math.min(H.pick(panningState === null || panningState === void 0 ? void 0 : panningState.startMin, extremes.dataMin), halfPointRange ?
+                paddedMin = Math.min(pick(panningState === null || panningState === void 0 ? void 0 : panningState.startMin, extremes.dataMin), halfPointRange ?
                     extremes.min :
                     axis.toValue(axis.toPixels(extremes.min) -
                         axis.minPixelPadding));
-                paddedMax = Math.max(H.pick(panningState === null || panningState === void 0 ? void 0 : panningState.startMax, extremes.dataMax), halfPointRange ?
+                paddedMax = Math.max(pick(panningState === null || panningState === void 0 ? void 0 : panningState.startMax, extremes.dataMax), halfPointRange ?
                     extremes.max :
                     axis.toValue(axis.toPixels(extremes.max) +
                         axis.minPixelPadding));
@@ -875,7 +878,7 @@ extend(Point.prototype, /** @lends Highcharts.Point.prototype */ {
     }
 });
 // Extend the Series object with interaction
-extend(Series.prototype, /** @lends Highcharts.Series.prototype */ {
+extend(LineSeries.prototype, /** @lends Highcharts.Series.prototype */ {
     /**
      * Runs on mouse over the series graphical items.
      *

package/es-modules/Core/Legend.js

@@ -8,6 +8,8 @@
  *
  * */
 'use strict';
+import A from './Animation/AnimationUtilities.js';
+var animObject = A.animObject, setAnimation = A.setAnimation;
 import H from './Globals.js';
 /**
  * Gets fired when the legend item belonging to a point is clicked. The default
@@ -78,7 +80,7 @@ import H from './Globals.js';
 * @type {"legendItemClick"}
 */
 import U from './Utilities.js';
-var addEvent = U.addEvent, animObject = U.animObject, css = U.css, defined = U.defined, discardElement = U.discardElement, find = U.find, fireEvent = U.fireEvent, format = U.format, isNumber = U.isNumber, merge = U.merge, pick = U.pick, relativeLength = U.relativeLength, setAnimation = U.setAnimation, stableSort = U.stableSort, syncTimeout = U.syncTimeout, wrap = U.wrap;
+var addEvent = U.addEvent, css = U.css, defined = U.defined, discardElement = U.discardElement, find = U.find, fireEvent = U.fireEvent, format = U.format, isNumber = U.isNumber, merge = U.merge, pick = U.pick, relativeLength = U.relativeLength, stableSort = U.stableSort, syncTimeout = U.syncTimeout, wrap = U.wrap;
 var isFirefox = H.isFirefox, marginNames = H.marginNames, win = H.win;
 /* eslint-disable no-invalid-this, valid-jsdoc */
 /**