highcharts 10.2.0 → 10.2.1

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

@@ -10,8 +10,8 @@
 'use strict';
 import A from '../Animation/AnimationUtilities.js';
 var animObject = A.animObject, setAnimation = A.setAnimation;
-import D from '../DefaultOptions.js';
-var defaultOptions = D.defaultOptions;
+import DO from '../DefaultOptions.js';
+var defaultOptions = DO.defaultOptions;
 import F from '../Foundation.js';
 var registerEventOptions = F.registerEventOptions;
 import H from '../Globals.js';
@@ -670,7 +670,7 @@ var Series = /** @class */ (function () {
     };
     /**
      * Internal function called from setData. If the point count is the same
-     * as is was, or if there are overlapping X values, just run
+     * as it was, or if there are overlapping X values, just run
      * Point.update which is cheaper, allows animation, and keeps references
      * to points. This also allows adding or removing points if the X-es
      * don't match.
@@ -825,6 +825,7 @@ var Series = /** @class */ (function () {
      *        `false` to prevent.
      */
     Series.prototype.setData = function (data, redraw, animation, updatePoints) {
+        if (redraw === void 0) { redraw = true; }
         var series = this, oldData = series.points, oldDataLength = (oldData && oldData.length) || 0, options = series.options, chart = series.chart, dataSorting = options.dataSorting, xAxis = series.xAxis, turboThreshold = options.turboThreshold, xData = this.xData, yData = this.yData, pointArrayMap = series.pointArrayMap, valueCount = pointArrayMap && pointArrayMap.length, keys = options.keys;
         var i, pt, updatedData, indexOfX = 0, indexOfY = 1, firstPoint = null, copiedData;
         if (!chart.options.chart.allowMutatingData) { // #4259
@@ -839,7 +840,6 @@ var Series = /** @class */ (function () {
         }
         data = copiedData || data || [];
         var dataLength = data.length;
-        redraw = pick(redraw, true);
         if (dataSorting && dataSorting.enabled) {
             data = this.sortData(data);
         }
@@ -854,7 +854,7 @@ var Series = /** @class */ (function () {
             series.visible &&
             // Soft updating has no benefit in boost, and causes JS error
             // (#8355)
-            !series.isSeriesBoosting) {
+            !series.boosted) {
             updatedData = this.updateData(data, animation);
         }
         if (!updatedData) {
@@ -1200,26 +1200,6 @@ var Series = /** @class */ (function () {
             else {
                 // splat the y data in case of ohlc data array
                 point = (new PointClass()).init(series, [processedXData[i]].concat(splat(processedYData[i])));
-                /**
-                 * Highcharts Stock only. If a point object is created by data
-                 * grouping, it doesn't reflect actual points in the raw
-                 * data. In this case, the `dataGroup` property holds
-                 * information that points back to the raw data.
-                 *
-                 * - `dataGroup.start` is the index of the first raw data
-                 *   point in the group.
-                 *
-                 * - `dataGroup.length` is the amount of points in the
-                 *   group.
-                 *
-                 * @product highstock
-                 *
-                 * @name Highcharts.Point#dataGroup
-                 * @type {Highcharts.DataGroupingInfoObject|undefined}
-                 *
-                 * @sample stock/members/point-datagroup
-                 *         Click to inspect raw data points
-                 */
                 point.dataGroup = series.groupMap[groupCropStartIndex + i];
                 if (point.dataGroup.options) {
                     point.options = point.dataGroup.options;
@@ -2017,7 +1997,7 @@ var Series = /** @class */ (function () {
      * @function Highcharts.Series#applyZones
      */
     Series.prototype.applyZones = function () {
-        var series = this, chart = this.chart, renderer = chart.renderer, zones = this.zones, clips = (this.clips || []), graph = this.graph, area = this.area, chartSizeMax = Math.max(chart.chartWidth, chart.chartHeight), axis = this[(this.zoneAxis || 'y') + 'Axis'], inverted = chart.inverted;
+        var series = this, chart = this.chart, renderer = chart.renderer, zones = this.zones, clips = (this.clips || []), graph = this.graph, area = this.area, plotSizeMax = Math.max(chart.plotWidth, chart.plotHeight), axis = this[(this.zoneAxis || 'y') + 'Axis'], inverted = chart.inverted;
         var translatedFrom, translatedTo, clipAttr, extremes, reversed, horiz, pxRange, pxPosMin, pxPosMax, zoneArea, zoneGraph, ignoreZones = false;
         if (zones.length &&
             (graph || area) &&
@@ -2041,8 +2021,8 @@ var Series = /** @class */ (function () {
                 translatedFrom = reversed ?
                     (horiz ? chart.plotWidth : 0) :
                     (horiz ? 0 : (axis.toPixels(extremes.min) || 0));
-                translatedFrom = clamp(pick(translatedTo, translatedFrom), 0, chartSizeMax);
-                translatedTo = clamp(Math.round(axis.toPixels(pick(threshold.value, extremes.max), true) || 0), 0, chartSizeMax);
+                translatedFrom = clamp(pick(translatedTo, translatedFrom), 0, plotSizeMax);
+                translatedTo = clamp(Math.round(axis.toPixels(pick(threshold.value, extremes.max), true) || 0), 0, plotSizeMax);
                 if (ignoreZones) {
                     translatedFrom = translatedTo =
                         axis.toPixels(extremes.max);
@@ -2055,7 +2035,7 @@ var Series = /** @class */ (function () {
                         x: inverted ? pxPosMax : pxPosMin,
                         y: 0,
                         width: pxRange,
-                        height: chartSizeMax
+                        height: plotSizeMax
                     };
                     if (!horiz) {
                         clipAttr.x = chart.plotHeight - clipAttr.x;
@@ -2065,7 +2045,7 @@ var Series = /** @class */ (function () {
                     clipAttr = {
                         x: 0,
                         y: inverted ? pxPosMax : pxPosMin,
-                        width: chartSizeMax,
+                        width: plotSizeMax,
                         height: pxRange
                     };
                     if (horiz) {
@@ -2491,7 +2471,7 @@ var Series = /** @class */ (function () {
             }
             if (tree[sideB]) {
                 // compare distance to current best to splitting point to
-                // decide wether to check side B or not
+                // decide whether to check side B or not
                 if (Math.sqrt(tdist * tdist) < ret[kdComparer]) {
                     nPoint2 = _search(search, tree[sideB], depth + 1, dimensions);
                     ret = (nPoint2[kdComparer] <
@@ -3358,6 +3338,31 @@ var Series = /** @class */ (function () {
         return this.chart.isInsidePlot(plotX, plotY, options);
     };
     Series.defaultOptions = SeriesDefaults;
+    /**
+     * Registry of all available series types.
+     *
+     * @name Highcharts.Series.types
+     * @type {Highcharts.Dictionary<typeof_Highcharts.Series>}
+     */
+    Series.types = SeriesRegistry.seriesTypes;
+    /* *
+     *
+     *  Static Functions
+     *
+     * */
+    /**
+     * Registers a series class to be accessible via `Series.types`.
+     *
+     * @function Highcharts.Series.registerType
+     *
+     * @param {string} seriesType
+     * The series type as an identifier string in lower case.
+     *
+     * @param {Function} SeriesClass
+     * The series class as a class pattern or a constructor function with
+     * prototype.
+     */
+    Series.registerType = SeriesRegistry.registerSeriesType;
     return Series;
 }());
 extend(Series.prototype, {

package/es-modules/Core/Series/Series3D.js

@@ -25,7 +25,7 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-import Math3D from '../../Extensions/Math3D.js';
+import Math3D from '../Math3D.js';
 var perspective = Math3D.perspective;
 import Series from '../Series/Series.js';
 import U from '../Utilities.js';

package/es-modules/Core/Series/SeriesDefaults.js

@@ -410,6 +410,9 @@ var seriesDefaults = {
     /**
      * The line cap used for line ends and line joins on the graph.
      *
+     * @sample highcharts/series-line/linecap/
+     *         Line cap comparison
+     *
      * @type       {Highcharts.SeriesLinecapValue}
      * @default    round
      * @product    highcharts highstock
@@ -1811,13 +1814,13 @@ var seriesDefaults = {
          */
         x: 0,
         /**
-         * The Z index of the data labels. The default Z index puts it above
-         * the series. Use a Z index of 2 to display it behind the series.
+         * The z index of the data labels. Use a `zIndex` of 6 to display it above
+         * the series, or use a `zIndex` of 2 to display it behind the series.
          *
          * @type      {number}
          * @default   6
          * @since     2.3.5
-         * @apioption plotOptions.series.dataLabels.z
+         * @apioption plotOptions.series.dataLabels.zIndex
          */
         /**
          * The y position offset of the label relative to the point in
@@ -2255,6 +2258,8 @@ var seriesDefaults = {
      *
      * @sample highcharts/coloraxis/custom-color-key/
      *         Custom color key
+     * @sample highcharts/coloraxis/color-key-with-stops/
+     *         Custom colorKey with color axis stops
      * @sample highcharts/coloraxis/changed-default-color-key/
      *         Changed default color key
      *

package/es-modules/Core/Series/SeriesRegistry.js

@@ -36,43 +36,21 @@ var SeriesRegistry;
      *  Functions
      *
      * */
-    /* eslint-disable valid-jsdoc */
-    /**
-     * Internal function to initialize an individual series.
-     * @private
-     */
-    function getSeries(chart, options) {
-        if (options === void 0) { options = {}; }
-        var optionsChart = chart.options.chart, type = (options.type ||
-            optionsChart.type ||
-            optionsChart.defaultSeriesType ||
-            ''), SeriesClass = SeriesRegistry.seriesTypes[type];
-        // No such series type
-        if (!SeriesRegistry) {
-            error(17, true, chart, { missingModuleFor: type });
-        }
-        var series = new SeriesClass();
-        if (typeof series.init === 'function') {
-            series.init(chart, options);
-        }
-        return series;
-    }
-    SeriesRegistry.getSeries = getSeries;
     /**
      * Registers class pattern of a series.
      *
      * @private
      */
-    function registerSeriesType(seriesType, seriesClass) {
-        var defaultPlotOptions = defaultOptions.plotOptions || {}, seriesOptions = seriesClass.defaultOptions;
-        if (!seriesClass.prototype.pointClass) {
-            seriesClass.prototype.pointClass = Point;
+    function registerSeriesType(seriesType, SeriesClass) {
+        var defaultPlotOptions = defaultOptions.plotOptions || {}, seriesOptions = SeriesClass.defaultOptions, seriesProto = SeriesClass.prototype;
+        seriesProto.type = seriesType;
+        if (!seriesProto.pointClass) {
+            seriesProto.pointClass = Point;
         }
-        seriesClass.prototype.type = seriesType;
         if (seriesOptions) {
             defaultPlotOptions[seriesType] = seriesOptions;
         }
-        SeriesRegistry.seriesTypes[seriesType] = seriesClass;
+        SeriesRegistry.seriesTypes[seriesType] = SeriesClass;
     }
     SeriesRegistry.registerSeriesType = registerSeriesType;
     /**
@@ -117,7 +95,6 @@ var SeriesRegistry;
         return SeriesRegistry.seriesTypes[type];
     }
     SeriesRegistry.seriesType = seriesType;
-    /* eslint-enable valid-jsdoc */
 })(SeriesRegistry || (SeriesRegistry = {}));
 /* *
  *

package/es-modules/Core/Tooltip.js

@@ -383,11 +383,22 @@ var Tooltip = /** @class */ (function () {
         return this.label;
     };
     /**
-     * Place the tooltip in a chart without spilling over
-     * and not covering the point it self.
+     * Place the tooltip in a chart without spilling over and not covering the
+     * point itself.
      *
-     * @private
      * @function Highcharts.Tooltip#getPosition
+     *
+     * @param {number} boxWidth
+     *        Width of the tooltip box.
+     *
+     * @param {number} boxHeight
+     *        Height of the tooltip box.
+     *
+     * @param {Highcharts.Point} point
+     *        Tooltip related point.
+     *
+     * @return {Highcharts.PositionObject}
+     *         Recommended position of the tooltip.
      */
     Tooltip.prototype.getPosition = function (boxWidth, boxHeight, point) {
         var chart = this.chart, distance = this.distance, ret = {}, 

package/es-modules/Core/Utilities.js

@@ -1005,7 +1005,7 @@ function getStyle(el, prop, toInt) {
         error(27, true);
     }
     // Otherwise, get the computed style
-    var css = win.getComputedStyle(el, undefined); // eslint-disable-line no-undefined
+    var css = win.getComputedStyle(el, void 0); // eslint-disable-line no-undefined
     if (css) {
         style = css.getPropertyValue(prop);
         if (pick(toInt, prop !== 'opacity')) {
@@ -1125,8 +1125,6 @@ function offset(el) {
  *
  * @param {T} [ctx]
  *        The context.
- *
- * @return {void}
  */
 function objectEach(obj, fn, ctx) {
     /* eslint-enable valid-jsdoc */

package/es-modules/Data/DataConverter.js

@@ -466,6 +466,11 @@ var DataConverter = /** @class */ (function () {
         }
         return format;
     };
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
     /**
      * Default options
      */

package/es-modules/Data/DataPromise.js

@@ -1,6 +1,6 @@
 /* *
  *
- *  (c) 2020-2021 Highsoft AS
+ *  (c) 2020-2022 Highsoft AS
  *
  *  License: www.highcharts.com/license
  *

package/es-modules/Data/DataSeriesComposition.js

@@ -0,0 +1,288 @@
+/* *
+ *
+ *  Imports
+ *
+ * */
+import DataTable from './DataTable.js';
+import U from '../Core/Utilities.js';
+var addEvent = U.addEvent, fireEvent = U.fireEvent, isNumber = U.isNumber, merge = U.merge, wrap = U.wrap;
+/* *
+ *
+ *  Constants
+ *
+ * */
+var composedClasses = [];
+/* *
+ *
+ *  Functions
+ *
+ * */
+/**
+ * @private
+ */
+function wrapSeriesGeneratePoints(proceed) {
+    if (this.hasGroupedData) {
+        return proceed.call(this);
+    }
+    var PointClass = this.pointClass, cropStart = this.cropStart || 0, data = this.data || [], points = [], processedXData = this.processedXData, processedYData = this.processedYData;
+    var cursor, point;
+    for (var i = 0, iEnd = processedXData.length; i < iEnd; ++i) {
+        cursor = cropStart + i;
+        point = data[cursor];
+        if (!point) {
+            point = data[cursor] = (new PointClass()).init(this, processedYData[cursor], processedXData[i]);
+        }
+        point.index = cursor;
+        points[i] = point;
+    }
+    this.data = data;
+    this.points = points;
+    fireEvent(this, 'afterGeneratePoints');
+}
+/**
+ * @private
+ */
+function wrapSeriesSetData(proceed, data, redraw, animation) {
+    if (data === void 0) { data = []; }
+    if (redraw === void 0) { redraw = true; }
+    var datas = this.datas;
+    if (this.hasGroupedData || !this.options.dataAsColumns) {
+        return proceed.call(this, data, redraw, animation);
+    }
+    data = this.options.data = this.userOptions.data = (this.chart.options.chart.allowMutatingData ?
+        (data || []) :
+        merge(true, data));
+    var columns = {}, keys = (this.options.keys || this.parallelArrays).slice();
+    if (isNumber(data[0]) || keys.length === 1) {
+        // first column is implicit index
+        var xData = columns.x = [];
+        for (var i = 0, iEnd = data.length; i < iEnd; ++i) {
+            xData.push(this.autoIncrement());
+        }
+        columns[keys[1] || 'y'] = data;
+    }
+    else {
+        if (keys.indexOf('x') === -1 && keys.length > data.length) {
+            // first column is implicit index
+            var xData = columns.x = [];
+            for (var i = 0, iEnd = data.length; i < iEnd; ++i) {
+                xData.push(this.autoIncrement());
+            }
+        }
+        for (var i = 0, iEnd = Math.min(data.length, keys.length); i < iEnd; ++i) {
+            if (data[i] instanceof Array) {
+                columns[keys[i]] = data[i];
+            }
+        }
+    }
+    datas.setTable(new DataTable(columns, this.name));
+}
+/* *
+ *
+ *  Class
+ *
+ * */
+var DataSeriesAdditions = /** @class */ (function () {
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    function DataSeriesAdditions(series) {
+        this.unlisteners = [];
+        var columns = {}, keys = series.parallelArrays;
+        for (var i = 0, iEnd = keys.length; i < iEnd; ++i) {
+            columns[keys[i]] = [];
+        }
+        this.series = series;
+        this.table = new DataTable();
+    }
+    /* *
+     *
+     *  Static Functions
+     *
+     * */
+    /**
+     * @private
+     */
+    DataSeriesAdditions.compose = function (SeriesClass) {
+        if (composedClasses.indexOf(SeriesClass) === -1) {
+            composedClasses.push(SeriesClass);
+            addEvent(SeriesClass, 'init', function () {
+                this.datas = new DataSeriesAdditions(this);
+            });
+            var seriesProto = SeriesClass.prototype;
+            wrap(seriesProto, 'generatePoints', wrapSeriesGeneratePoints);
+            wrap(seriesProto, 'setData', wrapSeriesSetData);
+        }
+    };
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Triggers processing and redrawing
+     * @private
+     */
+    DataSeriesAdditions.prototype.processTable = function (redraw, animation) {
+        var series = this.series;
+        if (series.options.legendType === 'point') {
+            series.processData();
+            series.generatePoints();
+        }
+        if (redraw) {
+            var chart = series.chart;
+            series.isDirty = chart.isDirtyBox = true;
+            series.isDirtyData = true;
+            chart.redraw(animation);
+        }
+    };
+    /**
+     * Experimental integration of the data layer
+     * @private
+     */
+    DataSeriesAdditions.prototype.setTable = function (table, redraw, animation) {
+        if (redraw === void 0) { redraw = true; }
+        var series = this.series, anySeries = series, oldData = series.points, keys = series.parallelArrays, rowCount = table.getRowCount();
+        var key;
+        if (oldData) {
+            var xAxis = series.xAxis;
+            series.colorCounter = 0;
+            series.data = [];
+            delete anySeries.points;
+            delete anySeries.processedXData;
+            delete anySeries.processedYData;
+            delete anySeries.xIncrement;
+            for (var i = 0, iEnd = keys.length; i < iEnd; ++i) {
+                key = keys[i];
+                anySeries["".concat(key, "Data")] = [];
+            }
+            for (var i = 0, iEnd = oldData.length; i < iEnd; ++i) {
+                if (oldData[i] && (oldData[i].destroy)) {
+                    oldData[i].destroy();
+                }
+            }
+            if (xAxis) {
+                xAxis.minRange = xAxis.userMinRange;
+            }
+        }
+        var column, failure = false, indexAsX = false;
+        for (var i = 0, iEnd = keys.length; i < iEnd; ++i) {
+            key = keys[i];
+            column = table.getColumn(key, true);
+            if (!column) {
+                if (key === 'x') {
+                    indexAsX = true;
+                    continue;
+                }
+                else {
+                    failure = true;
+                    break;
+                }
+            }
+            anySeries["".concat(key, "Data")] = column;
+        }
+        if (failure) {
+            // fallback to index
+            var columnNames = table.getColumnNames(), emptyColumn = [];
+            emptyColumn.length = rowCount;
+            var columnOffset = 0;
+            if (columnNames.length === keys.length - 1) {
+                // table index becomes x
+                columnOffset = 1;
+                indexAsX = true;
+            }
+            for (var i = columnOffset, iEnd = keys.length; i < iEnd; ++i) {
+                column = table.getColumn(columnNames[i], true);
+                key = keys[i];
+                anySeries["".concat(key, "Data")] = column || emptyColumn.slice();
+            }
+        }
+        this.indexAsX = indexAsX;
+        if (indexAsX && keys.indexOf('x') !== -1) {
+            column = [];
+            for (var x = 0; x < rowCount; ++x) {
+                column.push(series.autoIncrement());
+            }
+            anySeries.xData = column;
+        }
+        this.syncOff();
+        this.table = table;
+        if (redraw) {
+            this.syncOn();
+        }
+        this.processTable(redraw, oldData && animation);
+    };
+    /**
+     * Stops synchronisation of table changes with series.
+     * @private
+     */
+    DataSeriesAdditions.prototype.syncOff = function () {
+        var unlisteners = this.unlisteners;
+        for (var i = 0, iEnd = unlisteners.length; i < iEnd; ++i) {
+            unlisteners[i]();
+        }
+        unlisteners.length = 0;
+    };
+    /**
+     * Activates synchronization of table changes with series.
+     * @private
+     */
+    DataSeriesAdditions.prototype.syncOn = function () {
+        var _this = this;
+        if (this.unlisteners.length) {
+            return;
+        }
+        var series = this.series, table = this.table, anySeries = series, onChange = function (e) {
+            if (e.type === 'afterDeleteColumns') {
+                // deletion affects all points
+                _this.setTable(table, true);
+                return;
+            }
+            if (e.type === 'afterDeleteRows') {
+                if (e.rowIndex > 0 &&
+                    e.rowIndex + e.rowCount < series.points.length) {
+                    // deletion affects trailing points
+                    _this.setTable(table, true);
+                    return;
+                }
+                for (var i = e.rowIndex, iEnd = i + e.rowCount; i < iEnd; ++i) {
+                    series.removePoint(i, false);
+                }
+            }
+            if (_this.indexAsX) {
+                if (e.type === 'afterSetCell') {
+                    anySeries.xData[e.rowIndex] = e.rowIndex;
+                }
+                else if (e.type === 'afterSetRows') {
+                    for (var i = e.rowIndex, iEnd = i + e.rowCount; i < iEnd; ++i) {
+                        anySeries.xData[i] = series.autoIncrement();
+                    }
+                }
+            }
+            _this.processTable(true);
+        };
+        this.unlisteners.push(table.on('afterDeleteColumns', onChange), table.on('afterDeleteRows', onChange), table.on('afterSetCell', onChange), table.on('afterSetRows', onChange));
+    };
+    return DataSeriesAdditions;
+}());
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default DataSeriesAdditions;
+/* *
+ *
+ *  API Options
+ *
+ * */
+/**
+ * Indicates data is structured as columns instead of rows.
+ *
+ * @type      {boolean}
+ * @requires  es-modules/Data/DataSeriesComposition.js
+ * @apioption plotOptions.series.dataAsColumns
+ */
+(''); // keeps doclets above in JS file

package/es-modules/Data/DataSeriesConverter.js

@@ -1,6 +1,6 @@
 /* *
  *
- *  (c) 2020-2021 Highsoft AS
+ *  (c) 2020-2022 Highsoft AS
  *
  *  License: www.highcharts.com/license
  *

package/es-modules/Data/DataTable.js

@@ -1,6 +1,6 @@
 /* *
  *
- *  (c) 2020-2021 Highsoft AS
+ *  (c) 2020-2022 Highsoft AS
  *
  *  License: www.highcharts.com/license
  *
@@ -579,7 +579,7 @@ var DataTable = /** @class */ (function () {
      * @function Highcharts.DataTable#getRow
      *
      * @param {number} rowIndex
-     * Row index.
+     * Row index to retrieve. First row has index 0.
      *
      * @param {Array<string>} [columnNamesOrAliases]
      * Column names or aliases in order to retrieve.

package/es-modules/Data/Modifiers/ChainModifier.js

@@ -1,6 +1,6 @@
 /* *
  *
- *  (c) 2020-2021 Highsoft AS
+ *  (c) 2020-2022 Highsoft AS
  *
  *  License: www.highcharts.com/license
  *

package/es-modules/Data/Modifiers/DataModifier.js

@@ -1,6 +1,6 @@
 /* *
  *
- *  (c) 2020-2021 Highsoft AS
+ *  (c) 2020-2022 Highsoft AS
  *
  *  License: www.highcharts.com/license
  *

package/es-modules/Data/Modifiers/GroupModifier.js

@@ -1,6 +1,6 @@
 /* *
  *
- *  (c) 2020-2021 Highsoft AS
+ *  (c) 2020-2022 Highsoft AS
  *
  *  License: www.highcharts.com/license
  *

package/es-modules/Data/Modifiers/InvertModifier.js

@@ -1,6 +1,6 @@
 /* *
  *
- *  (c) 2020-2021 Highsoft AS
+ *  (c) 2020-2022 Highsoft AS
  *
  *  License: www.highcharts.com/license
  *

package/es-modules/Data/Modifiers/RangeModifier.js

@@ -1,6 +1,6 @@
 /* *
  *
- *  (c) 2020-2021 Highsoft AS
+ *  (c) 2020-2022 Highsoft AS
  *
  *  License: www.highcharts.com/license
  *