ps-toolkit-ui 0.0.212 → 0.0.216

package/src/assets/plugins/highcharts/code/es-modules/Core/Axis/GridAxis.js

@@ -1,1046 +0,0 @@
-/* *
- *
- *  (c) 2016 Highsoft AS
- *  Authors: Lars A. V. Cabrera
- *
- *  License: www.highcharts.com/license
- *
- *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
- *
- * */
-'use strict';
-import Axis from './Axis.js';
-import AxisDefaults from './AxisDefaults.js';
-import H from '../Globals.js';
-var dateFormats = H.dateFormats;
-import U from '../Utilities.js';
-var addEvent = U.addEvent, defined = U.defined, erase = U.erase, find = U.find, isArray = U.isArray, isNumber = U.isNumber, merge = U.merge, pick = U.pick, timeUnits = U.timeUnits, wrap = U.wrap;
-/* *
- *
- *  Functions
- *
- * */
-/* eslint-disable require-jsdoc */
-function argsToArray(args) {
-    return Array.prototype.slice.call(args, 1);
-}
-function isObject(x) {
-    // Always use strict mode
-    return U.isObject(x, true);
-}
-function applyGridOptions(axis) {
-    var options = axis.options;
-    // Center-align by default
-    /*
-    if (!options.labels) {
-        options.labels = {};
-    }
-    */
-    options.labels.align = pick(options.labels.align, 'center');
-    // @todo: Check against tickLabelPlacement between/on etc
-    /* Prevents adding the last tick label if the axis is not a category
-       axis.
-       Since numeric labels are normally placed at starts and ends of a
-       range of value, and this module makes the label point at the value,
-       an "extra" label would appear. */
-    if (!axis.categories) {
-        options.showLastLabel = false;
-    }
-    // Prevents rotation of labels when squished, as rotating them would not
-    // help.
-    axis.labelRotation = 0;
-    options.labels.rotation = 0;
-}
-/**
- * Axis with grid support.
- * @private
- */
-var GridAxis;
-(function (GridAxis) {
-    /* *
-     *
-     *  Declarations
-     *
-     * */
-    /**
-     * Enum for which side the axis is on. Maps to axis.side.
-     * @private
-     */
-    var Side;
-    (function (Side) {
-        Side[Side["top"] = 0] = "top";
-        Side[Side["right"] = 1] = "right";
-        Side[Side["bottom"] = 2] = "bottom";
-        Side[Side["left"] = 3] = "left";
-    })(Side = GridAxis.Side || (GridAxis.Side = {}));
-    /* *
-     *
-     *  Functions
-     *
-     * */
-    /* eslint-disable valid-jsdoc */
-    /**
-     * Extends axis class with grid support.
-     * @private
-     */
-    function compose(AxisClass, ChartClass, TickClass) {
-        if (AxisClass.keepProps.indexOf('grid') === -1) {
-            AxisClass.keepProps.push('grid');
-            AxisClass.prototype.getMaxLabelDimensions = getMaxLabelDimensions;
-            wrap(AxisClass.prototype, 'unsquish', wrapUnsquish);
-            // Add event handlers
-            addEvent(AxisClass, 'init', onInit);
-            addEvent(AxisClass, 'afterGetOffset', onAfterGetOffset);
-            addEvent(AxisClass, 'afterGetTitlePosition', onAfterGetTitlePosition);
-            addEvent(AxisClass, 'afterInit', onAfterInit);
-            addEvent(AxisClass, 'afterRender', onAfterRender);
-            addEvent(AxisClass, 'afterSetAxisTranslation', onAfterSetAxisTranslation);
-            addEvent(AxisClass, 'afterSetOptions', onAfterSetOptions);
-            addEvent(AxisClass, 'afterSetOptions', onAfterSetOptions2);
-            addEvent(AxisClass, 'afterSetScale', onAfterSetScale);
-            addEvent(AxisClass, 'afterTickSize', onAfterTickSize);
-            addEvent(AxisClass, 'trimTicks', onTrimTicks);
-            addEvent(AxisClass, 'destroy', onDestroy);
-        }
-        addEvent(ChartClass, 'afterSetChartSize', onChartAfterSetChartSize);
-        addEvent(TickClass, 'afterGetLabelPosition', onTickAfterGetLabelPosition);
-        addEvent(TickClass, 'labelFormat', onTickLabelFormat);
-        return AxisClass;
-    }
-    GridAxis.compose = compose;
-    /**
-     * Get the largest label width and height.
-     *
-     * @private
-     * @function Highcharts.Axis#getMaxLabelDimensions
-     *
-     * @param {Highcharts.Dictionary<Highcharts.Tick>} ticks
-     * All the ticks on one axis.
-     *
-     * @param {Array<number|string>} tickPositions
-     * All the tick positions on one axis.
-     *
-     * @return {Highcharts.SizeObject}
-     * Object containing the properties height and width.
-     *
-     * @todo Move this to the generic axis implementation, as it is used there.
-     */
-    function getMaxLabelDimensions(ticks, tickPositions) {
-        var dimensions = {
-            width: 0,
-            height: 0
-        };
-        tickPositions.forEach(function (pos) {
-            var tick = ticks[pos];
-            var labelHeight = 0, labelWidth = 0, label;
-            if (isObject(tick)) {
-                label = isObject(tick.label) ? tick.label : {};
-                // Find width and height of label
-                labelHeight = label.getBBox ? label.getBBox().height : 0;
-                if (label.textStr && !isNumber(label.textPxLength)) {
-                    label.textPxLength = label.getBBox().width;
-                }
-                labelWidth = isNumber(label.textPxLength) ?
-                    // Math.round ensures crisp lines
-                    Math.round(label.textPxLength) :
-                    0;
-                if (label.textStr) {
-                    // Set the tickWidth same as the label width after ellipsis
-                    // applied #10281
-                    labelWidth = Math.round(label.getBBox().width);
-                }
-                // Update the result if width and/or height are larger
-                dimensions.height = Math.max(labelHeight, dimensions.height);
-                dimensions.width = Math.max(labelWidth, dimensions.width);
-            }
-        });
-        // For tree grid, add indentation
-        if (this.options.type === 'treegrid' &&
-            this.treeGrid &&
-            this.treeGrid.mapOfPosToGridNode) {
-            var treeDepth = this.treeGrid.mapOfPosToGridNode[-1].height || 0;
-            dimensions.width += (this.options.labels.indentation *
-                (treeDepth - 1));
-        }
-        return dimensions;
-    }
-    /**
-     * Handle columns and getOffset.
-     * @private
-     */
-    function onAfterGetOffset() {
-        var grid = this.grid;
-        (grid && grid.columns || []).forEach(function (column) {
-            column.getOffset();
-        });
-    }
-    /**
-     * @private
-     */
-    function onAfterGetTitlePosition(e) {
-        var axis = this;
-        var options = axis.options;
-        var gridOptions = options.grid || {};
-        if (gridOptions.enabled === true) {
-            // compute anchor points for each of the title align options
-            var axisTitle = axis.axisTitle, axisHeight = axis.height, horiz = axis.horiz, axisLeft = axis.left, offset = axis.offset, opposite = axis.opposite, options_1 = axis.options, axisTop = axis.top, axisWidth = axis.width;
-            var tickSize = axis.tickSize();
-            var titleWidth = axisTitle && axisTitle.getBBox().width;
-            var xOption = options_1.title.x;
-            var yOption = options_1.title.y;
-            var titleMargin = pick(options_1.title.margin, horiz ? 5 : 10);
-            var titleFontSize = axis.chart.renderer.fontMetrics(options_1.title.style.fontSize, axisTitle).f;
-            var crispCorr = tickSize ? tickSize[0] / 2 : 0;
-            // TODO account for alignment
-            // the position in the perpendicular direction of the axis
-            var offAxis = ((horiz ? axisTop + axisHeight : axisLeft) +
-                (horiz ? 1 : -1) * // horizontal axis reverses the margin
-                    (opposite ? -1 : 1) * // so does opposite axes
-                    crispCorr +
-                (axis.side === GridAxis.Side.bottom ? titleFontSize : 0));
-            e.titlePosition.x = horiz ?
-                axisLeft - (titleWidth || 0) / 2 - titleMargin + xOption :
-                offAxis + (opposite ? axisWidth : 0) + offset + xOption;
-            e.titlePosition.y = horiz ?
-                (offAxis -
-                    (opposite ? axisHeight : 0) +
-                    (opposite ? titleFontSize : -titleFontSize) / 2 +
-                    offset +
-                    yOption) :
-                axisTop - titleMargin + yOption;
-        }
-    }
-    /**
-     * @private
-     */
-    function onAfterInit() {
-        var axis = this;
-        var chart = axis.chart, _a = axis.options.grid, gridOptions = _a === void 0 ? {} : _a, userOptions = axis.userOptions;
-        if (gridOptions.enabled) {
-            applyGridOptions(axis);
-        }
-        if (gridOptions.columns) {
-            var columns = axis.grid.columns = [];
-            var columnIndex = axis.grid.columnIndex = 0;
-            // Handle columns, each column is a grid axis
-            while (++columnIndex < gridOptions.columns.length) {
-                var columnOptions = merge(userOptions, gridOptions.columns[gridOptions.columns.length - columnIndex - 1], {
-                    linkedTo: 0,
-                    // Force to behave like category axis
-                    type: 'category',
-                    // Disable by default the scrollbar on the grid axis
-                    scrollbar: {
-                        enabled: false
-                    }
-                });
-                delete columnOptions.grid.columns; // Prevent recursion
-                var column = new Axis(axis.chart, columnOptions);
-                column.grid.isColumn = true;
-                column.grid.columnIndex = columnIndex;
-                // Remove column axis from chart axes array, and place it
-                // in the columns array.
-                erase(chart.axes, column);
-                erase(chart[axis.coll], column);
-                columns.push(column);
-            }
-        }
-    }
-    /**
-     * Draw an extra line on the far side of the outermost axis,
-     * creating floor/roof/wall of a grid. And some padding.
-     * ```
-     * Make this:
-     *             (axis.min) __________________________ (axis.max)
-     *                           |    |    |    |    |
-     * Into this:
-     *             (axis.min) __________________________ (axis.max)
-     *                        ___|____|____|____|____|__
-     * ```
-     * @private
-     */
-    function onAfterRender() {
-        var axis = this, grid = axis.grid, options = axis.options, gridOptions = options.grid || {};
-        if (gridOptions.enabled === true) {
-            var min = axis.min || 0, max = axis.max || 0;
-            // @todo acutual label padding (top, bottom, left, right)
-            axis.maxLabelDimensions = axis.getMaxLabelDimensions(axis.ticks, axis.tickPositions);
-            // Remove right wall before rendering if updating
-            if (axis.rightWall) {
-                axis.rightWall.destroy();
-            }
-            /*
-            Draw an extra axis line on outer axes
-                        >
-            Make this:    |______|______|______|___
-
-                        > _________________________
-            Into this:    |______|______|______|__|
-                                                    */
-            if (axis.grid && axis.grid.isOuterAxis() && axis.axisLine) {
-                var lineWidth = options.lineWidth;
-                if (lineWidth) {
-                    var linePath = axis.getLinePath(lineWidth), startPoint = linePath[0], endPoint = linePath[1], 
-                    // Negate distance if top or left axis
-                    // Subtract 1px to draw the line at the end of the tick
-                    tickLength = (axis.tickSize('tick') || [1])[0], distance = (tickLength - 1) * ((axis.side === GridAxis.Side.top ||
-                        axis.side === GridAxis.Side.left) ? -1 : 1);
-                    // If axis is horizontal, reposition line path vertically
-                    if (startPoint[0] === 'M' && endPoint[0] === 'L') {
-                        if (axis.horiz) {
-                            startPoint[2] += distance;
-                            endPoint[2] += distance;
-                        }
-                        else {
-                            startPoint[1] += distance;
-                            endPoint[1] += distance;
-                        }
-                    }
-                    // If it doesn't exist, add an upper and lower border
-                    // for the vertical grid axis.
-                    if (!axis.horiz && axis.chart.marginRight) {
-                        var upperBorderStartPoint = startPoint, upperBorderEndPoint = [
-                            'L',
-                            axis.left,
-                            startPoint[2] || 0
-                        ], upperBorderPath = [
-                            upperBorderStartPoint,
-                            upperBorderEndPoint
-                        ], lowerBorderEndPoint = [
-                            'L',
-                            axis.chart.chartWidth - axis.chart.marginRight,
-                            axis.toPixels(max + axis.tickmarkOffset)
-                        ], lowerBorderStartPoint = [
-                            'M',
-                            endPoint[1] || 0,
-                            axis.toPixels(max + axis.tickmarkOffset)
-                        ], lowerBorderPath = [
-                            lowerBorderStartPoint,
-                            lowerBorderEndPoint
-                        ];
-                        if (!axis.grid.upperBorder && min % 1 !== 0) {
-                            axis.grid.upperBorder = axis.grid.renderBorder(upperBorderPath);
-                        }
-                        if (axis.grid.upperBorder) {
-                            axis.grid.upperBorder.attr({
-                                stroke: options.lineColor,
-                                'stroke-width': options.lineWidth
-                            });
-                            axis.grid.upperBorder.animate({
-                                d: upperBorderPath
-                            });
-                        }
-                        if (!axis.grid.lowerBorder && max % 1 !== 0) {
-                            axis.grid.lowerBorder = axis.grid.renderBorder(lowerBorderPath);
-                        }
-                        if (axis.grid.lowerBorder) {
-                            axis.grid.lowerBorder.attr({
-                                stroke: options.lineColor,
-                                'stroke-width': options.lineWidth
-                            });
-                            axis.grid.lowerBorder.animate({
-                                d: lowerBorderPath
-                            });
-                        }
-                    }
-                    // Render an extra line parallel to the existing axes, to
-                    // close the grid.
-                    if (!axis.grid.axisLineExtra) {
-                        axis.grid.axisLineExtra = axis.grid.renderBorder(linePath);
-                    }
-                    else {
-                        axis.grid.axisLineExtra.attr({
-                            stroke: options.lineColor,
-                            'stroke-width': options.lineWidth
-                        });
-                        axis.grid.axisLineExtra.animate({
-                            d: linePath
-                        });
-                    }
-                    // show or hide the line depending on options.showEmpty
-                    axis.axisLine[axis.showAxis ? 'show' : 'hide'](true);
-                }
-            }
-            (grid && grid.columns || []).forEach(function (column) {
-                column.render();
-            });
-            // Manipulate the tick mark visibility
-            // based on the axis.max- allows smooth scrolling.
-            if (!axis.horiz &&
-                axis.chart.hasRendered &&
-                (axis.scrollbar ||
-                    (axis.linkedParent && axis.linkedParent.scrollbar))) {
-                var tickmarkOffset = axis.tickmarkOffset, lastTick = axis.tickPositions[axis.tickPositions.length - 1], firstTick = axis.tickPositions[0];
-                var label = void 0;
-                while ((label = axis.hiddenLabels.pop()) && label.element) {
-                    label.show(); // #15453
-                }
-                // Hide/show firts tick label.
-                label = axis.ticks[firstTick].label;
-                if (label) {
-                    if (min - firstTick > tickmarkOffset) {
-                        axis.hiddenLabels.push(label.hide());
-                    }
-                    else {
-                        label.show();
-                    }
-                }
-                // Hide/show last tick mark/label.
-                label = axis.ticks[lastTick].label;
-                if (label) {
-                    if (lastTick - max > tickmarkOffset) {
-                        axis.hiddenLabels.push(label.hide());
-                    }
-                    else {
-                        label.show();
-                    }
-                }
-                var mark = axis.ticks[lastTick].mark;
-                if (mark) {
-                    if (lastTick - max < tickmarkOffset &&
-                        lastTick - max > 0 && axis.ticks[lastTick].isLast) {
-                        mark.hide();
-                    }
-                    else if (axis.ticks[lastTick - 1]) {
-                        mark.show();
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * @private
-     */
-    function onAfterSetAxisTranslation() {
-        var axis = this;
-        var tickInfo = axis.tickPositions && axis.tickPositions.info;
-        var options = axis.options;
-        var gridOptions = options.grid || {};
-        var userLabels = axis.userOptions.labels || {};
-        // Fire this only for the Gantt type chart, #14868.
-        if (gridOptions.enabled) {
-            if (axis.horiz) {
-                axis.series.forEach(function (series) {
-                    series.options.pointRange = 0;
-                });
-                // Lower level time ticks, like hours or minutes, represent
-                // points in time and not ranges. These should be aligned
-                // left in the grid cell by default. The same applies to
-                // years of higher order.
-                if (tickInfo &&
-                    options.dateTimeLabelFormats &&
-                    options.labels &&
-                    !defined(userLabels.align) &&
-                    (options.dateTimeLabelFormats[tickInfo.unitName]
-                        .range === false ||
-                        tickInfo.count > 1 // years
-                    )) {
-                    options.labels.align = 'left';
-                    if (!defined(userLabels.x)) {
-                        options.labels.x = 3;
-                    }
-                }
-            }
-            else {
-                // Don't trim ticks which not in min/max range but
-                // they are still in the min/max plus tickInterval.
-                if (this.options.type !== 'treegrid' &&
-                    axis.grid &&
-                    axis.grid.columns) {
-                    this.minPointOffset = this.tickInterval;
-                }
-            }
-        }
-    }
-    /**
-     * Creates a left and right wall on horizontal axes:
-     * - Places leftmost tick at the start of the axis, to create a left
-     *   wall
-     * - Ensures that the rightmost tick is at the end of the axis, to
-     *   create a right wall.
-     * @private
-     */
-    function onAfterSetOptions(e) {
-        var options = this.options, userOptions = e.userOptions, gridOptions = ((options && isObject(options.grid)) ? options.grid : {});
-        var gridAxisOptions;
-        if (gridOptions.enabled === true) {
-            // Merge the user options into default grid axis options so
-            // that when a user option is set, it takes presedence.
-            gridAxisOptions = merge(true, {
-                className: ('highcharts-grid-axis ' + (userOptions.className || '')),
-                dateTimeLabelFormats: {
-                    hour: {
-                        list: ['%H:%M', '%H']
-                    },
-                    day: {
-                        list: ['%A, %e. %B', '%a, %e. %b', '%E']
-                    },
-                    week: {
-                        list: ['Week %W', 'W%W']
-                    },
-                    month: {
-                        list: ['%B', '%b', '%o']
-                    }
-                },
-                grid: {
-                    borderWidth: 1
-                },
-                labels: {
-                    padding: 2,
-                    style: {
-                        fontSize: '13px'
-                    }
-                },
-                margin: 0,
-                title: {
-                    text: null,
-                    reserveSpace: false,
-                    rotation: 0
-                },
-                // In a grid axis, only allow one unit of certain types,
-                // for example we shouln't have one grid cell spanning
-                // two days.
-                units: [[
-                        'millisecond',
-                        [1, 10, 100]
-                    ], [
-                        'second',
-                        [1, 10]
-                    ], [
-                        'minute',
-                        [1, 5, 15]
-                    ], [
-                        'hour',
-                        [1, 6]
-                    ], [
-                        'day',
-                        [1]
-                    ], [
-                        'week',
-                        [1]
-                    ], [
-                        'month',
-                        [1]
-                    ], [
-                        'year',
-                        null
-                    ]]
-            }, userOptions);
-            // X-axis specific options
-            if (this.coll === 'xAxis') {
-                // For linked axes, tickPixelInterval is used only if
-                // the tickPositioner below doesn't run or returns
-                // undefined (like multiple years)
-                if (defined(userOptions.linkedTo) &&
-                    !defined(userOptions.tickPixelInterval)) {
-                    gridAxisOptions.tickPixelInterval = 350;
-                }
-                // For the secondary grid axis, use the primary axis'
-                // tick intervals and return ticks one level higher.
-                if (
-                // Check for tick pixel interval in options
-                !defined(userOptions.tickPixelInterval) &&
-                    // Only for linked axes
-                    defined(userOptions.linkedTo) &&
-                    !defined(userOptions.tickPositioner) &&
-                    !defined(userOptions.tickInterval)) {
-                    gridAxisOptions.tickPositioner = function (min, max) {
-                        var parentInfo = (this.linkedParent &&
-                            this.linkedParent.tickPositions &&
-                            this.linkedParent.tickPositions.info);
-                        if (parentInfo) {
-                            var units = (gridAxisOptions.units || []);
-                            var unitIdx = void 0, count = void 0, unitName = void 0;
-                            for (var i = 0; i < units.length; i++) {
-                                if (units[i][0] ===
-                                    parentInfo.unitName) {
-                                    unitIdx = i;
-                                    break;
-                                }
-                            }
-                            // Get the first allowed count on the next
-                            // unit.
-                            if (units[unitIdx + 1]) {
-                                unitName = units[unitIdx + 1][0];
-                                count =
-                                    (units[unitIdx + 1][1] || [1])[0];
-                                // In case the base X axis shows years, make
-                                // the secondary axis show ten times the
-                                // years (#11427)
-                            }
-                            else if (parentInfo.unitName === 'year') {
-                                unitName = 'year';
-                                count = parentInfo.count * 10;
-                            }
-                            var unitRange = timeUnits[unitName];
-                            this.tickInterval = unitRange * count;
-                            return this.getTimeTicks({
-                                unitRange: unitRange,
-                                count: count,
-                                unitName: unitName
-                            }, min, max, this.options.startOfWeek);
-                        }
-                    };
-                }
-            }
-            // Now merge the combined options into the axis options
-            merge(true, this.options, gridAxisOptions);
-            if (this.horiz) {
-                /*               _________________________
-                Make this:    ___|_____|_____|_____|__|
-                                ^                     ^
-                                _________________________
-                Into this:    |_____|_____|_____|_____|
-                                    ^                 ^    */
-                options.minPadding = pick(userOptions.minPadding, 0);
-                options.maxPadding = pick(userOptions.maxPadding, 0);
-            }
-            // If borderWidth is set, then use its value for tick and
-            // line width.
-            if (isNumber(options.grid.borderWidth)) {
-                options.tickWidth = options.lineWidth =
-                    gridOptions.borderWidth;
-            }
-        }
-    }
-    /**
-     * @private
-     */
-    function onAfterSetOptions2(e) {
-        var axis = this;
-        var userOptions = e.userOptions;
-        var gridOptions = userOptions && userOptions.grid || {};
-        var columns = gridOptions.columns;
-        // Add column options to the parent axis. Children has their column
-        // options set on init in onGridAxisAfterInit.
-        if (gridOptions.enabled && columns) {
-            merge(true, axis.options, columns[columns.length - 1]);
-        }
-    }
-    /**
-     * Handle columns and setScale.
-     * @private
-     */
-    function onAfterSetScale() {
-        var axis = this;
-        (axis.grid.columns || []).forEach(function (column) {
-            column.setScale();
-        });
-    }
-    /**
-     * Draw vertical axis ticks extra long to create cell floors and roofs.
-     * Overrides the tickLength for vertical axes.
-     * @private
-     */
-    function onAfterTickSize(e) {
-        var defaultLeftAxisOptions = AxisDefaults.defaultLeftAxisOptions;
-        var _a = this, horiz = _a.horiz, maxLabelDimensions = _a.maxLabelDimensions, _b = _a.options.grid, gridOptions = _b === void 0 ? {} : _b;
-        if (gridOptions.enabled && maxLabelDimensions) {
-            var labelPadding = (Math.abs(defaultLeftAxisOptions.labels.x) * 2);
-            var distance = horiz ?
-                (gridOptions.cellHeight ||
-                    labelPadding + maxLabelDimensions.height) :
-                labelPadding + maxLabelDimensions.width;
-            if (isArray(e.tickSize)) {
-                e.tickSize[0] = distance;
-            }
-            else {
-                e.tickSize = [distance, 0];
-            }
-        }
-    }
-    /**
-     * @private
-     */
-    function onChartAfterSetChartSize() {
-        this.axes.forEach(function (axis) {
-            (axis.grid && axis.grid.columns || []).forEach(function (column) {
-                column.setAxisSize();
-                column.setAxisTranslation();
-            });
-        });
-    }
-    /**
-     * @private
-     */
-    function onDestroy(e) {
-        var grid = this.grid;
-        (grid.columns || []).forEach(function (column) {
-            column.destroy(e.keepEvents);
-        });
-        grid.columns = void 0;
-    }
-    /**
-     * Wraps axis init to draw cell walls on vertical axes.
-     * @private
-     */
-    function onInit(e) {
-        var axis = this;
-        var userOptions = e.userOptions || {};
-        var gridOptions = userOptions.grid || {};
-        if (gridOptions.enabled && defined(gridOptions.borderColor)) {
-            userOptions.tickColor = userOptions.lineColor = (gridOptions.borderColor);
-        }
-        if (!axis.grid) {
-            axis.grid = new Additions(axis);
-        }
-        axis.hiddenLabels = [];
-    }
-    /**
-     * Center tick labels in cells.
-     * @private
-     */
-    function onTickAfterGetLabelPosition(e) {
-        var tick = this, label = tick.label, axis = tick.axis, reversed = axis.reversed, chart = axis.chart, options = axis.options, gridOptions = options.grid || {}, labelOpts = axis.options.labels, align = labelOpts.align, 
-        // verticalAlign is currently not supported for axis.labels.
-        verticalAlign = 'middle', // labelOpts.verticalAlign,
-        side = GridAxis.Side[axis.side], tickmarkOffset = e.tickmarkOffset, tickPositions = axis.tickPositions, tickPos = tick.pos - tickmarkOffset, nextTickPos = (isNumber(tickPositions[e.index + 1]) ?
-            tickPositions[e.index + 1] - tickmarkOffset :
-            (axis.max || 0) + tickmarkOffset), tickSize = axis.tickSize('tick'), tickWidth = tickSize ? tickSize[0] : 0, crispCorr = tickSize ? tickSize[1] / 2 : 0;
-        var labelHeight, lblMetrics, lines, bottom, top, left, right;
-        // Only center tick labels in grid axes
-        if (gridOptions.enabled === true) {
-            // Calculate top and bottom positions of the cell.
-            if (side === 'top') {
-                bottom = axis.top + axis.offset;
-                top = bottom - tickWidth;
-            }
-            else if (side === 'bottom') {
-                top = chart.chartHeight - axis.bottom + axis.offset;
-                bottom = top + tickWidth;
-            }
-            else {
-                bottom = axis.top + axis.len - (axis.translate(reversed ? nextTickPos : tickPos) || 0);
-                top = axis.top + axis.len - (axis.translate(reversed ? tickPos : nextTickPos) || 0);
-            }
-            // Calculate left and right positions of the cell.
-            if (side === 'right') {
-                left = chart.chartWidth - axis.right + axis.offset;
-                right = left + tickWidth;
-            }
-            else if (side === 'left') {
-                right = axis.left + axis.offset;
-                left = right - tickWidth;
-            }
-            else {
-                left = Math.round(axis.left + (axis.translate(reversed ? nextTickPos : tickPos) || 0)) - crispCorr;
-                right = Math.min(// #15742
-                Math.round(axis.left + (axis.translate(reversed ? tickPos : nextTickPos) || 0)) - crispCorr, axis.left + axis.len);
-            }
-            tick.slotWidth = right - left;
-            // Calculate the positioning of the label based on
-            // alignment.
-            e.pos.x = (align === 'left' ?
-                left :
-                align === 'right' ?
-                    right :
-                    left + ((right - left) / 2) // default to center
-            );
-            e.pos.y = (verticalAlign === 'top' ?
-                top :
-                verticalAlign === 'bottom' ?
-                    bottom :
-                    top + ((bottom - top) / 2) // default to middle
-            );
-            lblMetrics = chart.renderer.fontMetrics(labelOpts.style.fontSize, label && label.element);
-            labelHeight = label ? label.getBBox().height : 0;
-            // Adjustment to y position to align the label correctly.
-            // Would be better to have a setter or similar for this.
-            if (!labelOpts.useHTML) {
-                lines = Math.round(labelHeight / lblMetrics.h);
-                e.pos.y += (
-                // Center the label
-                // TODO: why does this actually center the label?
-                ((lblMetrics.b - (lblMetrics.h - lblMetrics.f)) / 2) +
-                    // Adjust for height of additional lines.
-                    -(((lines - 1) * lblMetrics.h) / 2));
-            }
-            else {
-                e.pos.y += (
-                // Readjust yCorr in htmlUpdateTransform
-                lblMetrics.b +
-                    // Adjust for height of html label
-                    -(labelHeight / 2));
-            }
-            e.pos.x += (axis.horiz && labelOpts.x) || 0;
-        }
-    }
-    /**
-     * @private
-     */
-    function onTickLabelFormat(ctx) {
-        var axis = ctx.axis, value = ctx.value;
-        if (axis.options.grid &&
-            axis.options.grid.enabled) {
-            var tickPos = axis.tickPositions;
-            var series = (axis.linkedParent || axis).series[0];
-            var isFirst = value === tickPos[0];
-            var isLast = value === tickPos[tickPos.length - 1];
-            var point = series && find(series.options.data, function (p) {
-                return p[axis.isXAxis ? 'x' : 'y'] === value;
-            });
-            var pointCopy = void 0;
-            if (point && series.is('gantt')) {
-                // For the Gantt set point aliases to the pointCopy
-                // to do not change the original point
-                pointCopy = merge(point);
-                H.seriesTypes.gantt.prototype.pointClass
-                    .setGanttPointAliases(pointCopy);
-            }
-            // Make additional properties available for the
-            // formatter
-            ctx.isFirst = isFirst;
-            ctx.isLast = isLast;
-            ctx.point = pointCopy;
-        }
-    }
-    /**
-     * Makes tick labels which are usually ignored in a linked axis
-     * displayed if they are within range of linkedParent.min.
-     * ```
-     *                        _____________________________
-     *                        |   |       |       |       |
-     * Make this:             |   |   2   |   3   |   4   |
-     *                        |___|_______|_______|_______|
-     *                          ^
-     *                        _____________________________
-     *                        |   |       |       |       |
-     * Into this:             | 1 |   2   |   3   |   4   |
-     *                        |___|_______|_______|_______|
-     *                          ^
-     * ```
-     * @private
-     * @todo Does this function do what the drawing says? Seems to affect
-     *       ticks and not the labels directly?
-     */
-    function onTrimTicks() {
-        var axis = this;
-        var options = axis.options;
-        var gridOptions = options.grid || {};
-        var categoryAxis = axis.categories;
-        var tickPositions = axis.tickPositions;
-        var firstPos = tickPositions[0];
-        var lastPos = tickPositions[tickPositions.length - 1];
-        var linkedMin = axis.linkedParent && axis.linkedParent.min;
-        var linkedMax = axis.linkedParent && axis.linkedParent.max;
-        var min = linkedMin || axis.min;
-        var max = linkedMax || axis.max;
-        var tickInterval = axis.tickInterval;
-        var endMoreThanMin = (firstPos < min &&
-            firstPos + tickInterval > min);
-        var startLessThanMax = (lastPos > max &&
-            lastPos - tickInterval < max);
-        if (gridOptions.enabled === true &&
-            !categoryAxis &&
-            (axis.horiz || axis.isLinked)) {
-            if (endMoreThanMin && !options.startOnTick) {
-                tickPositions[0] = min;
-            }
-            if (startLessThanMax && !options.endOnTick) {
-                tickPositions[tickPositions.length - 1] = max;
-            }
-        }
-    }
-    /**
-     * Avoid altering tickInterval when reserving space.
-     * @private
-     */
-    function wrapUnsquish(proceed) {
-        var axis = this;
-        var _a = axis.options.grid, gridOptions = _a === void 0 ? {} : _a;
-        if (gridOptions.enabled === true && axis.categories) {
-            return axis.tickInterval;
-        }
-        return proceed.apply(axis, argsToArray(arguments));
-    }
-    /* *
-     *
-     *  Class
-     *
-     * */
-    /**
-     * Additions for grid axes.
-     * @private
-     * @class
-     */
-    var Additions = /** @class */ (function () {
-        /* *
-        *
-        *  Constructors
-        *
-        * */
-        function Additions(axis) {
-            this.axis = axis;
-        }
-        /* *
-        *
-        *  Functions
-        *
-        * */
-        /**
-         * Checks if an axis is the outer axis in its dimension. Since
-         * axes are placed outwards in order, the axis with the highest
-         * index is the outermost axis.
-         *
-         * Example: If there are multiple x-axes at the top of the chart,
-         * this function returns true if the axis supplied is the last
-         * of the x-axes.
-         *
-         * @private
-         *
-         * @return {boolean}
-         * True if the axis is the outermost axis in its dimension; false if
-         * not.
-         */
-        Additions.prototype.isOuterAxis = function () {
-            var axis = this.axis;
-            var chart = axis.chart;
-            var columnIndex = axis.grid.columnIndex;
-            var columns = (axis.linkedParent && axis.linkedParent.grid.columns ||
-                axis.grid.columns);
-            var parentAxis = columnIndex ? axis.linkedParent : axis;
-            var thisIndex = -1, lastIndex = 0;
-            chart[axis.coll].forEach(function (otherAxis, index) {
-                if (otherAxis.side === axis.side &&
-                    !otherAxis.options.isInternal) {
-                    lastIndex = index;
-                    if (otherAxis === parentAxis) {
-                        // Get the index of the axis in question
-                        thisIndex = index;
-                    }
-                }
-            });
-            return (lastIndex === thisIndex &&
-                (isNumber(columnIndex) ?
-                    columns.length === columnIndex :
-                    true));
-        };
-        /**
-         * Add extra border based on the provided path.
-         * @private
-         * @param {SVGPath} path
-         * The path of the border.
-         * @return {Highcharts.SVGElement}
-         * Border
-         */
-        Additions.prototype.renderBorder = function (path) {
-            var axis = this.axis, renderer = axis.chart.renderer, options = axis.options, extraBorderLine = renderer.path(path)
-                .addClass('highcharts-axis-line')
-                .add(axis.axisBorder);
-            if (!renderer.styledMode) {
-                extraBorderLine.attr({
-                    stroke: options.lineColor,
-                    'stroke-width': options.lineWidth,
-                    zIndex: 7
-                });
-            }
-            return extraBorderLine;
-        };
-        return Additions;
-    }());
-    GridAxis.Additions = Additions;
-})(GridAxis || (GridAxis = {}));
-/* *
- *
- *  Registry
- *
- * */
-// First letter of the day of the week, e.g. 'M' for 'Monday'.
-dateFormats.E = function (timestamp) {
-    return this.dateFormat('%a', timestamp, true).charAt(0);
-};
-// Adds week date format
-dateFormats.W = function (timestamp) {
-    var d = new this.Date(timestamp);
-    var firstDay = (this.get('Day', d) + 6) % 7;
-    var thursday = new this.Date(d.valueOf());
-    this.set('Date', thursday, this.get('Date', d) - firstDay + 3);
-    var firstThursday = new this.Date(this.get('FullYear', thursday), 0, 1);
-    if (this.get('Day', firstThursday) !== 4) {
-        this.set('Month', d, 0);
-        this.set('Date', d, 1 + (11 - this.get('Day', firstThursday)) % 7);
-    }
-    return (1 +
-        Math.floor((thursday.valueOf() - firstThursday.valueOf()) / 604800000)).toString();
-};
-/* *
- *
- *  Default Export
- *
- * */
-export default GridAxis;
-/* *
- *
- *  API Options
- *
- * */
-/**
- * @productdesc {gantt}
- * For grid axes (like in Gantt charts),
- * it is possible to declare as a list to provide different
- * formats depending on available space.
- *
- * Defaults to:
- * ```js
- * {
- *     hour: { list: ['%H:%M', '%H'] },
- *     day: { list: ['%A, %e. %B', '%a, %e. %b', '%E'] },
- *     week: { list: ['Week %W', 'W%W'] },
- *     month: { list: ['%B', '%b', '%o'] }
- * }
- * ```
- *
- * @sample {gantt} gantt/grid-axis/date-time-label-formats
- *         Gantt chart with custom axis date format.
- *
- * @apioption xAxis.dateTimeLabelFormats
- */
-/**
- * Set grid options for the axis labels. Requires Highcharts Gantt.
- *
- * @since     6.2.0
- * @product   gantt
- * @apioption xAxis.grid
- */
-/**
- * Enable grid on the axis labels. Defaults to true for Gantt charts.
- *
- * @type      {boolean}
- * @default   true
- * @since     6.2.0
- * @product   gantt
- * @apioption xAxis.grid.enabled
- */
-/**
- * Set specific options for each column (or row for horizontal axes) in the
- * grid. Each extra column/row is its own axis, and the axis options can be set
- * here.
- *
- * @sample gantt/demo/left-axis-table
- *         Left axis as a table
- *
- * @type      {Array<Highcharts.XAxisOptions>}
- * @apioption xAxis.grid.columns
- */
-/**
- * Set border color for the label grid lines.
- *
- * @type      {Highcharts.ColorString}
- * @apioption xAxis.grid.borderColor
- */
-/**
- * Set border width of the label grid lines.
- *
- * @type      {number}
- * @default   1
- * @apioption xAxis.grid.borderWidth
- */
-/**
- * Set cell height for grid axis labels. By default this is calculated from font
- * size. This option only applies to horizontal axes.
- *
- * @sample gantt/grid-axis/cellheight
- *         Gant chart with custom cell height
- * @type      {number}
- * @apioption xAxis.grid.cellHeight
- */
-''; // keeps doclets above in JS file