@ntlab/ntjs-assets 2.0.21 → 2.0.22

package/assets/js/highcharts/es-modules/Series/AreaRange/AreaRangeSeriesDefaults.js

@@ -0,0 +1,273 @@
+/* *
+ *
+ *  (c) 2010-2024 Torstein Honsi
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+/* *
+ *
+ *  API Options
+ *
+ * */
+/**
+ * The area range series is a carteseian series with higher and lower values for
+ * each point along an X axis, where the area between the values is shaded.
+ *
+ * @sample {highcharts} highcharts/demo/arearange/
+ *         Area range chart
+ * @sample {highstock} stock/demo/arearange/
+ *         Area range chart
+ *
+ * @extends      plotOptions.area
+ * @product      highcharts highstock
+ * @excluding    stack, stacking
+ * @requires     highcharts-more
+ * @optionparent plotOptions.arearange
+ *
+ * @private
+ */
+const AreaRangeSeriesDefaults = {
+    /**
+     * @see [fillColor](#plotOptions.arearange.fillColor)
+     * @see [fillOpacity](#plotOptions.arearange.fillOpacity)
+     *
+     * @apioption plotOptions.arearange.color
+     */
+    /**
+     * @default   low
+     * @apioption plotOptions.arearange.colorKey
+     */
+    /**
+     * @see [color](#plotOptions.arearange.color)
+     * @see [fillOpacity](#plotOptions.arearange.fillOpacity)
+     *
+     * @apioption plotOptions.arearange.fillColor
+     */
+    /**
+     * @see [color](#plotOptions.arearange.color)
+     * @see [fillColor](#plotOptions.arearange.fillColor)
+     *
+     * @default   {highcharts} 0.75
+     * @default   {highstock} 0.75
+     * @apioption plotOptions.arearange.fillOpacity
+     */
+    /**
+     * Whether to apply a drop shadow to the graph line. Since 2.3 the
+     * shadow can be an object configuration containing `color`, `offsetX`,
+     * `offsetY`, `opacity` and `width`.
+     *
+     * @type      {boolean|Highcharts.ShadowOptionsObject}
+     * @product   highcharts
+     * @apioption plotOptions.arearange.shadow
+     */
+    /**
+     * Pixel width of the arearange graph line.
+     *
+     * @since 2.3.0
+     *
+     * @private
+     */
+    lineWidth: 1,
+    /**
+     * @type {number|null}
+     */
+    threshold: null,
+    tooltip: {
+        pointFormat: '<span style="color:{series.color}">\u25CF</span> ' +
+            '{series.name}: <b>{point.low}</b> - <b>{point.high}</b><br/>'
+    },
+    /**
+     * Whether the whole area or just the line should respond to mouseover
+     * tooltips and other mouse or touch events.
+     *
+     * @since 2.3.0
+     *
+     * @private
+     */
+    trackByArea: true,
+    /**
+     * Extended data labels for range series types. Range series data
+     * labels use no `x` and `y` options. Instead, they have `xLow`,
+     * `xHigh`, `yLow` and `yHigh` options to allow the higher and lower
+     * data label sets individually.
+     *
+     * @declare Highcharts.SeriesAreaRangeDataLabelsOptionsObject
+     * @exclude x, y
+     * @since   2.3.0
+     * @product highcharts highstock
+     *
+     * @private
+     */
+    dataLabels: {
+        align: void 0,
+        verticalAlign: void 0,
+        /**
+         * X offset of the lower data labels relative to the point value.
+         *
+         * @sample highcharts/plotoptions/arearange-datalabels/
+         *         Data labels on range series
+         * @sample highcharts/plotoptions/arearange-datalabels/
+         *         Data labels on range series
+         */
+        xLow: 0,
+        /**
+         * X offset of the higher data labels relative to the point value.
+         *
+         * @sample highcharts/plotoptions/arearange-datalabels/
+         *         Data labels on range series
+         */
+        xHigh: 0,
+        /**
+         * Y offset of the lower data labels relative to the point value.
+         *
+         * @sample highcharts/plotoptions/arearange-datalabels/
+         *         Data labels on range series
+         */
+        yLow: 0,
+        /**
+         * Y offset of the higher data labels relative to the point value.
+         *
+         * @sample highcharts/plotoptions/arearange-datalabels/
+         *         Data labels on range series
+         */
+        yHigh: 0
+    }
+};
+/**
+ * A `arearange` series. If the [type](#series.arearange.type) option is not
+ * specified, it is inherited from [chart.type](#chart.type).
+ *
+ *
+ * @extends   series,plotOptions.arearange
+ * @excluding dataParser, dataURL, stack, stacking
+ * @product   highcharts highstock
+ * @requires  highcharts-more
+ * @apioption series.arearange
+ */
+/**
+ * @see [fillColor](#series.arearange.fillColor)
+ * @see [fillOpacity](#series.arearange.fillOpacity)
+ *
+ * @apioption series.arearange.color
+ */
+/**
+ * An array of data points for the series. For the `arearange` series type,
+ * points can be given in the following ways:
+ *
+ * 1.  An array of arrays with 3 or 2 values. In this case, the values
+ *     correspond to `x,low,high`. If the first value is a string, it is
+ *     applied as the name of the point, and the `x` value is inferred.
+ *     The `x` value can also be omitted, in which case the inner arrays
+ *     should be of length 2\. Then the `x` value is automatically calculated,
+ *     either starting at 0 and incremented by 1, or from `pointStart`
+ *     and `pointInterval` given in the series options.
+ *     ```js
+ *     data: [
+ *         [0, 8, 3],
+ *         [1, 1, 1],
+ *         [2, 6, 8]
+ *     ]
+ *     ```
+ *
+ * 2.  An array of objects with named values. The following snippet shows only a
+ *     few settings, see the complete options set below. If the total number of
+ *     data points exceeds the series'
+ *     [turboThreshold](#series.arearange.turboThreshold),
+ *     this option is not available.
+ *     ```js
+ *     data: [{
+ *         x: 1,
+ *         low: 9,
+ *         high: 0,
+ *         name: "Point2",
+ *         color: "#00FF00"
+ *     }, {
+ *         x: 1,
+ *         low: 3,
+ *         high: 4,
+ *         name: "Point1",
+ *         color: "#FF00FF"
+ *     }]
+ *     ```
+ *
+ * @sample {highcharts} highcharts/series/data-array-of-arrays/
+ *         Arrays of numeric x and y
+ * @sample {highcharts} highcharts/series/data-array-of-arrays-datetime/
+ *         Arrays of datetime x and y
+ * @sample {highcharts} highcharts/series/data-array-of-name-value/
+ *         Arrays of point.name and y
+ * @sample {highcharts} highcharts/series/data-array-of-objects/
+ *         Config objects
+ *
+ * @type      {Array<Array<(number|string),number>|Array<(number|string),number,number>|*>}
+ * @extends   series.line.data
+ * @excluding marker, y
+ * @product   highcharts highstock
+ * @apioption series.arearange.data
+ */
+/**
+ * @extends   series.arearange.dataLabels
+ * @product   highcharts highstock
+ * @apioption series.arearange.data.dataLabels
+ */
+/**
+ * @see [color](#series.arearange.color)
+ * @see [fillOpacity](#series.arearange.fillOpacity)
+ *
+ * @apioption series.arearange.fillColor
+ */
+/**
+ * @see [color](#series.arearange.color)
+ * @see [fillColor](#series.arearange.fillColor)
+ *
+ * @default   {highcharts} 0.75
+ * @default   {highstock} 0.75
+ * @apioption series.arearange.fillOpacity
+ */
+/**
+ * Options for the lower markers of the arearange-like series. When `lowMarker`
+ * is not defined, options inherit form the marker.
+ *
+ * @see [marker](#series.arearange.marker)
+ *
+ * @declare   Highcharts.PointMarkerOptionsObject
+ * @extends   plotOptions.series.marker
+ * @default   undefined
+ * @product   highcharts highstock
+ * @apioption plotOptions.arearange.lowMarker
+ */
+/**
+ *
+ * @sample {highcharts} highcharts/series-arearange/lowmarker/
+ *         Area range chart with `lowMarker` option
+ *
+ * @declare   Highcharts.PointMarkerOptionsObject
+ * @extends   plotOptions.series.marker.symbol
+ * @product   highcharts highstock
+ * @apioption plotOptions.arearange.lowMarker.symbol
+ */
+/**
+ * The high or maximum value for each data point.
+ *
+ * @type      {number}
+ * @product   highcharts highstock
+ * @apioption series.arearange.data.high
+ */
+/**
+ * The low or minimum value for each data point.
+ *
+ * @type      {number}
+ * @product   highcharts highstock
+ * @apioption series.arearange.data.low
+ */
+''; // Adds doclets above to transpiled file
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default AreaRangeSeriesDefaults;

package/assets/js/highcharts/es-modules/Series/BoxPlot/BoxPlotSeries.js

@@ -14,7 +14,7 @@ import H from '../../Core/Globals.js';
 const { noop } = H;
 import SeriesRegistry from '../../Core/Series/SeriesRegistry.js';
 import U from '../../Core/Utilities.js';
-const { extend, merge, pick } = U;
+const { crisp, extend, merge, pick } = U;
 /* *
  *
  *  Class
@@ -62,20 +62,20 @@ class BoxPlotSeries extends ColumnSeries {
         const series = this, points = series.points, options = series.options, chart = series.chart, renderer = chart.renderer, 
         // Error bar inherits this series type but doesn't do quartiles
         doQuartiles = series.doQuartiles !== false, whiskerLength = series.options.whiskerLength;
-        let q1Plot, q3Plot, highPlot, lowPlot, medianPlot, medianPath, crispCorr, crispX = 0, boxPath, graphic, width, left, right, halfWidth, pointWiskerLength;
+        let q1Plot, q3Plot, highPlot, lowPlot, medianPlot, medianPath, boxPath, graphic, width, x, right, halfWidth, pointWiskerLength;
         for (const point of points) {
             graphic = point.graphic;
             const verb = graphic ? 'animate' : 'attr', shapeArgs = point.shapeArgs, boxAttr = {}, stemAttr = {}, whiskersAttr = {}, medianAttr = {}, color = point.color || series.color;
             if (typeof point.plotY !== 'undefined') {
-                // Crisp vector coordinates
-                width = Math.round(shapeArgs.width);
-                left = Math.floor(shapeArgs.x);
-                right = left + width;
-                halfWidth = Math.round(width / 2);
-                q1Plot = Math.floor(doQuartiles ? point.q1Plot : point.lowPlot);
-                q3Plot = Math.floor(doQuartiles ? point.q3Plot : point.lowPlot);
-                highPlot = Math.floor(point.highPlot);
-                lowPlot = Math.floor(point.lowPlot);
+                // Vector coordinates
+                width = shapeArgs.width;
+                x = shapeArgs.x;
+                right = x + width;
+                halfWidth = width / 2;
+                q1Plot = doQuartiles ? point.q1Plot : point.lowPlot;
+                q3Plot = doQuartiles ? point.q3Plot : point.lowPlot;
+                highPlot = point.highPlot;
+                lowPlot = point.lowPlot;
                 if (!graphic) {
                     point.graphic = graphic = renderer.g('point')
                         .add(series.group);
@@ -139,58 +139,56 @@ class BoxPlotSeries extends ColumnSeries {
                 }
                 let d;
                 // The stem
-                crispCorr = (point.stem.strokeWidth() % 2) / 2;
-                crispX = left + halfWidth + crispCorr;
+                const stemX = crisp(point.plotX || 0, point.stem.strokeWidth());
                 d = [
                     // Stem up
-                    ['M', crispX, q3Plot],
-                    ['L', crispX, highPlot],
+                    ['M', stemX, q3Plot],
+                    ['L', stemX, highPlot],
                     // Stem down
-                    ['M', crispX, q1Plot],
-                    ['L', crispX, lowPlot]
+                    ['M', stemX, q1Plot],
+                    ['L', stemX, lowPlot]
                 ];
                 point.stem[verb]({ d });
                 // The box
                 if (doQuartiles) {
-                    crispCorr = (point.box.strokeWidth() % 2) / 2;
-                    q1Plot = Math.floor(q1Plot) + crispCorr;
-                    q3Plot = Math.floor(q3Plot) + crispCorr;
-                    left += crispCorr;
-                    right += crispCorr;
+                    const boxStrokeWidth = point.box.strokeWidth();
+                    q1Plot = crisp(q1Plot, boxStrokeWidth);
+                    q3Plot = crisp(q3Plot, boxStrokeWidth);
+                    x = crisp(x, boxStrokeWidth);
+                    right = crisp(right, boxStrokeWidth);
                     d = [
-                        ['M', left, q3Plot],
-                        ['L', left, q1Plot],
+                        ['M', x, q3Plot],
+                        ['L', x, q1Plot],
                         ['L', right, q1Plot],
                         ['L', right, q3Plot],
-                        ['L', left, q3Plot],
+                        ['L', x, q3Plot],
                         ['Z']
                     ];
                     point.box[verb]({ d });
                 }
                 // The whiskers
                 if (whiskerLength) {
-                    crispCorr = (point.whiskers.strokeWidth() % 2) / 2;
-                    highPlot = highPlot + crispCorr;
-                    lowPlot = lowPlot + crispCorr;
-                    pointWiskerLength = (/%$/).test(whiskerLength) ?
+                    const whiskerStrokeWidth = point.whiskers.strokeWidth();
+                    highPlot = crisp(point.highPlot, whiskerStrokeWidth);
+                    lowPlot = crisp(point.lowPlot, whiskerStrokeWidth);
+                    pointWiskerLength = (typeof whiskerLength === 'string' &&
+                        (/%$/).test(whiskerLength)) ?
                         halfWidth * parseFloat(whiskerLength) / 100 :
-                        whiskerLength / 2;
+                        Number(whiskerLength) / 2;
                     d = [
                         // High whisker
-                        ['M', crispX - pointWiskerLength, highPlot],
-                        ['L', crispX + pointWiskerLength, highPlot],
+                        ['M', crisp(stemX - pointWiskerLength), highPlot],
+                        ['L', crisp(stemX + pointWiskerLength), highPlot],
                         // Low whisker
-                        ['M', crispX - pointWiskerLength, lowPlot],
-                        ['L', crispX + pointWiskerLength, lowPlot]
+                        ['M', crisp(stemX - pointWiskerLength), lowPlot],
+                        ['L', crisp(stemX + pointWiskerLength), lowPlot]
                     ];
                     point.whiskers[verb]({ d });
                 }
                 // The median
-                medianPlot = Math.round(point.medianPlot);
-                crispCorr = (point.medianShape.strokeWidth() % 2) / 2;
-                medianPlot = medianPlot + crispCorr;
+                medianPlot = crisp(point.medianPlot, point.medianShape.strokeWidth());
                 d = [
-                    ['M', left, medianPlot],
+                    ['M', x, medianPlot],
                     ['L', right, medianPlot]
                 ];
                 point.medianShape[verb]({ d });

package/assets/js/highcharts/es-modules/Series/Bubble/BubbleSeries.js

@@ -107,18 +107,17 @@ class BubbleSeries extends ScatterSeries {
             this.points.length < this.options.animationLimit // #8099
         ) {
             this.points.forEach(function (point) {
-                const { graphic } = point;
+                const { graphic, plotX = 0, plotY = 0 } = point;
                 if (graphic && graphic.width) { // URL symbols don't have width
                     // Start values
                     if (!this.hasRendered) {
                         graphic.attr({
-                            x: point.plotX,
-                            y: point.plotY,
+                            x: plotX,
+                            y: plotY,
                             width: 1,
                             height: 1
                         });
                     }
-                    // Run animation
                     graphic.animate(this.markerAttribs(point), this.options.animation);
                 }
             }, this);
@@ -211,6 +210,19 @@ class BubbleSeries extends ScatterSeries {
     hasData() {
         return !!this.processedXData.length; // != 0
     }
+    /**
+     * @private
+     */
+    markerAttribs(point, state) {
+        const attr = super.markerAttribs(point, state), { height = 0, width = 0 } = attr;
+        // Bubble needs a specific `markerAttribs` override because the markers
+        // are rendered into the potentially inverted `series.group`. Unlike
+        // regular markers, which are rendered into the `markerGroup` (#21125).
+        return this.chart.inverted ? extend(attr, {
+            x: (point.plotX || 0) - width / 2,
+            y: (point.plotY || 0) - height / 2
+        }) : attr;
+    }
     /**
      * @private
      */
@@ -238,8 +250,7 @@ class BubbleSeries extends ScatterSeries {
         // Set the shape type and arguments to be picked up in drawPoints
         let i = data.length;
         while (i--) {
-            const point = data[i];
-            const radius = radii ? radii[i] : 0; // #1737
+            const point = data[i], radius = radii ? radii[i] : 0; // #1737
             // Negative points means negative z values (#9728)
             if (this.zoneAxis === 'z') {
                 point.negative = (point.z || 0) < (options.zThreshold || 0);

package/assets/js/highcharts/es-modules/Series/Candlestick/CandlestickSeries.js

@@ -9,12 +9,10 @@
  * */
 'use strict';
 import CandlestickSeriesDefaults from './CandlestickSeriesDefaults.js';
-import D from '../../Core/Defaults.js';
-const { defaultOptions } = D;
 import SeriesRegistry from '../../Core/Series/SeriesRegistry.js';
 const { column: ColumnSeries, ohlc: OHLCSeries } = SeriesRegistry.seriesTypes;
 import U from '../../Core/Utilities.js';
-const { merge } = U;
+const { crisp, merge } = U;
 /* *
  *
  *  Class
@@ -67,7 +65,7 @@ class CandlestickSeries extends OHLCSeries {
     drawPoints() {
         const series = this, points = series.points, chart = series.chart, reversedYAxis = series.yAxis.reversed;
         for (const point of points) {
-            let graphic = point.graphic, plotOpen, plotClose, topBox, bottomBox, hasTopWhisker, hasBottomWhisker, crispCorr, crispX, path, halfWidth;
+            let graphic = point.graphic, plotOpen, plotClose, topBox, bottomBox, hasTopWhisker, hasBottomWhisker, crispX, path, halfWidth;
             const isNew = !graphic;
             if (typeof point.plotY !== 'undefined') {
                 if (!graphic) {
@@ -80,9 +78,9 @@ class CandlestickSeries extends OHLCSeries {
                         .shadow(series.options.shadow);
                 }
                 // Crisp vector coordinates
-                crispCorr = (graphic.strokeWidth() % 2) / 2;
+                const strokeWidth = graphic.strokeWidth();
                 // #2596:
-                crispX = Math.round(point.plotX) - crispCorr;
+                crispX = crisp(point.plotX || 0, strokeWidth);
                 plotOpen = point.plotOpen;
                 plotClose = point.plotClose;
                 topBox = Math.min(plotOpen, plotClose);
@@ -91,13 +89,13 @@ class CandlestickSeries extends OHLCSeries {
                 hasTopWhisker = reversedYAxis ?
                     bottomBox !== point.yBottom :
                     Math.round(topBox) !==
-                        Math.round(point.plotHigh);
+                        Math.round(point.plotHigh || 0);
                 hasBottomWhisker = reversedYAxis ?
                     Math.round(topBox) !==
-                        Math.round(point.plotHigh) :
+                        Math.round(point.plotHigh || 0) :
                     bottomBox !== point.yBottom;
-                topBox = Math.round(topBox) + crispCorr;
-                bottomBox = Math.round(bottomBox) + crispCorr;
+                topBox = crisp(topBox, strokeWidth);
+                bottomBox = crisp(bottomBox, strokeWidth);
                 // Create the path. Due to a bug in Chrome 49, the path is
                 // first instantiated with no values, then the values
                 // pushed. For unknown reasons, instantiating the path array
@@ -135,7 +133,7 @@ class CandlestickSeries extends OHLCSeries {
  *  Static Properties
  *
  * */
-CandlestickSeries.defaultOptions = merge(OHLCSeries.defaultOptions, defaultOptions.plotOptions, { tooltip: OHLCSeries.defaultOptions.tooltip }, CandlestickSeriesDefaults);
+CandlestickSeries.defaultOptions = merge(OHLCSeries.defaultOptions, { tooltip: OHLCSeries.defaultOptions.tooltip }, CandlestickSeriesDefaults);
 SeriesRegistry.registerSeriesType('candlestick', CandlestickSeries);
 /* *
  *

package/assets/js/highcharts/es-modules/Series/ColorMapComposition.js

@@ -10,6 +10,7 @@
 'use strict';
 import SeriesRegistry from '../Core/Series/SeriesRegistry.js';
 const { column: { prototype: columnProto } } = SeriesRegistry.seriesTypes;
+import SVGElement from '../Core/Renderer/SVG/SVGElement.js';
 import U from '../Core/Utilities.js';
 const { addEvent, defined } = U;
 /* *
@@ -57,11 +58,34 @@ var ColorMapComposition;
      * @private
      */
     function onPointAfterSetState(e) {
-        const point = this;
+        const point = this, series = point.series, renderer = series.chart.renderer;
         if (point.moveToTopOnHover && point.graphic) {
-            point.graphic.attr({
-                zIndex: e && e.state === 'hover' ? 1 : 0
-            });
+            if (!series.stateMarkerGraphic) {
+                // Create a `use` element and add it to the end of the group,
+                // which would make it appear on top of the other elements. This
+                // deals with z-index without reordering DOM elements (#13049).
+                series.stateMarkerGraphic = new SVGElement(renderer, 'use')
+                    .css({
+                    pointerEvents: 'none'
+                })
+                    .add(point.graphic.parentGroup);
+            }
+            if (e?.state === 'hover') {
+                // Give the graphic DOM element the same id as the Point
+                // instance
+                point.graphic.attr({
+                    id: this.id
+                });
+                series.stateMarkerGraphic.attr({
+                    href: `${renderer.url}#${this.id}`,
+                    visibility: 'visible'
+                });
+            }
+            else {
+                series.stateMarkerGraphic.attr({
+                    href: ''
+                });
+            }
         }
     }
     /**

package/assets/js/highcharts/es-modules/Series/Column/ColumnDataLabel.js

@@ -52,7 +52,7 @@ var ColumnDataLabel;
                 // If parts of the box overshoots outside the plot area, modify
                 // the box to center the label inside
                 const overshoot = alignTo.y + alignTo.height - yLen;
-                if (overshoot > 0 && overshoot < alignTo.height) {
+                if (overshoot > 0 && overshoot < alignTo.height - 1) {
                     alignTo.height -= overshoot;
                 }
             }

package/assets/js/highcharts/es-modules/Series/Column/ColumnSeries.js

@@ -18,7 +18,7 @@ const { noop } = H;
 import Series from '../../Core/Series/Series.js';
 import SeriesRegistry from '../../Core/Series/SeriesRegistry.js';
 import U from '../../Core/Utilities.js';
-const { clamp, defined, extend, fireEvent, isArray, isNumber, merge, pick, objectEach } = U;
+const { clamp, crisp, defined, extend, fireEvent, isArray, isNumber, merge, pick, objectEach } = U;
 /* *
  *
  *  Class
@@ -50,17 +50,27 @@ class ColumnSeries extends Series {
      *        Whether to initialize the animation or run it
      */
     animate(init) {
-        const series = this, yAxis = this.yAxis, yAxisPos = yAxis.pos, options = series.options, inverted = this.chart.inverted, attr = {}, translateProp = inverted ?
+        const series = this, yAxis = this.yAxis, yAxisPos = yAxis.pos, reversed = yAxis.reversed, options = series.options, { clipOffset, inverted } = this.chart, attr = {}, translateProp = inverted ?
             'translateX' :
             'translateY';
         let translateStart, translatedThreshold;
-        if (init) {
+        if (init && clipOffset) {
             attr.scaleY = 0.001;
             translatedThreshold = clamp(yAxis.toPixels(options.threshold), yAxisPos, yAxisPos + yAxis.len);
             if (inverted) {
+                // Make sure the columns don't cover the axis line during
+                // entrance animation
+                translatedThreshold += reversed ?
+                    -Math.floor(clipOffset[0]) :
+                    Math.ceil(clipOffset[2]);
                 attr.translateX = translatedThreshold - yAxis.len;
             }
             else {
+                // Make sure the columns don't cover the axis line during
+                // entrance animation
+                translatedThreshold += reversed ?
+                    Math.ceil(clipOffset[0]) :
+                    -Math.floor(clipOffset[2]);
                 attr.translateY = translatedThreshold;
             }
             // Apply final clipping (used in Highcharts Stock) (#7083)
@@ -180,31 +190,19 @@ class ColumnSeries extends Series {
      * @private
      * @function Highcharts.seriesTypes.column#crispCol
      */
-    crispCol(x, y, w, h) {
-        const borderWidth = this.borderWidth, xCrisp = -(borderWidth % 2 ? 0.5 : 0), yCrisp = borderWidth % 2 ? 0.5 : 1;
-        let right;
+    crispCol(x, y, width, height) {
+        const borderWidth = this.borderWidth, inverted = this.chart.inverted, bottom = crisp(y + height, borderWidth, inverted);
+        // Vertical
+        y = crisp(y, borderWidth, inverted);
+        height = bottom - y;
         // Horizontal. We need to first compute the exact right edge, then
         // round it and compute the width from there.
         if (this.options.crisp) {
-            right = Math.round(x + w) + xCrisp;
-            x = Math.round(x) + xCrisp;
-            w = right - x;
-        }
-        // Vertical
-        const bottom = Math.round(y + h) + yCrisp, fromTop = Math.abs(y) <= 0.5 && bottom > 0.5; // #4504, #4656
-        y = Math.round(y) + yCrisp;
-        h = bottom - y;
-        // Top edges are exceptions
-        if (fromTop && h) { // #5146
-            y -= 1;
-            h += 1;
+            const right = crisp(x + width, borderWidth);
+            x = crisp(x, borderWidth);
+            width = right - x;
         }
-        return {
-            x: x,
-            y: y,
-            width: w,
-            height: h
-        };
+        return { x, y, width, height };
     }
     /**
      * Adjust for missing columns, according to the `centerInCategory`
@@ -286,14 +284,11 @@ class ColumnSeries extends Series {
     translate() {
         const series = this, chart = series.chart, options = series.options, dense = series.dense =
             series.closestPointRange * series.xAxis.transA < 2, borderWidth = series.borderWidth = pick(options.borderWidth, dense ? 0 : 1 // #3635
-        ), xAxis = series.xAxis, yAxis = series.yAxis, threshold = options.threshold, minPointLength = pick(options.minPointLength, 5), metrics = series.getColumnMetrics(), seriesPointWidth = metrics.width, seriesXOffset = series.pointXOffset = metrics.offset, dataMin = series.dataMin, dataMax = series.dataMax;
+        ), xAxis = series.xAxis, yAxis = series.yAxis, threshold = options.threshold, minPointLength = pick(options.minPointLength, 5), metrics = series.getColumnMetrics(), seriesPointWidth = metrics.width, seriesXOffset = series.pointXOffset = metrics.offset, dataMin = series.dataMin, dataMax = series.dataMax, translatedThreshold = series.translatedThreshold =
+            yAxis.getThreshold(threshold);
         // Postprocessed for border width
         let seriesBarW = series.barW =
-            Math.max(seriesPointWidth, 1 + 2 * borderWidth), translatedThreshold = series.translatedThreshold =
-            yAxis.getThreshold(threshold);
-        if (chart.inverted) {
-            translatedThreshold -= 0.5; // #3355
-        }
+            Math.max(seriesPointWidth, 1 + 2 * borderWidth);
         // When the pointPadding is 0, we want the columns to be packed
         // tightly, so we allow individual columns to have individual sizes.
         // When pointPadding is greater, we strive for equal-width columns